0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be of a number. It is \\\" + str(value))\\r\\n ret = 0\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set to a number.\\\")\\r\\n if value < 0:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be greater than zero.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is greater than zero.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"generations\\\"]:\\r\\n if not isinstance(value, int):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be an integer. It is \\\" + str(value))\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is an integer.\\\")\\r\\n if param in [\\\"fitness_function\\\", \\\"population_function\\\",\\r\\n \\\"mutate_function\\\", \\\"cross_function\\\", \\\"weighting_bias\\\"]:\\r\\n if not callable(value):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be a callable function.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is a callable function.\\\")\\r\\n if param == \\\"end_condition\\\":\\r\\n if value not in [\\\"time_constraint\\\", \\\"generations\\\"]:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be 'time_constraint' or 'generations'\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is a correct string.\\\")\\r\\n if param == \\\"seed\\\":\\r\\n if not (value is None or isinstance(value, int)):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is incorrectly set.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set.\\\")\\r\\n return ret\",\n \"def validate(self, value):\\r\\n return value\",\n \"def has_value(cls, value):\\n return bool(isinstance(value, numbers.Number) or isinstance(value, time) or \\\\\\n isinstance(value, datetime) or value)\",\n \"def test_set_value_valid(self):\\r\\n name = 'option2'\\r\\n option = self.config.options[name]\\r\\n value = 'hello'\\r\\n\\r\\n self.config.set_value(name, option, value)\\r\\n self.assertEqual(self.config.values[name], value)\",\n \"def test_card_value(mock_card):\\n assert mock_card.value == 1\",\n \"def c_test_set_inp(self, param, value):\\r\\n ret = 1\\r\\n if \\\"__hash__\\\" not in dir(param): # param must be hashable\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is not hashable. It will be unable to be set in a dict.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is hashable.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"time_constraint\\\", \\\"generations\\\", \\\"point_count\\\"]:\\r\\n if not ((isinstance(value, int) or\\r\\n isinstance(value, float) or\\r\\n isinstance(value, long))):\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be of a number. It is \\\" + str(value))\\r\\n ret = 0\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set to a number.\\\")\\r\\n if value < 0:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be greater than zero.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is greater than zero.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"generations\\\", \\\"point_count\\\"]:\\r\\n if not isinstance(value, int):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be an integer. It is \\\" + str(value))\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is an integer.\\\")\\r\\n if param in [\\\"fitness_function\\\", \\\"population_function\\\",\\r\\n \\\"mutate_function\\\", \\\"cross_function\\\", \\\"weighting_bias\\\"]:\\r\\n if not callable(value):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be a callable function.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is a callable function.\\\")\\r\\n if param == \\\"end_condition\\\":\\r\\n if value not in [\\\"time_constraint\\\", \\\"generations\\\"]:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be 'time_constraint' or 'generations'\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is a correct string.\\\")\\r\\n if param == \\\"seed\\\":\\r\\n if not (value is None or isinstance(value, int)):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is incorrectly set.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set.\\\")\\r\\n return ret\",\n \"def test_get_enum_by_value():\\n assert BusinessType.get_enum_by_value('CP') == BusinessType.COOPERATIVE\\n assert BusinessType.get_enum_by_value('FM') == BusinessType.PARTNERSHIP_AND_SOLE_PROP\\n assert BusinessType.get_enum_by_value('NOT_FOUND') is None\",\n \"def test_value_error(self):\\n self._error_test(ValueError)\",\n \"def test(self, values: Dict[str, Any]) -> Optional[str]:\\n # This is always True\\n if self.cond == '#':\\n return None\\n\\n def why(cond, field, explanation) -> Optional[str]:\\n if cond:\\n return None\\n return '{}: {}'.format(field, explanation)\\n\\n # If it's missing, it's only True if it's a missing test.\\n if self.field not in values:\\n # Default to ignoring id field as long as no version.\\n if self.field == '':\\n return why('-' not in self.value, 'id', 'unknown version {}'.format(self.value))\\n return why(self.cond == '!', self.field, 'is missing')\\n\\n # If they supply a function, hand it to them.\\n if callable(values[self.field]):\\n return values[self.field](self)\\n\\n val = str(values[self.field])\\n if self.cond == '!':\\n return why(False, self.field, 'is present')\\n elif self.cond == '=':\\n return why(val == self.value,\\n self.field,\\n '!= {}'.format(self.value))\\n elif self.cond == '/':\\n return why(val != self.value,\\n self.field,\\n '= {}'.format(self.value))\\n elif self.cond == '^':\\n return why(val.startswith(self.value),\\n self.field,\\n 'does not start with {}'.format(self.value))\\n elif self.cond == '$':\\n return why(val.endswith(self.value),\\n self.field,\\n 'does not end with {}'.format(self.value))\\n elif self.cond == '~':\\n return why(self.value in val,\\n self.field,\\n 'does not contain {}'.format(self.value))\\n elif self.cond == '<':\\n try:\\n actual_int = int(val)\\n except ValueError:\\n return why(False, self.field, \\\"not an integer field\\\")\\n try:\\n restriction_val = int(self.value)\\n except ValueError:\\n return why(False, self.field, \\\"not a valid integer\\\")\\n return why(actual_int < restriction_val,\\n self.field,\\n \\\">= {}\\\".format(restriction_val))\\n elif self.cond == '>':\\n try:\\n actual_int = int(val)\\n except ValueError:\\n return why(False, self.field, \\\"not an integer field\\\")\\n try:\\n restriction_val = int(self.value)\\n except ValueError:\\n return why(False, self.field, \\\"not a valid integer\\\")\\n return why(actual_int > restriction_val,\\n self.field,\\n \\\"<= {}\\\".format(restriction_val))\\n elif self.cond == '{':\\n return why(val < self.value,\\n self.field,\\n 'is the same or ordered after {}'.format(self.value))\\n elif self.cond == '}':\\n return why(val > self.value,\\n self.field,\\n 'is the same or ordered before {}'.format(self.value))\\n else:\\n # We checked this in init!\\n assert False\",\n \"def valid(rv:Optional[int])->bool:\\n # return False # stub\\n # template from optional\\n if rv is None:\\n return False\\n else:\\n return True\\n \\n \\n\\n\\n start_testing()\",\n \"def check(self, value) -> bool:\\n return self._check_helper(value, raise_exceptions=False)\",\n \"def validate(self, value):\\r\\n if isinstance(value, self.Quoter):\\r\\n value = value.value\\r\\n return bool(value)\",\n \"def validate(self, value):\\n\\n return True\",\n \"def c_test_set_inp(self, param, value):\\r\\n ret = 1\\r\\n if \\\"__hash__\\\" not in dir(param): # param must be hashable\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is not hashable. It will be unable to be set in a dict.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is hashable.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"time_constraint\\\", \\\"generations\\\", \\\"point_count\\\",\\r\\n \\\"PSO_VELOCITY_WEIGHT\\\", \\\"PSO_INDIVIDUAL_WEIGHT\\\", \\\"PSO_GROUP_WEIGHT\\\"]:\\r\\n if not ((isinstance(value, int) or\\r\\n isinstance(value, float) or\\r\\n isinstance(value, long))):\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be of a number. It is \\\" + str(value))\\r\\n ret = 0\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set to a number.\\\")\\r\\n if value < 0:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be greater than zero.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is greater than zero.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"generations\\\", \\\"point_count\\\"]:\\r\\n if not isinstance(value, int):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be an integer. It is \\\" + str(value))\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is an integer.\\\")\\r\\n if param in [\\\"fitness_function\\\", \\\"weighting_bias\\\"]:\\r\\n if not callable(value):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be a callable function.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is a callable function.\\\")\\r\\n if param == \\\"end_condition\\\":\\r\\n if value not in [\\\"time_constraint\\\", \\\"generations\\\"]:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be 'time_constraint' or 'generations'\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is a correct string.\\\")\\r\\n if param == \\\"seed\\\":\\r\\n if not (value is None or isinstance(value, int)):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is incorrectly set.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set.\\\")\\r\\n return ret\",\n \"def test_get_value_bool(self):\\n val = self.setting_bool.get_value()\\n self.assertIsInstance(val, bool)\\n self.assertEqual(val, True)\",\n \"def test_get_value_bool(self):\\n val = self.setting_bool.get_value()\\n self.assertIsInstance(val, bool)\\n self.assertEqual(val, True)\",\n \"def __contains__(self, val):\\n if self.lookup.get(val, 0) > 0:\\n return True\\n else:\\n return False\",\n \"def validate(self, value, obj=None):\\n return True\",\n \"def _check_value(self,val):\\n if self.allow_None and val is None:\\n return\\n\\n if not _is_number(val):\\n raise ValueError(\\\"Parameter '%s' only takes numeric values\\\"%(self._attrib_name))\\n \\n self._checkBounds(val)\",\n \"def test_single_value(self, test_input, expected, sc):\\n assert sc.add(test_input) == expected\",\n \"def _side_effect_for_get_value(value, default=None):\\n if value == 'ALLOW_PUBLIC_ACCOUNT_CREATION':\\n return False\\n else:\\n return get_value(value, default)\",\n \"def is_satisfied_by(self, val):\",\n \"def validate(self, value):\\n return value\",\n \"def test_task_with_one_int_validation_parameter_validate_data(number, expected_value):\\r\\n\\r\\n assert algo.TaskWithOneIntValidationParameter.validate_data(number) == expected_value\",\n \"def set_value ( var , value , ok = lambda a , b : True ) :\\n\\n ## must be roofit variable! \\n assert isinstance ( var , ROOT.RooAbsReal ) , 'Invalid type of ``var'' %s' % type ( var )\\n \\n if not hasattr ( var , 'setVal' ) :\\n raise ValueError ( \\\"No value can be set for %s/%s\\\" % ( var , type ( var ) ) ) \\n\\n ## convert to float \\n value = float ( value )\\n\\n ## check for the range, if defined \\n minmax = var.minmax ()\\n if minmax :\\n mn , mx = minmax\\n if not ( mn <= value <= mx or isequal ( mn , value ) or isequal ( mx , value ) ) :\\n raise ValueError ( \\\"Value %s is outside of the [%s,%s] region\\\" % ( value , mn , mx ) ) \\n \\n ## check for external conditions, if specified \\n if not ok ( var , value ) :\\n raise ValueError ( \\\"Value %s is not OK\\\" % value ) \\n\\n ## finally set the value \\n var.setVal ( value )\\n\\n return isequal ( value , var.getVal () )\",\n \"def _check_valid_value(self, value):\\n if self._possible_values is None: # validation not defined (profile)\\n return\\n if value in self._possible_values:\\n return\\n if value is not None and \\\"ANY\\\" in self._possible_values:\\n return\\n msg = (\\\"'%s' is not a valid 'options.%s' value.\\\\nPossible values are %s\\\"\\n % (value, self._name, self._possible_values))\\n raise ConanException(msg)\",\n \"def __call__(self, value):\\n return self.validate(value)\",\n \"def hasVeryTrustedValue():\\n return True\",\n \"def expected_value(self):\\n raise NotImplementedError\",\n \"def is_placeholder_value(cls, value):\\n return value == cls.PLACEHOLDER_VALUE\",\n \"def value_check(unit, value):\\n while True:\\n try: # <=== Checks that value isn't below abs 0\\n t = value_input(unit) # Returns value if okay\\n if value(t) != None:\\n return t\\n break\\n except ValueError:\\n tempConv(t)\",\n \"def _get_test_value(cls, v):\\r\\n # avoid circular import\\r\\n from theano.compile.sharedvalue import SharedVariable\\r\\n\\r\\n if isinstance(v, graph.Constant):\\r\\n return v.value\\r\\n elif isinstance(v, SharedVariable):\\r\\n return v.get_value(borrow=True, return_internal_type=True)\\r\\n elif isinstance(v, graph.Variable) and hasattr(v.tag, 'test_value'):\\r\\n # ensure that the test value is correct\\r\\n return v.type.filter(v.tag.test_value)\\r\\n\\r\\n raise AttributeError('%s has no test value' % v)\",\n \"def test_generic_failed_code_value(self):\\n value = 0\\n\\n for elem in self.test_generic_failed_code:\\n self.assertEqual(value, elem)\",\n \"def test(self):\\n\\t\\tdb=simpledb.DB(debug=0)\\n\\t\\tfor t in self.KnownValues:\\n\\t\\t\\tresult=db.onecmd(t[0])\\n\\t\\t\\tself.assertEqual(t[1], result)\",\n \"def test_get_value(self) -> None:\\n\\n expected = False\\n actual = self.helper.set_name(self.test_name).exists()\\n\\n self.assertEqual(expected, actual)\\n\\n expected = \\\"Hello\\\"\\n actual = self.helper.get_value(default=\\\"Hello\\\")\\n\\n self.assertEqual(expected, actual)\\n\\n expected = \\\"This is a test.\\\"\\n\\n os.environ[self.test_name] = \\\"This is a test.\\\"\\n\\n actual = self.helper.get_value(default=\\\"Hello\\\")\\n\\n self.assertEqual(expected, actual)\\n\\n del os.environ[self.test_name]\",\n \"def validate(self, value: Any, low: int, high: int) -> bool:\\n pass\",\n \"def test_task178e(input_value, expected_value):\\r\\n assert algo.Task178e.main_logic(input_value) == expected_value\",\n \"def func3(key):\\n value = my_test_dict.get(key)\\n if value is None:\\n return False\\n else:\\n return True\",\n \"def validate(self,value):\\r\\n return type(value) is self.datatype\",\n \"def testItKnownValues(self):\\n\\t\\toutput = calc.it(self.Z,self.c,self.max_iteration)\\n\\t\\tnotError = (self.I == output).all()\\n\\t\\tself.assertEqual(True, notError)\",\n \"def validate_value_flag(self):\\n if not self.app.args.value is None or self.app.args.value == '':\\n return True\\n else:\\n return False\",\n \"def check(self, value: Any) -> None:\\n if not isinstance(value, self.oktype):\\n raise TypeError(value)\",\n \"def __checkInput(self, var):\\n try:\\n int(var)\\n\\n except:\\n return False\\n\\n else:\\n return True\",\n \"def _check_helper(self, value, raise_exceptions: bool = True) -> bool:\\n return super(ParameterMixin, self)._check_helper(\\n value, raise_exceptions=raise_exceptions\\n )\",\n \"def test_allow_none():\\n value = None\\n num_a = param.Integer(value=value, allow_None=True)\\n assert num_a.value == value\",\n \"def hasVeryTrustedValue():\\n return False\",\n \"def hasVeryTrustedValue():\\n return False\",\n \"def hasVeryTrustedValue():\\n return False\",\n \"def hasVeryTrustedValue():\\n return False\",\n \"def hasVeryTrustedValue():\\n return False\",\n \"def test_correct_value(self):\\n self.assertTrue(py_function(6) == 36)\\n self.assertFalse(py_function(5) == 9)\\n for i in range(0, 10):\\n self.assertTrue(py_function(i) == i**2 if i != 0 else 100)\",\n \"def test_value(mocker):\\n transaction = Transaction(\\n chain=0,\\n nonce=0,\\n fee=0,\\n value=18_446_744_073_709_551_616,\\n to_address=\\\"1H7NtUENrEbwSVm52fHePzBnu4W3bCqimP\\\",\\n unlock_sig=Config.COINBASE_UNLOCK_SIGNATURE,\\n )\\n\\n assert transaction.validate() == False\\n with pytest.raises(\\n TransactionNotValid, match=errors.TRANSACTION_FIELD_VALUE\\n ):\\n transaction.validate(raise_exception=True)\\n\\n transaction.value = 18_446_744_073_709_551_615\\n assert transaction.validate() == True\\n assert transaction.validate(raise_exception=True) == True\\n\\n transaction.value = 9_551_615\\n assert transaction.validate() == True\\n assert transaction.validate(raise_exception=True) == True\\n\\n transaction.value = 0\\n assert transaction.validate() == False\\n with pytest.raises(\\n TransactionNotValid, match=errors.TRANSACTION_FIELD_VALUE\\n ):\\n transaction.validate(raise_exception=True)\\n\\n transaction.value = -1\\n assert transaction.validate() == False\\n with pytest.raises(\\n TransactionNotValid, match=errors.TRANSACTION_FIELD_VALUE\\n ):\\n transaction.validate(raise_exception=True)\",\n \"def is_valid_input(value):\\n if value is None:\\n return None\\n\\n try:\\n value = int(value)\\n except ValueError:\\n return None\\n\\n if 1 <= value <= 5:\\n return value\\n else:\\n return None\",\n \"def test_set_value(self) -> None:\\n\\n expected = False\\n actual = self.helper.set_name(self.test_name).exists()\\n\\n self.assertEqual(expected, actual)\\n\\n self.helper.set_value(\\\"Hello, World!\\\")\\n\\n expected = \\\"Hello, World!\\\"\\n actual = self.helper.get_value()\\n\\n self.assertEqual(expected, actual)\\n\\n del os.environ[self.test_name]\",\n \"def _check_value(self,val,obj=None):\\n if not (isinstance(val,self.class_)) and not (val is None and self.allow_None):\\n raise ValueError(\\n \\\"Parameter '%s' value must be an instance of %s, not '%s'\\\" %\\n (self._attrib_name, self.class_.__name__, val))\",\n \"def check_value(self, position):\\n\\n # Check that we do not have a NaN or an Inf as those will\\n # will make the PLC very unhappy ...\\n if position is None or np.isnan(position) or np.isinf(position):\\n raise ValueError(\\\"Invalid value inputted: '{0}'\\\".format(position))\\n # Use the built-in PVPositioner check_value\\n super().check_value(position)\",\n \"def val(self) -> bool:\\n return self._val\",\n \"def check_parameter(cls, par: str, value):\\n\\n global dtParameterDesc\\n if par not in dtParameterDesc:\\n return False\\n\\n pardata = dtParameterDesc[par]\\n\\n if isinstance(value, str):\\n try:\\n value = float(value.replace(',', '.')) * dtg.units[pardata['dunit']]['multiple']\\n except ValueError:\\n return False\\n\\n if pardata['type'] is Integral and value != int(value):\\n return False\\n\\n if 'uplim' in pardata and (value > pardata['uplim'] or value < pardata['lowlim']):\\n return False\\n\\n return True\",\n \"def check(self, value):\\n return self(value)\",\n \"def is_value_legit(self, value):\\n return value in self.domain and value in self.possible_domain\",\n \"def test_set_get_value_1(self):\\n value = 23.0\\n port = cn.Port(value)\\n self.assertEqual(port.value, value)\",\n \"def honeypot_equals(val):\\n expected = getattr(settings, 'HONEYPOT_VALUE', '')\\n if callable(expected):\\n expected = expected()\\n return val == expected\",\n \"def check_foobar(self):\\n return self.foobar < 10 if self.foobar is not None else NA\",\n \"def check_type_value(val, name, expected_type, allow_none=False, print_value=True, none_msg=''):\\n message = name\\n\\n if print_value:\\n message += ' of value ' + str(val)\\n\\n if val is None and not allow_none:\\n raise ValueError(message + ' should not be None.' + none_msg)\\n if not isinstance(val, expected_type):\\n raise TypeError(message + ' should be of type ' + str(expected_type) + '.' + ' but is of type ' + type(val).__name__)\\n\\n return val\",\n \"def eval_value(self, v):\\n okay = False\\n if ast_class(v) == 'Dict':\\n # dict\\n if self.eval_dict(v):\\n okay = True\\n elif ast_class(v) == 'List':\\n # list\\n if self.eval_list(v):\\n okay = True\\n elif ast_class(v) == 'Str':\\n # string\\n okay = True\\n elif ast_class(v) == 'Name' and v.id in ('True', 'False', 'None'):\\n # booleans or None\\n okay = True\\n elif ast_class(v) == 'Num':\\n # numbers\\n okay = True\\n elif ast_class(v) == 'UnaryOp' and ast_class(v.op) == 'USub' and ast_class(v.operand) == 'Num':\\n # negative numbers\\n okay = True\\n return okay\",\n \"def _truth_value(self, condition):\\n if condition:\\n return 'true stuff'\\n else:\\n return 'false stuff'\",\n \"def _truth_value(self, condition):\\n if condition:\\n return 'true stuff'\\n else:\\n return 'false stuff'\",\n \"def test_is_valid_label_value_valid_input():\\n # test valid label values\\n assert is_valid_label_value(value=None)\\n assert is_valid_label_value(value=\\\"\\\")\\n assert is_valid_label_value(value=\\\"l0L\\\")\\n assert is_valid_label_value(value=\\\"L-l\\\")\\n assert is_valid_label_value(value=\\\"L.L\\\")\\n assert is_valid_label_value(value=\\\"l_4\\\")\\n assert is_valid_label_value(value=\\\"4-you\\\")\\n assert is_valid_label_value(value=\\\"You.2\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80775046","0.7501336","0.7266181","0.7051244","0.6900198","0.6898595","0.6877228","0.684004","0.6814614","0.6802086","0.6755023","0.6750932","0.66680443","0.66036206","0.6560172","0.65543497","0.6528797","0.6458347","0.64339","0.642714","0.64136505","0.64021534","0.6395371","0.63847876","0.63540447","0.6334309","0.6323961","0.6319041","0.62890875","0.62814033","0.6268924","0.6268924","0.62546515","0.6210797","0.61923295","0.6189003","0.61796045","0.6161212","0.61549044","0.6150377","0.6148398","0.61454785","0.61408937","0.6133659","0.6131344","0.61278355","0.6122453","0.60972023","0.60972023","0.60969466","0.60792154","0.60667026","0.6066613","0.6065901","0.6048836","0.60279447","0.6024727","0.5999132","0.5998603","0.5986157","0.59813684","0.59788626","0.5976385","0.5975935","0.5974172","0.59719396","0.59694463","0.5968218","0.5964116","0.59532654","0.592613","0.5919308","0.5918529","0.5918426","0.5915281","0.59118927","0.59097785","0.5906322","0.5889613","0.5889613","0.5889613","0.5889613","0.5889613","0.5888467","0.58865696","0.5877734","0.5852999","0.58505565","0.5846621","0.5845283","0.5840841","0.5834239","0.5828963","0.5828414","0.5828198","0.58081937","0.5806791","0.58029693","0.5800859","0.5800859","0.5793456"],"string":"[\n \"0.80775046\",\n \"0.7501336\",\n \"0.7266181\",\n \"0.7051244\",\n \"0.6900198\",\n \"0.6898595\",\n \"0.6877228\",\n \"0.684004\",\n \"0.6814614\",\n \"0.6802086\",\n \"0.6755023\",\n \"0.6750932\",\n \"0.66680443\",\n \"0.66036206\",\n \"0.6560172\",\n \"0.65543497\",\n \"0.6528797\",\n \"0.6458347\",\n \"0.64339\",\n \"0.642714\",\n \"0.64136505\",\n \"0.64021534\",\n \"0.6395371\",\n \"0.63847876\",\n \"0.63540447\",\n \"0.6334309\",\n \"0.6323961\",\n \"0.6319041\",\n \"0.62890875\",\n \"0.62814033\",\n \"0.6268924\",\n \"0.6268924\",\n \"0.62546515\",\n \"0.6210797\",\n \"0.61923295\",\n \"0.6189003\",\n \"0.61796045\",\n \"0.6161212\",\n \"0.61549044\",\n \"0.6150377\",\n \"0.6148398\",\n \"0.61454785\",\n \"0.61408937\",\n \"0.6133659\",\n \"0.6131344\",\n \"0.61278355\",\n \"0.6122453\",\n \"0.60972023\",\n \"0.60972023\",\n \"0.60969466\",\n \"0.60792154\",\n \"0.60667026\",\n \"0.6066613\",\n \"0.6065901\",\n \"0.6048836\",\n \"0.60279447\",\n \"0.6024727\",\n \"0.5999132\",\n \"0.5998603\",\n \"0.5986157\",\n \"0.59813684\",\n \"0.59788626\",\n \"0.5976385\",\n \"0.5975935\",\n \"0.5974172\",\n \"0.59719396\",\n \"0.59694463\",\n \"0.5968218\",\n \"0.5964116\",\n \"0.59532654\",\n \"0.592613\",\n \"0.5919308\",\n \"0.5918529\",\n \"0.5918426\",\n \"0.5915281\",\n \"0.59118927\",\n \"0.59097785\",\n \"0.5906322\",\n \"0.5889613\",\n \"0.5889613\",\n \"0.5889613\",\n \"0.5889613\",\n \"0.5889613\",\n \"0.5888467\",\n \"0.58865696\",\n \"0.5877734\",\n \"0.5852999\",\n \"0.58505565\",\n \"0.5846621\",\n \"0.5845283\",\n \"0.5840841\",\n \"0.5834239\",\n \"0.5828963\",\n \"0.5828414\",\n \"0.5828198\",\n \"0.58081937\",\n \"0.5806791\",\n \"0.58029693\",\n \"0.5800859\",\n \"0.5800859\",\n \"0.5793456\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":90788,"cells":{"query":{"kind":"string","value":"Test that CAEKL is always less than or equal to the normalized total correlation."},"document":{"kind":"string","value":"def test_caekl_4(d):\n assert J(d) <= (T(d) / 3) + 1e-6"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _is_absolutely_monotonic(self,r,tol):\n s=len(self)\n K=np.vstack([self.A.astype(float),self.b.astype(float)])\n K=np.hstack([K,np.zeros([s+1,1])])\n X=np.eye(s+1)+r*K\n if abs(np.linalg.det(X))<tol: return 0\n beta_r=np.linalg.solve(X,K)\n v_r_sum = np.dot(np.eye(s+1)-r*beta_r,np.ones([s+1,1]))\n if beta_r.min()<-tol or v_r_sum.min()<-tol:\n return 0\n else:\n return 1\n # Need an exception here if rhi==rmax","def test_c(self):\n self.failIf(cgs.speed_of_light/mks.speed_of_light!=100)","def test_cval_equal_one(self):\n plugin = NonLinearWeights(cval=1.0)\n result = plugin.process(self.cube, self.coord_name)\n expected_result = np.array([0.5, 0.5])\n self.assertArrayAlmostEqual(result.data, expected_result)","def test_concentration_limit(self):\n np.testing.assert_array_less(-self.c_e(self.t, self.x), 0)","def test_correlation_test_perfect_correlation(self):\r\n # These results were verified with R.\r\n obs = correlation_test([1, 2, 3, 4], [1, 2, 3, 4])\r\n self.assertFloatEqual(obs[:2],\r\n (0.99999999999999978, 2.2204460492503131e-16))\r\n self.assertEqual(len(obs[2]), 999)\r\n for r in obs[2]:\r\n self.assertTrue(r >= -1.0 and r <= 1.0)\r\n self.assertCorrectPValue(0.06, 0.09, correlation_test,\r\n ([1, 2, 3, 4], [1, 2, 3, 4]), p_val_idx=3)\r\n self.assertFloatEqual(obs[4], (0.99999999999998879, 1.0))","def test_lcl_convergence():\n with pytest.raises(RuntimeError):\n lcl(1000. * units.mbar, 30. * units.degC, 20. * units.degC, max_iters=2)","def test_equivalence_to_filter_output(self):\n error = np.linalg.norm(self.postmean - self.mean[[-1, -10]])/np.linalg.norm(self.mean[-1])\n self.assertLess(error, 1e-12)","def test_equivalence_to_filter_output(self):\n error = np.linalg.norm(self.postmean - self.mean[[-1, -10]])/np.linalg.norm(self.mean[-1])\n self.assertLess(error, 1e-12)","def test_equivalence_to_filter_output(self):\n error = np.linalg.norm(self.postmean - self.mean[[-1, -10]])/np.linalg.norm(self.mean[-1])\n self.assertLess(error, 1e-12)","def cointoss():\n return random.random() < 0.5","def test_equivalence_to_filter_output(self):\n error = np.linalg.norm(self.postmean - self.mean[-1])/np.linalg.norm(self.mean[-1])\n self.assertLess(error, 1e-12)","def test_equivalence_to_filter_output(self):\n error = np.linalg.norm(self.postmean - self.mean[-1])/np.linalg.norm(self.mean[-1])\n self.assertLess(error, 1e-12)","def test_equivalence_to_filter_output(self):\n error = np.linalg.norm(self.postmean - self.mean[-1])/np.linalg.norm(self.mean[-1])\n self.assertLess(error, 1e-12)","def testAlphaZeroNllsMatchACauchyDistribution(self):\n x = jnp.linspace(-10, 10, 1000)\n scale = 1.7\n nll = self.variant(self._distribution.nllfun)(x, 0, scale)\n nll_true = -scipy.stats.cauchy(0, scale * jnp.sqrt(2)).logpdf(x)\n chex.assert_tree_all_close(nll, nll_true, atol=1e-5, rtol=1e-5)","def test_lcl_convergence_issue():\n pressure = np.array([990, 973, 931, 925, 905]) * units.hPa\n temperature = np.array([14.4, 14.2, 13, 12.6, 11.4]) * units.degC\n dewpoint = np.array([14.4, 11.7, 8.2, 7.8, 7.6]) * units.degC\n lcl_pressure, _ = lcl(pressure[0], temperature[0], dewpoint[0])\n assert_almost_equal(lcl_pressure, 990 * units.hPa, 0)","def normalisable(self):\n\n return np.abs(np.nansum(self.data)) > 0","def test_check_conformer_energy(self):\n v_list = [-272.2779012225, -272.2774933703, -272.2768397635, -272.2778432059, -272.278645477, -272.2789602654,\n -272.2788749196, -272.278496709, -272.2779350675, -272.2777008843, -272.2777167286, -272.2780937643,\n -272.2784838846, -272.2788050464, -272.2787865352, -272.2785091607, -272.2779977452, -272.2777957743,\n -272.2779134906, -272.2781827547, -272.278443339, -272.2788244214, -272.2787748749]\n v_list = np.array(v_list, np.float64)\n v_diff = (v_list[0] - np.min(v_list)) * constants.E_h * constants.Na / 1000\n self.assertAlmostEqual(v_diff / 2.7805169838282797, 1, 5)","def test_compute_correlation_invalid_confidence_level(self):\r\n self.assertRaises(ValueError, _compute_correlation,\r\n self.taxa_summary1, self.taxa_summary1, 'paired',\r\n 'spearman', 'high', 10, 0)","def test_compare_different_expectations(self):\n\n pd_single = norm(0, 1)\n pd = []\n for i in range(0, 3):\n pd.append(pd_single)\n meas = [-1, 0, 1]\n meanCRIGN1, singleCRIGN1 = crign.crign(pd, meas)\n\n pd2 = []\n for i in range(0, 3):\n pd2.append(norm(i, 1))\n meas2 = [-1, 1, 3]\n\n meanCRIGN2, singleCRIGN2 = crign.crign(pd2, meas2)\n\n is_good = np.isclose(singleCRIGN1, singleCRIGN2).all()\n assert_true(is_good, msg=\"Relation of individual CRIGN values should return roughly the same value.\")","def testrescorr():\n tau = np.zeros((2,50))\n tau[0,25] = 2\n tau[1,23] = 3\n tau2 = spec_utils.res_corr(tau, 2, 8)\n #Check flux conserved\n assert np.abs(np.sum(tau2[0,:])/ np.sum(tau[0,:]) -1) < 1e-6\n assert np.abs(np.sum(tau2[1,:])/ np.sum(tau[1,:]) -1) < 1e-6\n #Check expanded by expected amount\n for i in (0,1):\n assert np.size(np.where(tau2[i,:]> 0)) == 15","def test_l1norm () :\n n = 10\n rfs = RewardFnSpace(list(range(n)))\n for i in range(10): \n b = rfs.bs[i]\n rfs.lp += b == 0\n rfs.lp.solve()\n rfs._setCoeffs()\n coeffs = np.array(rfs.coeffs)\n assert(np.linalg.norm(coeffs - np.ones(n)) < 1e-4)","def test_correctness(self):\n M_win = 1024\n N_fft = 131072\n # Set norm=False for correctness as the values obtained from the\n # scientific publication do not normalize the values. Normalizing\n # changes the sidelobe level from the desired value.\n w = windows.taylor(M_win, nbar=4, sll=35, norm=False, sym=False)\n f = fft(w, N_fft)\n spec = 20 * np.log10(np.abs(f / np.amax(f)))\n\n first_zero = np.argmax(np.diff(spec) > 0)\n\n PSLL = np.amax(spec[first_zero:-first_zero])\n\n BW_3dB = 2*np.argmax(spec <= -3.0102999566398121) / N_fft * M_win\n BW_18dB = 2*np.argmax(spec <= -18.061799739838872) / N_fft * M_win\n\n assert_allclose(PSLL, -35.1672, atol=1)\n assert_allclose(BW_3dB, 1.1822, atol=0.1)\n assert_allclose(BW_18dB, 2.6112, atol=0.1)","def test_continuous():\n # assert the distribution of the samples is close to the distribution of the data\n # using kstest:\n # - uniform (assert p-value > 0.05)\n # - gaussian (assert p-value > 0.05)\n # - inversely correlated (assert correlation < 0)","def test_conservation(self):\n # sufficient to check average concentration is constant\n\n diff = (\n self.c_e_tot(self.solution.t[1:]) - self.c_e_tot(self.solution.t[:-1])\n ) / self.c_e_tot(self.solution.t[:-1])\n np.testing.assert_array_almost_equal(diff, 0)","def check_initial_confidence(self): # pragma: no cover\n if self.test_type != 'perf':\n return True\n\n if self.required_initial_confidence is None:\n return True # pragma: no cover\n\n # TODO(robertocn): Remove all uses of \"confidence\".\n if self.dummy_initial_confidence is not None:\n self.initial_confidence = float(\n self.dummy_initial_confidence)\n if (float(self.initial_confidence) <\n float(self.required_initial_confidence)):\n self._set_insufficient_confidence_warning()\n return False\n return True\n\n if self.dummy_builds:\n dummy_result = self.good_rev.values != self.bad_rev.values\n if not dummy_result:\n self._set_insufficient_confidence_warning()\n return dummy_result\n\n with self.api.m.step.nest('Re-testing reference range'):\n expiration_time = time.time() + REGRESSION_CHECK_TIMEOUT\n while time.time() < expiration_time:\n if len(self.good_rev.values) >= 5 and len(self.bad_rev.values) >= 5:\n if self.significantly_different(self.good_rev.values,\n self.bad_rev.values):\n return True\n if len(self.good_rev.values) == len(self.bad_rev.values):\n revision_to_retest = self.last_tested_revision\n else:\n revision_to_retest = min(self.good_rev, self.bad_rev,\n key=lambda x: len(x.values))\n if len(revision_to_retest.values) < MAX_REQUIRED_SAMPLES:\n revision_to_retest.retest()\n else:\n break\n self._set_insufficient_confidence_warning()\n return False","def test_correlation(self):\r\n x = [1, 2, 3, 5]\r\n y = [0, 0, 0, 0]\r\n z = [1, 1, 1, 1]\r\n a = [2, 4, 6, 8]\r\n b = [1.5, 1.4, 1.2, 1.1]\r\n c = [15, 10, 5, 20]\r\n\r\n bad = [1, 2, 3] # originally gave r = 1.0000000002\r\n\r\n self.assertFloatEqual(correlation(x, x), (1, 0))\r\n self.assertFloatEqual(correlation(x, y), (0, 1))\r\n self.assertFloatEqual(correlation(y, z), (0, 1))\r\n self.assertFloatEqualAbs(correlation(x, a), (0.9827076, 0.01729), 1e-5)\r\n self.assertFloatEqualAbs(\r\n correlation(x, b), (-0.9621405, 0.03786), 1e-5)\r\n self.assertFloatEqualAbs(correlation(x, c), (0.3779645, 0.622), 1e-3)\r\n self.assertEqual(correlation(bad, bad), (1, 0))","def compute_confidence_interval(self) -> bool:\n return False","def sanity_check(self):\n score = 0\n curvatures = self._curvature()\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\n # difference in curvature is more than 15%\n score -= 1\n\n diff_std = np.std(self.right_fitx - self.left_fitx)\n if diff_std > 30:\n # std of the difference between the right lane and left lane is more than 30 pixel\n score -= 1\n\n # roughly parallel\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\n # difference in slope is more than 15%\n score -= 1\n\n return score","def testCalcCorrNaN(self):\n self.assertEqual(INF, calc_corr(2.050000, INF, EXP_KBT))","def test_compute_correlation_invalid_comparison_mode(self):\r\n self.assertRaises(ValueError, _compute_correlation,\r\n self.taxa_summary1, self.taxa_summary2, 'foo',\r\n 'pearson', 'two-sided', 999, 0.90)","def getMinAbundanceOfClrSample(self):\n #try: minimum = min(self.clr_sample['abundance'])-0.001\n try: minimum = min(self.clr_sample)-0.01\n except: minimum = 0\n return minimum","def test_lfc_equals_lcl():\n levels = np.array([912., 905.3, 874.4, 850., 815.1, 786.6, 759.1,\n 748., 732.2, 700., 654.8]) * units.mbar\n temperatures = np.array([29.4, 28.7, 25.2, 22.4, 19.4, 16.8,\n 14.0, 13.2, 12.6, 11.4, 7.1]) * units.celsius\n dewpoints = np.array([18.4, 18.1, 16.6, 15.4, 13.2, 11.4, 9.6,\n 8.8, 0., -18.6, -22.9]) * units.celsius\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints)\n assert_almost_equal(lfc_pressure, 777.0786 * units.mbar, 2)\n assert_almost_equal(lfc_temp, 15.8714 * units.celsius, 2)","def test_centeredEquation(self):\n\n A33, K = self.cs.centeredEquation\n self.assertTrue((self.A33 == A33).all())\n self.assertEqual(K, 1.)","def test_xx1_thr(self):\n u_spec = leabra.UnitSpec()\n u_spec.act_thr = 0.25\n u = leabra.Unit(spec=u_spec)\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\n self.assertTrue(0.0 < u_spec.xx1(0.1))\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))","def test_chao1_confidence(self): \n #NOTE: EstimateS rounds to 2 dp\n self.assertFloatEqual(chao1_confidence(self.TestData), (9.07,17.45), \\\n eps=0.01)\n self.assertFloatEqual(chao1_confidence(self.TestData, \\\n bias_corrected=False), (9.17,21.89), eps=0.01)\n self.assertFloatEqualAbs(chao1_confidence(self.NoSingles),\\\n (4, 4.95), eps=0.01)\n self.assertFloatEqualAbs(chao1_confidence(self.NoSingles, \\\n bias_corrected=False), (4,4.95), eps=0.01)\n self.assertFloatEqualAbs(chao1_confidence(self.NoDoubles), \\\n (4.08,17.27), eps=0.01)\n self.assertFloatEqualAbs(chao1_confidence(self.NoDoubles, \\\n bias_corrected=False), (4.08,17.27), eps=0.01)","def test_extreme_values(self):\n with pytest.warns(RuntimeWarning) as warninfo:\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\n with pytest.warns(RuntimeWarning) as warninfo:\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0","def test_Calc_accuracy(self, start, end, expected_len_result, expected_first_angles, expected_LHumerus):\n angles, jcs = pycgmCalc.Calc(start, end, self.motion_data, self.cal_SM)\n np.testing.assert_equal(len(angles), expected_len_result)\n np.testing.assert_equal(len(jcs), expected_len_result)\n np.testing.assert_almost_equal(angles[0][:5], expected_first_angles, self.rounding_precision)\n np.testing.assert_almost_equal(jcs[0]['LHumerus'], expected_LHumerus, self.rounding_precision)","def test_robbins_confidence(self):\n c = array([1,2,3,0,1])\n r = robbins_confidence(c, 0.05)\n n = 7\n s = 2\n k = sqrt(8/0.05)\n self.assertEqual(r, ((s-k)/(n+1), (s+k)/(n+1)))","def Q4_test():\n chemin = [3,2,1,0]\n tab_dist = [[0, 4.123105625617661, 4.242640687119285, 4.47213595499958], [4.123105625617661, 0, 4.123105625617661, 7.810249675906654], [4.242640687119285, 4.123105625617661, 0, 5.0990195135927845], [4.47213595499958, 7.810249675906654, 5.0990195135927845, 0]]\n d = longueur(chemin, tab_dist)\n return (d > 13.34523076) and (d < 13.34523077)","def test_lfc_not_below_lcl():\n levels = np.array([1002.5, 1001.7, 1001., 1000.3, 999.7, 999., 998.2, 977.9,\n 966.2, 952.3, 940.6, 930.5, 919.8, 909.1, 898.9, 888.4,\n 878.3, 868.1, 858., 848., 837.2, 827., 816.7, 805.4]) * units.hPa\n temperatures = np.array([17.9, 17.9, 17.8, 17.7, 17.7, 17.6, 17.5, 16.,\n 15.2, 14.5, 13.8, 13., 12.5, 11.9, 11.4, 11.,\n 10.3, 9.7, 9.2, 8.7, 8., 7.4, 6.8, 6.1]) * units.degC\n dewpoints = np.array([13.6, 13.6, 13.5, 13.5, 13.5, 13.5, 13.4, 12.5,\n 12.1, 11.8, 11.4, 11.3, 11., 9.3, 10., 8.7, 8.9,\n 8.6, 8.1, 7.6, 7., 6.5, 6., 5.4]) * units.degC\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints)\n # Before patch, LFC pressure would show 1000.5912165339967 hPa\n assert_almost_equal(lfc_pressure, 811.618879 * units.mbar, 3)\n assert_almost_equal(lfc_temp, 6.48644650 * units.celsius, 3)","def is_librating(triple):\n return triple.CKL <= 0","def conf_test(self, trial_coords: np.ndarray) -> bool:\n #N = len(trial_coords)\n r2: float = 0\n i =0\n r2 = np.inner(trial_coords, trial_coords)\n if (r2> self.m_radius2):\n return False\n return True","def test_continuity():\n dc = cs[:,0:Nr-1]-cs[:,1:Nr]\n assert dc.any < cmax","def test_coherence_regularized():\r\n for method in methods:\r\n f, c = tsa.coherence_regularized(tseries, 0.05, 1000,\r\n csd_method=method)\r\n npt.assert_array_almost_equal(c[0, 1], c[1, 0])","def mirkin_mismatch_coeff(self, normalize=True):\n score = 2 * (self.pairwise.FN + self.pairwise.FP)\n if normalize:\n score = _div(score, self.grand_total ** 2)\n return score","def _corrtheoerr(self, nvar):\n min_var = self.proje_var.argsort()[:nvar]\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\n return 1/np.sum(proje_cov_inv)","def test_error_at_confidence(self, threshold):\r\n\r\n nominator = numpy.sum(numpy.logical_and(self.test_errors, self.test_confidences >= threshold))\r\n denominator = numpy.sum(self.test_confidences >= threshold)\r\n if denominator > 0:\r\n return nominator / float(denominator)\r\n else:\r\n return 0","def expected_calibration_error(data_length, bucket_accs, bucket_confs, bucket_totals):\n # TODO: If the docstring is longer than the function logic, usually the docstring should be shorter or it shouldn't\n # be a function.\n # Remember that the point of a function is to be an abstraction: something that hides complexity.\n # If it's easier to read the code than understand the docstring, we haven't hidden any complexity.\n # (Often this has to do with the number of arguments. More args tends to be harder to understand.)\n\n normalization = (1 / data_length) * np.array(bucket_totals)\n ece = np.abs(np.array(bucket_accs) - np.array(bucket_confs))\n\n ece = np.dot(normalization, ece)\n\n return ece","def test_concentration_limits(self):\n t, x_n, x_p, r_n, r_p = self.t, self.x_n, self.x_p, self.r_n, self.r_p\n\n np.testing.assert_array_less(-self.c_s_n(t, x_n, r_n), 0)\n np.testing.assert_array_less(-self.c_s_p(t, x_p, r_p), 0)\n\n np.testing.assert_array_less(self.c_s_n(t, x_n, r_n), 1)\n np.testing.assert_array_less(self.c_s_p(t, x_p, r_p), 1)","def test_fits_lcurve1(self):\n lcurve_ftools = os.path.join(self.datadir,\n 'lcurve_ftools_lc' +\n HEN_FILE_EXTENSION)\n\n lcurve_mp = os.path.join(self.datadir,\n 'lcurve_lc' +\n HEN_FILE_EXTENSION)\n\n lcdata_mp = hen.io.load_data(lcurve_mp)\n lcdata_ftools = hen.io.load_data(lcurve_ftools)\n\n lc_mp = lcdata_mp['counts']\n\n lenmp = len(lc_mp)\n lc_ftools = lcdata_ftools['counts']\n lenftools = len(lc_ftools)\n goodlen = min([lenftools, lenmp])\n\n diff = lc_mp[:goodlen] - lc_ftools[:goodlen]\n\n assert np.all(np.abs(diff) <= 1e-3), \\\n 'Light curve data do not coincide between FITS and HEN'","def check_correlation(self, alpha = 0.05):\n\n if self.y is None:\n return None\n if len(self.x) != len(self.y):\n return None\n\n if self.is_normal:\n stat, p = pearsonr(self.x, self.y)\n else:\n stat, p = spearmanr(self.x, self.y)\n \n return self._result(p,alpha)","def test_kw_correction(self):\r\n self.assertEqual(_corr_kw(10), 990)\r\n self.assertEqual(_corr_kw(5), 120)\r\n self.assertFloatEqual(_corr_kw(5.4), 152.064)","def chance(c: float) -> bool:\n return c > r()","def test_statistics_calculator_partial_coherence():\n from resistics.statistics.calculator import StatisticCalculator\n import numpy as np\n\n specData, evalfreq = get_spectrum_data()\n calculator = StatisticCalculator()\n calculator.winLen = 1\n assert calculator.winLen == 1\n calculator.setSpectra(specData.freqArray, specData, evalfreq)\n statData = calculator.getDataForStatName(\"partialCoherence\")\n testData = {\n 24: {\n \"cohExHx\": 0.5462519936204147,\n \"cohExHy\": 0.13675856307435255,\n \"cohEyHx\": 0.590909090909091,\n \"cohEyHy\": 0.19523809523809524,\n \"bivarEx\": (1 + 0j),\n \"parExHx\": (1 + 0j),\n \"parExHy\": (1 + 0j),\n \"bivarEy\": (1 + 4.4408920985006264e-17j),\n \"parEyHx\": (1 + 5.518268288077701e-17j),\n \"parEyHy\": (0.9999999999999999 + 1.085551401855709e-16j),\n },\n 40: {\n \"cohExHx\": 0.49360956503813647,\n \"cohExHy\": 0.6379980563654033,\n \"cohEyHx\": 0.6734006734006734,\n \"cohEyHy\": 0.20634920634920634,\n \"bivarEx\": (1 + 0j),\n \"parExHx\": (1 + 0j),\n \"parExHy\": (1 + 0j),\n \"bivarEy\": (1 + 2.960594732333751e-17j),\n \"parEyHx\": (0.9999999999999999 + 3.7303493627405256e-17j),\n \"parEyHy\": (0.9999999999999999 + 9.064913768073444e-17j),\n },\n }\n for efreq in evalfreq:\n for key, val in statData[efreq].items():\n np.testing.assert_almost_equal(val, testData[efreq][key])","def compare_rmse(x_true, x_pred):\n x_true, x_pred = x_true.astype(np.float32), x_pred.astype(np.float32)\n return np.linalg.norm(x_true - x_pred) / (np.sqrt(x_true.shape[0] * x_true.shape[1] * x_true.shape[2]))","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def check(self, full=True):\n CFL_x=self.u_scale*self.dt/self.domain.dx\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\n print('dx/dz : {:2.1f}\\t\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\n print('lx/z_inv : {:2.1f}\\t\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\n divs = []\n for i in range(2,140):\n if self.domain.nz%i == 0:\n divs.append(i)\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\n if full:\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))","def test_coherence_linear_dependence():\r\n t = np.linspace(0, 16 * np.pi, 2 ** 14)\r\n x = np.sin(t) + np.sin(2 * t) + np.sin(3 * t) + \\\r\n 0.1 * np.random.rand(t.shape[-1])\r\n N = x.shape[-1]\r\n\r\n alpha = 10\r\n m = 3\r\n noise = 0.1 * np.random.randn(t.shape[-1])\r\n y = alpha * np.roll(x, m) + noise\r\n\r\n f_noise = fftpack.fft(noise)[0:N / 2]\r\n f_x = fftpack.fft(x)[0:N / 2]\r\n\r\n c_t = (1 / (1 + (f_noise / (f_x * (alpha ** 2)))))\r\n\r\n method = {\"this_method\": 'welch',\r\n \"NFFT\": 2048,\r\n \"Fs\": 2 * np.pi}\r\n\r\n f, c = tsa.coherence(np.vstack([x, y]), csd_method=method)\r\n c_t = np.abs(signaltools.resample(c_t, c.shape[-1]))\r\n\r\n npt.assert_array_almost_equal(c[0, 1], c_t, 2)","def test_norm():\n A = np.diag([1, 1, 1, 1])\n assert abs(norm(A) - 2.0) < 1e-12\n assert abs(norm(scipy.sparse.coo_matrix(A)) - 2.0) < 1e-12","def __eq__(self, candidate):\n return np.linalg.norm(self.components()\n -\n candidate.components()) < 1.e-7","def test_parcel_profile_below_lcl():\n pressure = np.array([981, 949.2, 925., 913.9, 903, 879.4, 878, 864, 855,\n 850, 846.3, 838, 820, 814.5, 799, 794]) * units.hPa\n truth = np.array([276.35, 273.760341, 271.747753, 270.812026, 269.885225,\n 267.850849, 267.728946, 266.502214, 265.706084, 265.261201,\n 264.930782, 264.185801, 262.551884, 262.047526, 260.61294,\n 260.145932]) * units.kelvin\n profile = parcel_profile(pressure, 3.2 * units.degC, -10.8 * units.degC)\n assert_almost_equal(profile, truth, 6)","def check_accuracy(self, W_rho, rho):\n tol = 1e-5 # Set an arbitrary tolerance\n LHS = np.dot(W_rho, rho)\n RHS = np.trace(np.dot(W_rho, rho)) * rho\n \n return np.linalg.norm(LHS - RHS, np.inf) < tol","def __basic_adaptive_comp_theorem(self):\n global_epsilon, global_delta = self._epsilon_delta\n epsilon_sum, delta_sum = \\\n map(sum, zip(*self._private_data_epsilon_delta_access_history))\n return epsilon_sum > global_epsilon or delta_sum > global_delta","def test_minvar_total(self):\n vrot, v, w = minvar(self.rdata)\n total1 = (self.rdata**2).sum(axis=1)\n total2 = (vrot ** 2).sum(axis=1)\n # Compare totals\n self.assertTrue(np.sum(total1 - total2) < self.tol)","def test_leading_order_convergence(self):\n # Create models\n leading_order_model = pybamm.lead_acid.LOQS()\n composite_model = pybamm.lead_acid.Composite()\n full_model = pybamm.lead_acid.Full()\n\n # Same parameters, same geometry\n parameter_values = full_model.default_parameter_values\n parameter_values[\"Current function [A]\"] = \"[input]\"\n parameter_values.process_model(leading_order_model)\n parameter_values.process_model(composite_model)\n parameter_values.process_model(full_model)\n geometry = full_model.default_geometry\n parameter_values.process_geometry(geometry)\n\n # Discretise (same mesh, create different discretisations)\n var = pybamm.standard_spatial_vars\n var_pts = {var.x_n: 3, var.x_s: 3, var.x_p: 3}\n mesh = pybamm.Mesh(geometry, full_model.default_submesh_types, var_pts)\n\n method_options = {\"extrapolation\": {\"order\": \"linear\", \"use bcs\": False}}\n spatial_methods = {\n \"macroscale\": pybamm.FiniteVolume(method_options),\n \"current collector\": pybamm.ZeroDimensionalSpatialMethod(method_options),\n }\n loqs_disc = pybamm.Discretisation(mesh, spatial_methods)\n loqs_disc.process_model(leading_order_model)\n comp_disc = pybamm.Discretisation(mesh, spatial_methods)\n comp_disc.process_model(composite_model)\n full_disc = pybamm.Discretisation(mesh, spatial_methods)\n full_disc.process_model(full_model)\n\n def get_max_error(current):\n pybamm.logger.info(\"current = {}\".format(current))\n # Solve, make sure times are the same and use tight tolerances\n t_eval = np.linspace(0, 3600 * 17 / current)\n solver = pybamm.CasadiSolver()\n solver.rtol = 1e-8\n solver.atol = 1e-8\n solution_loqs = solver.solve(\n leading_order_model, t_eval, inputs={\"Current function [A]\": current}\n )\n solution_comp = solver.solve(\n composite_model, t_eval, inputs={\"Current function [A]\": current}\n )\n solution_full = solver.solve(\n full_model, t_eval, inputs={\"Current function [A]\": current}\n )\n\n # Post-process variables\n voltage_loqs = solution_loqs[\"Terminal voltage\"]\n voltage_comp = solution_comp[\"Terminal voltage\"]\n voltage_full = solution_full[\"Terminal voltage\"]\n\n # Compare\n t_loqs = solution_loqs.t\n t_comp = solution_comp.t\n t_full = solution_full.t\n t = t_full[: np.min([len(t_loqs), len(t_comp), len(t_full)])]\n loqs_error = np.max(np.abs(voltage_loqs(t) - voltage_full(t)))\n comp_error = np.max(np.abs(voltage_comp(t) - voltage_full(t)))\n return (loqs_error, comp_error)\n\n # Get errors\n currents = 0.5 / (2 ** np.arange(3))\n errs = np.array([get_max_error(current) for current in currents])\n loqs_errs, comp_errs = [np.array(err) for err in zip(*errs)]\n # Get rates: expect linear convergence for loqs, quadratic for composite\n loqs_rates = np.log2(loqs_errs[:-1] / loqs_errs[1:])\n\n np.testing.assert_array_less(0.99 * np.ones_like(loqs_rates), loqs_rates)\n # Composite not converging as expected\n comp_rates = np.log2(comp_errs[:-1] / comp_errs[1:])\n np.testing.assert_array_less(0.99 * np.ones_like(comp_rates), comp_rates)\n # Check composite more accurate than loqs\n np.testing.assert_array_less(comp_errs, loqs_errs)","def test_lfc_and_el_below_lcl():\n dewpoint = [264.5351, 261.13443, 259.0122, 252.30063, 248.58017, 242.66582] * units.kelvin\n temperature = [273.09723, 268.40173, 263.56207, 260.257, 256.63538,\n 252.91345] * units.kelvin\n pressure = [1017.16, 950, 900, 850, 800, 750] * units.hPa\n el_pressure, el_temperature = el(pressure, temperature, dewpoint)\n lfc_pressure, lfc_temperature = lfc(pressure, temperature, dewpoint)\n assert_nan(lfc_pressure, pressure.units)\n assert_nan(lfc_temperature, temperature.units)\n assert_nan(el_pressure, pressure.units)\n assert_nan(el_temperature, temperature.units)","def testConsistency(self):\n #self.assertAlmostEqual(self.fxlinkedcashflow.amount(),0)","def is_lmtp_over(self):\n\t\tif self._c >= self._C:\n\t\t\treturn True\n\t\treturn False","def test_coherency_calc_errors():\n coord = SkyCoord(ra=30.0 * units.deg, dec=40 * units.deg, frame=\"icrs\")\n\n stokes_radec = [1, -0.2, 0.3, 0.1] * units.Jy\n\n source = SkyModel(\n name=\"test\", skycoord=coord, stokes=stokes_radec, spectral_type=\"flat\"\n )\n\n with uvtest.check_warnings(UserWarning, match=\"Horizon cutoff undefined\"):\n with pytest.raises(ValueError, match=\"telescope_location must be an\"):\n source.coherency_calc().squeeze()","def check_csl(l_csl_p, l_p1_po, T_p1top2_p1, Sigma, print_val):\n l_po_p1 = nla.inv(l_p1_po)\n\n l_csl_po = l_p1_po.dot(l_csl_p)\n cond1 = int_man.check_int_mat(l_po_p1.dot(l_csl_po), 1e-10)\n\n l_p2_p1 = np.copy(T_p1top2_p1)\n l_p2_po = l_p1_po.dot(l_p2_p1)\n l_po_p2 = nla.inv(l_p2_po)\n cond2 = int_man.check_int_mat(l_po_p2.dot(l_csl_po), 1e-10)\n\n Sigma1 = nla.det(l_csl_po) / nla.det(l_p1_po)\n cond3 = (np.abs(Sigma-Sigma1) < 1e-8)\n\n if print_val:\n if cond1:\n Disp_str = 'l_csl_po is defined in the l_p1_po lattice'\n print(Disp_str)\n if cond2:\n Disp_str = 'l_csl_po is defined in the l_p2_po lattice'\n print(Disp_str)\n if cond3:\n Disp_str = ('V(csl_po)/V(p1_po) = Sigma = ' + \"%0.0f\" % (Sigma))\n print(Disp_str)\n return (cond1 and cond2 and cond3)","def check_normality(serie: List[float], alpha: int = 0.05) -> bool:\n stat, p = stats.shapiro(serie)\n print('Statistics=%.3f, p=%.3f' % (stat, p))\n\n if p > alpha:\n return True\n else:\n return False","def aerosols(self):\n return 1.","def rmsle(self) -> float:\n return float(np.sqrt(np.mean(np.power(np.log1p(self.predicted) - np.log1p(self.true), 2))))","def _calculate_covariance_error(self, lc_x, lc_y):\n # Excess Variance of reference band\n xs_x = self._calculate_excess_variance(lc_x)\n # Standard deviation of light curve\n err_y = self._calculate_std(lc_y)\n # Excess Variance of reference band\n xs_y = self._calculate_excess_variance(lc_y)\n # Standard deviation of light curve\n err_x = self._calculate_std(lc_x)\n # Number of time bins in lightcurve\n N = lc_x.ncounts\n # Number of segments averaged\n if not self.avg_covar:\n M = 1\n else:\n M = self.nbins\n\n num = xs_x*err_y + xs_y*err_x + err_x*err_y\n denom = N * M * xs_y\n\n return (num / denom)**0.5","def check_ccf(lags, coeffs, confidence, threshold=0.95):\n in_band = np.sum(np.abs(coeffs) < confidence) / len(coeffs)\n return in_band >= threshold, in_band","def test_error_at_98tpr(self):\r\n\r\n return self.test_error_at_confidence(self.confidence_at_tpr(0.98))","def test_compute_unnormalized_scores(self):\n # todo: implement this test!\n pass","def cross_corr_comparison(data, synth):\n synth_normalised = (synth - np.mean(synth))/np.std(synth)/len(synth) # normalise and detrend\n std_data = np.std(data) \n #correlation of unnormalized data and normalized template:\n f_corr = signal.correlate(data, synth_normalised, mode='valid', method='fft') # Note: Needs scipy version 19 or greater (mode = full or valid, use full if want to allow shift)\n ncc = np.true_divide(f_corr, std_data) #normalization of the cross correlation\n ncc_max = np.max(ncc) # get max cross-correlation coefficient (only if use full mode)\n if ncc_max<0.:\n ncc_max = 0.\n return ncc_max","def _evaluate_centroids(self):\n\n for c in self.centroids:\n _prev_cent = self._prev_centroids[c]\n _curr_cent = self.centroids[c]\n\n if self._euclidean_distance(_prev_cent, _curr_cent) > self.tol:\n return\n self._optimized = True","def _find_cutoff(self):\n cutoff = 1\n while ((self.linear_rstar_unnorm(cutoff) -\n self.turing_rstar_unnorm(cutoff))**2\n > self.approx_turing_variance(cutoff)):\n cutoff += 1\n return cutoff","def preprocess_data(self, lidar_data):\n lidar_data = np.min(lidar_data.reshape(-1, self.num_sectors), axis=1)\n return (lidar_data < self.max_lidar_dist).astype(float)","def get_correlation(colA, colB, seuil_cramer, seuil_corr):\n if len(colA.unique()) == 1 or len(colB.unique()) == 1:\n return 0, False\n else:\n if column_type(colA) == 'continuous':\n if column_type(colB) == 'continuous':\n corr = get_R_continuous(colA,colB,m=3)\n return corr, abs(corr) > seuil_corr\n \n else:\n temp = colA.copy()\n temp = quantify_col(temp, treat_na_as_zero = False)\n c = cramer(temp,colB)\n return c, c > seuil_cramer\n \n \n elif column_type(colA) == 'discrete':\n if column_type(colB) == 'continuous':\n temp = colB.copy()\n temp = quantify_col(temp, treat_na_as_zero = False)\n c = cramer(temp,colA)\n return c, c > seuil_cramer\n else:\n c = cramer(colA,colB)\n return c, c > seuil_cramer","def check_normalize(self):\n # generate array for easier handling\n values = np.swapaxes(self.psf.psf_value, 0, 2)\n\n # init fail count\n fail_count = 0\n\n # loop over energies\n for i, arr in enumerate(values):\n energy_hi = self.psf.energy_hi[i]\n energy_lo = self.psf.energy_lo[i]\n\n # check if energy is outside of safe energy threshold\n if self.psf.energy_thresh_lo > energy_hi:\n continue\n if self.psf.energy_thresh_hi < energy_lo:\n continue\n\n # loop over offsets\n for arr2 in arr:\n\n # init integral\n sum = 0\n\n # loop over deltas\n for j, v in enumerate(arr2):\n # calculate contribution to integral\n width = self.psf.rad_hi[j].rad - self.psf.rad_lo[j].rad\n rad = 0.5 * (self.psf.rad_hi[j].rad + self.psf.rad_lo[j].rad)\n sum += v.value * width * rad * 2 * np.pi\n\n # check if integral is close enough to 1\n if np.abs(sum - 1.0) > self.config[\"d_norm\"]:\n # add to fail counter\n fail_count += 1\n\n # write results to dict\n results = {}\n if fail_count == 0:\n results[\"status\"] = \"ok\"\n else:\n results[\"status\"] = \"failed\"\n results[\"n_failed_bins\"] = fail_count\n self.results[\"normalize\"] = results","def _coherence_reqularized(fxy, fxx, fyy, epsilon, alpha):\r\n return (((alpha * np.abs(fxy) + epsilon) ** 2) /\r\n ((alpha ** 2) * (fxx + epsilon) * (fyy + epsilon)))","def test_e0_reac(self):\n self.assertAlmostEqual(self.tunneling.E0_reac.value_si * 0.001, self.E0_reac, 4)","def agreement_precent(s):\n return 1.0 * np.sum(s > 0) / s.shape[0]","def get_strict_valence_flag(self):\n d_min = self.fmodel.f_obs().d_min()\n return (d_min < self.params.d_min_strict_valence)","def test_daal_pca_train(self):\n pca_train_out = self.context.daaltk.models.dimreduction.pca.train(self.frame,\n [\"X1\", \"X2\", \"X3\", \"X4\", \"X5\",\n \"X6\", \"X7\", \"X8\", \"X9\", \"X10\"],\n False, 10)\n\n # actual right-singular vectors\n actual_R_singular_vec = pca_train_out.right_singular_vectors\n\n # actual singular values\n actual_singular_val = pca_train_out.singular_values\n\n expected_actual = zip(self.expected_singular_val, actual_singular_val)\n for expected, actual in expected_actual:\n self.assertAlmostEqual(expected, actual, 8)\n\n expected_actual = zip(actual_R_singular_vec,\n self.expected_R_singular_vec)\n for expected, actual in expected_actual:\n for f1, f2 in zip(expected, actual):\n self.assertAlmostEqual(abs(f1), abs(f2), 4)","def convergence_on_track(self):\n\n on_track = True\n threshold = 5. # used to check condition if at least one of charnge_neutrality, rms-error goes down fast enough\n\n # first check if previous calculation was stopped due to reaching the QBOUND limit\n try:\n calc_reached_qbound = self.ctx.last_calc.outputs.output_parameters.get_dict(\n )['convergence_group']['calculation_converged']\n except AttributeError: # captures error when last_calc dies not have an output node\n calc_reached_qbound = False\n except KeyError: # captures\n calc_reached_qbound = False\n\n if self.ctx.kkrimp_step_success and not calc_reached_qbound:\n first_rms = self.ctx.last_rms_all[0]\n # skip first if this is the initial LDA+U iteration because there we see the original non-LDAU convergence value\n if 'settings_LDAU' in self.inputs and self.ctx.loop_count < 2 and len(self.ctx.last_rms_all) > 1:\n first_rms = self.ctx.last_rms_all[1]\n last_rms = self.ctx.last_rms_all[-1]\n # use this trick to avoid division by zero\n if last_rms == 0:\n last_rms = 10**-16\n r = last_rms / first_rms\n message = f'INFO: convergence check: first/last rms {first_rms}, {last_rms}'\n self.report(message)\n if r < 1:\n message = 'INFO: convergence check: rms goes down'\n self.report(message)\n on_track = True\n elif r > threshold:\n message = 'INFO: convergence check: rms goes up too fast, convergence is not expected'\n self.report(message)\n on_track = False\n elif len(self.ctx.last_rms_all) == 1:\n message = 'INFO: convergence check: already converged after single iteration'\n self.report(message)\n on_track = True\n else:\n message = 'INFO: convergence check: rms does not shrink fast enough, convergence is not expected'\n self.report(message)\n on_track = False\n elif calc_reached_qbound:\n message = 'INFO: convergence check: calculation reached QBOUND'\n self.report(message)\n on_track = True\n else:\n message = 'INFO: convergence check: calculation unsuccessful'\n self.report(message)\n on_track = False\n\n message = f'INFO: convergence check result: {on_track}'\n self.report(message)\n\n return on_track","def isFullConf(triols, rThreshold = 0.2):\n for i in range(2,len(triols),3):\n if triols[i] < rThreshold:\n return False\n return True","def test_normal_unit_length(self):\n neighborhood, pc = create_point_cloud_in_plane_and_neighborhood()\n normals = np.array(EigenValueVectorizeFeatureExtractor().extract(pc, neighborhood, None, None, None)[3:6])\n lengths = np.sum(normals * normals, axis=0)\n np.testing.assert_almost_equal(np.ones_like(lengths), lengths)","def loevinger_coeff(self):\n a, c, d, b = self.to_ccw()\n p1, q1 = a + b, c + d\n p2, q2 = a + c, b + d\n n = p1 + q1\n\n cov = self.covar()\n\n if n == 0:\n return np.nan\n elif a == n or d == n:\n # only one (diagonal) cell is non-zero\n return 0.5\n elif cov == 0.0:\n return 0.0\n else:\n return _div(cov, min(p1 * q2, p2 * q1))","def test_defaults(lam_uk_sample, stacked):\n result = to_cartesian(*lam_uk_sample, stacked=stacked)\n assert np.isclose(_distance(result, stacked=stacked), RADIUS)","def test_compute_correlation_incompatible_taxa(self):\r\n self.assertRaises(ValueError, _compute_correlation,\r\n self.taxa_summary_obs1_mismatch,\r\n self.taxa_summary_exp1,\r\n 'expected', 'pearson', 'low', 999, 0.5)","def _check_normalization(self):\n lastDistance = None\n distance = None\n for idx in xrange(len(self) - 1):\n distance = self[idx+1][0] - self[idx][0]\n\n # first run\n if lastDistance is None:\n lastDistance = distance\n continue\n\n if lastDistance != distance:\n return False\n\n lastDistance = distance\n\n return True","def _confirm_constant(a):\n a = np.asanyarray(a)\n return np.isclose(a, 1.0).all(axis=0).any()","def err_k(self, X, Y):\n\t\tY_hat = self.predict(X)\n\t\treturn np.mean(Y_hat != from_1_of_k(Y))","def check(self):\n self.lower_bound(5e-4)\n self.upper_bound(5e2)"],"string":"[\n \"def _is_absolutely_monotonic(self,r,tol):\\n s=len(self)\\n K=np.vstack([self.A.astype(float),self.b.astype(float)])\\n K=np.hstack([K,np.zeros([s+1,1])])\\n X=np.eye(s+1)+r*K\\n if abs(np.linalg.det(X))<tol: return 0\\n beta_r=np.linalg.solve(X,K)\\n v_r_sum = np.dot(np.eye(s+1)-r*beta_r,np.ones([s+1,1]))\\n if beta_r.min()<-tol or v_r_sum.min()<-tol:\\n return 0\\n else:\\n return 1\\n # Need an exception here if rhi==rmax\",\n \"def test_c(self):\\n self.failIf(cgs.speed_of_light/mks.speed_of_light!=100)\",\n \"def test_cval_equal_one(self):\\n plugin = NonLinearWeights(cval=1.0)\\n result = plugin.process(self.cube, self.coord_name)\\n expected_result = np.array([0.5, 0.5])\\n self.assertArrayAlmostEqual(result.data, expected_result)\",\n \"def test_concentration_limit(self):\\n np.testing.assert_array_less(-self.c_e(self.t, self.x), 0)\",\n \"def test_correlation_test_perfect_correlation(self):\\r\\n # These results were verified with R.\\r\\n obs = correlation_test([1, 2, 3, 4], [1, 2, 3, 4])\\r\\n self.assertFloatEqual(obs[:2],\\r\\n (0.99999999999999978, 2.2204460492503131e-16))\\r\\n self.assertEqual(len(obs[2]), 999)\\r\\n for r in obs[2]:\\r\\n self.assertTrue(r >= -1.0 and r <= 1.0)\\r\\n self.assertCorrectPValue(0.06, 0.09, correlation_test,\\r\\n ([1, 2, 3, 4], [1, 2, 3, 4]), p_val_idx=3)\\r\\n self.assertFloatEqual(obs[4], (0.99999999999998879, 1.0))\",\n \"def test_lcl_convergence():\\n with pytest.raises(RuntimeError):\\n lcl(1000. * units.mbar, 30. * units.degC, 20. * units.degC, max_iters=2)\",\n \"def test_equivalence_to_filter_output(self):\\n error = np.linalg.norm(self.postmean - self.mean[[-1, -10]])/np.linalg.norm(self.mean[-1])\\n self.assertLess(error, 1e-12)\",\n \"def test_equivalence_to_filter_output(self):\\n error = np.linalg.norm(self.postmean - self.mean[[-1, -10]])/np.linalg.norm(self.mean[-1])\\n self.assertLess(error, 1e-12)\",\n \"def test_equivalence_to_filter_output(self):\\n error = np.linalg.norm(self.postmean - self.mean[[-1, -10]])/np.linalg.norm(self.mean[-1])\\n self.assertLess(error, 1e-12)\",\n \"def cointoss():\\n return random.random() < 0.5\",\n \"def test_equivalence_to_filter_output(self):\\n error = np.linalg.norm(self.postmean - self.mean[-1])/np.linalg.norm(self.mean[-1])\\n self.assertLess(error, 1e-12)\",\n \"def test_equivalence_to_filter_output(self):\\n error = np.linalg.norm(self.postmean - self.mean[-1])/np.linalg.norm(self.mean[-1])\\n self.assertLess(error, 1e-12)\",\n \"def test_equivalence_to_filter_output(self):\\n error = np.linalg.norm(self.postmean - self.mean[-1])/np.linalg.norm(self.mean[-1])\\n self.assertLess(error, 1e-12)\",\n \"def testAlphaZeroNllsMatchACauchyDistribution(self):\\n x = jnp.linspace(-10, 10, 1000)\\n scale = 1.7\\n nll = self.variant(self._distribution.nllfun)(x, 0, scale)\\n nll_true = -scipy.stats.cauchy(0, scale * jnp.sqrt(2)).logpdf(x)\\n chex.assert_tree_all_close(nll, nll_true, atol=1e-5, rtol=1e-5)\",\n \"def test_lcl_convergence_issue():\\n pressure = np.array([990, 973, 931, 925, 905]) * units.hPa\\n temperature = np.array([14.4, 14.2, 13, 12.6, 11.4]) * units.degC\\n dewpoint = np.array([14.4, 11.7, 8.2, 7.8, 7.6]) * units.degC\\n lcl_pressure, _ = lcl(pressure[0], temperature[0], dewpoint[0])\\n assert_almost_equal(lcl_pressure, 990 * units.hPa, 0)\",\n \"def normalisable(self):\\n\\n return np.abs(np.nansum(self.data)) > 0\",\n \"def test_check_conformer_energy(self):\\n v_list = [-272.2779012225, -272.2774933703, -272.2768397635, -272.2778432059, -272.278645477, -272.2789602654,\\n -272.2788749196, -272.278496709, -272.2779350675, -272.2777008843, -272.2777167286, -272.2780937643,\\n -272.2784838846, -272.2788050464, -272.2787865352, -272.2785091607, -272.2779977452, -272.2777957743,\\n -272.2779134906, -272.2781827547, -272.278443339, -272.2788244214, -272.2787748749]\\n v_list = np.array(v_list, np.float64)\\n v_diff = (v_list[0] - np.min(v_list)) * constants.E_h * constants.Na / 1000\\n self.assertAlmostEqual(v_diff / 2.7805169838282797, 1, 5)\",\n \"def test_compute_correlation_invalid_confidence_level(self):\\r\\n self.assertRaises(ValueError, _compute_correlation,\\r\\n self.taxa_summary1, self.taxa_summary1, 'paired',\\r\\n 'spearman', 'high', 10, 0)\",\n \"def test_compare_different_expectations(self):\\n\\n pd_single = norm(0, 1)\\n pd = []\\n for i in range(0, 3):\\n pd.append(pd_single)\\n meas = [-1, 0, 1]\\n meanCRIGN1, singleCRIGN1 = crign.crign(pd, meas)\\n\\n pd2 = []\\n for i in range(0, 3):\\n pd2.append(norm(i, 1))\\n meas2 = [-1, 1, 3]\\n\\n meanCRIGN2, singleCRIGN2 = crign.crign(pd2, meas2)\\n\\n is_good = np.isclose(singleCRIGN1, singleCRIGN2).all()\\n assert_true(is_good, msg=\\\"Relation of individual CRIGN values should return roughly the same value.\\\")\",\n \"def testrescorr():\\n tau = np.zeros((2,50))\\n tau[0,25] = 2\\n tau[1,23] = 3\\n tau2 = spec_utils.res_corr(tau, 2, 8)\\n #Check flux conserved\\n assert np.abs(np.sum(tau2[0,:])/ np.sum(tau[0,:]) -1) < 1e-6\\n assert np.abs(np.sum(tau2[1,:])/ np.sum(tau[1,:]) -1) < 1e-6\\n #Check expanded by expected amount\\n for i in (0,1):\\n assert np.size(np.where(tau2[i,:]> 0)) == 15\",\n \"def test_l1norm () :\\n n = 10\\n rfs = RewardFnSpace(list(range(n)))\\n for i in range(10): \\n b = rfs.bs[i]\\n rfs.lp += b == 0\\n rfs.lp.solve()\\n rfs._setCoeffs()\\n coeffs = np.array(rfs.coeffs)\\n assert(np.linalg.norm(coeffs - np.ones(n)) < 1e-4)\",\n \"def test_correctness(self):\\n M_win = 1024\\n N_fft = 131072\\n # Set norm=False for correctness as the values obtained from the\\n # scientific publication do not normalize the values. Normalizing\\n # changes the sidelobe level from the desired value.\\n w = windows.taylor(M_win, nbar=4, sll=35, norm=False, sym=False)\\n f = fft(w, N_fft)\\n spec = 20 * np.log10(np.abs(f / np.amax(f)))\\n\\n first_zero = np.argmax(np.diff(spec) > 0)\\n\\n PSLL = np.amax(spec[first_zero:-first_zero])\\n\\n BW_3dB = 2*np.argmax(spec <= -3.0102999566398121) / N_fft * M_win\\n BW_18dB = 2*np.argmax(spec <= -18.061799739838872) / N_fft * M_win\\n\\n assert_allclose(PSLL, -35.1672, atol=1)\\n assert_allclose(BW_3dB, 1.1822, atol=0.1)\\n assert_allclose(BW_18dB, 2.6112, atol=0.1)\",\n \"def test_continuous():\\n # assert the distribution of the samples is close to the distribution of the data\\n # using kstest:\\n # - uniform (assert p-value > 0.05)\\n # - gaussian (assert p-value > 0.05)\\n # - inversely correlated (assert correlation < 0)\",\n \"def test_conservation(self):\\n # sufficient to check average concentration is constant\\n\\n diff = (\\n self.c_e_tot(self.solution.t[1:]) - self.c_e_tot(self.solution.t[:-1])\\n ) / self.c_e_tot(self.solution.t[:-1])\\n np.testing.assert_array_almost_equal(diff, 0)\",\n \"def check_initial_confidence(self): # pragma: no cover\\n if self.test_type != 'perf':\\n return True\\n\\n if self.required_initial_confidence is None:\\n return True # pragma: no cover\\n\\n # TODO(robertocn): Remove all uses of \\\"confidence\\\".\\n if self.dummy_initial_confidence is not None:\\n self.initial_confidence = float(\\n self.dummy_initial_confidence)\\n if (float(self.initial_confidence) <\\n float(self.required_initial_confidence)):\\n self._set_insufficient_confidence_warning()\\n return False\\n return True\\n\\n if self.dummy_builds:\\n dummy_result = self.good_rev.values != self.bad_rev.values\\n if not dummy_result:\\n self._set_insufficient_confidence_warning()\\n return dummy_result\\n\\n with self.api.m.step.nest('Re-testing reference range'):\\n expiration_time = time.time() + REGRESSION_CHECK_TIMEOUT\\n while time.time() < expiration_time:\\n if len(self.good_rev.values) >= 5 and len(self.bad_rev.values) >= 5:\\n if self.significantly_different(self.good_rev.values,\\n self.bad_rev.values):\\n return True\\n if len(self.good_rev.values) == len(self.bad_rev.values):\\n revision_to_retest = self.last_tested_revision\\n else:\\n revision_to_retest = min(self.good_rev, self.bad_rev,\\n key=lambda x: len(x.values))\\n if len(revision_to_retest.values) < MAX_REQUIRED_SAMPLES:\\n revision_to_retest.retest()\\n else:\\n break\\n self._set_insufficient_confidence_warning()\\n return False\",\n \"def test_correlation(self):\\r\\n x = [1, 2, 3, 5]\\r\\n y = [0, 0, 0, 0]\\r\\n z = [1, 1, 1, 1]\\r\\n a = [2, 4, 6, 8]\\r\\n b = [1.5, 1.4, 1.2, 1.1]\\r\\n c = [15, 10, 5, 20]\\r\\n\\r\\n bad = [1, 2, 3] # originally gave r = 1.0000000002\\r\\n\\r\\n self.assertFloatEqual(correlation(x, x), (1, 0))\\r\\n self.assertFloatEqual(correlation(x, y), (0, 1))\\r\\n self.assertFloatEqual(correlation(y, z), (0, 1))\\r\\n self.assertFloatEqualAbs(correlation(x, a), (0.9827076, 0.01729), 1e-5)\\r\\n self.assertFloatEqualAbs(\\r\\n correlation(x, b), (-0.9621405, 0.03786), 1e-5)\\r\\n self.assertFloatEqualAbs(correlation(x, c), (0.3779645, 0.622), 1e-3)\\r\\n self.assertEqual(correlation(bad, bad), (1, 0))\",\n \"def compute_confidence_interval(self) -> bool:\\n return False\",\n \"def sanity_check(self):\\n score = 0\\n curvatures = self._curvature()\\n if abs(curvatures[0] - curvatures[1]) / max(curvatures) > 0.15:\\n # difference in curvature is more than 15%\\n score -= 1\\n\\n diff_std = np.std(self.right_fitx - self.left_fitx)\\n if diff_std > 30:\\n # std of the difference between the right lane and left lane is more than 30 pixel\\n score -= 1\\n\\n # roughly parallel\\n if abs(self.left_fit[0] - self.right_fit[0]) / max(self.left_fit[0], self.right_fit[0]) > 0.15:\\n # difference in slope is more than 15%\\n score -= 1\\n\\n return score\",\n \"def testCalcCorrNaN(self):\\n self.assertEqual(INF, calc_corr(2.050000, INF, EXP_KBT))\",\n \"def test_compute_correlation_invalid_comparison_mode(self):\\r\\n self.assertRaises(ValueError, _compute_correlation,\\r\\n self.taxa_summary1, self.taxa_summary2, 'foo',\\r\\n 'pearson', 'two-sided', 999, 0.90)\",\n \"def getMinAbundanceOfClrSample(self):\\n #try: minimum = min(self.clr_sample['abundance'])-0.001\\n try: minimum = min(self.clr_sample)-0.01\\n except: minimum = 0\\n return minimum\",\n \"def test_lfc_equals_lcl():\\n levels = np.array([912., 905.3, 874.4, 850., 815.1, 786.6, 759.1,\\n 748., 732.2, 700., 654.8]) * units.mbar\\n temperatures = np.array([29.4, 28.7, 25.2, 22.4, 19.4, 16.8,\\n 14.0, 13.2, 12.6, 11.4, 7.1]) * units.celsius\\n dewpoints = np.array([18.4, 18.1, 16.6, 15.4, 13.2, 11.4, 9.6,\\n 8.8, 0., -18.6, -22.9]) * units.celsius\\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints)\\n assert_almost_equal(lfc_pressure, 777.0786 * units.mbar, 2)\\n assert_almost_equal(lfc_temp, 15.8714 * units.celsius, 2)\",\n \"def test_centeredEquation(self):\\n\\n A33, K = self.cs.centeredEquation\\n self.assertTrue((self.A33 == A33).all())\\n self.assertEqual(K, 1.)\",\n \"def test_xx1_thr(self):\\n u_spec = leabra.UnitSpec()\\n u_spec.act_thr = 0.25\\n u = leabra.Unit(spec=u_spec)\\n self.assertEqual(u_spec.xx1(-0.1), 0.0)\\n self.assertTrue(0.0 < u_spec.xx1(0.1))\\n self.assertEqual(u_spec.noisy_xx1(-0.1), 0.0)\\n self.assertTrue(0.1 < u_spec.noisy_xx1(0.1))\",\n \"def test_chao1_confidence(self): \\n #NOTE: EstimateS rounds to 2 dp\\n self.assertFloatEqual(chao1_confidence(self.TestData), (9.07,17.45), \\\\\\n eps=0.01)\\n self.assertFloatEqual(chao1_confidence(self.TestData, \\\\\\n bias_corrected=False), (9.17,21.89), eps=0.01)\\n self.assertFloatEqualAbs(chao1_confidence(self.NoSingles),\\\\\\n (4, 4.95), eps=0.01)\\n self.assertFloatEqualAbs(chao1_confidence(self.NoSingles, \\\\\\n bias_corrected=False), (4,4.95), eps=0.01)\\n self.assertFloatEqualAbs(chao1_confidence(self.NoDoubles), \\\\\\n (4.08,17.27), eps=0.01)\\n self.assertFloatEqualAbs(chao1_confidence(self.NoDoubles, \\\\\\n bias_corrected=False), (4.08,17.27), eps=0.01)\",\n \"def test_extreme_values(self):\\n with pytest.warns(RuntimeWarning) as warninfo:\\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\\n with pytest.warns(RuntimeWarning) as warninfo:\\n assert np.exp(laplace_approx(999999, 999999, self.data)) == 0\",\n \"def test_Calc_accuracy(self, start, end, expected_len_result, expected_first_angles, expected_LHumerus):\\n angles, jcs = pycgmCalc.Calc(start, end, self.motion_data, self.cal_SM)\\n np.testing.assert_equal(len(angles), expected_len_result)\\n np.testing.assert_equal(len(jcs), expected_len_result)\\n np.testing.assert_almost_equal(angles[0][:5], expected_first_angles, self.rounding_precision)\\n np.testing.assert_almost_equal(jcs[0]['LHumerus'], expected_LHumerus, self.rounding_precision)\",\n \"def test_robbins_confidence(self):\\n c = array([1,2,3,0,1])\\n r = robbins_confidence(c, 0.05)\\n n = 7\\n s = 2\\n k = sqrt(8/0.05)\\n self.assertEqual(r, ((s-k)/(n+1), (s+k)/(n+1)))\",\n \"def Q4_test():\\n chemin = [3,2,1,0]\\n tab_dist = [[0, 4.123105625617661, 4.242640687119285, 4.47213595499958], [4.123105625617661, 0, 4.123105625617661, 7.810249675906654], [4.242640687119285, 4.123105625617661, 0, 5.0990195135927845], [4.47213595499958, 7.810249675906654, 5.0990195135927845, 0]]\\n d = longueur(chemin, tab_dist)\\n return (d > 13.34523076) and (d < 13.34523077)\",\n \"def test_lfc_not_below_lcl():\\n levels = np.array([1002.5, 1001.7, 1001., 1000.3, 999.7, 999., 998.2, 977.9,\\n 966.2, 952.3, 940.6, 930.5, 919.8, 909.1, 898.9, 888.4,\\n 878.3, 868.1, 858., 848., 837.2, 827., 816.7, 805.4]) * units.hPa\\n temperatures = np.array([17.9, 17.9, 17.8, 17.7, 17.7, 17.6, 17.5, 16.,\\n 15.2, 14.5, 13.8, 13., 12.5, 11.9, 11.4, 11.,\\n 10.3, 9.7, 9.2, 8.7, 8., 7.4, 6.8, 6.1]) * units.degC\\n dewpoints = np.array([13.6, 13.6, 13.5, 13.5, 13.5, 13.5, 13.4, 12.5,\\n 12.1, 11.8, 11.4, 11.3, 11., 9.3, 10., 8.7, 8.9,\\n 8.6, 8.1, 7.6, 7., 6.5, 6., 5.4]) * units.degC\\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints)\\n # Before patch, LFC pressure would show 1000.5912165339967 hPa\\n assert_almost_equal(lfc_pressure, 811.618879 * units.mbar, 3)\\n assert_almost_equal(lfc_temp, 6.48644650 * units.celsius, 3)\",\n \"def is_librating(triple):\\n return triple.CKL <= 0\",\n \"def conf_test(self, trial_coords: np.ndarray) -> bool:\\n #N = len(trial_coords)\\n r2: float = 0\\n i =0\\n r2 = np.inner(trial_coords, trial_coords)\\n if (r2> self.m_radius2):\\n return False\\n return True\",\n \"def test_continuity():\\n dc = cs[:,0:Nr-1]-cs[:,1:Nr]\\n assert dc.any < cmax\",\n \"def test_coherence_regularized():\\r\\n for method in methods:\\r\\n f, c = tsa.coherence_regularized(tseries, 0.05, 1000,\\r\\n csd_method=method)\\r\\n npt.assert_array_almost_equal(c[0, 1], c[1, 0])\",\n \"def mirkin_mismatch_coeff(self, normalize=True):\\n score = 2 * (self.pairwise.FN + self.pairwise.FP)\\n if normalize:\\n score = _div(score, self.grand_total ** 2)\\n return score\",\n \"def _corrtheoerr(self, nvar):\\n min_var = self.proje_var.argsort()[:nvar]\\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\\n return 1/np.sum(proje_cov_inv)\",\n \"def test_error_at_confidence(self, threshold):\\r\\n\\r\\n nominator = numpy.sum(numpy.logical_and(self.test_errors, self.test_confidences >= threshold))\\r\\n denominator = numpy.sum(self.test_confidences >= threshold)\\r\\n if denominator > 0:\\r\\n return nominator / float(denominator)\\r\\n else:\\r\\n return 0\",\n \"def expected_calibration_error(data_length, bucket_accs, bucket_confs, bucket_totals):\\n # TODO: If the docstring is longer than the function logic, usually the docstring should be shorter or it shouldn't\\n # be a function.\\n # Remember that the point of a function is to be an abstraction: something that hides complexity.\\n # If it's easier to read the code than understand the docstring, we haven't hidden any complexity.\\n # (Often this has to do with the number of arguments. More args tends to be harder to understand.)\\n\\n normalization = (1 / data_length) * np.array(bucket_totals)\\n ece = np.abs(np.array(bucket_accs) - np.array(bucket_confs))\\n\\n ece = np.dot(normalization, ece)\\n\\n return ece\",\n \"def test_concentration_limits(self):\\n t, x_n, x_p, r_n, r_p = self.t, self.x_n, self.x_p, self.r_n, self.r_p\\n\\n np.testing.assert_array_less(-self.c_s_n(t, x_n, r_n), 0)\\n np.testing.assert_array_less(-self.c_s_p(t, x_p, r_p), 0)\\n\\n np.testing.assert_array_less(self.c_s_n(t, x_n, r_n), 1)\\n np.testing.assert_array_less(self.c_s_p(t, x_p, r_p), 1)\",\n \"def test_fits_lcurve1(self):\\n lcurve_ftools = os.path.join(self.datadir,\\n 'lcurve_ftools_lc' +\\n HEN_FILE_EXTENSION)\\n\\n lcurve_mp = os.path.join(self.datadir,\\n 'lcurve_lc' +\\n HEN_FILE_EXTENSION)\\n\\n lcdata_mp = hen.io.load_data(lcurve_mp)\\n lcdata_ftools = hen.io.load_data(lcurve_ftools)\\n\\n lc_mp = lcdata_mp['counts']\\n\\n lenmp = len(lc_mp)\\n lc_ftools = lcdata_ftools['counts']\\n lenftools = len(lc_ftools)\\n goodlen = min([lenftools, lenmp])\\n\\n diff = lc_mp[:goodlen] - lc_ftools[:goodlen]\\n\\n assert np.all(np.abs(diff) <= 1e-3), \\\\\\n 'Light curve data do not coincide between FITS and HEN'\",\n \"def check_correlation(self, alpha = 0.05):\\n\\n if self.y is None:\\n return None\\n if len(self.x) != len(self.y):\\n return None\\n\\n if self.is_normal:\\n stat, p = pearsonr(self.x, self.y)\\n else:\\n stat, p = spearmanr(self.x, self.y)\\n \\n return self._result(p,alpha)\",\n \"def test_kw_correction(self):\\r\\n self.assertEqual(_corr_kw(10), 990)\\r\\n self.assertEqual(_corr_kw(5), 120)\\r\\n self.assertFloatEqual(_corr_kw(5.4), 152.064)\",\n \"def chance(c: float) -> bool:\\n return c > r()\",\n \"def test_statistics_calculator_partial_coherence():\\n from resistics.statistics.calculator import StatisticCalculator\\n import numpy as np\\n\\n specData, evalfreq = get_spectrum_data()\\n calculator = StatisticCalculator()\\n calculator.winLen = 1\\n assert calculator.winLen == 1\\n calculator.setSpectra(specData.freqArray, specData, evalfreq)\\n statData = calculator.getDataForStatName(\\\"partialCoherence\\\")\\n testData = {\\n 24: {\\n \\\"cohExHx\\\": 0.5462519936204147,\\n \\\"cohExHy\\\": 0.13675856307435255,\\n \\\"cohEyHx\\\": 0.590909090909091,\\n \\\"cohEyHy\\\": 0.19523809523809524,\\n \\\"bivarEx\\\": (1 + 0j),\\n \\\"parExHx\\\": (1 + 0j),\\n \\\"parExHy\\\": (1 + 0j),\\n \\\"bivarEy\\\": (1 + 4.4408920985006264e-17j),\\n \\\"parEyHx\\\": (1 + 5.518268288077701e-17j),\\n \\\"parEyHy\\\": (0.9999999999999999 + 1.085551401855709e-16j),\\n },\\n 40: {\\n \\\"cohExHx\\\": 0.49360956503813647,\\n \\\"cohExHy\\\": 0.6379980563654033,\\n \\\"cohEyHx\\\": 0.6734006734006734,\\n \\\"cohEyHy\\\": 0.20634920634920634,\\n \\\"bivarEx\\\": (1 + 0j),\\n \\\"parExHx\\\": (1 + 0j),\\n \\\"parExHy\\\": (1 + 0j),\\n \\\"bivarEy\\\": (1 + 2.960594732333751e-17j),\\n \\\"parEyHx\\\": (0.9999999999999999 + 3.7303493627405256e-17j),\\n \\\"parEyHy\\\": (0.9999999999999999 + 9.064913768073444e-17j),\\n },\\n }\\n for efreq in evalfreq:\\n for key, val in statData[efreq].items():\\n np.testing.assert_almost_equal(val, testData[efreq][key])\",\n \"def compare_rmse(x_true, x_pred):\\n x_true, x_pred = x_true.astype(np.float32), x_pred.astype(np.float32)\\n return np.linalg.norm(x_true - x_pred) / (np.sqrt(x_true.shape[0] * x_true.shape[1] * x_true.shape[2]))\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def check(self, full=True):\\n CFL_x=self.u_scale*self.dt/self.domain.dx\\n print('CFL (u_scale*dt/dx) : {:.2e}'.format(CFL_x))\\n print('dx/dz : {:2.1f}\\\\t\\\\t{}'.format(self.domain.dx/self.domain.dz,'-- Should be < 5 in practice'))\\n print('lx/z_inv : {:2.1f}\\\\t\\\\t{}'.format(self.domain.lx/self.inversion_depth,'-- Should be > 6. At *least* 4.'))\\n divs = []\\n for i in range(2,140):\\n if self.domain.nz%i == 0:\\n divs.append(i)\\n print('Nz = {:03d} and is divisible by : {}'.format(self.domain.nz, divs))\\n if full:\\n print('Coriolis timescale : {:1.1e} timesteps'.format(int(1./self.freq_coriolis/self.dt)))\",\n \"def test_coherence_linear_dependence():\\r\\n t = np.linspace(0, 16 * np.pi, 2 ** 14)\\r\\n x = np.sin(t) + np.sin(2 * t) + np.sin(3 * t) + \\\\\\r\\n 0.1 * np.random.rand(t.shape[-1])\\r\\n N = x.shape[-1]\\r\\n\\r\\n alpha = 10\\r\\n m = 3\\r\\n noise = 0.1 * np.random.randn(t.shape[-1])\\r\\n y = alpha * np.roll(x, m) + noise\\r\\n\\r\\n f_noise = fftpack.fft(noise)[0:N / 2]\\r\\n f_x = fftpack.fft(x)[0:N / 2]\\r\\n\\r\\n c_t = (1 / (1 + (f_noise / (f_x * (alpha ** 2)))))\\r\\n\\r\\n method = {\\\"this_method\\\": 'welch',\\r\\n \\\"NFFT\\\": 2048,\\r\\n \\\"Fs\\\": 2 * np.pi}\\r\\n\\r\\n f, c = tsa.coherence(np.vstack([x, y]), csd_method=method)\\r\\n c_t = np.abs(signaltools.resample(c_t, c.shape[-1]))\\r\\n\\r\\n npt.assert_array_almost_equal(c[0, 1], c_t, 2)\",\n \"def test_norm():\\n A = np.diag([1, 1, 1, 1])\\n assert abs(norm(A) - 2.0) < 1e-12\\n assert abs(norm(scipy.sparse.coo_matrix(A)) - 2.0) < 1e-12\",\n \"def __eq__(self, candidate):\\n return np.linalg.norm(self.components()\\n -\\n candidate.components()) < 1.e-7\",\n \"def test_parcel_profile_below_lcl():\\n pressure = np.array([981, 949.2, 925., 913.9, 903, 879.4, 878, 864, 855,\\n 850, 846.3, 838, 820, 814.5, 799, 794]) * units.hPa\\n truth = np.array([276.35, 273.760341, 271.747753, 270.812026, 269.885225,\\n 267.850849, 267.728946, 266.502214, 265.706084, 265.261201,\\n 264.930782, 264.185801, 262.551884, 262.047526, 260.61294,\\n 260.145932]) * units.kelvin\\n profile = parcel_profile(pressure, 3.2 * units.degC, -10.8 * units.degC)\\n assert_almost_equal(profile, truth, 6)\",\n \"def check_accuracy(self, W_rho, rho):\\n tol = 1e-5 # Set an arbitrary tolerance\\n LHS = np.dot(W_rho, rho)\\n RHS = np.trace(np.dot(W_rho, rho)) * rho\\n \\n return np.linalg.norm(LHS - RHS, np.inf) < tol\",\n \"def __basic_adaptive_comp_theorem(self):\\n global_epsilon, global_delta = self._epsilon_delta\\n epsilon_sum, delta_sum = \\\\\\n map(sum, zip(*self._private_data_epsilon_delta_access_history))\\n return epsilon_sum > global_epsilon or delta_sum > global_delta\",\n \"def test_minvar_total(self):\\n vrot, v, w = minvar(self.rdata)\\n total1 = (self.rdata**2).sum(axis=1)\\n total2 = (vrot ** 2).sum(axis=1)\\n # Compare totals\\n self.assertTrue(np.sum(total1 - total2) < self.tol)\",\n \"def test_leading_order_convergence(self):\\n # Create models\\n leading_order_model = pybamm.lead_acid.LOQS()\\n composite_model = pybamm.lead_acid.Composite()\\n full_model = pybamm.lead_acid.Full()\\n\\n # Same parameters, same geometry\\n parameter_values = full_model.default_parameter_values\\n parameter_values[\\\"Current function [A]\\\"] = \\\"[input]\\\"\\n parameter_values.process_model(leading_order_model)\\n parameter_values.process_model(composite_model)\\n parameter_values.process_model(full_model)\\n geometry = full_model.default_geometry\\n parameter_values.process_geometry(geometry)\\n\\n # Discretise (same mesh, create different discretisations)\\n var = pybamm.standard_spatial_vars\\n var_pts = {var.x_n: 3, var.x_s: 3, var.x_p: 3}\\n mesh = pybamm.Mesh(geometry, full_model.default_submesh_types, var_pts)\\n\\n method_options = {\\\"extrapolation\\\": {\\\"order\\\": \\\"linear\\\", \\\"use bcs\\\": False}}\\n spatial_methods = {\\n \\\"macroscale\\\": pybamm.FiniteVolume(method_options),\\n \\\"current collector\\\": pybamm.ZeroDimensionalSpatialMethod(method_options),\\n }\\n loqs_disc = pybamm.Discretisation(mesh, spatial_methods)\\n loqs_disc.process_model(leading_order_model)\\n comp_disc = pybamm.Discretisation(mesh, spatial_methods)\\n comp_disc.process_model(composite_model)\\n full_disc = pybamm.Discretisation(mesh, spatial_methods)\\n full_disc.process_model(full_model)\\n\\n def get_max_error(current):\\n pybamm.logger.info(\\\"current = {}\\\".format(current))\\n # Solve, make sure times are the same and use tight tolerances\\n t_eval = np.linspace(0, 3600 * 17 / current)\\n solver = pybamm.CasadiSolver()\\n solver.rtol = 1e-8\\n solver.atol = 1e-8\\n solution_loqs = solver.solve(\\n leading_order_model, t_eval, inputs={\\\"Current function [A]\\\": current}\\n )\\n solution_comp = solver.solve(\\n composite_model, t_eval, inputs={\\\"Current function [A]\\\": current}\\n )\\n solution_full = solver.solve(\\n full_model, t_eval, inputs={\\\"Current function [A]\\\": current}\\n )\\n\\n # Post-process variables\\n voltage_loqs = solution_loqs[\\\"Terminal voltage\\\"]\\n voltage_comp = solution_comp[\\\"Terminal voltage\\\"]\\n voltage_full = solution_full[\\\"Terminal voltage\\\"]\\n\\n # Compare\\n t_loqs = solution_loqs.t\\n t_comp = solution_comp.t\\n t_full = solution_full.t\\n t = t_full[: np.min([len(t_loqs), len(t_comp), len(t_full)])]\\n loqs_error = np.max(np.abs(voltage_loqs(t) - voltage_full(t)))\\n comp_error = np.max(np.abs(voltage_comp(t) - voltage_full(t)))\\n return (loqs_error, comp_error)\\n\\n # Get errors\\n currents = 0.5 / (2 ** np.arange(3))\\n errs = np.array([get_max_error(current) for current in currents])\\n loqs_errs, comp_errs = [np.array(err) for err in zip(*errs)]\\n # Get rates: expect linear convergence for loqs, quadratic for composite\\n loqs_rates = np.log2(loqs_errs[:-1] / loqs_errs[1:])\\n\\n np.testing.assert_array_less(0.99 * np.ones_like(loqs_rates), loqs_rates)\\n # Composite not converging as expected\\n comp_rates = np.log2(comp_errs[:-1] / comp_errs[1:])\\n np.testing.assert_array_less(0.99 * np.ones_like(comp_rates), comp_rates)\\n # Check composite more accurate than loqs\\n np.testing.assert_array_less(comp_errs, loqs_errs)\",\n \"def test_lfc_and_el_below_lcl():\\n dewpoint = [264.5351, 261.13443, 259.0122, 252.30063, 248.58017, 242.66582] * units.kelvin\\n temperature = [273.09723, 268.40173, 263.56207, 260.257, 256.63538,\\n 252.91345] * units.kelvin\\n pressure = [1017.16, 950, 900, 850, 800, 750] * units.hPa\\n el_pressure, el_temperature = el(pressure, temperature, dewpoint)\\n lfc_pressure, lfc_temperature = lfc(pressure, temperature, dewpoint)\\n assert_nan(lfc_pressure, pressure.units)\\n assert_nan(lfc_temperature, temperature.units)\\n assert_nan(el_pressure, pressure.units)\\n assert_nan(el_temperature, temperature.units)\",\n \"def testConsistency(self):\\n #self.assertAlmostEqual(self.fxlinkedcashflow.amount(),0)\",\n \"def is_lmtp_over(self):\\n\\t\\tif self._c >= self._C:\\n\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def test_coherency_calc_errors():\\n coord = SkyCoord(ra=30.0 * units.deg, dec=40 * units.deg, frame=\\\"icrs\\\")\\n\\n stokes_radec = [1, -0.2, 0.3, 0.1] * units.Jy\\n\\n source = SkyModel(\\n name=\\\"test\\\", skycoord=coord, stokes=stokes_radec, spectral_type=\\\"flat\\\"\\n )\\n\\n with uvtest.check_warnings(UserWarning, match=\\\"Horizon cutoff undefined\\\"):\\n with pytest.raises(ValueError, match=\\\"telescope_location must be an\\\"):\\n source.coherency_calc().squeeze()\",\n \"def check_csl(l_csl_p, l_p1_po, T_p1top2_p1, Sigma, print_val):\\n l_po_p1 = nla.inv(l_p1_po)\\n\\n l_csl_po = l_p1_po.dot(l_csl_p)\\n cond1 = int_man.check_int_mat(l_po_p1.dot(l_csl_po), 1e-10)\\n\\n l_p2_p1 = np.copy(T_p1top2_p1)\\n l_p2_po = l_p1_po.dot(l_p2_p1)\\n l_po_p2 = nla.inv(l_p2_po)\\n cond2 = int_man.check_int_mat(l_po_p2.dot(l_csl_po), 1e-10)\\n\\n Sigma1 = nla.det(l_csl_po) / nla.det(l_p1_po)\\n cond3 = (np.abs(Sigma-Sigma1) < 1e-8)\\n\\n if print_val:\\n if cond1:\\n Disp_str = 'l_csl_po is defined in the l_p1_po lattice'\\n print(Disp_str)\\n if cond2:\\n Disp_str = 'l_csl_po is defined in the l_p2_po lattice'\\n print(Disp_str)\\n if cond3:\\n Disp_str = ('V(csl_po)/V(p1_po) = Sigma = ' + \\\"%0.0f\\\" % (Sigma))\\n print(Disp_str)\\n return (cond1 and cond2 and cond3)\",\n \"def check_normality(serie: List[float], alpha: int = 0.05) -> bool:\\n stat, p = stats.shapiro(serie)\\n print('Statistics=%.3f, p=%.3f' % (stat, p))\\n\\n if p > alpha:\\n return True\\n else:\\n return False\",\n \"def aerosols(self):\\n return 1.\",\n \"def rmsle(self) -> float:\\n return float(np.sqrt(np.mean(np.power(np.log1p(self.predicted) - np.log1p(self.true), 2))))\",\n \"def _calculate_covariance_error(self, lc_x, lc_y):\\n # Excess Variance of reference band\\n xs_x = self._calculate_excess_variance(lc_x)\\n # Standard deviation of light curve\\n err_y = self._calculate_std(lc_y)\\n # Excess Variance of reference band\\n xs_y = self._calculate_excess_variance(lc_y)\\n # Standard deviation of light curve\\n err_x = self._calculate_std(lc_x)\\n # Number of time bins in lightcurve\\n N = lc_x.ncounts\\n # Number of segments averaged\\n if not self.avg_covar:\\n M = 1\\n else:\\n M = self.nbins\\n\\n num = xs_x*err_y + xs_y*err_x + err_x*err_y\\n denom = N * M * xs_y\\n\\n return (num / denom)**0.5\",\n \"def check_ccf(lags, coeffs, confidence, threshold=0.95):\\n in_band = np.sum(np.abs(coeffs) < confidence) / len(coeffs)\\n return in_band >= threshold, in_band\",\n \"def test_error_at_98tpr(self):\\r\\n\\r\\n return self.test_error_at_confidence(self.confidence_at_tpr(0.98))\",\n \"def test_compute_unnormalized_scores(self):\\n # todo: implement this test!\\n pass\",\n \"def cross_corr_comparison(data, synth):\\n synth_normalised = (synth - np.mean(synth))/np.std(synth)/len(synth) # normalise and detrend\\n std_data = np.std(data) \\n #correlation of unnormalized data and normalized template:\\n f_corr = signal.correlate(data, synth_normalised, mode='valid', method='fft') # Note: Needs scipy version 19 or greater (mode = full or valid, use full if want to allow shift)\\n ncc = np.true_divide(f_corr, std_data) #normalization of the cross correlation\\n ncc_max = np.max(ncc) # get max cross-correlation coefficient (only if use full mode)\\n if ncc_max<0.:\\n ncc_max = 0.\\n return ncc_max\",\n \"def _evaluate_centroids(self):\\n\\n for c in self.centroids:\\n _prev_cent = self._prev_centroids[c]\\n _curr_cent = self.centroids[c]\\n\\n if self._euclidean_distance(_prev_cent, _curr_cent) > self.tol:\\n return\\n self._optimized = True\",\n \"def _find_cutoff(self):\\n cutoff = 1\\n while ((self.linear_rstar_unnorm(cutoff) -\\n self.turing_rstar_unnorm(cutoff))**2\\n > self.approx_turing_variance(cutoff)):\\n cutoff += 1\\n return cutoff\",\n \"def preprocess_data(self, lidar_data):\\n lidar_data = np.min(lidar_data.reshape(-1, self.num_sectors), axis=1)\\n return (lidar_data < self.max_lidar_dist).astype(float)\",\n \"def get_correlation(colA, colB, seuil_cramer, seuil_corr):\\n if len(colA.unique()) == 1 or len(colB.unique()) == 1:\\n return 0, False\\n else:\\n if column_type(colA) == 'continuous':\\n if column_type(colB) == 'continuous':\\n corr = get_R_continuous(colA,colB,m=3)\\n return corr, abs(corr) > seuil_corr\\n \\n else:\\n temp = colA.copy()\\n temp = quantify_col(temp, treat_na_as_zero = False)\\n c = cramer(temp,colB)\\n return c, c > seuil_cramer\\n \\n \\n elif column_type(colA) == 'discrete':\\n if column_type(colB) == 'continuous':\\n temp = colB.copy()\\n temp = quantify_col(temp, treat_na_as_zero = False)\\n c = cramer(temp,colA)\\n return c, c > seuil_cramer\\n else:\\n c = cramer(colA,colB)\\n return c, c > seuil_cramer\",\n \"def check_normalize(self):\\n # generate array for easier handling\\n values = np.swapaxes(self.psf.psf_value, 0, 2)\\n\\n # init fail count\\n fail_count = 0\\n\\n # loop over energies\\n for i, arr in enumerate(values):\\n energy_hi = self.psf.energy_hi[i]\\n energy_lo = self.psf.energy_lo[i]\\n\\n # check if energy is outside of safe energy threshold\\n if self.psf.energy_thresh_lo > energy_hi:\\n continue\\n if self.psf.energy_thresh_hi < energy_lo:\\n continue\\n\\n # loop over offsets\\n for arr2 in arr:\\n\\n # init integral\\n sum = 0\\n\\n # loop over deltas\\n for j, v in enumerate(arr2):\\n # calculate contribution to integral\\n width = self.psf.rad_hi[j].rad - self.psf.rad_lo[j].rad\\n rad = 0.5 * (self.psf.rad_hi[j].rad + self.psf.rad_lo[j].rad)\\n sum += v.value * width * rad * 2 * np.pi\\n\\n # check if integral is close enough to 1\\n if np.abs(sum - 1.0) > self.config[\\\"d_norm\\\"]:\\n # add to fail counter\\n fail_count += 1\\n\\n # write results to dict\\n results = {}\\n if fail_count == 0:\\n results[\\\"status\\\"] = \\\"ok\\\"\\n else:\\n results[\\\"status\\\"] = \\\"failed\\\"\\n results[\\\"n_failed_bins\\\"] = fail_count\\n self.results[\\\"normalize\\\"] = results\",\n \"def _coherence_reqularized(fxy, fxx, fyy, epsilon, alpha):\\r\\n return (((alpha * np.abs(fxy) + epsilon) ** 2) /\\r\\n ((alpha ** 2) * (fxx + epsilon) * (fyy + epsilon)))\",\n \"def test_e0_reac(self):\\n self.assertAlmostEqual(self.tunneling.E0_reac.value_si * 0.001, self.E0_reac, 4)\",\n \"def agreement_precent(s):\\n return 1.0 * np.sum(s > 0) / s.shape[0]\",\n \"def get_strict_valence_flag(self):\\n d_min = self.fmodel.f_obs().d_min()\\n return (d_min < self.params.d_min_strict_valence)\",\n \"def test_daal_pca_train(self):\\n pca_train_out = self.context.daaltk.models.dimreduction.pca.train(self.frame,\\n [\\\"X1\\\", \\\"X2\\\", \\\"X3\\\", \\\"X4\\\", \\\"X5\\\",\\n \\\"X6\\\", \\\"X7\\\", \\\"X8\\\", \\\"X9\\\", \\\"X10\\\"],\\n False, 10)\\n\\n # actual right-singular vectors\\n actual_R_singular_vec = pca_train_out.right_singular_vectors\\n\\n # actual singular values\\n actual_singular_val = pca_train_out.singular_values\\n\\n expected_actual = zip(self.expected_singular_val, actual_singular_val)\\n for expected, actual in expected_actual:\\n self.assertAlmostEqual(expected, actual, 8)\\n\\n expected_actual = zip(actual_R_singular_vec,\\n self.expected_R_singular_vec)\\n for expected, actual in expected_actual:\\n for f1, f2 in zip(expected, actual):\\n self.assertAlmostEqual(abs(f1), abs(f2), 4)\",\n \"def convergence_on_track(self):\\n\\n on_track = True\\n threshold = 5. # used to check condition if at least one of charnge_neutrality, rms-error goes down fast enough\\n\\n # first check if previous calculation was stopped due to reaching the QBOUND limit\\n try:\\n calc_reached_qbound = self.ctx.last_calc.outputs.output_parameters.get_dict(\\n )['convergence_group']['calculation_converged']\\n except AttributeError: # captures error when last_calc dies not have an output node\\n calc_reached_qbound = False\\n except KeyError: # captures\\n calc_reached_qbound = False\\n\\n if self.ctx.kkrimp_step_success and not calc_reached_qbound:\\n first_rms = self.ctx.last_rms_all[0]\\n # skip first if this is the initial LDA+U iteration because there we see the original non-LDAU convergence value\\n if 'settings_LDAU' in self.inputs and self.ctx.loop_count < 2 and len(self.ctx.last_rms_all) > 1:\\n first_rms = self.ctx.last_rms_all[1]\\n last_rms = self.ctx.last_rms_all[-1]\\n # use this trick to avoid division by zero\\n if last_rms == 0:\\n last_rms = 10**-16\\n r = last_rms / first_rms\\n message = f'INFO: convergence check: first/last rms {first_rms}, {last_rms}'\\n self.report(message)\\n if r < 1:\\n message = 'INFO: convergence check: rms goes down'\\n self.report(message)\\n on_track = True\\n elif r > threshold:\\n message = 'INFO: convergence check: rms goes up too fast, convergence is not expected'\\n self.report(message)\\n on_track = False\\n elif len(self.ctx.last_rms_all) == 1:\\n message = 'INFO: convergence check: already converged after single iteration'\\n self.report(message)\\n on_track = True\\n else:\\n message = 'INFO: convergence check: rms does not shrink fast enough, convergence is not expected'\\n self.report(message)\\n on_track = False\\n elif calc_reached_qbound:\\n message = 'INFO: convergence check: calculation reached QBOUND'\\n self.report(message)\\n on_track = True\\n else:\\n message = 'INFO: convergence check: calculation unsuccessful'\\n self.report(message)\\n on_track = False\\n\\n message = f'INFO: convergence check result: {on_track}'\\n self.report(message)\\n\\n return on_track\",\n \"def isFullConf(triols, rThreshold = 0.2):\\n for i in range(2,len(triols),3):\\n if triols[i] < rThreshold:\\n return False\\n return True\",\n \"def test_normal_unit_length(self):\\n neighborhood, pc = create_point_cloud_in_plane_and_neighborhood()\\n normals = np.array(EigenValueVectorizeFeatureExtractor().extract(pc, neighborhood, None, None, None)[3:6])\\n lengths = np.sum(normals * normals, axis=0)\\n np.testing.assert_almost_equal(np.ones_like(lengths), lengths)\",\n \"def loevinger_coeff(self):\\n a, c, d, b = self.to_ccw()\\n p1, q1 = a + b, c + d\\n p2, q2 = a + c, b + d\\n n = p1 + q1\\n\\n cov = self.covar()\\n\\n if n == 0:\\n return np.nan\\n elif a == n or d == n:\\n # only one (diagonal) cell is non-zero\\n return 0.5\\n elif cov == 0.0:\\n return 0.0\\n else:\\n return _div(cov, min(p1 * q2, p2 * q1))\",\n \"def test_defaults(lam_uk_sample, stacked):\\n result = to_cartesian(*lam_uk_sample, stacked=stacked)\\n assert np.isclose(_distance(result, stacked=stacked), RADIUS)\",\n \"def test_compute_correlation_incompatible_taxa(self):\\r\\n self.assertRaises(ValueError, _compute_correlation,\\r\\n self.taxa_summary_obs1_mismatch,\\r\\n self.taxa_summary_exp1,\\r\\n 'expected', 'pearson', 'low', 999, 0.5)\",\n \"def _check_normalization(self):\\n lastDistance = None\\n distance = None\\n for idx in xrange(len(self) - 1):\\n distance = self[idx+1][0] - self[idx][0]\\n\\n # first run\\n if lastDistance is None:\\n lastDistance = distance\\n continue\\n\\n if lastDistance != distance:\\n return False\\n\\n lastDistance = distance\\n\\n return True\",\n \"def _confirm_constant(a):\\n a = np.asanyarray(a)\\n return np.isclose(a, 1.0).all(axis=0).any()\",\n \"def err_k(self, X, Y):\\n\\t\\tY_hat = self.predict(X)\\n\\t\\treturn np.mean(Y_hat != from_1_of_k(Y))\",\n \"def check(self):\\n self.lower_bound(5e-4)\\n self.upper_bound(5e2)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.604998","0.6012431","0.59215325","0.5856045","0.58455676","0.58151805","0.5794475","0.5794475","0.5794475","0.5787765","0.57562685","0.57562685","0.57562685","0.5755928","0.5742629","0.57194674","0.5675751","0.56736386","0.566482","0.5655411","0.5621105","0.5617157","0.5609037","0.5608688","0.5607581","0.559929","0.5595361","0.558012","0.55758154","0.55726206","0.5571133","0.5554573","0.55502826","0.55486023","0.55401236","0.5518474","0.55040985","0.5500317","0.54733706","0.5453717","0.5447074","0.54463","0.5443778","0.5439075","0.54387","0.5437382","0.54276526","0.5423257","0.5418424","0.5412339","0.5411513","0.54099756","0.54061216","0.5400565","0.5398987","0.53822505","0.53822505","0.53822505","0.53822505","0.5369284","0.53643525","0.5355871","0.53538054","0.5341163","0.5340101","0.53378224","0.5337537","0.53333014","0.53317606","0.53229666","0.53156626","0.53155184","0.53144294","0.5311946","0.53102344","0.5297206","0.5295547","0.52875364","0.52865696","0.528218","0.52699524","0.5265042","0.5264974","0.52647096","0.525889","0.5252688","0.5248613","0.5246611","0.52456","0.5243011","0.5238438","0.5235736","0.5230656","0.5227566","0.5225439","0.5222258","0.5216926","0.520877","0.52040714","0.51951855"],"string":"[\n \"0.604998\",\n \"0.6012431\",\n \"0.59215325\",\n \"0.5856045\",\n \"0.58455676\",\n \"0.58151805\",\n \"0.5794475\",\n \"0.5794475\",\n \"0.5794475\",\n \"0.5787765\",\n \"0.57562685\",\n \"0.57562685\",\n \"0.57562685\",\n \"0.5755928\",\n \"0.5742629\",\n \"0.57194674\",\n \"0.5675751\",\n \"0.56736386\",\n \"0.566482\",\n \"0.5655411\",\n \"0.5621105\",\n \"0.5617157\",\n \"0.5609037\",\n \"0.5608688\",\n \"0.5607581\",\n \"0.559929\",\n \"0.5595361\",\n \"0.558012\",\n \"0.55758154\",\n \"0.55726206\",\n \"0.5571133\",\n \"0.5554573\",\n \"0.55502826\",\n \"0.55486023\",\n \"0.55401236\",\n \"0.5518474\",\n \"0.55040985\",\n \"0.5500317\",\n \"0.54733706\",\n \"0.5453717\",\n \"0.5447074\",\n \"0.54463\",\n \"0.5443778\",\n \"0.5439075\",\n \"0.54387\",\n \"0.5437382\",\n \"0.54276526\",\n \"0.5423257\",\n \"0.5418424\",\n \"0.5412339\",\n \"0.5411513\",\n \"0.54099756\",\n \"0.54061216\",\n \"0.5400565\",\n \"0.5398987\",\n \"0.53822505\",\n \"0.53822505\",\n \"0.53822505\",\n \"0.53822505\",\n \"0.5369284\",\n \"0.53643525\",\n \"0.5355871\",\n \"0.53538054\",\n \"0.5341163\",\n \"0.5340101\",\n \"0.53378224\",\n \"0.5337537\",\n \"0.53333014\",\n \"0.53317606\",\n \"0.53229666\",\n \"0.53156626\",\n \"0.53155184\",\n \"0.53144294\",\n \"0.5311946\",\n \"0.53102344\",\n \"0.5297206\",\n \"0.5295547\",\n \"0.52875364\",\n \"0.52865696\",\n \"0.528218\",\n \"0.52699524\",\n \"0.5265042\",\n \"0.5264974\",\n \"0.52647096\",\n \"0.525889\",\n \"0.5252688\",\n \"0.5248613\",\n \"0.5246611\",\n \"0.52456\",\n \"0.5243011\",\n \"0.5238438\",\n \"0.5235736\",\n \"0.5230656\",\n \"0.5227566\",\n \"0.5225439\",\n \"0.5222258\",\n \"0.5216926\",\n \"0.520877\",\n \"0.52040714\",\n \"0.51951855\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.53975534"},"document_rank":{"kind":"string","value":"55"}}},{"rowIdx":90789,"cells":{"query":{"kind":"string","value":"Applies the logistic function to x, elementwise."},"document":{"kind":"string","value":"def sigmoid(X):\n return 1 / (1 + np.exp(-X))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def logistic(self,w,Xi):\n # print(w.T)\n # print(Xi)\n a = np.dot(w.T,Xi)\n return 1/(1+np.exp(-a))","def logistic(self, X, w):\n g = 1 / (1 + np.exp(-X.dot(w)))\n return g","def forward(self, x):\n\n embeds = self.dvector(x)\n logits = self.linear(embeds)\n\n return logits","def logistic(mu, hw, x): \n n = np.exp(- ((x-mu)/(.477*hw))**2)\n return (2. * n)/( 1 + n)","def apply(cls, x):\n return 1.0 / (1.0 + np.exp(-x))","def logistic_predict(self, x: np.array) -> np.array:\r\n if self.LogisticModel is None:\r\n print('Logistic Model not trained, please run logistic_fit first!')\r\n return None\r\n else:\r\n return self.LogisticModel.predict(x)","def forward(self, x):\n return F.log_softmax(self.proj(x), dim=-1)","def logistic(val):\n return 1.0 / (1.0 + np.exp(-val))","def logistic(x):\n try:\n denom = (1 + math.e ** -x)\n except OverflowError:\n return 0.0\n return 1.0 / denom","def get_output(self, X):\n return logistic(X)","def logistic_function(self, data, b0, b1):\n return np.array([1/(1+exp(-1*b0+(-1*b1*x))) for x in data])","def log_forward_computations(self, x: list): \n n_x = len(x)\n \n # log_f_x initialized to -Inf because log(0) = -Inf\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\n \n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\n \n for i in range(1,n_x):\n for s in range(self.n_states):\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \n log_f_x[:,i-1]) + x_emission_scores[s, i]\n\n \n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\n \n return log_f_x, log_likelihood","def __logistic_prime(self, x):\n \n return self.__logistic(x)*(1.0-self.__logistic(x))","def log_target(self, x):\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)","def logistic_function(self, real_value):\n return 1/(1+np.exp(-real_value))","def prob_logit(x):\n try:\n if len(x.shape) != 1:\n raise ValueError(\"unexpected shape of input vector\\nexpected:\" + str(1) + \", actual: \" + str(len(x.shape)))\n except ValueError as e:\n print(e)\n print()\n raise\n\n x = 1.0 * np.exp(-x)\n\n probability = np.concatenate(\n (\n (x / (1.0 + x)).reshape(x.shape[0], 1),\n (1.0 / (1.0 + x)).reshape(x.shape[0], 1)\n ),\n axis=1\n )\n\n return probability","def f(self, x):\n error = log_likelihood_calc(x[1], x[0], self.data)\n return error","def log_likelihood(self, x):\n return self.log_likelihood_exp(x) + self.log_prior_nuisance_parameters(x)","def log_probability(self, X):\n\n\t\treturn self.__log_probability(X)","def apply(self, y, a):\n return np.sum(y*np.log(a) + (1 - y)*(np.log(1 - a)))","def logistic_loss(x, y):\n N = x.shape[0]\n x_flat = np.squeeze(x)\n ex = np.exp(x_flat)\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\n dx = (-y+ex/(1+ex))/N\n # dx = np.reshape(dx,(len(dx),1))\n return loss, dx","def logistic(weights, data, targets, hyperparameters):\n\n # TODO: Finish this function\n\n return f, df, y","def logistic(mu):\n mu4 = 4*mu\n def f(x):\n return mu4*x*(1.-x)\n return f","def run_logistic_regression(training, testing, feature_cols, outcome_col):\n if 'intercept' not in training.columns:\n training['intercept'] = 1\n if 'intercept' not in testing.columns:\n testing['intercept'] = 1\n intercept_feature_cols = feature_cols + ['intercept']\n logit = sm.Logit(training[outcome_col], training[intercept_feature_cols])\n fitted_logit_model = logit.fit()\n logit_diagnostics = get_diagnostics(testing[outcome_col], testing[intercept_feature_cols], fitted_logit_model, model_type = 'logit')\n predicted_logit_probs = fitted_logit_model.predict(testing[intercept_feature_cols])\n\n return fitted_logit_model, logit_diagnostics, predicted_logit_probs","def _log_posterior_x(self, X):\r\n LL = self.log_likelihood(X=X)\r\n LP = self._log_prior_x(X)\r\n return LL + LP","def calculate_logistic(c, z, v, x):\n a = (c / v) - 1 # Determines the y-intercept\n b = 4 * (z / c) # Determines the aggressiveness/max slope of the curve at the inflection point\n f = (c / (1 + a * (pow(e, -b * x)))) # Resultant logistic value\n return f","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def logistic(weights, data, targets, hyperparameters):\n # TODO: Finish this function\n n_data = len(data)\n dim_data = len(data[0])\n\n f = 0\n y = logistic_predict(weights, data)\n\n data = mod_data(data)\n\n # dl/dw_j = SUM(x_ij * (t_i - (1 - sigmoid(z))))\n df = np.dot(data.T, (1.0 * targets) - (1 - y))\n\n # to calculate f, we need to sum the negative log of all y iff target is 0 and (1-y) iff target is 1\n f = -1.0 * np.dot(targets.T, np.log(1 - y)) - 1.0 * np.dot(1 - targets.T, np.log(y))\n\n # calculate P(C=0|x_i) for all x_i \n return f[0,0], df, y","def _log_posterior_x(self, X):\n if self.marginalize:\n LL = self.log_marginal_likelihood(X, self.W)\n else:\n LL = self.log_likelihood(X=X)\n LP = self._log_prior_x(X)\n return LL + LP","def likelihood(self,x,params = None,**kwargs):\n return np.exp(self.log_likelihood(x,params=params,**kwargs))","def log_prob_from_logits(x):\n axis = len(x.shape) - 1\n m = x.max(dim=axis, keepdim=True)[0]\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))","def logp_logistic(X, alpha, lambda_, dtype):\n\n mu = tf.log(alpha)\n return tf.subtract(tf.add(tf.subtract(tf.log(lambda_), tf.multiply(lambda_, X)), mu),\n tf.multiply(tf.constant(2.0, dtype=dtype), tf.log(tf.add(tf.constant(1.0, dtype=dtype), tf.exp(\n tf.add(tf.negative(tf.multiply(lambda_, X)), mu))))))","def forward(self, x):\n out = self.net(x)\n out = self.avg(out)\n out = out.view(out.size(0), -1)\n out = self.fc1(out)\n\n return func.log_softmax(out, dim=-1)","def logistic_function(z):\n\tg = 1/(1+np.exp(-z))\n\t#g = np.exp(z)/(1+np.exp(z))\n\treturn g","def forward(self, x):\n hidden_states = self.transformer(x)\n logits = self.lm_head(hidden_states)\n\n return logits","def log_likelihood(self, theta, x, **kwargs):\n\n u, logdet_dudx, log_a = self.forward(theta, x, **kwargs)\n\n constant = float(-0.5 * self.n_inputs * np.log(2.0 * np.pi))\n # log_likelihood = torch.log(torch.sum(torch.exp(log_a - 0.5 * u ** 2 + logdet_dudx), dim=2))\n log_likelihood = torch.logsumexp(log_a - 0.5 * u**2 + logdet_dudx, dim=2)\n log_likelihood = constant + torch.sum(log_likelihood, dim=1)\n\n return u, log_likelihood","def predict_logit(self, x):\n with torch.no_grad():\n y_ = self.tr_model(x)\n return y_","def logistic_hypothesis(theta):\n return lambda X: sigmoid(np.dot(x_strich(X), theta))","def __call__(self, y, f):\n ll = self._loglike(y, f)\n return ll","def logistic(v: float) -> float:\n v = clip(v, -50, 50) # Improve numerical stability.\n return 1 / (1 + math.exp(-v))","def logistic_map(x, r=1):\n def _map(x):\n return r * x * (1 - x)\n output = _map(x)\n while True:\n yield output\n output = _map(output)","def forward_pass(self, x):\n self.x = x\n exp_x = np.exp(x)\n sum_x = np.sum(axis=1)\n return exp_x/sum_x","def _logprob_X(self, X, **kwargs):\n pass","def log_prior(x):\n logp = (-0.5 * x.pow(2) - torch.tensor(2 * math.pi).sqrt().log()).sum(dim=1)\n return logp","def predict(self, x):\n with torch.no_grad():\n y_ = F.softmax(self.predict_logit(x), dim = 1)\n return y_","def log_prob(self, x):\n z, log_det = self.backward_p(x)\n return self.prior.log_prob(z) + log_det","def my_loglike(theta, x, data, sigma):\n\n model = my_model(theta, x)\n\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)","def log_sum_exp(x):\n x_max = x.max()\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max","def logit_link(x):\n\n return 1 / (1 + math.exp(-0.05 * x))\n # return 1 / (1 + math.exp(-0.01 * x))","def logistic(weights, data, targets, hyperparameters):\n y = logistic_predict(weights, data)\n\n #####################################################################\n # TODO: #\n # Given weights and data, return the averaged loss over all data #\n # points, gradient of parameters, and the probabilities given by #\n # logistic regression. #\n #####################################################################\n f = None\n df = None\n\n f = evaluate(targets, y)[0]\n\n N = len(data)\n M = len(weights) - 1 \n temp = np.ones([N, M + 1])\n temp[: N, : M] = np.array(data)\n\n\n df = np.zeros([M+1, 1])\n\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n #####################################################################\n # END OF YOUR CODE #\n #####################################################################\n return f, df, y","def objective_function(self, x):\n self._set_params_transformed(x)\n return -self.log_likelihood() - self.log_prior()","def _call(self, x):\n if functional.prior is None:\n tmp = np.log(x)\n else:\n tmp = np.log(x / functional.prior)\n\n if np.all(np.isfinite(tmp)):\n return tmp\n else:\n # The derivative is not defined.\n raise ValueError('The gradient of the Kullback-Leibler '\n 'Cross Entropy functional is not defined '\n 'for `x` with one or more components '\n 'less than or equal to zero.'.format(x))","def log_likelihood_exp(self, x):\n predictions = self.get_predictions(x)\n ll = 0.\n for measurement in self.get_measurements:\n m_obj = flavio.Measurement[measurement]\n m_obs = m_obj.all_parameters\n exclude_observables = set(m_obs) - set(self.observables)\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\n ll += sum(prob_dict.values())\n return ll","def run_logistic(X_train, X_test, y_train, y_test, C=1, penalty = 'l2', solver = 'lbfgs'):\n \n logreg = LogisticRegression(fit_intercept=True, C=C, penalty = penalty, solver = solver)\n logreg.fit(X_train, y_train)\n get_scores(logreg, X_train, X_test, y_train, y_test)","def likelihood(mean, logs, x):\n return -0.5 * (logs * 2. + ((x - mean) ** 2) / np.exp(logs * 2.) + GaussianDiag.Log2PI)","def log_softmax(x: jnp.DeviceArray, *, axis: int = 0) -> jnp.DeviceArray:\n return x - jnp.expand_dims(jnp.log(jnp.sum(jnp.exp(x), axis=axis)), axis)","def log_sum_exp(x):\n x_max = x.data.max()\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max","def log_sum_exp(x):\n x_max = x.data.max()\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max","def logistic_loss(x, y):\n x = x.reshape((-1,))\n y = y.reshape((-1,))\n \n N, = x.shape\n \n y_p = np.where(y == 1,1,0)\n\n p = sigmoid(x)\n loss = -(y_p*np.log(p) + (1-y_p)*np.log(1-p))\n loss = np.sum(loss)/N\n\n dx = (1/N)*(p - y_p)\n \n return loss, dx","def forward(self, x, logits=True):\n assert not torch.isnan(x).any(), f\"NaN in input {x}\"\n x = F.relu(self.l1(x))\n x = F.relu(self.l2(x))\n x = self.l3(x)\n if not logits:\n x = torch.softmax(x, dim=1)\n return x","def logm(self, x):\n\n if K.backend() == 'theano':\n # construct theano tensor operation\n from theano.tensor.nlinalg import svd, diag\n from theano.tensor.elemwise import Elemwise\n from theano.scalar import log\n import theano.tensor as T\n # This implementation would be extremely slow. but efficient?\n u, d, v = svd(x)\n d += self.eps\n inner = diag(T.log(d))\n res = T.dot(u, T.dot(inner, v))\n return res\n else:\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\n return batch_matrix_log(x, self.eps)","def test_logistic():\n r=np.random.normal(size=20)\n assert np.isclose( ilogistic(logistic(r)),r ).all()","def logistic(weights, data, targets, hyperparameters):\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n df = np.reshape(df, ((len(df), 1)))\n\n return f, df, np.reshape(y, (len(y), 1))","def forward(self, x):\n (N,D) = x.shape\n #self.w = np.random.rand(1,D)\n w = self.w\n\n self.x = np.copy(x)\n b = self.b\n f = 1 / (1 + np.exp(-(np.dot(w, np.transpose(self.x)) + b)))\n return f\n\n #raise NotImplementedError","def logistic(x_0, max_value, midpoint, steepness):\n return max_value / (1 + math.exp(-(x_0 - midpoint) / steepness))","def log_likelihood(self, X, Y):\n\t\tr,c = twod(Y).shape\n\t\tif r == 1 and c != 1:\n\t\t\tY = twod(Y).T\n\n\t\tsoft = self.predict_soft(X)\n\t\treturn np.mean(np.sum(np.log(np.power(soft, Y, )), 1), 0)","def compute_logistic_loss(y, tx, w):\n pred = tx.dot(w)\n y = np.asarray(y)\n logsig = -np.logaddexp(0, -pred) # == np.log(sigmoid(pred))\n\n return np.mean((1 - y) * pred - logsig)","def _calculate_ll(self, x):\n observation_log_probs = self._observation_log_probs(x, mask=None)\n forward_log_probs = self._forward(observation_log_probs)\n log_likelihood = logsumexp(\n forward_log_probs[forward_log_probs.shape[0] - 1, :].numpy())\n return log_likelihood","def forward(self, x) -> Tuple[Tensor, Tensor]:\n x = F.relu(self.fc1(x.float()))\n a = F.log_softmax(self.actor_head(x), dim=-1)\n c = self.critic_head(x)\n return a, c","def eval(self, x, log=True):\n\n # compile theano function, if haven't already done so\n if self.eval_lprob_f is None:\n self.eval_lprob_f = theano.function(\n inputs=[self.input],\n outputs=self.L,\n givens=[(bn.m, bn.bm) for bn in self.bns] + [(bn.v, bn.bv) for bn in self.bns]\n )\n\n lprob = self.eval_lprob_f(x.astype(dtype))\n\n return lprob if log else np.exp(lprob)","def log_sum_exp(x, dim=0):\n max_x = torch.max(x, dim)[0]\n new_x = x - max_x.unsqueeze(dim).expand_as(x)\n return max_x + (new_x.exp().sum(dim)).log()","def forward(self, x):\n # action\n act = self.act_fc1(x)\n act = torch.tanh(act)\n act = self.act_fc2(act)\n act = torch.tanh(act)\n mean = self.mu(act) # N, num_actions\n logstd = self.logstd.expand_as(mean)\n std = torch.exp(logstd)\n action = torch.normal(mean, std)\n\n # value\n v = self.value_fc1(x)\n v = torch.tanh(v)\n v = self.value_fc2(v)\n v = torch.tanh(v)\n v = self.value_fc3(v)\n\n # action prob on log scale\n logprob = log_normal_density(action, mean, std=std, log_std=logstd)\n return v, action, logprob, mean","def forward(self, x):\n if self.train():\n # N(0,1)\n epsilon = Variable(torch.randn(x.size()))\n if x.is_cuda:\n epsilon = epsilon.cuda()\n \n # Clip alpha\n self.log_alpha.data = torch.clamp(self.log_alpha.data, max=self.max_alpha)\n alpha = self.log_alpha.exp()\n \n # N(1, alpha)\n epsilon = epsilon * alpha\n \n return x * epsilon\n else:\n return x","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def logistic_regression(y, tx, initial_w, max_iters, gamma, verbose=False):\n return gradient_descent(y, tx, initial_w, max_iters, gamma, \n compute_logistic_loss, compute_logistic_gradient, verbose=verbose)","def generalized_logistic(x, floor=0, capacity=1, C=1, y_intercept=None, Q=None, growth=1, v=1):\n A = floor\n K = capacity\n C = C\n B = growth\n if y_intercept is not None:\n if Q is not None:\n raise AssertionError('cannot specify Q and y_intercept')\n Q = -C + ((A - K) / (A - y_intercept)) ** v\n elif Q is None:\n Q = 1\n y = A + (K - A) / (C + Q * np.exp(-B * x)) ** (1 / v)\n return y","def probability(self, X_):\n X = np.c_[np.ones(X_.shape[0]), X_] # Add one for bias to the first columns\n probs = np.zeros(X.shape[0])\n ### YOUR CODE HERE\n z = X.dot(self.w)\n probs = log_reg.logistic(z)\n ### END CODE\n assert probs.shape == (X.shape[0],)\n return probs","def log_prob_from_logits(x):\n axis = len(x.get_shape()) - 1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))","def forward(self, x, mask):\n # Compute the parameters for the Bernoulli\n embeddings = self.compute_embedding(x)\n dist_params = self.predict_distribution(embeddings)\n dist_params = dist_params.squeeze() \n # Sample\n sampler = dist.Bernoulli(probs=dist_params)\n actions = sampler.sample()\n \n # Compute LogProba\n log_probas = sampler.log_prob(actions)\n log_probas = apply_mask(log_probas, mask)\n\n # Compute Entropy\n entropy = sampler.entropy()\n entropy = apply_mask(log_probas, mask)\n \n return actions, log_probas, entropy, dist_params","def predict(self, x, logits=False, batch_size=128):\n logger.info('Applying expectation over transformations.')\n prediction = self.classifier.predict(next(self.transformation())(x), logits, batch_size)\n for _ in range(self.sample_size-1):\n prediction += self.classifier.predict(next(self.transformation())(x), logits, batch_size)\n return prediction/self.sample_size","def forward(self, x):\n x = self.feature_extractor(x)\n batch_size, hidden = x.size()\n\n x = self.layer_1(x)\n x = torch.relu(x)\n x = self.layer_2(x)\n x = torch.relu(x)\n x = self.layer_3(x)\n\n x = torch.log_softmax(x, dim=1)\n return x","def logistic_predict(weights, data):\n\n # TODO: Finish this function\n\n return y","def log_prob(target_distribution, x0, xs, accepteds):\n return np.mean([target_distribution.log_probability(x) for x in xs])","def logit_cost(self, theta, X, y):\n\n cost = 0.0\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n \n for i in range(0, X.shape[0]):\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\n ### END YOUR CODE\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\n return cost","def normalize_log_likelihoods(X):\n h, w = np.shape(X)\n return X - np.tile(logsumexp(X, axis=0), (h, 1))\n # return X - np.matlib.repmat(logsumexp(X, axis=0), h, 1)","def L_fun(x):\n \n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\n action = sum_values(ad.get_deriv(f_x0))\n return action","def _loglike(self, y, f):\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\n - tf.lgamma(self.n - y + 1)\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\n return ll","def chaotic_logistic(self, data, weights, biases):\n\n state_weight_prods = np.dot(data, weights)\n # for x in np.nditer(state_weight_prods):\n # if x < -4:\n # x = 0\n # elif x < \n # return","def predict_probs(self, x):\n # Note start time\n start_time = time.time()\n\n # Insert a column of 1 in the vector X\n x = np.insert(x,0,1,axis=1)\n\n # Initiate array to store predictions\n predictions = []\n\n # Get the probability value of being in class 1 for each training example\n for _ in x: \n predictions.append(self.logistic_function(self.weights.dot(_)))\n\n # Note end time\n end_time = time.time()\n\n # Log Predict Runtime\n print(\"Logistic Regression predict time: {0:.2f}s\".format(end_time - start_time))\n\n return predictions","def log_prob_from_logits(x):\n axis = len(x.get_shape())-1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))","def forward(self, x):\n for layer in self.hidden_layers:\n x = F.relu(layer(x))\n x = self.dropout(x)\n x = self.output(x)\n\n return F.log_softmax(x, dim=1)","def decision_function(self, X):\n self._check_is_fitted()\n # X = _check_X(X, n_features=self.means_.shape[1]) TODO\n X = _check_X(X)\n if self.use_weights:\n ret = self._estimate_weighted_log_prob(X)\n else:\n ret = self._estimate_log_prob(X)\n return ret","def compute_logistic_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w)) - y) / len(y)","def _call(self, x):\n if functional.prior is None:\n return np.exp(x)\n else:\n return functional.prior * np.exp(x)","def test_train_logist(x_train_variable, y_train_dep):\n # Ensure the function works\n try:\n lrc = cls.train_logistic(x_train_variable, y_train_dep)\n logging.info(\"Successful Logistic Model\")\n except Exception as err:\n logging.error(\"Errors in Fitting the Logistic Regression\")\n raise err\n return lrc","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def sigmoid(self, x):\n self.x = x\n output = 1 / (1 + np.exp(-x))\n return output","def _call(self, x):\n if self.prior is None:\n tmp = ((x - 1 - np.log(x)).inner(self.domain.one()))\n else:\n # This is the old line from odl version 0.6.0.\n # tmp = ((x - self.prior + self.prior * np.log(self.prior / x))\n tmp = ((x - self.prior + self.prior * np.log((self.prior + 1e-12) / x))\n .inner(self.domain.one()))\n if np.isnan(tmp):\n # In this case, some element was less than or equal to zero\n return np.inf\n else:\n return tmp","def logit(x: torch.Tensor, eps=1e-5) -> torch.Tensor:\n x = torch.clamp(x, eps, 1.0 - eps)\n return torch.log(x / (1.0 - x))","def sigmoid(self, x):\r\n self.x = x\r\n return 1 / (1 + np.exp(-x))"],"string":"[\n \"def logistic(self,w,Xi):\\n # print(w.T)\\n # print(Xi)\\n a = np.dot(w.T,Xi)\\n return 1/(1+np.exp(-a))\",\n \"def logistic(self, X, w):\\n g = 1 / (1 + np.exp(-X.dot(w)))\\n return g\",\n \"def forward(self, x):\\n\\n embeds = self.dvector(x)\\n logits = self.linear(embeds)\\n\\n return logits\",\n \"def logistic(mu, hw, x): \\n n = np.exp(- ((x-mu)/(.477*hw))**2)\\n return (2. * n)/( 1 + n)\",\n \"def apply(cls, x):\\n return 1.0 / (1.0 + np.exp(-x))\",\n \"def logistic_predict(self, x: np.array) -> np.array:\\r\\n if self.LogisticModel is None:\\r\\n print('Logistic Model not trained, please run logistic_fit first!')\\r\\n return None\\r\\n else:\\r\\n return self.LogisticModel.predict(x)\",\n \"def forward(self, x):\\n return F.log_softmax(self.proj(x), dim=-1)\",\n \"def logistic(val):\\n return 1.0 / (1.0 + np.exp(-val))\",\n \"def logistic(x):\\n try:\\n denom = (1 + math.e ** -x)\\n except OverflowError:\\n return 0.0\\n return 1.0 / denom\",\n \"def get_output(self, X):\\n return logistic(X)\",\n \"def logistic_function(self, data, b0, b1):\\n return np.array([1/(1+exp(-1*b0+(-1*b1*x))) for x in data])\",\n \"def log_forward_computations(self, x: list): \\n n_x = len(x)\\n \\n # log_f_x initialized to -Inf because log(0) = -Inf\\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\\n \\n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\\n \\n for i in range(1,n_x):\\n for s in range(self.n_states):\\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \\n log_f_x[:,i-1]) + x_emission_scores[s, i]\\n\\n \\n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\\n \\n return log_f_x, log_likelihood\",\n \"def __logistic_prime(self, x):\\n \\n return self.__logistic(x)*(1.0-self.__logistic(x))\",\n \"def log_target(self, x):\\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)\",\n \"def logistic_function(self, real_value):\\n return 1/(1+np.exp(-real_value))\",\n \"def prob_logit(x):\\n try:\\n if len(x.shape) != 1:\\n raise ValueError(\\\"unexpected shape of input vector\\\\nexpected:\\\" + str(1) + \\\", actual: \\\" + str(len(x.shape)))\\n except ValueError as e:\\n print(e)\\n print()\\n raise\\n\\n x = 1.0 * np.exp(-x)\\n\\n probability = np.concatenate(\\n (\\n (x / (1.0 + x)).reshape(x.shape[0], 1),\\n (1.0 / (1.0 + x)).reshape(x.shape[0], 1)\\n ),\\n axis=1\\n )\\n\\n return probability\",\n \"def f(self, x):\\n error = log_likelihood_calc(x[1], x[0], self.data)\\n return error\",\n \"def log_likelihood(self, x):\\n return self.log_likelihood_exp(x) + self.log_prior_nuisance_parameters(x)\",\n \"def log_probability(self, X):\\n\\n\\t\\treturn self.__log_probability(X)\",\n \"def apply(self, y, a):\\n return np.sum(y*np.log(a) + (1 - y)*(np.log(1 - a)))\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x_flat = np.squeeze(x)\\n ex = np.exp(x_flat)\\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\\n dx = (-y+ex/(1+ex))/N\\n # dx = np.reshape(dx,(len(dx),1))\\n return loss, dx\",\n \"def logistic(weights, data, targets, hyperparameters):\\n\\n # TODO: Finish this function\\n\\n return f, df, y\",\n \"def logistic(mu):\\n mu4 = 4*mu\\n def f(x):\\n return mu4*x*(1.-x)\\n return f\",\n \"def run_logistic_regression(training, testing, feature_cols, outcome_col):\\n if 'intercept' not in training.columns:\\n training['intercept'] = 1\\n if 'intercept' not in testing.columns:\\n testing['intercept'] = 1\\n intercept_feature_cols = feature_cols + ['intercept']\\n logit = sm.Logit(training[outcome_col], training[intercept_feature_cols])\\n fitted_logit_model = logit.fit()\\n logit_diagnostics = get_diagnostics(testing[outcome_col], testing[intercept_feature_cols], fitted_logit_model, model_type = 'logit')\\n predicted_logit_probs = fitted_logit_model.predict(testing[intercept_feature_cols])\\n\\n return fitted_logit_model, logit_diagnostics, predicted_logit_probs\",\n \"def _log_posterior_x(self, X):\\r\\n LL = self.log_likelihood(X=X)\\r\\n LP = self._log_prior_x(X)\\r\\n return LL + LP\",\n \"def calculate_logistic(c, z, v, x):\\n a = (c / v) - 1 # Determines the y-intercept\\n b = 4 * (z / c) # Determines the aggressiveness/max slope of the curve at the inflection point\\n f = (c / (1 + a * (pow(e, -b * x)))) # Resultant logistic value\\n return f\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def logistic(weights, data, targets, hyperparameters):\\n # TODO: Finish this function\\n n_data = len(data)\\n dim_data = len(data[0])\\n\\n f = 0\\n y = logistic_predict(weights, data)\\n\\n data = mod_data(data)\\n\\n # dl/dw_j = SUM(x_ij * (t_i - (1 - sigmoid(z))))\\n df = np.dot(data.T, (1.0 * targets) - (1 - y))\\n\\n # to calculate f, we need to sum the negative log of all y iff target is 0 and (1-y) iff target is 1\\n f = -1.0 * np.dot(targets.T, np.log(1 - y)) - 1.0 * np.dot(1 - targets.T, np.log(y))\\n\\n # calculate P(C=0|x_i) for all x_i \\n return f[0,0], df, y\",\n \"def _log_posterior_x(self, X):\\n if self.marginalize:\\n LL = self.log_marginal_likelihood(X, self.W)\\n else:\\n LL = self.log_likelihood(X=X)\\n LP = self._log_prior_x(X)\\n return LL + LP\",\n \"def likelihood(self,x,params = None,**kwargs):\\n return np.exp(self.log_likelihood(x,params=params,**kwargs))\",\n \"def log_prob_from_logits(x):\\n axis = len(x.shape) - 1\\n m = x.max(dim=axis, keepdim=True)[0]\\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))\",\n \"def logp_logistic(X, alpha, lambda_, dtype):\\n\\n mu = tf.log(alpha)\\n return tf.subtract(tf.add(tf.subtract(tf.log(lambda_), tf.multiply(lambda_, X)), mu),\\n tf.multiply(tf.constant(2.0, dtype=dtype), tf.log(tf.add(tf.constant(1.0, dtype=dtype), tf.exp(\\n tf.add(tf.negative(tf.multiply(lambda_, X)), mu))))))\",\n \"def forward(self, x):\\n out = self.net(x)\\n out = self.avg(out)\\n out = out.view(out.size(0), -1)\\n out = self.fc1(out)\\n\\n return func.log_softmax(out, dim=-1)\",\n \"def logistic_function(z):\\n\\tg = 1/(1+np.exp(-z))\\n\\t#g = np.exp(z)/(1+np.exp(z))\\n\\treturn g\",\n \"def forward(self, x):\\n hidden_states = self.transformer(x)\\n logits = self.lm_head(hidden_states)\\n\\n return logits\",\n \"def log_likelihood(self, theta, x, **kwargs):\\n\\n u, logdet_dudx, log_a = self.forward(theta, x, **kwargs)\\n\\n constant = float(-0.5 * self.n_inputs * np.log(2.0 * np.pi))\\n # log_likelihood = torch.log(torch.sum(torch.exp(log_a - 0.5 * u ** 2 + logdet_dudx), dim=2))\\n log_likelihood = torch.logsumexp(log_a - 0.5 * u**2 + logdet_dudx, dim=2)\\n log_likelihood = constant + torch.sum(log_likelihood, dim=1)\\n\\n return u, log_likelihood\",\n \"def predict_logit(self, x):\\n with torch.no_grad():\\n y_ = self.tr_model(x)\\n return y_\",\n \"def logistic_hypothesis(theta):\\n return lambda X: sigmoid(np.dot(x_strich(X), theta))\",\n \"def __call__(self, y, f):\\n ll = self._loglike(y, f)\\n return ll\",\n \"def logistic(v: float) -> float:\\n v = clip(v, -50, 50) # Improve numerical stability.\\n return 1 / (1 + math.exp(-v))\",\n \"def logistic_map(x, r=1):\\n def _map(x):\\n return r * x * (1 - x)\\n output = _map(x)\\n while True:\\n yield output\\n output = _map(output)\",\n \"def forward_pass(self, x):\\n self.x = x\\n exp_x = np.exp(x)\\n sum_x = np.sum(axis=1)\\n return exp_x/sum_x\",\n \"def _logprob_X(self, X, **kwargs):\\n pass\",\n \"def log_prior(x):\\n logp = (-0.5 * x.pow(2) - torch.tensor(2 * math.pi).sqrt().log()).sum(dim=1)\\n return logp\",\n \"def predict(self, x):\\n with torch.no_grad():\\n y_ = F.softmax(self.predict_logit(x), dim = 1)\\n return y_\",\n \"def log_prob(self, x):\\n z, log_det = self.backward_p(x)\\n return self.prior.log_prob(z) + log_det\",\n \"def my_loglike(theta, x, data, sigma):\\n\\n model = my_model(theta, x)\\n\\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)\",\n \"def log_sum_exp(x):\\n x_max = x.max()\\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max\",\n \"def logit_link(x):\\n\\n return 1 / (1 + math.exp(-0.05 * x))\\n # return 1 / (1 + math.exp(-0.01 * x))\",\n \"def logistic(weights, data, targets, hyperparameters):\\n y = logistic_predict(weights, data)\\n\\n #####################################################################\\n # TODO: #\\n # Given weights and data, return the averaged loss over all data #\\n # points, gradient of parameters, and the probabilities given by #\\n # logistic regression. #\\n #####################################################################\\n f = None\\n df = None\\n\\n f = evaluate(targets, y)[0]\\n\\n N = len(data)\\n M = len(weights) - 1 \\n temp = np.ones([N, M + 1])\\n temp[: N, : M] = np.array(data)\\n\\n\\n df = np.zeros([M+1, 1])\\n\\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n #####################################################################\\n # END OF YOUR CODE #\\n #####################################################################\\n return f, df, y\",\n \"def objective_function(self, x):\\n self._set_params_transformed(x)\\n return -self.log_likelihood() - self.log_prior()\",\n \"def _call(self, x):\\n if functional.prior is None:\\n tmp = np.log(x)\\n else:\\n tmp = np.log(x / functional.prior)\\n\\n if np.all(np.isfinite(tmp)):\\n return tmp\\n else:\\n # The derivative is not defined.\\n raise ValueError('The gradient of the Kullback-Leibler '\\n 'Cross Entropy functional is not defined '\\n 'for `x` with one or more components '\\n 'less than or equal to zero.'.format(x))\",\n \"def log_likelihood_exp(self, x):\\n predictions = self.get_predictions(x)\\n ll = 0.\\n for measurement in self.get_measurements:\\n m_obj = flavio.Measurement[measurement]\\n m_obs = m_obj.all_parameters\\n exclude_observables = set(m_obs) - set(self.observables)\\n prob_dict = m_obj.get_logprobability_all(predictions, exclude_parameters=exclude_observables)\\n ll += sum(prob_dict.values())\\n return ll\",\n \"def run_logistic(X_train, X_test, y_train, y_test, C=1, penalty = 'l2', solver = 'lbfgs'):\\n \\n logreg = LogisticRegression(fit_intercept=True, C=C, penalty = penalty, solver = solver)\\n logreg.fit(X_train, y_train)\\n get_scores(logreg, X_train, X_test, y_train, y_test)\",\n \"def likelihood(mean, logs, x):\\n return -0.5 * (logs * 2. + ((x - mean) ** 2) / np.exp(logs * 2.) + GaussianDiag.Log2PI)\",\n \"def log_softmax(x: jnp.DeviceArray, *, axis: int = 0) -> jnp.DeviceArray:\\n return x - jnp.expand_dims(jnp.log(jnp.sum(jnp.exp(x), axis=axis)), axis)\",\n \"def log_sum_exp(x):\\n x_max = x.data.max()\\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max\",\n \"def log_sum_exp(x):\\n x_max = x.data.max()\\n return torch.log(torch.sum(torch.exp(x - x_max), 1, keepdim=True)) + x_max\",\n \"def logistic_loss(x, y):\\n x = x.reshape((-1,))\\n y = y.reshape((-1,))\\n \\n N, = x.shape\\n \\n y_p = np.where(y == 1,1,0)\\n\\n p = sigmoid(x)\\n loss = -(y_p*np.log(p) + (1-y_p)*np.log(1-p))\\n loss = np.sum(loss)/N\\n\\n dx = (1/N)*(p - y_p)\\n \\n return loss, dx\",\n \"def forward(self, x, logits=True):\\n assert not torch.isnan(x).any(), f\\\"NaN in input {x}\\\"\\n x = F.relu(self.l1(x))\\n x = F.relu(self.l2(x))\\n x = self.l3(x)\\n if not logits:\\n x = torch.softmax(x, dim=1)\\n return x\",\n \"def logm(self, x):\\n\\n if K.backend() == 'theano':\\n # construct theano tensor operation\\n from theano.tensor.nlinalg import svd, diag\\n from theano.tensor.elemwise import Elemwise\\n from theano.scalar import log\\n import theano.tensor as T\\n # This implementation would be extremely slow. but efficient?\\n u, d, v = svd(x)\\n d += self.eps\\n inner = diag(T.log(d))\\n res = T.dot(u, T.dot(inner, v))\\n return res\\n else:\\n from kyu.tensorflow.ops.svd_gradients import batch_matrix_log\\n return batch_matrix_log(x, self.eps)\",\n \"def test_logistic():\\n r=np.random.normal(size=20)\\n assert np.isclose( ilogistic(logistic(r)),r ).all()\",\n \"def logistic(weights, data, targets, hyperparameters):\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n df = np.reshape(df, ((len(df), 1)))\\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def forward(self, x):\\n (N,D) = x.shape\\n #self.w = np.random.rand(1,D)\\n w = self.w\\n\\n self.x = np.copy(x)\\n b = self.b\\n f = 1 / (1 + np.exp(-(np.dot(w, np.transpose(self.x)) + b)))\\n return f\\n\\n #raise NotImplementedError\",\n \"def logistic(x_0, max_value, midpoint, steepness):\\n return max_value / (1 + math.exp(-(x_0 - midpoint) / steepness))\",\n \"def log_likelihood(self, X, Y):\\n\\t\\tr,c = twod(Y).shape\\n\\t\\tif r == 1 and c != 1:\\n\\t\\t\\tY = twod(Y).T\\n\\n\\t\\tsoft = self.predict_soft(X)\\n\\t\\treturn np.mean(np.sum(np.log(np.power(soft, Y, )), 1), 0)\",\n \"def compute_logistic_loss(y, tx, w):\\n pred = tx.dot(w)\\n y = np.asarray(y)\\n logsig = -np.logaddexp(0, -pred) # == np.log(sigmoid(pred))\\n\\n return np.mean((1 - y) * pred - logsig)\",\n \"def _calculate_ll(self, x):\\n observation_log_probs = self._observation_log_probs(x, mask=None)\\n forward_log_probs = self._forward(observation_log_probs)\\n log_likelihood = logsumexp(\\n forward_log_probs[forward_log_probs.shape[0] - 1, :].numpy())\\n return log_likelihood\",\n \"def forward(self, x) -> Tuple[Tensor, Tensor]:\\n x = F.relu(self.fc1(x.float()))\\n a = F.log_softmax(self.actor_head(x), dim=-1)\\n c = self.critic_head(x)\\n return a, c\",\n \"def eval(self, x, log=True):\\n\\n # compile theano function, if haven't already done so\\n if self.eval_lprob_f is None:\\n self.eval_lprob_f = theano.function(\\n inputs=[self.input],\\n outputs=self.L,\\n givens=[(bn.m, bn.bm) for bn in self.bns] + [(bn.v, bn.bv) for bn in self.bns]\\n )\\n\\n lprob = self.eval_lprob_f(x.astype(dtype))\\n\\n return lprob if log else np.exp(lprob)\",\n \"def log_sum_exp(x, dim=0):\\n max_x = torch.max(x, dim)[0]\\n new_x = x - max_x.unsqueeze(dim).expand_as(x)\\n return max_x + (new_x.exp().sum(dim)).log()\",\n \"def forward(self, x):\\n # action\\n act = self.act_fc1(x)\\n act = torch.tanh(act)\\n act = self.act_fc2(act)\\n act = torch.tanh(act)\\n mean = self.mu(act) # N, num_actions\\n logstd = self.logstd.expand_as(mean)\\n std = torch.exp(logstd)\\n action = torch.normal(mean, std)\\n\\n # value\\n v = self.value_fc1(x)\\n v = torch.tanh(v)\\n v = self.value_fc2(v)\\n v = torch.tanh(v)\\n v = self.value_fc3(v)\\n\\n # action prob on log scale\\n logprob = log_normal_density(action, mean, std=std, log_std=logstd)\\n return v, action, logprob, mean\",\n \"def forward(self, x):\\n if self.train():\\n # N(0,1)\\n epsilon = Variable(torch.randn(x.size()))\\n if x.is_cuda:\\n epsilon = epsilon.cuda()\\n \\n # Clip alpha\\n self.log_alpha.data = torch.clamp(self.log_alpha.data, max=self.max_alpha)\\n alpha = self.log_alpha.exp()\\n \\n # N(1, alpha)\\n epsilon = epsilon * alpha\\n \\n return x * epsilon\\n else:\\n return x\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def logistic_regression(y, tx, initial_w, max_iters, gamma, verbose=False):\\n return gradient_descent(y, tx, initial_w, max_iters, gamma, \\n compute_logistic_loss, compute_logistic_gradient, verbose=verbose)\",\n \"def generalized_logistic(x, floor=0, capacity=1, C=1, y_intercept=None, Q=None, growth=1, v=1):\\n A = floor\\n K = capacity\\n C = C\\n B = growth\\n if y_intercept is not None:\\n if Q is not None:\\n raise AssertionError('cannot specify Q and y_intercept')\\n Q = -C + ((A - K) / (A - y_intercept)) ** v\\n elif Q is None:\\n Q = 1\\n y = A + (K - A) / (C + Q * np.exp(-B * x)) ** (1 / v)\\n return y\",\n \"def probability(self, X_):\\n X = np.c_[np.ones(X_.shape[0]), X_] # Add one for bias to the first columns\\n probs = np.zeros(X.shape[0])\\n ### YOUR CODE HERE\\n z = X.dot(self.w)\\n probs = log_reg.logistic(z)\\n ### END CODE\\n assert probs.shape == (X.shape[0],)\\n return probs\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape()) - 1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))\",\n \"def forward(self, x, mask):\\n # Compute the parameters for the Bernoulli\\n embeddings = self.compute_embedding(x)\\n dist_params = self.predict_distribution(embeddings)\\n dist_params = dist_params.squeeze() \\n # Sample\\n sampler = dist.Bernoulli(probs=dist_params)\\n actions = sampler.sample()\\n \\n # Compute LogProba\\n log_probas = sampler.log_prob(actions)\\n log_probas = apply_mask(log_probas, mask)\\n\\n # Compute Entropy\\n entropy = sampler.entropy()\\n entropy = apply_mask(log_probas, mask)\\n \\n return actions, log_probas, entropy, dist_params\",\n \"def predict(self, x, logits=False, batch_size=128):\\n logger.info('Applying expectation over transformations.')\\n prediction = self.classifier.predict(next(self.transformation())(x), logits, batch_size)\\n for _ in range(self.sample_size-1):\\n prediction += self.classifier.predict(next(self.transformation())(x), logits, batch_size)\\n return prediction/self.sample_size\",\n \"def forward(self, x):\\n x = self.feature_extractor(x)\\n batch_size, hidden = x.size()\\n\\n x = self.layer_1(x)\\n x = torch.relu(x)\\n x = self.layer_2(x)\\n x = torch.relu(x)\\n x = self.layer_3(x)\\n\\n x = torch.log_softmax(x, dim=1)\\n return x\",\n \"def logistic_predict(weights, data):\\n\\n # TODO: Finish this function\\n\\n return y\",\n \"def log_prob(target_distribution, x0, xs, accepteds):\\n return np.mean([target_distribution.log_probability(x) for x in xs])\",\n \"def logit_cost(self, theta, X, y):\\n\\n cost = 0.0\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n \\n for i in range(0, X.shape[0]):\\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\\n ### END YOUR CODE\\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\\n return cost\",\n \"def normalize_log_likelihoods(X):\\n h, w = np.shape(X)\\n return X - np.tile(logsumexp(X, axis=0), (h, 1))\\n # return X - np.matlib.repmat(logsumexp(X, axis=0), h, 1)\",\n \"def L_fun(x):\\n \\n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\\n action = sum_values(ad.get_deriv(f_x0))\\n return action\",\n \"def _loglike(self, y, f):\\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\\\\n - tf.lgamma(self.n - y + 1)\\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def chaotic_logistic(self, data, weights, biases):\\n\\n state_weight_prods = np.dot(data, weights)\\n # for x in np.nditer(state_weight_prods):\\n # if x < -4:\\n # x = 0\\n # elif x < \\n # return\",\n \"def predict_probs(self, x):\\n # Note start time\\n start_time = time.time()\\n\\n # Insert a column of 1 in the vector X\\n x = np.insert(x,0,1,axis=1)\\n\\n # Initiate array to store predictions\\n predictions = []\\n\\n # Get the probability value of being in class 1 for each training example\\n for _ in x: \\n predictions.append(self.logistic_function(self.weights.dot(_)))\\n\\n # Note end time\\n end_time = time.time()\\n\\n # Log Predict Runtime\\n print(\\\"Logistic Regression predict time: {0:.2f}s\\\".format(end_time - start_time))\\n\\n return predictions\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape())-1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))\",\n \"def forward(self, x):\\n for layer in self.hidden_layers:\\n x = F.relu(layer(x))\\n x = self.dropout(x)\\n x = self.output(x)\\n\\n return F.log_softmax(x, dim=1)\",\n \"def decision_function(self, X):\\n self._check_is_fitted()\\n # X = _check_X(X, n_features=self.means_.shape[1]) TODO\\n X = _check_X(X)\\n if self.use_weights:\\n ret = self._estimate_weighted_log_prob(X)\\n else:\\n ret = self._estimate_log_prob(X)\\n return ret\",\n \"def compute_logistic_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w)) - y) / len(y)\",\n \"def _call(self, x):\\n if functional.prior is None:\\n return np.exp(x)\\n else:\\n return functional.prior * np.exp(x)\",\n \"def test_train_logist(x_train_variable, y_train_dep):\\n # Ensure the function works\\n try:\\n lrc = cls.train_logistic(x_train_variable, y_train_dep)\\n logging.info(\\\"Successful Logistic Model\\\")\\n except Exception as err:\\n logging.error(\\\"Errors in Fitting the Logistic Regression\\\")\\n raise err\\n return lrc\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def sigmoid(self, x):\\n self.x = x\\n output = 1 / (1 + np.exp(-x))\\n return output\",\n \"def _call(self, x):\\n if self.prior is None:\\n tmp = ((x - 1 - np.log(x)).inner(self.domain.one()))\\n else:\\n # This is the old line from odl version 0.6.0.\\n # tmp = ((x - self.prior + self.prior * np.log(self.prior / x))\\n tmp = ((x - self.prior + self.prior * np.log((self.prior + 1e-12) / x))\\n .inner(self.domain.one()))\\n if np.isnan(tmp):\\n # In this case, some element was less than or equal to zero\\n return np.inf\\n else:\\n return tmp\",\n \"def logit(x: torch.Tensor, eps=1e-5) -> torch.Tensor:\\n x = torch.clamp(x, eps, 1.0 - eps)\\n return torch.log(x / (1.0 - x))\",\n \"def sigmoid(self, x):\\r\\n self.x = x\\r\\n return 1 / (1 + np.exp(-x))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7002704","0.6978957","0.6883872","0.68210745","0.6803985","0.6706345","0.66907454","0.6664395","0.6663363","0.66488755","0.664373","0.660833","0.6597647","0.6596353","0.6534404","0.64707106","0.64558506","0.64442515","0.64267933","0.6374905","0.6363094","0.6330866","0.6325426","0.6295384","0.62640357","0.62510604","0.624085","0.61845726","0.61786604","0.616505","0.61628073","0.6158248","0.6130904","0.6123011","0.6106705","0.60794395","0.60756564","0.60518694","0.60466146","0.6031954","0.6030787","0.60173553","0.601516","0.5991686","0.59900784","0.59845185","0.59717757","0.5961737","0.59599006","0.5953306","0.59475493","0.59411865","0.59330696","0.5927872","0.59250444","0.59242433","0.59123325","0.59123325","0.5896753","0.5894869","0.5891628","0.5882004","0.588139","0.5878317","0.58713883","0.5864988","0.586398","0.5856391","0.5847398","0.58229697","0.58185244","0.58062047","0.58044875","0.57910895","0.57910895","0.5789111","0.5788977","0.57850534","0.57830864","0.57797146","0.57721233","0.5765654","0.57634693","0.57631","0.57590044","0.57555234","0.57539815","0.5750549","0.57481295","0.57470614","0.5746061","0.572744","0.57256246","0.5719371","0.57152903","0.57141525","0.5714002","0.5707777","0.5701739","0.569958","0.56990945"],"string":"[\n \"0.7002704\",\n \"0.6978957\",\n \"0.6883872\",\n \"0.68210745\",\n \"0.6803985\",\n \"0.6706345\",\n \"0.66907454\",\n \"0.6664395\",\n \"0.6663363\",\n \"0.66488755\",\n \"0.664373\",\n \"0.660833\",\n \"0.6597647\",\n \"0.6596353\",\n \"0.6534404\",\n \"0.64707106\",\n \"0.64558506\",\n \"0.64442515\",\n \"0.64267933\",\n \"0.6374905\",\n \"0.6363094\",\n \"0.6330866\",\n \"0.6325426\",\n \"0.6295384\",\n \"0.62640357\",\n \"0.62510604\",\n \"0.624085\",\n \"0.61845726\",\n \"0.61786604\",\n \"0.616505\",\n \"0.61628073\",\n \"0.6158248\",\n \"0.6130904\",\n \"0.6123011\",\n \"0.6106705\",\n \"0.60794395\",\n \"0.60756564\",\n \"0.60518694\",\n \"0.60466146\",\n \"0.6031954\",\n \"0.6030787\",\n \"0.60173553\",\n \"0.601516\",\n \"0.5991686\",\n \"0.59900784\",\n \"0.59845185\",\n \"0.59717757\",\n \"0.5961737\",\n \"0.59599006\",\n \"0.5953306\",\n \"0.59475493\",\n \"0.59411865\",\n \"0.59330696\",\n \"0.5927872\",\n \"0.59250444\",\n \"0.59242433\",\n \"0.59123325\",\n \"0.59123325\",\n \"0.5896753\",\n \"0.5894869\",\n \"0.5891628\",\n \"0.5882004\",\n \"0.588139\",\n \"0.5878317\",\n \"0.58713883\",\n \"0.5864988\",\n \"0.586398\",\n \"0.5856391\",\n \"0.5847398\",\n \"0.58229697\",\n \"0.58185244\",\n \"0.58062047\",\n \"0.58044875\",\n \"0.57910895\",\n \"0.57910895\",\n \"0.5789111\",\n \"0.5788977\",\n \"0.57850534\",\n \"0.57830864\",\n \"0.57797146\",\n \"0.57721233\",\n \"0.5765654\",\n \"0.57634693\",\n \"0.57631\",\n \"0.57590044\",\n \"0.57555234\",\n \"0.57539815\",\n \"0.5750549\",\n \"0.57481295\",\n \"0.57470614\",\n \"0.5746061\",\n \"0.572744\",\n \"0.57256246\",\n \"0.5719371\",\n \"0.57152903\",\n \"0.57141525\",\n \"0.5714002\",\n \"0.5707777\",\n \"0.5701739\",\n \"0.569958\",\n \"0.56990945\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":90790,"cells":{"query":{"kind":"string","value":"Combines given list argument in a logistic equation and returns it as a function"},"document":{"kind":"string","value":"def logistic_hypothesis(theta):\n return lambda X: sigmoid(np.dot(x_strich(X), theta))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def logistic(mu):\n mu4 = 4*mu\n def f(x):\n return mu4*x*(1.-x)\n return f","def logistic_function(self, data, b0, b1):\n return np.array([1/(1+exp(-1*b0+(-1*b1*x))) for x in data])","def logistic_function(z):\n\tg = 1/(1+np.exp(-z))\n\t#g = np.exp(z)/(1+np.exp(z))\n\treturn g","def logistic(weights, data, targets, hyperparameters):\n\n # TODO: Finish this function\n\n return f, df, y","def logistic(val):\n return 1.0 / (1.0 + np.exp(-val))","def logistic(mu, hw, x): \n n = np.exp(- ((x-mu)/(.477*hw))**2)\n return (2. * n)/( 1 + n)","def __call__(self, y, f):\n ll = self._loglike(y, f)\n return ll","def logistic_function(self, real_value):\n return 1/(1+np.exp(-real_value))","def calculate_logistic(c, z, v, x):\n a = (c / v) - 1 # Determines the y-intercept\n b = 4 * (z / c) # Determines the aggressiveness/max slope of the curve at the inflection point\n f = (c / (1 + a * (pow(e, -b * x)))) # Resultant logistic value\n return f","def logistic(self, X, w):\n g = 1 / (1 + np.exp(-X.dot(w)))\n return g","def logistic(weights, data, targets, hyperparameters):\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n df = np.reshape(df, ((len(df), 1)))\n\n return f, df, np.reshape(y, (len(y), 1))","def logistic(self,w,Xi):\n # print(w.T)\n # print(Xi)\n a = np.dot(w.T,Xi)\n return 1/(1+np.exp(-a))","def func_exp(x, a, b, c):\n return a * np.exp(b * x) + c","def func(x, a, c, d):\n return a*np.exp(-c*x)+d","def logistic(weights, data, targets, hyperparameters):\n y = logistic_predict(weights, data)\n\n #####################################################################\n # TODO: #\n # Given weights and data, return the averaged loss over all data #\n # points, gradient of parameters, and the probabilities given by #\n # logistic regression. #\n #####################################################################\n f = None\n df = None\n\n f = evaluate(targets, y)[0]\n\n N = len(data)\n M = len(weights) - 1 \n temp = np.ones([N, M + 1])\n temp[: N, : M] = np.array(data)\n\n\n df = np.zeros([M+1, 1])\n\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n #####################################################################\n # END OF YOUR CODE #\n #####################################################################\n return f, df, y","def func(self, X, a, b):\n return a*np.exp(-b*X)","def generalized_logistic(x, floor=0, capacity=1, C=1, y_intercept=None, Q=None, growth=1, v=1):\n A = floor\n K = capacity\n C = C\n B = growth\n if y_intercept is not None:\n if Q is not None:\n raise AssertionError('cannot specify Q and y_intercept')\n Q = -C + ((A - K) / (A - y_intercept)) ** v\n elif Q is None:\n Q = 1\n y = A + (K - A) / (C + Q * np.exp(-B * x)) ** (1 / v)\n return y","def logistic(weights, data, targets, hyperparameters):\n # TODO: Finish this function\n n_data = len(data)\n dim_data = len(data[0])\n\n f = 0\n y = logistic_predict(weights, data)\n\n data = mod_data(data)\n\n # dl/dw_j = SUM(x_ij * (t_i - (1 - sigmoid(z))))\n df = np.dot(data.T, (1.0 * targets) - (1 - y))\n\n # to calculate f, we need to sum the negative log of all y iff target is 0 and (1-y) iff target is 1\n f = -1.0 * np.dot(targets.T, np.log(1 - y)) - 1.0 * np.dot(1 - targets.T, np.log(y))\n\n # calculate P(C=0|x_i) for all x_i \n return f[0,0], df, y","def _object_func_marginals_log(log_params, *args, **kwargs):\n return _object_func_marginals(numpy.exp(log_params), *args, **kwargs)","def call(self, inputs):\n # print(f'type(inputs)={type(inputs)}.')\n # Transform a, e, and R from log to linear\n a = self.get_a()\n e = self.get_e()\n inc = self.get_inc()\n Omega = self.get_Omega()\n omega = self.get_omega()\n f = self.get_f()\n R = self.get_R()\n return a, e, inc, Omega, omega, f, self.epoch, R","def _pairing_func(x, a, b, c, d, e, f):\n y = a * np.exp(-(b * x)**c) + d * np.exp(-(e * x)**f)\n\n return y","def get_output(self, X):\n return logistic(X)","def fn(x):\n\n # coefficients\n A = 728.0\n B = 0.317\n C = 0.486\n D = -8.99 * 1.6\n\n # function\n fx = - D / x**2 - A / B * math.exp(- x / B) + 6 * C / x**7\n\n return fx","def _pairing_func(x, a, b, c, d, e, f):\n y = a * np.exp(-((b * x) ** c)) + d * np.exp(-((e * x) ** f))\n\n return y","def log_forward_computations(self, x: list): \n n_x = len(x)\n \n # log_f_x initialized to -Inf because log(0) = -Inf\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\n \n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\n \n for i in range(1,n_x):\n for s in range(self.n_states):\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \n log_f_x[:,i-1]) + x_emission_scores[s, i]\n\n \n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\n \n return log_f_x, log_likelihood","def _loglike(self, y, f):\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\n - tf.lgamma(self.n - y + 1)\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\n return ll","def logistic_loss(x, y):\n N = x.shape[0]\n x_flat = np.squeeze(x)\n ex = np.exp(x_flat)\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\n dx = (-y+ex/(1+ex))/N\n # dx = np.reshape(dx,(len(dx),1))\n return loss, dx","def f(x):\n return math.exp(-x**2)/(1+x**2)+(2*math.cos(x)**2)/(1+(x-4)**2)","def my_fn(x):\n return 0.4*(0.5*(np.exp(x*4) - np.exp(-x*4)) - 8*x + 0.3*x**2 - 2*x**3 + 0.8)","def logistic_regression_vec(theta, trainX, trainY):\n # Add column of ones for bias\n trainX = np.hstack((np.ones((trainX.shape[0], 1)), trainX))\n h = sigmoid(np.inner(trainX, theta))\n # np.log(1-h) can lead to problems for h = 1.0\n h = np.where(h == 1.0, 1 - 1e-12, h)\n fval = -(trainY * np.log(h) + (1 - trainY) * np.log(1 - h)).sum()\n error = h - trainY\n # Negative gradient for a minimization, must be flattened for np.minimize\n grad = np.dot(trainX.T, error).flatten()\n return fval, grad","def evaluate(observations, model, states=None, log=False):\r\n N = model.N\r\n T = observations.shape[0]\r\n A = numpy.log(model.A)\r\n B = numpy.log(model.B)\r\n\r\n if states is None:\r\n alphas = forward_path(observations, numpy.log(model.pi), A, B, T, N)\r\n\r\n \"\"\" Termination \"\"\"\r\n result = add_logs(alphas[T-1, :])\r\n if log:\r\n return result\r\n else:\r\n return math.exp(result)\r\n\r\n else:\r\n result = 0\r\n for i in range(T):\r\n result += B[states[i], observations[i]]\r\n\r\n if log:\r\n return result\r\n else:\r\n return math.exp(result)","def logistic_derivative(errors):\n return [log_deriv(error) for error in errors]","def logistic(x):\n try:\n denom = (1 + math.e ** -x)\n except OverflowError:\n return 0.0\n return 1.0 / denom","def logits_or(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n f = -(x + y) / 2\n t = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -f)\n return t - f","def sum_log(*args):\n # if all(a == LOG_ZERO for a in args):\n # return LOG_ZERO\n a_max = np.max(args, 0)\n lsp = np.log(np.sum([np.exp(a - a_max) for a in args], 0))\n return a_max + lsp","def logistic(v: float) -> float:\n v = clip(v, -50, 50) # Improve numerical stability.\n return 1 / (1 + math.exp(-v))","def feature_mapped_logistic_regression(power, l):\n df = pd.read_csv('ex2data2.txt', names=['test1', 'test2', 'accepted'])\n x1 = np.array(df.test1)\n x2 = np.array(df.test2)\n y = general.get_y(df)\n\n X = feature_mapping(x1, x2, power, as_ndarray=True)\n theta = np.zeros(X.shape[1])\n\n res = opt.minimize(fun=regularized_cost,\n x0=theta,\n args=(X, y, l),\n method='TNC',\n jac=regularized_gradient)\n final_theta = res.x\n\n return final_theta","def logistic(self, data, weights, biases):\n\n state_weight_prods = np.dot(data, weights)\n print(-state_weight_prods - biases)\n activations = 1.0 / (1 + np.exp(-state_weight_prods - biases))\n plt.plot(state_weight_prods, activations)\n plt.show()\n return activations","def f(x):\n return -math.exp(x[0]**3/-3 + x[0] - x[1]**2)","def f(x):\n return -math.exp(x[0]**3/-3 + x[0] - x[1]**2)","def logistic_equation(conc,drugless_rate,ic50,hc=-0.6824968):\n \n # conc = conc/10**6\n f = drugless_rate/(1+np.exp((ic50-np.log10(conc))/hc))\n \n return f","def __call__(self, teff, age):\n return self.fcn(np.log10(teff), np.log10(age) + 6)","def _object_func_marginals_c_log(log_params, *args, **kwargs):\n\t return _object_func_marginals_c(numpy.exp(log_params), *args, **kwargs)","def logistic_pen(weights, data, targets, hyperparameters):\n\n # TODO: Finish this function\n\n return f, df, y","def statePosteriors(log_alpha, log_beta):\n return log_alpha + log_beta - logsumexp(log_alpha[-1,:])","def prop_func_form_params(param1,param2,*arg):\n return np.log(MH.simple_2D_Gauss(param1-param2,arg[0],arg[1]))","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def reg_logistic_regression(y, tx, lambdas, initial_w, max_iters, gamma):\n w = initial_w\n for iter in range(max_iters):\n # compute gradient\n grad = reg_logistic_grad(y, tx, w, lambdas)\n # update w\n w = w - gamma * grad\n loss = reg_logistic_loss(y, tx, w, lambdas)\n return w, loss","def F(x):\n return math.exp(-0.5 * (x ** 2))","def f(t,y):\n return (lam*y)","def constant_equation(funct):\n return funct + \"x\"","def fn(a, y):\n return np.sum(np.nan_to_num(-y*np.log(a)-(1-y)*np.log(1-a)))","def reverse_logit_transform(params, bounds):\n\n return np.array(\n [a + ((b-a)*np.exp(x) / (1 + np.exp(x))) for x, (a, b) in zip(params, bounds)])","def kentaDataTofLogRhoFit1():\n func = lambda lr: getTRollFunc(20.0, 0.0, 14.25 - 0.07, .25)(lr) \\\n + getTRollFunc(10.0, 0.01, 11.5, .25)(lr)\n return func","def logit_link(x):\n\n return 1 / (1 + math.exp(-0.05 * x))\n # return 1 / (1 + math.exp(-0.01 * x))","def apply(self, y, a):\n return np.sum(y*np.log(a) + (1 - y)*(np.log(1 - a)))","def __call__(self, params):\n # Construct model for given set of parameters\n mod = self.model(params)\n\n # Input into equation (11) from Anderson (1990)\n # But we want log-likelihood not negative log-likelihood (in MCMC)\n # and so we add the -1.0\n like = np.sum(np.log(mod) + (self.power / mod))\n return -1.0*like","def logp_logistic(X, alpha, lambda_, dtype):\n\n mu = tf.log(alpha)\n return tf.subtract(tf.add(tf.subtract(tf.log(lambda_), tf.multiply(lambda_, X)), mu),\n tf.multiply(tf.constant(2.0, dtype=dtype), tf.log(tf.add(tf.constant(1.0, dtype=dtype), tf.exp(\n tf.add(tf.negative(tf.multiply(lambda_, X)), mu))))))","def test_loglike(dlm,Cl,noise,beam):\n lmax = Cl.shape[0]\n tt_exp = -1./2 * np.real(np.vdot(dlm.T,hp.almxfl(dlm,1/(beam[:lmax]**2*Cl[:,1]+noise[:lmax]))))\n #plt.plot(Cl[:,1])\n tt_det = - 1./2 *(np.arange(1,lmax+1)*np.log((noise[:lmax]+Cl[:,1]*beam[:lmax]**2))).sum() \n tt_f = tt_exp + tt_det\n return tt_exp,tt_det,tt_f#,Cl[:,1]","def _loglike(self, y, f):\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\n return ll","def log_deriv(error):\n return logistic(error) * (1 - logistic(error))","def test_func(x, a, b, c, d):\n return a + b * x + c * x**2 + d * x**3","def exp_fun(self, xs, *args, **kwargs):\n raise NotImplementedError","def log(a):","def __call__(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\n return torch.log(1 + torch.exp(-y1 * y2))","def logsum_pair(logx, logy):\n if logx == logzero():\n return logy\n elif logx > logy:\n return logx + np.log1p(np.exp(logy-logx))\n else:\n return logy + np.log1p(np.exp(logx-logy))","def logit_transform(params, bounds):\n with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n ret_array = np.ma.array(\n [np.ma.log(np.true_divide((x - a), (b - x))) for x, (a, b) in zip(params, bounds)])\n ret_array.set_fill_value(0)\n return np.ma.filled(ret_array)","def funcv(x):\n f0 = x[0] ** 3.0 + x[1] + 3.0\n f1 = x[1] - 4.0 * x[0]\n return f0, f1","def f(x):\n return ((x[0] - 1) ** 2) + ((x[1] + 3) ** 2)","def eval(self, x, log=True):\n\n # compile theano function, if haven't already done so\n if self.eval_lprob_f is None:\n self.eval_lprob_f = theano.function(\n inputs=[self.input],\n outputs=self.L,\n givens=[(bn.m, bn.bm) for bn in self.bns] + [(bn.v, bn.bv) for bn in self.bns]\n )\n\n lprob = self.eval_lprob_f(x.astype(dtype))\n\n return lprob if log else np.exp(lprob)","def func(x, a, b, c):\r\n return a + (b * x) + (c * x * x)","def forward(log_emlik, log_startprob, log_transmat):\n \n alpha = np.zeros(np.shape(log_emlik))\n N=len(alpha)\n # recursiveAlpha(N-1, alpha, log_emlik, log_startprob, log_transmat)\n alpha[0][:] = log_startprob.T + log_emlik[0]\n\n for n in range(1,len(alpha)):\n for i in range(alpha.shape[1]):\n alpha[n, i] = logsumexp(alpha[n - 1] + log_transmat[:,i]) + log_emlik[n,i]\n return alpha, logsumexp(alpha[N-1])","def reg_logistic_regression(y, tx, lambda_, initial_w, max_iters, gamma, verbose=False): \n reg_loss, reg_grad = add_l2_reg(compute_logistic_loss, \n compute_logistic_gradient,\n lambda_)\n \n return gradient_descent(y, tx, initial_w, max_iters, gamma, reg_loss, reg_grad)","def forward(log_emlik, log_startprob, log_transmat):\n logPi=log_startprob[:-1]\n logB=log_emlik\n logA=log_transmat[:-1,:-1]\n alpha = np.zeros_like(logB)\n alpha[0]=logB[0]+logPi\n for i in range(1,logB.shape[0]):\n for j in range(logA.shape[0]):\n alpha[i][j]=logsumexp(alpha[i-1]+logA[:,j]+logB[i][j])\n return alpha","def my_loglike(theta, x, data, sigma):\n\n model = my_model(theta, x)\n\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)","def logarithm(requestContext, seriesList, base=10):\n results = []\n for series in seriesList:\n newValues = []\n for val in series:\n if val is None:\n newValues.append(None)\n elif val <= 0:\n newValues.append(None)\n else:\n newValues.append(math.log(val, base))\n newName = \"log(%s, %s)\" % (series.name, base)\n newSeries = TimeSeries(newName, series.start, series.end, series.step, newValues)\n newSeries.pathExpression = newName\n results.append(newSeries)\n return results","def f(x, a, d1, d2):\n A = 10*a\n D1 = 10*d1\n D2 = 10*d2\n y = e * (frequency) * (1e9) * ( np.exp(-np.exp(-A*x+D1)) + np.exp(-np.exp(-A*x+D2)) + N)\n return y","def _loglike(self, y, f):\n raise NotImplementedError('Abstract base class only.')","def evalfunc(c, flist, x):\n return sum([c[i] * flist[i](x) for i in range(len(flist))])","def gaus(x,A,B,C):\n return A * np.exp( -(x-B)**2 / (2*C**2))","def spark_LogisticRegression(*args, **kwargs): \n return LogisticRegression(*args, **kwargs)","def log(self): # just use base?\n return Factor().__build( VarSet(self.v) , np.log(self.t) )","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def TargetFunction(p,x,y):\n \n return p[0] + p[1]*x + p[2]*(x**2) + p[3]*y + p[4]*(y**2) + p[5]*x*y","def f(self, X):\n\n return (X[0])**3 - (X[1])**2 + 1","def logistic_pen(weights, data, targets, hyperparameters):\n\n wr = hyperparameters['weight_regularization']\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\n df = np.reshape(df, ((len(df), 1)))\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\n\n f += (weights[-1, 0] ** 2) * wr / 2\n df[-1] += weights[-1,0] * wr \n\n return f, df, np.reshape(y, (len(y), 1))","def cost_function(self, X, y, theta_list, bias):\n total_samples = len(y)\n loss = 0\n\n for i in range(total_samples):\n hypothesis = bias\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\n \n de = 1.0 + np.exp(-hypothesis)\n sigmoidhypothesis = 1.0/de\n\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\n\n return -1 * (loss/total_samples) #loss calculation","def cost_function(x, params, y, m):\n\n x_theta = np.matmul(x, params)\n hypothesis = vectorized_sigmoid_function(x_theta)\n\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)","def f(x):\n\treturn (sc.log(x**2+5)*sc.cos(0.8*x)+3.5*x)/(sc.e**(x/10))","def logsumexp(logv):\n res = logzero()\n for val in logv:\n res = logsum_pair(res, val)\n return res","def logit_cost(self, theta, X, y):\n\n cost = 0.0\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n \n for i in range(0, X.shape[0]):\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\n ### END YOUR CODE\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\n return cost","def sigmoid(X):\n if isinstance(X,(list,tuple)):\n X=np.array(X)\n return 1/(1+np.exp(-X))\n #return np.exp(X)/(1+np.exp(X))","def logits_and(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n t = (x + y) / 2\n f = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -t)\n return t - f","def addlogs(a,b):\n \n if a>b:\n return a + np.log(1+np.exp(b-a))\n else:\n return b + np.log(1+np.exp(a-b))","def get_est_exp_discount_function(self,params):\n params = params[0:5]\n df = pd.DataFrame(self.maturity.apply(lambda x: x ** i) for i in range(1, 6)).T\n df.columns = ['M1', 'M2', 'M3', 'M4', 'M5']\n return np.exp(df.dot(params))","def apply_log(a: tuple, func: Callable[[Any], Tuple[Any, Log]]) -> Tuple[Any, Log]:\n value, log = a\n new, entry = func(value)\n return new, log + entry","def kentaDataTofLogRhoFit2():\n func = lambda lr: getTRollFunc(25.0, 0.0, 14.1875 - 0.07, .3125)(lr) \\\n + getTRollFunc(5.0, 0.01, 11.5, .25)(lr)\n return func","def logistic_regression(y, tx, initial_w, max_iters, gamma):\n return least_squares_SGD(y, tx, initial_w, max_iters, gamma, loss_function=logistic_loss, gradient=logistic_grad)","def L_fun(x):\n \n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\n action = sum_values(ad.get_deriv(f_x0))\n return action"],"string":"[\n \"def logistic(mu):\\n mu4 = 4*mu\\n def f(x):\\n return mu4*x*(1.-x)\\n return f\",\n \"def logistic_function(self, data, b0, b1):\\n return np.array([1/(1+exp(-1*b0+(-1*b1*x))) for x in data])\",\n \"def logistic_function(z):\\n\\tg = 1/(1+np.exp(-z))\\n\\t#g = np.exp(z)/(1+np.exp(z))\\n\\treturn g\",\n \"def logistic(weights, data, targets, hyperparameters):\\n\\n # TODO: Finish this function\\n\\n return f, df, y\",\n \"def logistic(val):\\n return 1.0 / (1.0 + np.exp(-val))\",\n \"def logistic(mu, hw, x): \\n n = np.exp(- ((x-mu)/(.477*hw))**2)\\n return (2. * n)/( 1 + n)\",\n \"def __call__(self, y, f):\\n ll = self._loglike(y, f)\\n return ll\",\n \"def logistic_function(self, real_value):\\n return 1/(1+np.exp(-real_value))\",\n \"def calculate_logistic(c, z, v, x):\\n a = (c / v) - 1 # Determines the y-intercept\\n b = 4 * (z / c) # Determines the aggressiveness/max slope of the curve at the inflection point\\n f = (c / (1 + a * (pow(e, -b * x)))) # Resultant logistic value\\n return f\",\n \"def logistic(self, X, w):\\n g = 1 / (1 + np.exp(-X.dot(w)))\\n return g\",\n \"def logistic(weights, data, targets, hyperparameters):\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n df = np.reshape(df, ((len(df), 1)))\\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def logistic(self,w,Xi):\\n # print(w.T)\\n # print(Xi)\\n a = np.dot(w.T,Xi)\\n return 1/(1+np.exp(-a))\",\n \"def func_exp(x, a, b, c):\\n return a * np.exp(b * x) + c\",\n \"def func(x, a, c, d):\\n return a*np.exp(-c*x)+d\",\n \"def logistic(weights, data, targets, hyperparameters):\\n y = logistic_predict(weights, data)\\n\\n #####################################################################\\n # TODO: #\\n # Given weights and data, return the averaged loss over all data #\\n # points, gradient of parameters, and the probabilities given by #\\n # logistic regression. #\\n #####################################################################\\n f = None\\n df = None\\n\\n f = evaluate(targets, y)[0]\\n\\n N = len(data)\\n M = len(weights) - 1 \\n temp = np.ones([N, M + 1])\\n temp[: N, : M] = np.array(data)\\n\\n\\n df = np.zeros([M+1, 1])\\n\\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n #####################################################################\\n # END OF YOUR CODE #\\n #####################################################################\\n return f, df, y\",\n \"def func(self, X, a, b):\\n return a*np.exp(-b*X)\",\n \"def generalized_logistic(x, floor=0, capacity=1, C=1, y_intercept=None, Q=None, growth=1, v=1):\\n A = floor\\n K = capacity\\n C = C\\n B = growth\\n if y_intercept is not None:\\n if Q is not None:\\n raise AssertionError('cannot specify Q and y_intercept')\\n Q = -C + ((A - K) / (A - y_intercept)) ** v\\n elif Q is None:\\n Q = 1\\n y = A + (K - A) / (C + Q * np.exp(-B * x)) ** (1 / v)\\n return y\",\n \"def logistic(weights, data, targets, hyperparameters):\\n # TODO: Finish this function\\n n_data = len(data)\\n dim_data = len(data[0])\\n\\n f = 0\\n y = logistic_predict(weights, data)\\n\\n data = mod_data(data)\\n\\n # dl/dw_j = SUM(x_ij * (t_i - (1 - sigmoid(z))))\\n df = np.dot(data.T, (1.0 * targets) - (1 - y))\\n\\n # to calculate f, we need to sum the negative log of all y iff target is 0 and (1-y) iff target is 1\\n f = -1.0 * np.dot(targets.T, np.log(1 - y)) - 1.0 * np.dot(1 - targets.T, np.log(y))\\n\\n # calculate P(C=0|x_i) for all x_i \\n return f[0,0], df, y\",\n \"def _object_func_marginals_log(log_params, *args, **kwargs):\\n return _object_func_marginals(numpy.exp(log_params), *args, **kwargs)\",\n \"def call(self, inputs):\\n # print(f'type(inputs)={type(inputs)}.')\\n # Transform a, e, and R from log to linear\\n a = self.get_a()\\n e = self.get_e()\\n inc = self.get_inc()\\n Omega = self.get_Omega()\\n omega = self.get_omega()\\n f = self.get_f()\\n R = self.get_R()\\n return a, e, inc, Omega, omega, f, self.epoch, R\",\n \"def _pairing_func(x, a, b, c, d, e, f):\\n y = a * np.exp(-(b * x)**c) + d * np.exp(-(e * x)**f)\\n\\n return y\",\n \"def get_output(self, X):\\n return logistic(X)\",\n \"def fn(x):\\n\\n # coefficients\\n A = 728.0\\n B = 0.317\\n C = 0.486\\n D = -8.99 * 1.6\\n\\n # function\\n fx = - D / x**2 - A / B * math.exp(- x / B) + 6 * C / x**7\\n\\n return fx\",\n \"def _pairing_func(x, a, b, c, d, e, f):\\n y = a * np.exp(-((b * x) ** c)) + d * np.exp(-((e * x) ** f))\\n\\n return y\",\n \"def log_forward_computations(self, x: list): \\n n_x = len(x)\\n \\n # log_f_x initialized to -Inf because log(0) = -Inf\\n log_f_x = np.zeros((self.n_states, n_x)) + logzero()\\n x_emission_scores = np.array([self.scores['emission'][:, self.word_to_pos[w] if w in list(self.word_to_pos.keys()) else self.word_to_pos['UnknownWord']] for w in x]).T\\n \\n log_f_x[:,0] = x_emission_scores[:, 0] + self.scores['initial']\\n \\n for i in range(1,n_x):\\n for s in range(self.n_states):\\n log_f_x[s,i] = logsumexp(self.scores['transition'][s,:] + \\n log_f_x[:,i-1]) + x_emission_scores[s, i]\\n\\n \\n log_likelihood = logsumexp(self.scores['final'] + log_f_x[:,-1])\\n \\n return log_f_x, log_likelihood\",\n \"def _loglike(self, y, f):\\n bincoef = tf.lgamma(self.n + 1) - tf.lgamma(y + 1) \\\\\\n - tf.lgamma(self.n - y + 1)\\n ll = bincoef + y * tf.log(pos(f)) + (self.n - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x_flat = np.squeeze(x)\\n ex = np.exp(x_flat)\\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\\n dx = (-y+ex/(1+ex))/N\\n # dx = np.reshape(dx,(len(dx),1))\\n return loss, dx\",\n \"def f(x):\\n return math.exp(-x**2)/(1+x**2)+(2*math.cos(x)**2)/(1+(x-4)**2)\",\n \"def my_fn(x):\\n return 0.4*(0.5*(np.exp(x*4) - np.exp(-x*4)) - 8*x + 0.3*x**2 - 2*x**3 + 0.8)\",\n \"def logistic_regression_vec(theta, trainX, trainY):\\n # Add column of ones for bias\\n trainX = np.hstack((np.ones((trainX.shape[0], 1)), trainX))\\n h = sigmoid(np.inner(trainX, theta))\\n # np.log(1-h) can lead to problems for h = 1.0\\n h = np.where(h == 1.0, 1 - 1e-12, h)\\n fval = -(trainY * np.log(h) + (1 - trainY) * np.log(1 - h)).sum()\\n error = h - trainY\\n # Negative gradient for a minimization, must be flattened for np.minimize\\n grad = np.dot(trainX.T, error).flatten()\\n return fval, grad\",\n \"def evaluate(observations, model, states=None, log=False):\\r\\n N = model.N\\r\\n T = observations.shape[0]\\r\\n A = numpy.log(model.A)\\r\\n B = numpy.log(model.B)\\r\\n\\r\\n if states is None:\\r\\n alphas = forward_path(observations, numpy.log(model.pi), A, B, T, N)\\r\\n\\r\\n \\\"\\\"\\\" Termination \\\"\\\"\\\"\\r\\n result = add_logs(alphas[T-1, :])\\r\\n if log:\\r\\n return result\\r\\n else:\\r\\n return math.exp(result)\\r\\n\\r\\n else:\\r\\n result = 0\\r\\n for i in range(T):\\r\\n result += B[states[i], observations[i]]\\r\\n\\r\\n if log:\\r\\n return result\\r\\n else:\\r\\n return math.exp(result)\",\n \"def logistic_derivative(errors):\\n return [log_deriv(error) for error in errors]\",\n \"def logistic(x):\\n try:\\n denom = (1 + math.e ** -x)\\n except OverflowError:\\n return 0.0\\n return 1.0 / denom\",\n \"def logits_or(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\\n f = -(x + y) / 2\\n t = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -f)\\n return t - f\",\n \"def sum_log(*args):\\n # if all(a == LOG_ZERO for a in args):\\n # return LOG_ZERO\\n a_max = np.max(args, 0)\\n lsp = np.log(np.sum([np.exp(a - a_max) for a in args], 0))\\n return a_max + lsp\",\n \"def logistic(v: float) -> float:\\n v = clip(v, -50, 50) # Improve numerical stability.\\n return 1 / (1 + math.exp(-v))\",\n \"def feature_mapped_logistic_regression(power, l):\\n df = pd.read_csv('ex2data2.txt', names=['test1', 'test2', 'accepted'])\\n x1 = np.array(df.test1)\\n x2 = np.array(df.test2)\\n y = general.get_y(df)\\n\\n X = feature_mapping(x1, x2, power, as_ndarray=True)\\n theta = np.zeros(X.shape[1])\\n\\n res = opt.minimize(fun=regularized_cost,\\n x0=theta,\\n args=(X, y, l),\\n method='TNC',\\n jac=regularized_gradient)\\n final_theta = res.x\\n\\n return final_theta\",\n \"def logistic(self, data, weights, biases):\\n\\n state_weight_prods = np.dot(data, weights)\\n print(-state_weight_prods - biases)\\n activations = 1.0 / (1 + np.exp(-state_weight_prods - biases))\\n plt.plot(state_weight_prods, activations)\\n plt.show()\\n return activations\",\n \"def f(x):\\n return -math.exp(x[0]**3/-3 + x[0] - x[1]**2)\",\n \"def f(x):\\n return -math.exp(x[0]**3/-3 + x[0] - x[1]**2)\",\n \"def logistic_equation(conc,drugless_rate,ic50,hc=-0.6824968):\\n \\n # conc = conc/10**6\\n f = drugless_rate/(1+np.exp((ic50-np.log10(conc))/hc))\\n \\n return f\",\n \"def __call__(self, teff, age):\\n return self.fcn(np.log10(teff), np.log10(age) + 6)\",\n \"def _object_func_marginals_c_log(log_params, *args, **kwargs):\\n\\t return _object_func_marginals_c(numpy.exp(log_params), *args, **kwargs)\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n # TODO: Finish this function\\n\\n return f, df, y\",\n \"def statePosteriors(log_alpha, log_beta):\\n return log_alpha + log_beta - logsumexp(log_alpha[-1,:])\",\n \"def prop_func_form_params(param1,param2,*arg):\\n return np.log(MH.simple_2D_Gauss(param1-param2,arg[0],arg[1]))\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def reg_logistic_regression(y, tx, lambdas, initial_w, max_iters, gamma):\\n w = initial_w\\n for iter in range(max_iters):\\n # compute gradient\\n grad = reg_logistic_grad(y, tx, w, lambdas)\\n # update w\\n w = w - gamma * grad\\n loss = reg_logistic_loss(y, tx, w, lambdas)\\n return w, loss\",\n \"def F(x):\\n return math.exp(-0.5 * (x ** 2))\",\n \"def f(t,y):\\n return (lam*y)\",\n \"def constant_equation(funct):\\n return funct + \\\"x\\\"\",\n \"def fn(a, y):\\n return np.sum(np.nan_to_num(-y*np.log(a)-(1-y)*np.log(1-a)))\",\n \"def reverse_logit_transform(params, bounds):\\n\\n return np.array(\\n [a + ((b-a)*np.exp(x) / (1 + np.exp(x))) for x, (a, b) in zip(params, bounds)])\",\n \"def kentaDataTofLogRhoFit1():\\n func = lambda lr: getTRollFunc(20.0, 0.0, 14.25 - 0.07, .25)(lr) \\\\\\n + getTRollFunc(10.0, 0.01, 11.5, .25)(lr)\\n return func\",\n \"def logit_link(x):\\n\\n return 1 / (1 + math.exp(-0.05 * x))\\n # return 1 / (1 + math.exp(-0.01 * x))\",\n \"def apply(self, y, a):\\n return np.sum(y*np.log(a) + (1 - y)*(np.log(1 - a)))\",\n \"def __call__(self, params):\\n # Construct model for given set of parameters\\n mod = self.model(params)\\n\\n # Input into equation (11) from Anderson (1990)\\n # But we want log-likelihood not negative log-likelihood (in MCMC)\\n # and so we add the -1.0\\n like = np.sum(np.log(mod) + (self.power / mod))\\n return -1.0*like\",\n \"def logp_logistic(X, alpha, lambda_, dtype):\\n\\n mu = tf.log(alpha)\\n return tf.subtract(tf.add(tf.subtract(tf.log(lambda_), tf.multiply(lambda_, X)), mu),\\n tf.multiply(tf.constant(2.0, dtype=dtype), tf.log(tf.add(tf.constant(1.0, dtype=dtype), tf.exp(\\n tf.add(tf.negative(tf.multiply(lambda_, X)), mu))))))\",\n \"def test_loglike(dlm,Cl,noise,beam):\\n lmax = Cl.shape[0]\\n tt_exp = -1./2 * np.real(np.vdot(dlm.T,hp.almxfl(dlm,1/(beam[:lmax]**2*Cl[:,1]+noise[:lmax]))))\\n #plt.plot(Cl[:,1])\\n tt_det = - 1./2 *(np.arange(1,lmax+1)*np.log((noise[:lmax]+Cl[:,1]*beam[:lmax]**2))).sum() \\n tt_f = tt_exp + tt_det\\n return tt_exp,tt_det,tt_f#,Cl[:,1]\",\n \"def _loglike(self, y, f):\\n ll = y * tf.log(pos(f)) + (1 - y) * tf.log(pos(1 - f))\\n return ll\",\n \"def log_deriv(error):\\n return logistic(error) * (1 - logistic(error))\",\n \"def test_func(x, a, b, c, d):\\n return a + b * x + c * x**2 + d * x**3\",\n \"def exp_fun(self, xs, *args, **kwargs):\\n raise NotImplementedError\",\n \"def log(a):\",\n \"def __call__(self, y1: torch.Tensor, y2: torch.Tensor) -> torch.Tensor:\\n return torch.log(1 + torch.exp(-y1 * y2))\",\n \"def logsum_pair(logx, logy):\\n if logx == logzero():\\n return logy\\n elif logx > logy:\\n return logx + np.log1p(np.exp(logy-logx))\\n else:\\n return logy + np.log1p(np.exp(logx-logy))\",\n \"def logit_transform(params, bounds):\\n with np.errstate(divide=\\\"ignore\\\", invalid=\\\"ignore\\\"):\\n ret_array = np.ma.array(\\n [np.ma.log(np.true_divide((x - a), (b - x))) for x, (a, b) in zip(params, bounds)])\\n ret_array.set_fill_value(0)\\n return np.ma.filled(ret_array)\",\n \"def funcv(x):\\n f0 = x[0] ** 3.0 + x[1] + 3.0\\n f1 = x[1] - 4.0 * x[0]\\n return f0, f1\",\n \"def f(x):\\n return ((x[0] - 1) ** 2) + ((x[1] + 3) ** 2)\",\n \"def eval(self, x, log=True):\\n\\n # compile theano function, if haven't already done so\\n if self.eval_lprob_f is None:\\n self.eval_lprob_f = theano.function(\\n inputs=[self.input],\\n outputs=self.L,\\n givens=[(bn.m, bn.bm) for bn in self.bns] + [(bn.v, bn.bv) for bn in self.bns]\\n )\\n\\n lprob = self.eval_lprob_f(x.astype(dtype))\\n\\n return lprob if log else np.exp(lprob)\",\n \"def func(x, a, b, c):\\r\\n return a + (b * x) + (c * x * x)\",\n \"def forward(log_emlik, log_startprob, log_transmat):\\n \\n alpha = np.zeros(np.shape(log_emlik))\\n N=len(alpha)\\n # recursiveAlpha(N-1, alpha, log_emlik, log_startprob, log_transmat)\\n alpha[0][:] = log_startprob.T + log_emlik[0]\\n\\n for n in range(1,len(alpha)):\\n for i in range(alpha.shape[1]):\\n alpha[n, i] = logsumexp(alpha[n - 1] + log_transmat[:,i]) + log_emlik[n,i]\\n return alpha, logsumexp(alpha[N-1])\",\n \"def reg_logistic_regression(y, tx, lambda_, initial_w, max_iters, gamma, verbose=False): \\n reg_loss, reg_grad = add_l2_reg(compute_logistic_loss, \\n compute_logistic_gradient,\\n lambda_)\\n \\n return gradient_descent(y, tx, initial_w, max_iters, gamma, reg_loss, reg_grad)\",\n \"def forward(log_emlik, log_startprob, log_transmat):\\n logPi=log_startprob[:-1]\\n logB=log_emlik\\n logA=log_transmat[:-1,:-1]\\n alpha = np.zeros_like(logB)\\n alpha[0]=logB[0]+logPi\\n for i in range(1,logB.shape[0]):\\n for j in range(logA.shape[0]):\\n alpha[i][j]=logsumexp(alpha[i-1]+logA[:,j]+logB[i][j])\\n return alpha\",\n \"def my_loglike(theta, x, data, sigma):\\n\\n model = my_model(theta, x)\\n\\n return -0.5*len(x)*np.log(2*math.pi*sigma**2) - (0.5/sigma**2) * np.sum((data-model)**2)\",\n \"def logarithm(requestContext, seriesList, base=10):\\n results = []\\n for series in seriesList:\\n newValues = []\\n for val in series:\\n if val is None:\\n newValues.append(None)\\n elif val <= 0:\\n newValues.append(None)\\n else:\\n newValues.append(math.log(val, base))\\n newName = \\\"log(%s, %s)\\\" % (series.name, base)\\n newSeries = TimeSeries(newName, series.start, series.end, series.step, newValues)\\n newSeries.pathExpression = newName\\n results.append(newSeries)\\n return results\",\n \"def f(x, a, d1, d2):\\n A = 10*a\\n D1 = 10*d1\\n D2 = 10*d2\\n y = e * (frequency) * (1e9) * ( np.exp(-np.exp(-A*x+D1)) + np.exp(-np.exp(-A*x+D2)) + N)\\n return y\",\n \"def _loglike(self, y, f):\\n raise NotImplementedError('Abstract base class only.')\",\n \"def evalfunc(c, flist, x):\\n return sum([c[i] * flist[i](x) for i in range(len(flist))])\",\n \"def gaus(x,A,B,C):\\n return A * np.exp( -(x-B)**2 / (2*C**2))\",\n \"def spark_LogisticRegression(*args, **kwargs): \\n return LogisticRegression(*args, **kwargs)\",\n \"def log(self): # just use base?\\n return Factor().__build( VarSet(self.v) , np.log(self.t) )\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def TargetFunction(p,x,y):\\n \\n return p[0] + p[1]*x + p[2]*(x**2) + p[3]*y + p[4]*(y**2) + p[5]*x*y\",\n \"def f(self, X):\\n\\n return (X[0])**3 - (X[1])**2 + 1\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n wr = hyperparameters['weight_regularization']\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n\\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\\n df = np.reshape(df, ((len(df), 1)))\\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\\n\\n f += (weights[-1, 0] ** 2) * wr / 2\\n df[-1] += weights[-1,0] * wr \\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def cost_function(self, X, y, theta_list, bias):\\n total_samples = len(y)\\n loss = 0\\n\\n for i in range(total_samples):\\n hypothesis = bias\\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\\n \\n de = 1.0 + np.exp(-hypothesis)\\n sigmoidhypothesis = 1.0/de\\n\\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\\n\\n return -1 * (loss/total_samples) #loss calculation\",\n \"def cost_function(x, params, y, m):\\n\\n x_theta = np.matmul(x, params)\\n hypothesis = vectorized_sigmoid_function(x_theta)\\n\\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)\",\n \"def f(x):\\n\\treturn (sc.log(x**2+5)*sc.cos(0.8*x)+3.5*x)/(sc.e**(x/10))\",\n \"def logsumexp(logv):\\n res = logzero()\\n for val in logv:\\n res = logsum_pair(res, val)\\n return res\",\n \"def logit_cost(self, theta, X, y):\\n\\n cost = 0.0\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n \\n for i in range(0, X.shape[0]):\\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\\n ### END YOUR CODE\\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\\n return cost\",\n \"def sigmoid(X):\\n if isinstance(X,(list,tuple)):\\n X=np.array(X)\\n return 1/(1+np.exp(-X))\\n #return np.exp(X)/(1+np.exp(X))\",\n \"def logits_and(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\\n t = (x + y) / 2\\n f = logaddexp(logaddexp((x - y) / 2, (y - x) / 2), -t)\\n return t - f\",\n \"def addlogs(a,b):\\n \\n if a>b:\\n return a + np.log(1+np.exp(b-a))\\n else:\\n return b + np.log(1+np.exp(a-b))\",\n \"def get_est_exp_discount_function(self,params):\\n params = params[0:5]\\n df = pd.DataFrame(self.maturity.apply(lambda x: x ** i) for i in range(1, 6)).T\\n df.columns = ['M1', 'M2', 'M3', 'M4', 'M5']\\n return np.exp(df.dot(params))\",\n \"def apply_log(a: tuple, func: Callable[[Any], Tuple[Any, Log]]) -> Tuple[Any, Log]:\\n value, log = a\\n new, entry = func(value)\\n return new, log + entry\",\n \"def kentaDataTofLogRhoFit2():\\n func = lambda lr: getTRollFunc(25.0, 0.0, 14.1875 - 0.07, .3125)(lr) \\\\\\n + getTRollFunc(5.0, 0.01, 11.5, .25)(lr)\\n return func\",\n \"def logistic_regression(y, tx, initial_w, max_iters, gamma):\\n return least_squares_SGD(y, tx, initial_w, max_iters, gamma, loss_function=logistic_loss, gradient=logistic_grad)\",\n \"def L_fun(x):\\n \\n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\\n action = sum_values(ad.get_deriv(f_x0))\\n return action\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68958294","0.68420416","0.6600226","0.65383476","0.6343635","0.628913","0.624117","0.62409633","0.61989814","0.6157783","0.61215085","0.6084098","0.60748845","0.6012121","0.5917856","0.5874498","0.58656096","0.5851732","0.58011216","0.57765955","0.5769953","0.5750175","0.57448536","0.5743547","0.57270294","0.5717032","0.57129365","0.5703321","0.5687399","0.5685464","0.566657","0.56622493","0.5656278","0.56456965","0.5635612","0.5635589","0.5635015","0.5626677","0.5609299","0.5609299","0.5597713","0.5589926","0.5585471","0.55603194","0.55579364","0.554355","0.55348426","0.55241257","0.551844","0.5510601","0.54957837","0.54900455","0.5486378","0.5485616","0.5478558","0.5475303","0.5473597","0.54634786","0.5461587","0.54596525","0.5452351","0.5444643","0.5440563","0.54261315","0.54230464","0.54200065","0.5418681","0.5408299","0.5402358","0.5399761","0.5399023","0.5395695","0.5390253","0.53793466","0.5378899","0.5378619","0.5369217","0.5364797","0.53634125","0.5361204","0.53602797","0.5358128","0.5350596","0.5350596","0.5350341","0.5349098","0.53336734","0.5331106","0.5329221","0.5325707","0.53238213","0.5320769","0.5320417","0.5317153","0.531394","0.5313643","0.53118354","0.5299386","0.529936","0.5287819"],"string":"[\n \"0.68958294\",\n \"0.68420416\",\n \"0.6600226\",\n \"0.65383476\",\n \"0.6343635\",\n \"0.628913\",\n \"0.624117\",\n \"0.62409633\",\n \"0.61989814\",\n \"0.6157783\",\n \"0.61215085\",\n \"0.6084098\",\n \"0.60748845\",\n \"0.6012121\",\n \"0.5917856\",\n \"0.5874498\",\n \"0.58656096\",\n \"0.5851732\",\n \"0.58011216\",\n \"0.57765955\",\n \"0.5769953\",\n \"0.5750175\",\n \"0.57448536\",\n \"0.5743547\",\n \"0.57270294\",\n \"0.5717032\",\n \"0.57129365\",\n \"0.5703321\",\n \"0.5687399\",\n \"0.5685464\",\n \"0.566657\",\n \"0.56622493\",\n \"0.5656278\",\n \"0.56456965\",\n \"0.5635612\",\n \"0.5635589\",\n \"0.5635015\",\n \"0.5626677\",\n \"0.5609299\",\n \"0.5609299\",\n \"0.5597713\",\n \"0.5589926\",\n \"0.5585471\",\n \"0.55603194\",\n \"0.55579364\",\n \"0.554355\",\n \"0.55348426\",\n \"0.55241257\",\n \"0.551844\",\n \"0.5510601\",\n \"0.54957837\",\n \"0.54900455\",\n \"0.5486378\",\n \"0.5485616\",\n \"0.5478558\",\n \"0.5475303\",\n \"0.5473597\",\n \"0.54634786\",\n \"0.5461587\",\n \"0.54596525\",\n \"0.5452351\",\n \"0.5444643\",\n \"0.5440563\",\n \"0.54261315\",\n \"0.54230464\",\n \"0.54200065\",\n \"0.5418681\",\n \"0.5408299\",\n \"0.5402358\",\n \"0.5399761\",\n \"0.5399023\",\n \"0.5395695\",\n \"0.5390253\",\n \"0.53793466\",\n \"0.5378899\",\n \"0.5378619\",\n \"0.5369217\",\n \"0.5364797\",\n \"0.53634125\",\n \"0.5361204\",\n \"0.53602797\",\n \"0.5358128\",\n \"0.5350596\",\n \"0.5350596\",\n \"0.5350341\",\n \"0.5349098\",\n \"0.53336734\",\n \"0.5331106\",\n \"0.5329221\",\n \"0.5325707\",\n \"0.53238213\",\n \"0.5320769\",\n \"0.5320417\",\n \"0.5317153\",\n \"0.531394\",\n \"0.5313643\",\n \"0.53118354\",\n \"0.5299386\",\n \"0.529936\",\n \"0.5287819\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60247886"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":90791,"cells":{"query":{"kind":"string","value":"Implements crossentropy as a function costs(theta) on given traning data"},"document":{"kind":"string","value":"def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def cross_entropy(y_observed, p):\n\n pass","def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)","def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]","def cross_entropy(\n **kwargs\n) -> Callable:\n return categorical_crossentropy","def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))","def cross_entropy(y, y_hat):\n return -tf.math.log(\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\n )","def cross_entropy_cost(output_out, target_out):\r\n total = 0\r\n for target_node in range(len(target_out)): # For each target data set\r\n for output_node in range(len(output_out)): # For each output node\r\n total += target_out[target_node][output_node] - target_out[target_node][output_node] * np.log(output_out[output_node]) - \\\r\n (1 - target_out[target_node][output_node]) * np.log(1 - output_out[output_node])\r\n\r\n total = 1 / total\r\n return total","def cross_entropy(self):\n return self._cross_entropy_func","def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n return -torch.log2(probability_fn(args))","def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\n log_pred = ivy.log(pred)\n # noinspection PyUnresolvedReferences\n return -ivy.reduce_sum(log_pred * true, axis)","def cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -Y / Y_hat\n \n return cost, dY_hat","def cross_entropy(targets, predictions, epsilon=1e-12):\n\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n\n N = predictions.shape[0]\n\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\n\n return ce","def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def cross_entropy(self, yhat):\n n = len(self._y)\n c = 0.0\n for i in range(0, n):\n c += self._y[i] * log(\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\n\n return c","def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(predicted)\n x_n_offset = predicted - a\n\n exp_xn_offset = x_n_offset.exp()\n\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\n denominator = a + log_sum_exp_xn_offset\n log_softmax = log_e_x - denominator\n\n labels = to_one_hot(target, num_classes)\n prod = log_softmax*labels\n total = prod.sum()\n batch_size = tensor.Tensor(-batch_size)\n\n total = total / batch_size\n\n return total","def softmax_cross_entropy(y, label):\r\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\r\n return losses\r\n pass","def get_reconstruction_cost(self, updates, pre_sigmoid_nv):\r\n\r\n cross_entropy = T.mean(\r\n T.sum(self.input * T.log(T.nnet.sigmoid(pre_sigmoid_nv)) +\r\n (1 - self.input) * T.log(1 - T.nnet.sigmoid(pre_sigmoid_nv)),\r\n axis=1))\r\n\r\n return cross_entropy","def grad_softmax_cross_entropy_loss(logit, labels):\n return softmax(logit) - labels","def cross_entropy_loss(self, logits, labels):\n return F.cross_entropy(logits, labels)","def cross_entropy_loss():\n return nn.CrossEntropyLoss()","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def cost(self, X=None, y=None, theta=None):\n X = self.X_train if X is None else X\n y = self.y_train if y is None else y\n m = X.shape[1]\n\n prob_mat = self.softmax_mat(X, theta)\n cost = -(y * np.log(prob_mat)).sum() / m\n return cost","def get_reconstruction_cost(self, nv):\n cross_entropy = T.mean(\n T.sum(\n self.input * T.log(nv) +\n (1 - self.input) * T.log(1 - nv),\n axis=1\n )\n )\n return cross_entropy","def my_softmax_cross_entropy(preds, labels):\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\n return tf.reduce_mean(loss)","def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def soft_cross_entropy(input, targets):\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\n return (- targets_prob * student_likelihood).sum(dim=-1).mean()","def get_reconstruction_cost(self, pre_sigmoid_nv):\n y = self.input\n a = T.nnet.sigmoid(pre_sigmoid_nv)\n\n cross_entropy = -T.mean(\n T.sum(y * T.log(a) + (1 - y) * T.log(1 - a), axis=1)\n )\n\n return cross_entropy","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def cross_entropy_cost(m, A, L):\n\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\n\n\n\t# Sanity checks\n\tcost = np.squeeze(cost) \t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\n\tassert(cost.shape == ()) \t#checks if cost value is a scalar\n\n\treturn cost","def binary_crossentropy(predictions, targets):\n return theano.tensor.nnet.binary_crossentropy(predictions, targets)","def delta_cross_entropy_softmax(outputs, labels):\n \n m = labels.shape[0]\n grad = outputs\n \n grad[range(m),labels] -= torch.tensor(1.)\n\n grad = grad/m\n avg_grads = grad\n return avg_grads","def cross_entropy(X, y, using_onehot=True):\n\tM = y.shape[0]\n\tif using_onehot :\n\t\tlog_likelihood = -np.log(np.max(X * y, -1))\n\telse:\n\t\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\n\tloss = np.sum(log_likelihood) / M\n\treturn loss","def binary_crossentropy(output, target):\r\n return -(target * tensor.log(output) + (1.0 - target) * tensor.log(1.0 - output))","def cross_entropy_gradient(self, yhat):\n n = len(self._y)\n p = len(self.beta)\n g = np.zeros(p)\n for i in range(0, n):\n g = g + (self._y[i] - yhat[i]) * np.array(\n [1.0, *self._feat_mtx[i, :]])\n\n return g","def get_cross_entropy(self):\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\n potential = 0.0\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\n return potential","def cross_entropy_fn(fc8, ground_truth_input):\n with tf.name_scope('cross_entropy') as scope:\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=fc8, labels=ground_truth_input)\n cross_entropy_mean = tf.reduce_mean(cross_entropy)\n\n tf.summary.scalar(scope + '/loss', cross_entropy_mean)\n\n return cross_entropy_mean","def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\n norm_log = log_softmax(input, 1)\n\n np_one_hot = np.eye(input.shape[1])[target.data]\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\n\n mask = -norm_log * tensor_one_hot\n mask_sum = sum(mask, 1)\n loss = sum(mask_sum, 0)\n\n return loss / input.shape[0]","def loss(logits, labels):\n labels = tf.to_int64(labels)\n# labels = tf.to_float(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\n# y_conv = tf.nn.softmax(logits)\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def loss_fn(y_true,y_pred): \n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\n y_pred,\n axis=-1,\n )\n loss = tf.reduce_mean(loss,name=\"loss\")\n return loss","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def binary_cross_entropy(y_true, y_preds):\n return np.sum(y_true * np.log(y_preds) + (1 - y_true) * np.log(1 - y_preds))","def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\n y_pred = tf.cast(y_pred, 'float64')\n y_true = tf.cast(y_true, 'float64')\n # deduce weights based on true pixel value\n class_weights = weights * y_true\n # compute your (unweighted) softmax cross entropy loss\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\n ##print(unweighted_losses.dtype, weights.dtype)\n weighted_losses = unweighted_losses * class_weights\n # reduce the result to get your final loss\n loss = -tf.reduce_sum(weighted_losses)\n return loss","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def crossentropy_loss(y_true, y_pred):\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \n return ce","def cross_entropy_loss(outputs, labels): \n# works properly\n \n m = labels.shape[0]\n p = outputs\n log_likelihood = -1*torch.log(p[range(m),labels])\n loss = torch.sum(log_likelihood) / m\n return loss.item()","def test_cross_entropy(self):\n loss = losses.cross_entropy_with_logits(\n logits=self.logits, targets=self.targets)\n kl = loss.mean()\n\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\n\n self.assertAlmostEqual(kl, expected_loss)","def sparse_cross_entropy(true, pred, axis=-1, epsilon=1e-7):\n true = ivy.one_hot(true, pred.shape[axis])\n return cross_entropy(true, pred, axis, epsilon)","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n # Tip: You can implement XELoss all here, without creating a new subclass of Function.\n # However, if you'd prefer to implement a Function subclass you're free to.\n # Just be sure that nn.loss.CrossEntropyLoss calls it properly.\n\n # Tip 2: Remember to divide the loss by batch_size; this is equivalent\n # to reduction='mean' in PyTorch's nn.CrossEntropyLoss\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(predicted)\n x_n_offset = predicted - a\n\n exp_xn_offset = x_n_offset.exp()\n\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\n denominator = a + log_sum_exp_xn_offset\n log_softmax = log_e_x - denominator\n\n labels = to_one_hot(target, num_classes)\n prod = log_softmax*labels\n total = prod.sum()\n batch_size = tensor.Tensor(-batch_size)\n\n total = total / batch_size\n\n return total","def categorical_crossentropy(predictions, targets):\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)","def categorical_crossentropy(predictions, targets):\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)","def compute_cost(Z6, Y):\n\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\n\n return cost","def logit_cost(self, theta, X, y):\n\n cost = 0.0\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n \n for i in range(0, X.shape[0]):\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\n ### END YOUR CODE\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\n return cost","def loss_function(self, targets, outputs):\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\n return tf.reduce_mean(cross_entropy)","def costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def cost(self, logits, labels, weights):\n return tf.multiply(\n tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels),\n weights)","def _Apply(self, c, p):\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\n entropy = tf.reduce_mean(entropy)\n return entropy","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def cross_entropy_loss(self, y, y_hat):\n if y.ndim == 1:\n batch_size = 1\n else:\n batch_size = y.shape[0]\n delta = 1e-7\n return -np.sum(y * np.log(y_hat + delta)) / batch_size","def cross_entropy_loss(predictions, targets, epsilon=1e-12):\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n N = predictions.shape[0]\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\n return ce","def compute_cross_entropy(probs, target):\n avg_probs_per_sample = probs.mean(\n -1)\n xe = torch.nn.CrossEntropyLoss(reduction='none')\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()","def forward_train(self, preds_T: torch.Tensor) -> torch.Tensor:\n fake_label = preds_T.data.max(1)[1]\n return F.cross_entropy(preds_T, fake_label)","def ovo_crossentropy_loss(y_true, y_pred):\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\n y_true_scaled = (y_true + 1.0) / 2.0\n y_pred_scaled = (y_pred + 1.0) / 2.0\n\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\n\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\n\n # J_{OvO} aus Pawara et al. anwenden\n log_function = tf.log if tf.__version__ == \"1.13.1\" else tf.math.log # flexibel für neue / alte Version\n loss = - tf.reduce_mean(\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\n return loss","def nll(y_true, y_pred):\n return K.sum(K.binary_crossentropy(y_true, y_pred), axis=-1)","def cross_entropy3(input, target, weight):\n loss = 0\n batch_size = target.data.shape[1]\n target = target.max(2)[1]\n input = input.transpose(0, 1)\n target = target.transpose(0, 1)\n weight = weight.transpose(0, 1)\n for i in range(batch_size):\n partial_loss = F.cross_entropy(input[i], target[i], size_average=False, reduce=False)\n partial_loss = torch.mul(partial_loss, weight[i])\n loss = loss + torch.sum(partial_loss)\n return loss / batch_size","def cross_entropy(input1, target, size_average=True):\n logsoftmax = nn.LogSoftmax(dim=0)\n return torch.sum(-target * logsoftmax(input1))\n # if size_average:\n # return torch.mean(torch.sum(-target * logsoftmax(input), dim=1))\n # else:\n # return torch.sum(torch.sum(-target * logsoftmax(input), dim=1))","def crossEntropy(obs, actual, offset=1e-7):\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\n # bound by clipping to avoid nan\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\n return -tf.reduce_sum(actual * tf.log(obs_) +\n (1 - actual) * tf.log(1 - obs_), 1)","def mean_cross_entropy_costs(X, y, lambda_reg=0.0):\n return lambda theta: np.mean(cross_entropy(X, y)(theta)) + L2_regularization_cost(\n X, theta, lambda_reg\n )","def loss_fn(outputs, labels):\n return nn.CrossEntropyLoss()(outputs, labels)","def sigmoid_cross_entropy(x, t, use_cudnn=True, normalize=True):\n return SigmoidCrossEntropy(use_cudnn, normalize)(x, t)","def binary_crossentropy(predictions, targets):\n predictions, targets = align_targets(predictions, targets)\n return theano.tensor.nnet.binary_crossentropy(predictions, targets)","def cost(TH,X,Y,lda=1):\n m = X.shape[0]\n htx = ff(X,TH)[-1]\n\n termsum = 0\n for rn in range(m):\n termsum += (-1.*Y[rn,:])*(np.log(htx[rn,:]).T) -(1. -Y[rn,:])*(np.log(1. -htx[rn,:]).T)\n termsum = 1./m*(termsum)\n\n regsum = 0\n for th in TH:\n regsum += sum(sum(np.power(th[:,1:],2)))\n regsum = lda/(2.*m)*regsum\n\n return termsum[0,0] +regsum","def test_asymptotic_32():\r\n\r\n #TODO: consider adding the optimization of crossentropy into the current\r\n # mode for the purpose of running this test\r\n\r\n for dtype in 'float32', 'float64':\r\n if dtype == 'float32':\r\n x = tensor.fmatrix()\r\n x2 = tensor.fvector()\r\n else:\r\n x = tensor.dmatrix()\r\n x2 = tensor.dvector()\r\n y = tensor.lvector()\r\n\r\n c = categorical_crossentropy(softmax(x + x2), y)\r\n f = theano.function([x, y, x2], [c.sum(),\r\n tensor.grad(c.sum(), x)], mode='FAST_RUN')\r\n if 0:\r\n for i, n in enumerate(f.maker.fgraph.toposort()):\r\n print i, n\r\n\r\n xval = numpy.zeros((5, 5), dtype=dtype).astype(dtype)\r\n x2val = numpy.zeros(5, dtype=xval.dtype).astype(dtype)\r\n for i in xrange(100):\r\n cval, gxval = f(xval, numpy.arange(5), x2val)\r\n xval -= 100.3 * gxval\r\n #print cval, gxval\r\n assert cval == 0 # no problem going to zero error\r\n\r\n #what about when x gets really big?\r\n\r\n xval = numpy.zeros((5, 5), dtype=dtype)\r\n x2val = numpy.zeros(5, dtype=xval.dtype)\r\n for i in xrange(100):\r\n\r\n cval, gxval = f(xval, numpy.arange(5), x2val)\r\n xval += 100000.3 * gxval\r\n #print cval, gxval\r\n\r\n assert cval > 61750000\r\n assert gxval[0, 0] == -1.0\r\n assert gxval[0, 1] == 0.25","def classification_loss(self, logit, target):\n return F.cross_entropy(logit, target)","def cross_entropy(p, q, base=2):\n q = ma.array(q, mask=(q == 0))\n return - np.vdot(p, ma.log(q)) / np.log(base)","def cross_entropoy_loss_naive(W, X, y, reg):\n # pylint: disable=too-many-locals\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n \n\n C = W.shape[1]\n# print(\"no. of classes {}\".format(C))\n N,D = X.shape\n# print(\"no. of data {} and dimension {}\".format(N,D))\n for i in range(N):\n xi = X[i,:]\n# print(\"one record shape: {}\".format(xi.shape))\n scores = np.zeros(C)\n for c in range(C):\n w = W[:,c]\n# print(\"weight for one record {}\".format(w.shape))\n scores[c] = xi.dot(w)\n scores -= np.max(scores)\n actual_y = y[i]\n total_score = np.sum(np.exp(scores)) \n loss_i = -scores[actual_y] + np.log(total_score)\n# print('naive score : {}'.format(scores[actual_y]))\n loss += loss_i\n \n #gradient\n probability = np.exp(scores)/total_score\n for j in range(C):\n dW[:,j] += probability[j]*xi\n \n dW[:,actual_y] -= xi\n loss = loss/N\n reg_loss = 0.5*reg*np.sum(W*W)\n loss = loss + reg_loss\n print(\"loss : {}\".format(loss))\n dW = dW/N\n dW += reg*W\n \n \n \n \n\n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def cross_entropoy_loss_vectorized(W, X, y, reg): \n loss = 0 \n dW = np.zeros_like(W)\n N, D = X.shape \n \n \n scores = X.dot(W) # [K, N]\n # for numerical stability)\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[range(N),y] \n scores_exp_sum = np.sum(scores_exp, axis=1) \n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= N\n loss += 0.5 * reg * np.sum(W * W)\n\n scores_exp_normalized = scores_exp.T / scores_exp_sum \n scores_exp_normalized[y, range(N)] -= 1 \n dW = np.dot(scores_exp_normalized,X)\n dW = dW.T\n dW /= N \n dW += reg * W\n \n \n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def softmax_cross_entropy_loss(logit, labels):\n p = softmax(logit)\n loss_i = - labels * np.log(p + 1e-8)\n return np.mean(loss_i)","def cross_entropy(m_true, alpha, alpha0, m_probs, lambd=1.0):\n\n loss = tf.reduce_sum(input_tensor=m_true * (tf.math.digamma(alpha0) - tf.math.digamma(alpha)), axis=1, keepdims=True)\n loss = tf.reduce_mean(input_tensor=loss)\n if lambd > 0:\n kl = kullback_leibler_dirichlet(m_true, alpha)\n loss = loss + lambd * kl\n return loss","def test_softmax_cross_entropy(self):\n loss_op = listwise_losses.SoftmaxCrossEntropy()\n\n y_pred = loss_op.final_activation_op({\n \"logits\": self.logits,\n \"metadata\": {\n \"mask\": self.mask\n }\n })\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\n\n loss = loss_op({\"mask\": self.mask}, self.y_true, y_pred)\n assert np.isclose(loss, 1.306335, atol=1e-5)","def cross_entropy(self, sents):\n return (-1) * self.log_prob(sents) / len(self._count)","def SoftEntropy_sequence(nn_last_layer, correct_label, learning_rate): \n \n loss = tf2.math.reduce_sum( tf2.nn.softmax_cross_entropy_with_logits(tf2.stop_gradient(correct_label[:,12:38,:]), nn_last_layer[:,12:38,:]))\n \n #obtain training operation\n optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate, epsilon = 1e-8) #Note default value of epsilon 1e-8 results in instability after few epochs\n \n #clip the gradients\n gvs = optimizer.compute_gradients(loss)\n #capped_gvs = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gvs]\n training_operation = optimizer.apply_gradients(gvs)\n\n return training_operation, loss","def compute_cost(A2, Y, parameters):\n\n\tm = Y.shape[1] # number of example\n\n\t# Compute the cross-entropy cost\n\tlogprobs = np.multiply(np.log(A2), Y)\n\tcost = -(1/m)*(np.sum((logprobs) + np.multiply(np.log(1-A2), 1-Y)))\n\n\tcost = np.squeeze(cost) # makes sure cost is the dimension we expect. \n\t \t# E.g., turns [[17]] into 17 \n\tassert(isinstance(cost, float))\n\n\treturn cost","def softmax_cross_entropy(logit, onehot, axis=-1):\n return SoftmaxCrossEntropy(axis).forward(logit, onehot)","def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\n if type(y_pred) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_pred)))\n if type(y_true) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_true)))\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\n # y_pred = clip(y_pred)\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\n loss = -1 * np.sum(l).item()\n if normalize:\n loss = loss / len(y_pred)\n return loss","def costFunction(theta,X,y):\n m = X.shape[0]\n J = 0\n h = sigmoid (np.dot(X,theta))\n \n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\n \n #grad = (1/m) * np.dot(X.T,(h-y))\n grad = (1/m) * np.dot((h.T - y), X).T\n \n return J, grad","def crossEntropy(p_m1):\n p_m2 = 1 - p_m1\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\n return D","def loss(logits, targets):\n targets = tf.to_int64(targets)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=targets, logits=logits, name='Crossentropy')\n return tf.reduce_mean(cross_entropy, name='Crossentropy_mean')","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return grad","def compute_cost(features, values, theta):\r\n \r\n # your code here\r\n error = (values - features.dot(theta))\r\n cost = error.dot(error) \r\n return cost","def rpn_cls_loss(*args):\n y_true, y_pred = args if len(args) == 2 else args[0]\n indices = tf.where(tf.not_equal(y_true, -1))\n target = tf.gather_nd(y_true, indices)\n output = tf.gather_nd(y_pred, indices)\n lf = tf.losses.BinaryCrossentropy()\n return lf(target, output)","def cost(self, x, y):\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()","def categorical_crossentropy(y_pred, y_true):\n with tf.name_scope(\"Crossentropy\"):\n y_pred /= tf.reduce_sum(y_pred,\n reduction_indices=len(y_pred.get_shape())-1,\n keep_dims=True)\n # manual computation of crossentropy\n y_pred = tf.clip_by_value(y_pred, tf.cast(_EPSILON, dtype=_FLOATX),\n tf.cast(1.-_EPSILON, dtype=_FLOATX))\n cross_entropy = - tf.reduce_sum(y_true * tf.log(y_pred),\n reduction_indices=len(y_pred.get_shape())-1)\n return tf.reduce_mean(cross_entropy)","def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas","def binary_cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (1 / m) * np.nansum(-np.log(Y_hat) * Y - np.log(1 - Y_hat) * (1 - Y))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -(Y / Y_hat) + (1 - Y) / (1 - Y_hat)\n \n return cost, dY_hat","def cost(theta, X, y, learning_rate):\n m = len(y) \n theta = theta.reshape((-1,1))\n h = sigmoid(np.dot(X, theta))\n\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n return float(J)","def class_balanced_cross_entropy(this,pred, label, name='cross_entropy_loss'):\n with tf.name_scope('class_balanced_cross_entropy'):\n z = this.batch_flatten(pred)\n y = tf.cast(this.batch_flatten(label), tf.float32)\n\n count_neg = tf.reduce_sum(1. - y)\n count_pos = tf.reduce_sum(y)\n beta = count_neg / ((count_neg + count_pos)+this.EPS)\n\n eps = 1e-12\n loss_pos = -beta * tf.reduce_mean(y * tf.log(z + eps))\n loss_neg = (1. - beta) * tf.reduce_mean((1. - y) * tf.log(1. - z + eps))\n cost = tf.subtract(loss_pos, loss_neg, name=name)\n return cost","def class_balanced_cross_entropy(this,pred, label, name='cross_entropy_loss'):\n with tf.name_scope('class_balanced_cross_entropy'):\n z = this.batch_flatten(pred)\n y = tf.cast(this.batch_flatten(label), tf.float32)\n\n count_neg = tf.reduce_sum(1. - y)\n count_pos = tf.reduce_sum(y)\n beta = count_neg / ((count_neg + count_pos)+this.EPS)\n\n eps = 1e-12\n loss_pos = -beta * tf.reduce_mean(y * tf.log(z + eps))\n loss_neg = (1. - beta) * tf.reduce_mean((1. - y) * tf.log(1. - z + eps))\n cost = tf.subtract(loss_pos, loss_neg, name=name)\n return cost"],"string":"[\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def cross_entropy(t,y):\\r\\n #print(-1*t*np.log(y))\\r\\n #print(np.shape(np.log(y)))\\r\\n #print(np.shape(t))\\r\\n return t*np.log(y)*(-1)\",\n \"def cross_entropy(predictions, targets):\\n likelihood = targets * np.log(predictions)\\n return -np.sum(likelihood) / predictions.shape[0]\",\n \"def cross_entropy(\\n **kwargs\\n) -> Callable:\\n return categorical_crossentropy\",\n \"def cross_entropy(y_pred,y):\\n \\n epsilon = 0.001 # To prevent overflow and ensure numerical stability\\n return sum(-y*np.log(y_pred+epsilon))\",\n \"def cross_entropy(y, y_hat):\\n return -tf.math.log(\\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\\n )\",\n \"def cross_entropy_cost(output_out, target_out):\\r\\n total = 0\\r\\n for target_node in range(len(target_out)): # For each target data set\\r\\n for output_node in range(len(output_out)): # For each output node\\r\\n total += target_out[target_node][output_node] - target_out[target_node][output_node] * np.log(output_out[output_node]) - \\\\\\r\\n (1 - target_out[target_node][output_node]) * np.log(1 - output_out[output_node])\\r\\n\\r\\n total = 1 / total\\r\\n return total\",\n \"def cross_entropy(self):\\n return self._cross_entropy_func\",\n \"def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n return -torch.log2(probability_fn(args))\",\n \"def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\\n log_pred = ivy.log(pred)\\n # noinspection PyUnresolvedReferences\\n return -ivy.reduce_sum(log_pred * true, axis)\",\n \"def cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -Y / Y_hat\\n \\n return cost, dY_hat\",\n \"def cross_entropy(targets, predictions, epsilon=1e-12):\\n\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n\\n N = predictions.shape[0]\\n\\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\\n\\n return ce\",\n \"def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def cross_entropy(self, yhat):\\n n = len(self._y)\\n c = 0.0\\n for i in range(0, n):\\n c += self._y[i] * log(\\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\\n\\n return c\",\n \"def cross_entropy(predicted, target):\\n batch_size, num_classes = predicted.shape\\n\\n e_x = predicted.exp()\\n log_e_x = e_x.log()\\n a = log_sum_x_trick(predicted)\\n x_n_offset = predicted - a\\n\\n exp_xn_offset = x_n_offset.exp()\\n\\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\\n denominator = a + log_sum_exp_xn_offset\\n log_softmax = log_e_x - denominator\\n\\n labels = to_one_hot(target, num_classes)\\n prod = log_softmax*labels\\n total = prod.sum()\\n batch_size = tensor.Tensor(-batch_size)\\n\\n total = total / batch_size\\n\\n return total\",\n \"def softmax_cross_entropy(y, label):\\r\\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\\r\\n return losses\\r\\n pass\",\n \"def get_reconstruction_cost(self, updates, pre_sigmoid_nv):\\r\\n\\r\\n cross_entropy = T.mean(\\r\\n T.sum(self.input * T.log(T.nnet.sigmoid(pre_sigmoid_nv)) +\\r\\n (1 - self.input) * T.log(1 - T.nnet.sigmoid(pre_sigmoid_nv)),\\r\\n axis=1))\\r\\n\\r\\n return cross_entropy\",\n \"def grad_softmax_cross_entropy_loss(logit, labels):\\n return softmax(logit) - labels\",\n \"def cross_entropy_loss(self, logits, labels):\\n return F.cross_entropy(logits, labels)\",\n \"def cross_entropy_loss():\\n return nn.CrossEntropyLoss()\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def cost(self, X=None, y=None, theta=None):\\n X = self.X_train if X is None else X\\n y = self.y_train if y is None else y\\n m = X.shape[1]\\n\\n prob_mat = self.softmax_mat(X, theta)\\n cost = -(y * np.log(prob_mat)).sum() / m\\n return cost\",\n \"def get_reconstruction_cost(self, nv):\\n cross_entropy = T.mean(\\n T.sum(\\n self.input * T.log(nv) +\\n (1 - self.input) * T.log(1 - nv),\\n axis=1\\n )\\n )\\n return cross_entropy\",\n \"def my_softmax_cross_entropy(preds, labels):\\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\\n return tf.reduce_mean(loss)\",\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def soft_cross_entropy(input, targets):\\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\\n return (- targets_prob * student_likelihood).sum(dim=-1).mean()\",\n \"def get_reconstruction_cost(self, pre_sigmoid_nv):\\n y = self.input\\n a = T.nnet.sigmoid(pre_sigmoid_nv)\\n\\n cross_entropy = -T.mean(\\n T.sum(y * T.log(a) + (1 - y) * T.log(1 - a), axis=1)\\n )\\n\\n return cross_entropy\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def cross_entropy_cost(m, A, L):\\n\\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\\n\\n\\n\\t# Sanity checks\\n\\tcost = np.squeeze(cost) \\t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\\n\\tassert(cost.shape == ()) \\t#checks if cost value is a scalar\\n\\n\\treturn cost\",\n \"def binary_crossentropy(predictions, targets):\\n return theano.tensor.nnet.binary_crossentropy(predictions, targets)\",\n \"def delta_cross_entropy_softmax(outputs, labels):\\n \\n m = labels.shape[0]\\n grad = outputs\\n \\n grad[range(m),labels] -= torch.tensor(1.)\\n\\n grad = grad/m\\n avg_grads = grad\\n return avg_grads\",\n \"def cross_entropy(X, y, using_onehot=True):\\n\\tM = y.shape[0]\\n\\tif using_onehot :\\n\\t\\tlog_likelihood = -np.log(np.max(X * y, -1))\\n\\telse:\\n\\t\\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\\n\\tloss = np.sum(log_likelihood) / M\\n\\treturn loss\",\n \"def binary_crossentropy(output, target):\\r\\n return -(target * tensor.log(output) + (1.0 - target) * tensor.log(1.0 - output))\",\n \"def cross_entropy_gradient(self, yhat):\\n n = len(self._y)\\n p = len(self.beta)\\n g = np.zeros(p)\\n for i in range(0, n):\\n g = g + (self._y[i] - yhat[i]) * np.array(\\n [1.0, *self._feat_mtx[i, :]])\\n\\n return g\",\n \"def get_cross_entropy(self):\\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\\n potential = 0.0\\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\\n return potential\",\n \"def cross_entropy_fn(fc8, ground_truth_input):\\n with tf.name_scope('cross_entropy') as scope:\\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=fc8, labels=ground_truth_input)\\n cross_entropy_mean = tf.reduce_mean(cross_entropy)\\n\\n tf.summary.scalar(scope + '/loss', cross_entropy_mean)\\n\\n return cross_entropy_mean\",\n \"def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\\n norm_log = log_softmax(input, 1)\\n\\n np_one_hot = np.eye(input.shape[1])[target.data]\\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\\n\\n mask = -norm_log * tensor_one_hot\\n mask_sum = sum(mask, 1)\\n loss = sum(mask_sum, 0)\\n\\n return loss / input.shape[0]\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n# labels = tf.to_float(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\\n# y_conv = tf.nn.softmax(logits)\\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def loss_fn(y_true,y_pred): \\n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\\n y_pred,\\n axis=-1,\\n )\\n loss = tf.reduce_mean(loss,name=\\\"loss\\\")\\n return loss\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def binary_cross_entropy(y_true, y_preds):\\n return np.sum(y_true * np.log(y_preds) + (1 - y_true) * np.log(1 - y_preds))\",\n \"def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\\n y_pred = tf.cast(y_pred, 'float64')\\n y_true = tf.cast(y_true, 'float64')\\n # deduce weights based on true pixel value\\n class_weights = weights * y_true\\n # compute your (unweighted) softmax cross entropy loss\\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\\n ##print(unweighted_losses.dtype, weights.dtype)\\n weighted_losses = unweighted_losses * class_weights\\n # reduce the result to get your final loss\\n loss = -tf.reduce_sum(weighted_losses)\\n return loss\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def crossentropy_loss(y_true, y_pred):\\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \\n return ce\",\n \"def cross_entropy_loss(outputs, labels): \\n# works properly\\n \\n m = labels.shape[0]\\n p = outputs\\n log_likelihood = -1*torch.log(p[range(m),labels])\\n loss = torch.sum(log_likelihood) / m\\n return loss.item()\",\n \"def test_cross_entropy(self):\\n loss = losses.cross_entropy_with_logits(\\n logits=self.logits, targets=self.targets)\\n kl = loss.mean()\\n\\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\\n\\n self.assertAlmostEqual(kl, expected_loss)\",\n \"def sparse_cross_entropy(true, pred, axis=-1, epsilon=1e-7):\\n true = ivy.one_hot(true, pred.shape[axis])\\n return cross_entropy(true, pred, axis, epsilon)\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def cross_entropy(predicted, target):\\n batch_size, num_classes = predicted.shape\\n\\n # Tip: You can implement XELoss all here, without creating a new subclass of Function.\\n # However, if you'd prefer to implement a Function subclass you're free to.\\n # Just be sure that nn.loss.CrossEntropyLoss calls it properly.\\n\\n # Tip 2: Remember to divide the loss by batch_size; this is equivalent\\n # to reduction='mean' in PyTorch's nn.CrossEntropyLoss\\n\\n e_x = predicted.exp()\\n log_e_x = e_x.log()\\n a = log_sum_x_trick(predicted)\\n x_n_offset = predicted - a\\n\\n exp_xn_offset = x_n_offset.exp()\\n\\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\\n denominator = a + log_sum_exp_xn_offset\\n log_softmax = log_e_x - denominator\\n\\n labels = to_one_hot(target, num_classes)\\n prod = log_softmax*labels\\n total = prod.sum()\\n batch_size = tensor.Tensor(-batch_size)\\n\\n total = total / batch_size\\n\\n return total\",\n \"def categorical_crossentropy(predictions, targets):\\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)\",\n \"def categorical_crossentropy(predictions, targets):\\n return theano.tensor.nnet.categorical_crossentropy(predictions, targets)\",\n \"def compute_cost(Z6, Y):\\n\\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\\n\\n return cost\",\n \"def logit_cost(self, theta, X, y):\\n\\n cost = 0.0\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n \\n for i in range(0, X.shape[0]):\\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\\n ### END YOUR CODE\\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\\n return cost\",\n \"def loss_function(self, targets, outputs):\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\\n return tf.reduce_mean(cross_entropy)\",\n \"def costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def cost(self, logits, labels, weights):\\n return tf.multiply(\\n tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels),\\n weights)\",\n \"def _Apply(self, c, p):\\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\\n entropy = tf.reduce_mean(entropy)\\n return entropy\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def cross_entropy_loss(self, y, y_hat):\\n if y.ndim == 1:\\n batch_size = 1\\n else:\\n batch_size = y.shape[0]\\n delta = 1e-7\\n return -np.sum(y * np.log(y_hat + delta)) / batch_size\",\n \"def cross_entropy_loss(predictions, targets, epsilon=1e-12):\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n N = predictions.shape[0]\\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\\n return ce\",\n \"def compute_cross_entropy(probs, target):\\n avg_probs_per_sample = probs.mean(\\n -1)\\n xe = torch.nn.CrossEntropyLoss(reduction='none')\\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()\",\n \"def forward_train(self, preds_T: torch.Tensor) -> torch.Tensor:\\n fake_label = preds_T.data.max(1)[1]\\n return F.cross_entropy(preds_T, fake_label)\",\n \"def ovo_crossentropy_loss(y_true, y_pred):\\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\\n y_true_scaled = (y_true + 1.0) / 2.0\\n y_pred_scaled = (y_pred + 1.0) / 2.0\\n\\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\\n\\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\\n\\n # J_{OvO} aus Pawara et al. anwenden\\n log_function = tf.log if tf.__version__ == \\\"1.13.1\\\" else tf.math.log # flexibel für neue / alte Version\\n loss = - tf.reduce_mean(\\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\\n return loss\",\n \"def nll(y_true, y_pred):\\n return K.sum(K.binary_crossentropy(y_true, y_pred), axis=-1)\",\n \"def cross_entropy3(input, target, weight):\\n loss = 0\\n batch_size = target.data.shape[1]\\n target = target.max(2)[1]\\n input = input.transpose(0, 1)\\n target = target.transpose(0, 1)\\n weight = weight.transpose(0, 1)\\n for i in range(batch_size):\\n partial_loss = F.cross_entropy(input[i], target[i], size_average=False, reduce=False)\\n partial_loss = torch.mul(partial_loss, weight[i])\\n loss = loss + torch.sum(partial_loss)\\n return loss / batch_size\",\n \"def cross_entropy(input1, target, size_average=True):\\n logsoftmax = nn.LogSoftmax(dim=0)\\n return torch.sum(-target * logsoftmax(input1))\\n # if size_average:\\n # return torch.mean(torch.sum(-target * logsoftmax(input), dim=1))\\n # else:\\n # return torch.sum(torch.sum(-target * logsoftmax(input), dim=1))\",\n \"def crossEntropy(obs, actual, offset=1e-7):\\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\\n # bound by clipping to avoid nan\\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\\n return -tf.reduce_sum(actual * tf.log(obs_) +\\n (1 - actual) * tf.log(1 - obs_), 1)\",\n \"def mean_cross_entropy_costs(X, y, lambda_reg=0.0):\\n return lambda theta: np.mean(cross_entropy(X, y)(theta)) + L2_regularization_cost(\\n X, theta, lambda_reg\\n )\",\n \"def loss_fn(outputs, labels):\\n return nn.CrossEntropyLoss()(outputs, labels)\",\n \"def sigmoid_cross_entropy(x, t, use_cudnn=True, normalize=True):\\n return SigmoidCrossEntropy(use_cudnn, normalize)(x, t)\",\n \"def binary_crossentropy(predictions, targets):\\n predictions, targets = align_targets(predictions, targets)\\n return theano.tensor.nnet.binary_crossentropy(predictions, targets)\",\n \"def cost(TH,X,Y,lda=1):\\n m = X.shape[0]\\n htx = ff(X,TH)[-1]\\n\\n termsum = 0\\n for rn in range(m):\\n termsum += (-1.*Y[rn,:])*(np.log(htx[rn,:]).T) -(1. -Y[rn,:])*(np.log(1. -htx[rn,:]).T)\\n termsum = 1./m*(termsum)\\n\\n regsum = 0\\n for th in TH:\\n regsum += sum(sum(np.power(th[:,1:],2)))\\n regsum = lda/(2.*m)*regsum\\n\\n return termsum[0,0] +regsum\",\n \"def test_asymptotic_32():\\r\\n\\r\\n #TODO: consider adding the optimization of crossentropy into the current\\r\\n # mode for the purpose of running this test\\r\\n\\r\\n for dtype in 'float32', 'float64':\\r\\n if dtype == 'float32':\\r\\n x = tensor.fmatrix()\\r\\n x2 = tensor.fvector()\\r\\n else:\\r\\n x = tensor.dmatrix()\\r\\n x2 = tensor.dvector()\\r\\n y = tensor.lvector()\\r\\n\\r\\n c = categorical_crossentropy(softmax(x + x2), y)\\r\\n f = theano.function([x, y, x2], [c.sum(),\\r\\n tensor.grad(c.sum(), x)], mode='FAST_RUN')\\r\\n if 0:\\r\\n for i, n in enumerate(f.maker.fgraph.toposort()):\\r\\n print i, n\\r\\n\\r\\n xval = numpy.zeros((5, 5), dtype=dtype).astype(dtype)\\r\\n x2val = numpy.zeros(5, dtype=xval.dtype).astype(dtype)\\r\\n for i in xrange(100):\\r\\n cval, gxval = f(xval, numpy.arange(5), x2val)\\r\\n xval -= 100.3 * gxval\\r\\n #print cval, gxval\\r\\n assert cval == 0 # no problem going to zero error\\r\\n\\r\\n #what about when x gets really big?\\r\\n\\r\\n xval = numpy.zeros((5, 5), dtype=dtype)\\r\\n x2val = numpy.zeros(5, dtype=xval.dtype)\\r\\n for i in xrange(100):\\r\\n\\r\\n cval, gxval = f(xval, numpy.arange(5), x2val)\\r\\n xval += 100000.3 * gxval\\r\\n #print cval, gxval\\r\\n\\r\\n assert cval > 61750000\\r\\n assert gxval[0, 0] == -1.0\\r\\n assert gxval[0, 1] == 0.25\",\n \"def classification_loss(self, logit, target):\\n return F.cross_entropy(logit, target)\",\n \"def cross_entropy(p, q, base=2):\\n q = ma.array(q, mask=(q == 0))\\n return - np.vdot(p, ma.log(q)) / np.log(base)\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n \\n\\n C = W.shape[1]\\n# print(\\\"no. of classes {}\\\".format(C))\\n N,D = X.shape\\n# print(\\\"no. of data {} and dimension {}\\\".format(N,D))\\n for i in range(N):\\n xi = X[i,:]\\n# print(\\\"one record shape: {}\\\".format(xi.shape))\\n scores = np.zeros(C)\\n for c in range(C):\\n w = W[:,c]\\n# print(\\\"weight for one record {}\\\".format(w.shape))\\n scores[c] = xi.dot(w)\\n scores -= np.max(scores)\\n actual_y = y[i]\\n total_score = np.sum(np.exp(scores)) \\n loss_i = -scores[actual_y] + np.log(total_score)\\n# print('naive score : {}'.format(scores[actual_y]))\\n loss += loss_i\\n \\n #gradient\\n probability = np.exp(scores)/total_score\\n for j in range(C):\\n dW[:,j] += probability[j]*xi\\n \\n dW[:,actual_y] -= xi\\n loss = loss/N\\n reg_loss = 0.5*reg*np.sum(W*W)\\n loss = loss + reg_loss\\n print(\\\"loss : {}\\\".format(loss))\\n dW = dW/N\\n dW += reg*W\\n \\n \\n \\n \\n\\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def cross_entropoy_loss_vectorized(W, X, y, reg): \\n loss = 0 \\n dW = np.zeros_like(W)\\n N, D = X.shape \\n \\n \\n scores = X.dot(W) # [K, N]\\n # for numerical stability)\\n scores -= np.max(scores)\\n scores_exp = np.exp(scores)\\n correct_scores_exp = scores_exp[range(N),y] \\n scores_exp_sum = np.sum(scores_exp, axis=1) \\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\\n loss /= N\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n scores_exp_normalized = scores_exp.T / scores_exp_sum \\n scores_exp_normalized[y, range(N)] -= 1 \\n dW = np.dot(scores_exp_normalized,X)\\n dW = dW.T\\n dW /= N \\n dW += reg * W\\n \\n \\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def softmax_cross_entropy_loss(logit, labels):\\n p = softmax(logit)\\n loss_i = - labels * np.log(p + 1e-8)\\n return np.mean(loss_i)\",\n \"def cross_entropy(m_true, alpha, alpha0, m_probs, lambd=1.0):\\n\\n loss = tf.reduce_sum(input_tensor=m_true * (tf.math.digamma(alpha0) - tf.math.digamma(alpha)), axis=1, keepdims=True)\\n loss = tf.reduce_mean(input_tensor=loss)\\n if lambd > 0:\\n kl = kullback_leibler_dirichlet(m_true, alpha)\\n loss = loss + lambd * kl\\n return loss\",\n \"def test_softmax_cross_entropy(self):\\n loss_op = listwise_losses.SoftmaxCrossEntropy()\\n\\n y_pred = loss_op.final_activation_op({\\n \\\"logits\\\": self.logits,\\n \\\"metadata\\\": {\\n \\\"mask\\\": self.mask\\n }\\n })\\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\\n\\n loss = loss_op({\\\"mask\\\": self.mask}, self.y_true, y_pred)\\n assert np.isclose(loss, 1.306335, atol=1e-5)\",\n \"def cross_entropy(self, sents):\\n return (-1) * self.log_prob(sents) / len(self._count)\",\n \"def SoftEntropy_sequence(nn_last_layer, correct_label, learning_rate): \\n \\n loss = tf2.math.reduce_sum( tf2.nn.softmax_cross_entropy_with_logits(tf2.stop_gradient(correct_label[:,12:38,:]), nn_last_layer[:,12:38,:]))\\n \\n #obtain training operation\\n optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate, epsilon = 1e-8) #Note default value of epsilon 1e-8 results in instability after few epochs\\n \\n #clip the gradients\\n gvs = optimizer.compute_gradients(loss)\\n #capped_gvs = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in gvs]\\n training_operation = optimizer.apply_gradients(gvs)\\n\\n return training_operation, loss\",\n \"def compute_cost(A2, Y, parameters):\\n\\n\\tm = Y.shape[1] # number of example\\n\\n\\t# Compute the cross-entropy cost\\n\\tlogprobs = np.multiply(np.log(A2), Y)\\n\\tcost = -(1/m)*(np.sum((logprobs) + np.multiply(np.log(1-A2), 1-Y)))\\n\\n\\tcost = np.squeeze(cost) # makes sure cost is the dimension we expect. \\n\\t \\t# E.g., turns [[17]] into 17 \\n\\tassert(isinstance(cost, float))\\n\\n\\treturn cost\",\n \"def softmax_cross_entropy(logit, onehot, axis=-1):\\n return SoftmaxCrossEntropy(axis).forward(logit, onehot)\",\n \"def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\\n if type(y_pred) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_pred)))\\n if type(y_true) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_true)))\\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\\n # y_pred = clip(y_pred)\\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\\n loss = -1 * np.sum(l).item()\\n if normalize:\\n loss = loss / len(y_pred)\\n return loss\",\n \"def costFunction(theta,X,y):\\n m = X.shape[0]\\n J = 0\\n h = sigmoid (np.dot(X,theta))\\n \\n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\\n \\n #grad = (1/m) * np.dot(X.T,(h-y))\\n grad = (1/m) * np.dot((h.T - y), X).T\\n \\n return J, grad\",\n \"def crossEntropy(p_m1):\\n p_m2 = 1 - p_m1\\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\\n return D\",\n \"def loss(logits, targets):\\n targets = tf.to_int64(targets)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=targets, logits=logits, name='Crossentropy')\\n return tf.reduce_mean(cross_entropy, name='Crossentropy_mean')\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return grad\",\n \"def compute_cost(features, values, theta):\\r\\n \\r\\n # your code here\\r\\n error = (values - features.dot(theta))\\r\\n cost = error.dot(error) \\r\\n return cost\",\n \"def rpn_cls_loss(*args):\\n y_true, y_pred = args if len(args) == 2 else args[0]\\n indices = tf.where(tf.not_equal(y_true, -1))\\n target = tf.gather_nd(y_true, indices)\\n output = tf.gather_nd(y_pred, indices)\\n lf = tf.losses.BinaryCrossentropy()\\n return lf(target, output)\",\n \"def cost(self, x, y):\\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()\",\n \"def categorical_crossentropy(y_pred, y_true):\\n with tf.name_scope(\\\"Crossentropy\\\"):\\n y_pred /= tf.reduce_sum(y_pred,\\n reduction_indices=len(y_pred.get_shape())-1,\\n keep_dims=True)\\n # manual computation of crossentropy\\n y_pred = tf.clip_by_value(y_pred, tf.cast(_EPSILON, dtype=_FLOATX),\\n tf.cast(1.-_EPSILON, dtype=_FLOATX))\\n cross_entropy = - tf.reduce_sum(y_true * tf.log(y_pred),\\n reduction_indices=len(y_pred.get_shape())-1)\\n return tf.reduce_mean(cross_entropy)\",\n \"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\\n thetas = [theta]\\n cost = np.zeros(num_iters)\\n\\n J = mean_cross_entropy_costs(X, y, lambda_reg)\\n cost[0] = J(thetas[0])\\n for i in range(1, num_iters):\\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\\n cost[i] = J(thetas[i])\\n return cost, thetas\",\n \"def binary_cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (1 / m) * np.nansum(-np.log(Y_hat) * Y - np.log(1 - Y_hat) * (1 - Y))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -(Y / Y_hat) + (1 - Y) / (1 - Y_hat)\\n \\n return cost, dY_hat\",\n \"def cost(theta, X, y, learning_rate):\\n m = len(y) \\n theta = theta.reshape((-1,1))\\n h = sigmoid(np.dot(X, theta))\\n\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n return float(J)\",\n \"def class_balanced_cross_entropy(this,pred, label, name='cross_entropy_loss'):\\n with tf.name_scope('class_balanced_cross_entropy'):\\n z = this.batch_flatten(pred)\\n y = tf.cast(this.batch_flatten(label), tf.float32)\\n\\n count_neg = tf.reduce_sum(1. - y)\\n count_pos = tf.reduce_sum(y)\\n beta = count_neg / ((count_neg + count_pos)+this.EPS)\\n\\n eps = 1e-12\\n loss_pos = -beta * tf.reduce_mean(y * tf.log(z + eps))\\n loss_neg = (1. - beta) * tf.reduce_mean((1. - y) * tf.log(1. - z + eps))\\n cost = tf.subtract(loss_pos, loss_neg, name=name)\\n return cost\",\n \"def class_balanced_cross_entropy(this,pred, label, name='cross_entropy_loss'):\\n with tf.name_scope('class_balanced_cross_entropy'):\\n z = this.batch_flatten(pred)\\n y = tf.cast(this.batch_flatten(label), tf.float32)\\n\\n count_neg = tf.reduce_sum(1. - y)\\n count_pos = tf.reduce_sum(y)\\n beta = count_neg / ((count_neg + count_pos)+this.EPS)\\n\\n eps = 1e-12\\n loss_pos = -beta * tf.reduce_mean(y * tf.log(z + eps))\\n loss_neg = (1. - beta) * tf.reduce_mean((1. - y) * tf.log(1. - z + eps))\\n cost = tf.subtract(loss_pos, loss_neg, name=name)\\n return cost\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73253536","0.6912139","0.6881294","0.6762478","0.6754978","0.6689187","0.6629159","0.660048","0.6590784","0.65587205","0.6547451","0.6451672","0.64506274","0.6429443","0.64189255","0.63606083","0.6355681","0.633888","0.6335124","0.6334","0.63227713","0.6316685","0.62987304","0.6298515","0.62785923","0.6271865","0.6264161","0.625034","0.6248897","0.62448007","0.6240032","0.6231044","0.62203956","0.61876106","0.61841434","0.6177379","0.61696196","0.61690426","0.6150057","0.6144386","0.61401004","0.61401004","0.61300457","0.61270964","0.6118697","0.6110647","0.60965806","0.60929286","0.6089115","0.6085578","0.60782343","0.60751075","0.60751075","0.606351","0.60583305","0.6024491","0.60010165","0.59993696","0.5997115","0.5987769","0.5979855","0.5974565","0.59629107","0.5960603","0.5951046","0.59471893","0.5933793","0.59281695","0.5927909","0.59256065","0.59032094","0.5902261","0.5876968","0.58760184","0.5870452","0.5860284","0.5855716","0.5852113","0.58469814","0.58451355","0.5837934","0.5835515","0.5833674","0.5832332","0.5825843","0.5824602","0.58118045","0.5806405","0.5805938","0.5797788","0.5797232","0.57934016","0.57918936","0.5790026","0.5789644","0.57853156","0.57809556","0.57699054","0.5767903","0.5767903"],"string":"[\n \"0.73253536\",\n \"0.6912139\",\n \"0.6881294\",\n \"0.6762478\",\n \"0.6754978\",\n \"0.6689187\",\n \"0.6629159\",\n \"0.660048\",\n \"0.6590784\",\n \"0.65587205\",\n \"0.6547451\",\n \"0.6451672\",\n \"0.64506274\",\n \"0.6429443\",\n \"0.64189255\",\n \"0.63606083\",\n \"0.6355681\",\n \"0.633888\",\n \"0.6335124\",\n \"0.6334\",\n \"0.63227713\",\n \"0.6316685\",\n \"0.62987304\",\n \"0.6298515\",\n \"0.62785923\",\n \"0.6271865\",\n \"0.6264161\",\n \"0.625034\",\n \"0.6248897\",\n \"0.62448007\",\n \"0.6240032\",\n \"0.6231044\",\n \"0.62203956\",\n \"0.61876106\",\n \"0.61841434\",\n \"0.6177379\",\n \"0.61696196\",\n \"0.61690426\",\n \"0.6150057\",\n \"0.6144386\",\n \"0.61401004\",\n \"0.61401004\",\n \"0.61300457\",\n \"0.61270964\",\n \"0.6118697\",\n \"0.6110647\",\n \"0.60965806\",\n \"0.60929286\",\n \"0.6089115\",\n \"0.6085578\",\n \"0.60782343\",\n \"0.60751075\",\n \"0.60751075\",\n \"0.606351\",\n \"0.60583305\",\n \"0.6024491\",\n \"0.60010165\",\n \"0.59993696\",\n \"0.5997115\",\n \"0.5987769\",\n \"0.5979855\",\n \"0.5974565\",\n \"0.59629107\",\n \"0.5960603\",\n \"0.5951046\",\n \"0.59471893\",\n \"0.5933793\",\n \"0.59281695\",\n \"0.5927909\",\n \"0.59256065\",\n \"0.59032094\",\n \"0.5902261\",\n \"0.5876968\",\n \"0.58760184\",\n \"0.5870452\",\n \"0.5860284\",\n \"0.5855716\",\n \"0.5852113\",\n \"0.58469814\",\n \"0.58451355\",\n \"0.5837934\",\n \"0.5835515\",\n \"0.5833674\",\n \"0.5832332\",\n \"0.5825843\",\n \"0.5824602\",\n \"0.58118045\",\n \"0.5806405\",\n \"0.5805938\",\n \"0.5797788\",\n \"0.5797232\",\n \"0.57934016\",\n \"0.57918936\",\n \"0.5790026\",\n \"0.5789644\",\n \"0.57853156\",\n \"0.57809556\",\n \"0.57699054\",\n \"0.5767903\",\n \"0.5767903\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71423405"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":90792,"cells":{"query":{"kind":"string","value":"Updates learnable parameters theta The update is done by calculating the partial derivities of the cost function including the linear hypothesis. The gradients scaled by a scalar are subtracted from the given theta values."},"document":{"kind":"string","value":"def compute_new_theta(X, y, theta, learning_rate, lambda_reg):\n\n thetas = np.zeros(len(theta))\n thetas = theta * (1 - learning_rate * (lambda_reg / len(X))) - (\n learning_rate / len(X)\n ) * np.sum((logistic_hypothesis(theta)(X) - y) * x_strich(X).T, axis=1)\n\n return thetas"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_grad_updates(self):\n \n gradients = T.grad(self.cost, self.theta)\n \n for target_param, grad in zip(self.theta, gradients):\n \n if target_param.name ==\"W\" and self.num_hidden ==0\\\n and self.zero_diag:\n \n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\n # for all i = 1, ..., D\n ##############################################################\n if target_param.name ==\"b\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n elif target_param.name ==\"bhid\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n else:\n \n if self.use_momentum:\n \n # alternative definition (mostly seen):\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n #self.updates[target_param] = target_param + g_tilda\n \n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n (1-self.momentum)*grad\n \n self.updates[target_param] = target_param +\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\n \n # store g_tilda for next iteration:\n self.updates[self.grad_vec[target_param.name]] = g_tilda\n \n else:\n \n self.updates[target_param] = target_param -\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n \n if (\"PCD\" in self.algorithm) and self.num_hidden > 0:\n \n self.updates[self.persistent_gibbs] = self.hid_samples","def gradient(self, theta):\n pass","def gradient(self, theta):\n pass","def theta(self, theta):\n n_theta_avail = self.n_theta\n n_theta_suggest = len(theta)\n if(n_theta_avail != n_theta_suggest):\n raise ValueError(\"theta has not the correct number of entries.\"\n \" Should be %d; given are %d\"\n % (n_theta_avail, n_theta_suggest)) \n\n i = 0\n if(self._FLAG_TYPE == 'base'): \n params = self.get_params(bounds = False)\n for p_name in self._LIST_PARAMETERS:\n mask_free = self._get_one_free_mask(p_name)\n nb_to_update = np.sum(mask_free)\n if nb_to_update > 0: \n params[p_name][mask_free] = np.array(theta[i:i + nb_to_update])\n i += nb_to_update\n\n #That's wehere the updates really happen\n self.set_params(**params)\n\n elif(self._FLAG_TYPE == 'collection'):\n #Delegate updates to subobj\n for sub in self.list_func_free:\n nb_to_update_sub = sub.n_theta\n if(nb_to_update_sub > 0):\n sub.theta = theta[i:i + nb_to_update_sub]\n i += nb_to_update_sub\n\n # check all the values in theta have been used\n if i != len(theta):\n raise ValueError(\"Something went wrong with nb of theta updated. \"\n \" Should be %d; but it is only %d\"\n % (n_theta_avail, i))\n\n self._check_integrity()","def update_thetas(self, X, y, theta_list, bias, learning_rate):\n total_samples = len(X)\n theta_derivative = [0]*len(theta_list)\n bias_derivative = 0\n\n for i in range(total_samples): #update the thetas and bias by gradient descent\n hypothesis = 0\n\n hypothesis = hypothesis+bias\n\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\n\n sigmoidhypothesis = 1./(1.+np.exp(-hypothesis))\n\n sigmoidhypothesis = sigmoidhypothesis - y[i]\n\n bias_derivative += sigmoidhypothesis\n\n\n feature_index=0\n for feature_index in range(len(theta_list)):\n theta_derivative[feature_index] += sigmoidhypothesis*X[i][feature_index]\n\n \n bias -= (bias_derivative/total_samples) * learning_rate\n\n for j in range(len(theta_list)):\n theta_list[j] -= (theta_derivative[j]/total_samples) * learning_rate\n\n return bias, theta_list","def gradient_function(theta, X, y):\n\n grad = None\n #######################################################################\n # TODO: #\n # Compute the gradient for a particular choice of theta. #\n # Compute the partial derivatives and set grad to the partial #\n # derivatives of the cost w.r.t. each parameter in theta #\n # #\n #######################################################################\n \n theta = theta[:, np.newaxis]\n \n thetatrans = theta.T\n Xtrans = X.T\n \n MulThetaX = np.dot(thetatrans, Xtrans)\n \n h = sigmoid(MulThetaX)\n \n grad = (y - h) * Xtrans\n\n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return grad","def update_parameters(parameters, grads, learning_rate):\n pass","def get_updates(self, theta, cost=None, gtheta=None):\n updates = []\n if gtheta is None:\n assert cost is not None\n gtheta = T.grad(cost, theta)\n\n g2_sum = theano.shared(theta.get_value() * 0.)\n g2_sum_upd = g2_sum + T.sqr(gtheta) \n theta_upd = theta - self.learning_rate * gtheta/T.sqrt(g2_sum_upd + self.epsilon) \n \n updates.append((g2_sum, g2_sum_upd))\n updates.append((theta, theta_upd))\n return updates","def gradientFunctionReg(theta, X, y, Lambda):\n m = len(y) # number of training examples\n grad = np.zeros(theta.shape[0])\n theta = np.transpose(theta)\n sum_1 = 0\n X = X.values\n y = y.values\n #calcuate the theta_0 \n# ====================== YOUR CODE HERE ======================\n# Instructions: Compute the gradient of a particular choice of theta.\n# Compute the partial derivatives and set grad to the partial\n# derivatives of the cost w.r.t. each parameter in theta\n for i in range(theta.shape[0]):\n if i == 0:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\n else:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\n grad[i] = sum_1/m\n sum_1 = 0\n\n# =============================================================\n\n return grad","def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\n # Initialize some useful values\n m = len(y) # number of training examples\n\n # You need to return the following variable correctly.\n grad = np.zeros(theta.shape)\n\n # ====================== YOUR CODE HERE ======================\n # Instructions: Compute the partial derivatives and set grad to the partial\n # derivatives of the cost w.r.t. each parameter in theta.\n\n # =============================================================\n return grad","def fit(self, X, y):\n\n n, m = X.shape[0], X.shape[1]\n\n # theta is (nx1) (one theta per dimension)\n self.theta = np.random.uniform(-10, 10, (n, 1))\n\n for i in range(self.epochs):\n # Get predictions\n y_pred = self.predict(X)\n\n # calculate cost\n # cost = ...\n cost = self._cost_function(y_pred, y, m)\n \n\n # gradient is an (n) x 1 array, it refers to the derivate per theta\n gradient = self._cost_function_derivative(y_pred, y, X, m)\n\n # delta/update rule\n self.theta = gradient\n\n self.costs.append(cost)\n pass\n\n print(\"Final theta is {} (cost: {})\".format(self.theta.T, cost))","def logit_cost_grad(self, theta, X, y):\n\n grad = np.zeros(len(theta))\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n # sig = np.subtract(sig, y)\n sig = sig - y\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\n ### END YOUR CODE\n\n return grad","def get_updates(self, theta, cost=None, gtheta=None):\n if gtheta is None:\n assert cost is not None\n #Gradient of weights\n gtheta = T.grad(cost, theta)\n\n i = theano.shared(np.asarray(0., dtype=theano.config.floatX))#floatX(0.))\n i_t = i + 1.\n\n l_r = self.lr_update(i_t)\n mom = self.momentum_update(i_t) # momentum\n\n updates = []\n #Previous update needed for momentum. Initalized to 0.\n v = theano.shared(value=np.zeros(theta.size.eval(), dtype=theano.config.floatX))\n v_upd = mom * v - l_r * gtheta\n\n if self.momentum_type == self.momentum_types[0]:\n theta_new = theta + v_upd\n elif self.momentum_type == self.momentum_types[1]:\n theta_new = theta + mom * v_upd - l_r * gtheta\n else:\n raise NotImplementedError\n\n updates.append((v, v_upd))\n updates.append((theta, theta_new))\n self.opt_parameters['lr'] = l_r\n self.opt_parameters['mom'] = mom\n\n return updates","def gradient(theta, X, y, learning_rate):\n m = len(y)\n\n theta = theta.reshape((-1,1))\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta)) \n \n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return grad","def update_parameters(self, learning_rate):\n for i in range(self.L - 1):\n self.W[i] -= learning_rate * self.dW[i]\n self.b[i] -= learning_rate * self.db[i]","def update_params(self, learning_rate):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\t\tself._W = self._W - learning_rate * self._grad_W_current\n\t\tself._b = self._b - learning_rate * self._grad_b_current\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def update(params: hk.Params, opt_state: OptState, batch, labels, xent_weight=self.weights, l1_coeff=self.l1_coef, l2_coeff=self.l2_coef) -> Tuple[hk.Params, OptState]:\n grads = jax.grad(loss)(params, batch, labels, xent_weight, l1_coeff, l2_coeff)\n updates, opt_state = opt.update(grads, opt_state)\n new_params = optax.apply_updates(params, updates)","def _update_parameters(self, loss):\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()","def solution_update(self, theta, force=False):\n \n self.x = self.eval(theta, force)\n \n return","def __update_weights_grad_desc(self, x_train, y_train):\n\n predictions = self.__compute_prediction(x_train)\n weights_delta = np.dot(x_train.T, y_train - predictions)\n\n m = y_train.shape[0]\n self.__weights += self.__learning_rate / float(m) * weights_delta","def gradientdescent(cost_func, theta, args=(), delta_func = 0):\n step = 1\n old_cost = 0\n while True:\n theta_old = theta.copy()\n cost = cost_func(theta, *args)\n delta = delta_func(theta, *args)\n theta = theta - step * delta\n if cost > old_cost and old_cost != 0:\n step = step*0.7\n if np.allclose(theta_old, theta):\n break\n old_cost = cost\n return theta","def update_param(self, lr):\n\n\n self.W=self.W-lr*self.W_grad\n self.b = self.b - lr*self.b_grad","def updateParams(self,gradients):\n for i in xrange(len(self.params)):\n self.params[i].set_value(self.params[i].get_value()-gradients[i]/(1/self.learning_rate+self.iterations))","def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas","def gradient_descent(features, values, theta, alpha, num_iterations):\n \n # number of points\n npoints = len(values)\n \n # intialize cost history\n cost_history = []\n \n # num_interations iterations\n for iiter in range(num_iterations):\n \n # compute and store cost\n cost = compute_cost(features, values, theta)\n cost_history.append(cost)\n \n # update values of theta\n values_predicted = np.dot(features, theta)\n theta = theta + (alpha/npoints)*(np.dot(values - values_predicted,features))\n \n return theta, pandas.Series(cost_history)","def _set_weights(self, theta):\n self.rnn.theta.set_value(theta)","def update_parameters(parameters, grads, learning_rate=0.01):\n # Retrieve each parameter from the dictionary \"parameters\"\n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = parameters[\"W1\"]\n b1 = parameters[\"b1\"]\n W2 = parameters[\"W2\"]\n b2 = parameters[\"b2\"]\n W3 = parameters[\"W3\"]\n b3 = parameters[\"b3\"]\n ### END CODE HERE ###\n\n # Retrieve each gradient from the dictionary \"grads\"\n ### START CODE HERE ### (≈ 4 lines of code)\n dW1 = grads[\"dW1\"]\n db1 = grads[\"db1\"]\n dW2 = grads[\"dW2\"]\n db2 = grads[\"db2\"]\n dW3 = grads[\"dW3\"]\n db3 = grads[\"db3\"]\n ## END CODE HERE ###\n\n # Update rule for each parameter\n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = W1 - (learning_rate * dW1)\n b1 = b1 - (learning_rate * db1)\n W2 = W2 - (learning_rate * dW2)\n b2 = b2 - (learning_rate * db2)\n W3 = W3 - (learning_rate * dW3)\n b3 = b3 - (learning_rate * db3)\n ### END CODE HERE ###\n\n parameters = {\"W1\": W1,\n \"b1\": b1,\n \"W2\": W2,\n \"b2\": b2,\n \"W3\": W3,\n \"b3\": b3}\n\n return parameters","def call(self, y_true, theta):\n\n @tf.custom_gradient\n def forward(theta):\n diff = self.perturbed(theta) - tf.cast(y_true, dtype=theta.dtype)\n if not self._maximize:\n diff = -diff\n\n def grad(dy):\n if self._batched: # dy has shape (batch_size,) in this case.\n dy = tf.reshape(dy, [tf.shape(dy)[0]] + (diff.shape.rank - 1) * [1])\n return dy * diff\n\n # Computes per-example loss for batched inputs. If the total loss for the\n # batch is the desired output, use `SUM` or `SUM_OVER_BATCH` as reduction.\n if self._batched:\n loss = tf.reduce_sum(\n tf.reshape(diff, [tf.shape(diff)[0], -1]) ** 2, axis=-1)\n else: # Computes loss for unbatched inputs.\n loss = tf.reduce_sum(diff ** 2)\n\n return loss, grad\n\n return forward(theta)","def update_weights(self):\n\n\n self.w += self.learn_rate * (self.X.T.dot(self.T - self.Y)\n - self.reg_L1 * np.sign(self.w)\n - self.reg_L2 * 2*self.w)","def reg_autograd(alpha,X,theta,y):\n g=grad(func)\n for i in range(0,20):\n theta=theta- alpha * g(theta)\n print(\"cost\", func(theta))\n print(\"final theta\",theta)","def gradientDescent(X, y, theta, alpha, num_iters):\n\n # Initialize some useful values\n J_history = []\n m = y.size # number of training examples\n\n for i in range(num_iters):\n # ====================== YOUR CODE HERE ======================\n # Instructions: Perform a single gradient step on the parameter vector\n # theta.\n #\n # Hint: While debugging, it can be useful to print out the values\n # of the cost function (computeCost) and gradient here.\n #\n # Calculate the gradient step according to the equation for theta1:\n g_step1 = (alpha / m * np.sum( (np.dot(X,theta) - y) * X[:,1]) )\n # Gradient step for theta knot:\n g_step0 = (alpha / m * np.sum( (np.dot(X,theta) - y) ) )\n \n #update theta\n theta[0] = (theta[0] - g_step0)\n theta[1] = (theta[1] - g_step1)\n \n #print([theta , g_step1, g_step0])\n\n # ============================================================\n\n # Save the cost J in every iteration\n J_history.append(computeCost(X, y, theta))\n\n return theta, J_history","def get_updates(self, theta, cost=None, gtheta=None):\n updates = []\n if gtheta is None:\n assert cost is not None\n gtheta = T.grad(cost, theta)\n i = theano.shared(np.asarray(0., dtype=theano.config.floatX))#floatX(0.))\n i_t = i + 1.\n fix1 = 1. - self.b1**i_t\n fix2 = 1. - self.b2**i_t\n lr_t = self.step_size * (T.sqrt(fix2) / fix1)\n\n m = theano.shared(theta.get_value() * 0.)\n v = theano.shared(theta.get_value() * 0.)\n m_t = self.b1 * m + (1-self.b1) * gtheta\n v_t = self.b2 * v + (1-self.b2) * T.sqr(gtheta)\n g_t = m_t / (T.sqrt(v_t) + self.e)\n theta_t = theta - (lr_t * g_t)\n updates.append((m, m_t))\n updates.append((v, v_t))\n updates.append((theta, theta_t))\n updates.append((i, i_t))\n return updates","def apply_gradient(self, learning_rate):\n raise NotImplementedError()","def update_params(self, learning_rate=0.1):\n\n self.params['W'] = self.params['W'] - learning_rate * self.dW # update weights\n self.params['b'] = self.params['b'] - learning_rate * self.db # update bias(es)","def perform_update(self, gradient):\n w = sys.modules[self.shared_mem_name].__dict__[\"w\"]\n w -= self.learning_rate * gradient","def gradient_descent(X, y, theta, alpha, total_iterations, hypothesis):\n len_theta = len(theta)\n m = len(y)\n one_over_m = (1.0 / float(m))\n\n for _ in range(0, total_iterations):\n temp_theta = numpy.zeros(len_theta)\n\n X_by_theta_minus_y = numpy.subtract(hypothesis(numpy.matrix(theta), X), y)\n\n for j in range(0, len_theta):\n jth_column_of_X = X[:,j]\n derivative_j = one_over_m * numpy.multiply(X_by_theta_minus_y, jth_column_of_X).sum()\n temp_theta[j] = theta[j] - alpha*derivative_j\n\n theta = temp_theta\n\n return numpy.matrix(theta)","def train_fn_grad(self, theta_value, theta):\n theta.set_value(theta_value, borrow=True)\n\n train_grads = [self.batch_grad(i, self.n_train)\n for i in xrange(self.n_train_batches)]\n train_batch_sizes = [self.get_batch_size(i, self.n_train)\n for i in xrange(self.n_train_batches)]\n\n return np.average(train_grads, weights=train_batch_sizes,\n axis=0)","def update(self, max_norm=1.0):\n \n theta_prime = []\n\n for i, batch in enumerate(self.tasks):\n y_hat = self.constraint(self.theta, self.f(batch)) # gather predictions to single dimension\n loss = self.criteon( y_hat, self.y )\n #compute gradients\n grad = torch.autograd.grad(loss, self.theta)\n #update params\n theta_prime.append( self.theta - self.alpha * grad[0] )\n\n del loss\n\n #perform meta-update\n m_loss = torch.tensor(0.0, requires_grad=True)\n for i in range(len(self.tasks)):\n theta = theta_prime[i]\n batch = self.tasks[i]\n y_hat = self.constraint(theta, self.f(batch)) # gather predictions to single dimension\n m_loss = m_loss + self.criteon( y_hat, self.y ) # updating meta-loss\n \n #zero gradient before running backward pass\n self.meta_optim.zero_grad()\n\n #backward pass\n m_loss.backward(retain_graph=True)\n\n #clip gradients\n nn.utils.clip_grad_norm_([self.theta], max_norm)\n \n #one-step gradient descent\n self.meta_optim.step()","def update_parameters(parameters, grads, learning_rate = 1.2):\n\t# Retrieve each parameter from the dictionary \"parameters\"\n\tW1 = parameters['W1']\n\tb1 = parameters['b1']\n\tW2 = parameters['W2']\n\tb2 = parameters['b2']\n\n\t# Retrieve each gradient from the dictionary \"grads\"\n\tdW1 = grads['dW1']\n\tdb1 = grads['db1']\n\tdW2 = grads['dW2']\n\tdb2 = grads['db2']\n\n\t# Update rule for each parameter\n\tW1 = W1 - learning_rate*dW1\n\tb1 = b1 - learning_rate*db1\n\tW2 = W2 - learning_rate*dW2\n\tb2 = b2 - learning_rate*db2\n\n\tparameters = {\"W1\": W1,\n\t\t\t\t\t\"b1\": b1,\n\t\t\t\t\t\"W2\": W2,\n\t\t\t\t\t\"b2\": b2}\n\n\treturn parameters","def with_params(self, theta):\n self.params = theta\n return self","def gradient_descent(features, values, theta, alpha, num_iterations):\r\n\r\n m = len(values)\r\n cost_history = []\r\n\r\n for i in range (num_iterations):\r\n \r\n h = numpy.dot(features, theta)\r\n \r\n theta = theta - alpha / m * numpy.dot((h-values),features)\r\n \r\n cost = compute_cost(features, values, theta)\r\n \r\n cost_history.append(cost)\r\n\r\n return theta, pandas.Series(cost_history) # leave this line for the grader\r","def _update_params(self, gradients: dict, learning_rate: float):\n L = len(self.activations)\n\n for l in range(L):\n self.params[\"W_\" + str(l + 1)] = self.params[\"W_\" + str(l + 1)] - learning_rate * gradients[\n \"dW\" + str(l + 1)]\n\n self.params[\"b_\" + str(l + 1)] = self.params[\"b_\" + str(l + 1)] - learning_rate * gradients[\n \"db\" + str(l + 1)]","def gradient_descent(initial_theta, X, y, niter, alpha, Lambda=0.0):\n theta_list = []\n cost_list = []\n\n theta = initial_theta\n for i in range(0, niter):\n theta -= alpha*gradient(theta, X, y, Lambda)\n theta_list.append(theta)\n cost_list.append(cost(theta, X, y, Lambda))\n\n return theta_list, cost_list","def _learn_using_GD(self, y, tx, w, fn, gamma, lambda_, regularization):\n loss, grad = fn(y, tx, w, lambda_)\n loss, grad = self.apply_regularization(w, loss, grad, regularization, lambda_, tx.shape[0])\n w = w - gamma * grad\n return loss, w","def grad(X, y, nn_params, _lambda, input_layer_size,\n hidden_layer_size, num_labels, n_hidden_layers=1):\n theta = unravel_params(nn_params, input_layer_size, hidden_layer_size,\n num_labels, n_hidden_layers)\n\n # Initi gradient with zeros\n theta_grad = empty((n_hidden_layers + 1), dtype=object)\n for i in range(len(theta)):\n theta_grad[i] = zeros(shape=theta[i].shape, dtype=float64)\n\n m, n = X.shape\n intercept = ones((m, 1), dtype=float64)\n X = append(intercept, X, axis=1)\n\n for t in range(m):\n\n z, a = feed_forward(X[[t], :], theta, n_hidden_layers)\n delta = back_propagation(y[t, :], theta, a, z,\n num_labels, n_hidden_layers)\n\n for l in range(len(theta_grad)):\n theta_grad[l] = theta_grad[l] + dot(delta[l + 1].T, a[l])\n\n for i in range(len(theta_grad)):\n theta_grad[i] = (1 / m) * theta_grad[i]\n\n # regularization\n for i in range(len(theta_grad)):\n theta_grad[i][:, 1:] = theta_grad[i][:, 1:] + \\\n (_lambda / m) * theta[i][:, 1:]\n\n flat_theta_grad = append(theta_grad[0].flatten(), theta_grad[1].flatten())\n for i in range(2, len(theta_grad)):\n flat_theta_grad = append(flat_theta_grad, theta_grad[i].flatten())\n\n return flat_theta_grad","def weights_update(self, previous_layer_output, learning_rate, l2_lambda, batch_size):\n theta, b, delta, alpha = self.theta, self.b, self.delta, learning_rate\n dc_dtheta = np.dot(previous_layer_output, delta.T).transpose()\n dc_dtheta = np.divide(1, batch_size) * dc_dtheta\n new_theta = theta*(1 - l2_lambda * alpha) - alpha * dc_dtheta\n b_prime = np.sum(delta, axis=1).reshape(b.shape)\n b_prime = b_prime * np.divide(1, batch_size)\n new_b = b - alpha * b_prime\n self.theta, self.b = new_theta, new_b","def update(self, X, y):\n proba = self.predict_proba(X)\n top_loss = proba - y\n bias_gradient = np.sum(top_loss)\n weight_gradient = (top_loss).T.dot(X)\n\n # the gradient update\n self.b = self.b - self.lrate * bias_gradient\n self.W = self.W - self.lrate * weight_gradient","def assign_value_to_theta(self, sess):\n import tensorflow as tf\n\n assert self.initialised, \"This model must be initialised (self.initialisation()).\"\n\n keys = sorted(self.variables.keys())\n keys = [ key for key in keys if critere_keys(key)]\n\n diff = 0\n for i, key in enumerate(keys):\n diff_temp = sess.run(self.variables[key]) - self.theta_copy[i]\n settings.l_theta[i] += diff_temp\n diff += np.linalg.norm(diff_temp)\n return diff","def gradient_descent(features, values, theta, alpha, num_iterations):\n m = len(values)\n cost_history = []\n\n for i in range(num_iterations):\n predicted_values = np.dot(features, theta)\n delta = alpha / m * np.dot((predicted_values - values), features)\n theta = theta - delta\n cost = compute_cost(features, values, theta)\n cost_history.append(cost)\n return theta, pandas.Series(cost_history)","def gradientFunctionReg(theta, X, y, Lambda): \n y = np.squeeze(y)\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad[1:] = grad[1:] + Lambda*theta[1:]\n grad /= m\n\n return grad","def jacobian(theta, event, parameters_to_fit):\n for (key, val) in enumerate(parameters_to_fit):\n setattr(event.model.parameters, val, theta[key])\n return event.chi2_gradient(parameters_to_fit)","def update_target(self):\n with torch.no_grad():\n for target_q_param, q_param in zip(self.target_q_funcs.parameters(), self.q_funcs.parameters()):\n target_q_param.data.copy_(self.tau * q_param.data + (1.0 - self.tau) * target_q_param.data)\n for target_pi_param, pi_param in zip(self.target_policy.parameters(), self.policy.parameters()):\n target_pi_param.data.copy_(self.tau * pi_param.data + (1.0 - self.tau) * target_pi_param.data)","def stochasticGradientDescent(x,y,theta,alpha):\n m,n = np.shape(x)\n convergence = 0.000000001\n lastCost = 0\n cost = -1 \n recurseCount = 0\n while abs(lastCost - cost) > convergence: # rcurse until converge\n lastCost = cost\n hypothesis = np.dot(x,theta) \n for i in range(m):\n # alpha = 4.0 / (1.0 + i) + 0.01 \n loss = hypothesis[i] - y[i]\n # gradient = np.dot(x[i],loss)\n gradient = x[i,:].transpose() * loss \n theta = theta - alpha * gradient\n cost = np.sum((hypothesis-y)**2)/(2*m)\n recurseCount += 1\n return recurseCount,theta","def lrCostFunction(theta,X,y, lambda_reg):\n m = np.size(y)\n grad = np.zeros(np.size((theta)))\n J_base, grad = costFunction(theta, X, y)\n \n\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\n \n reg_gradient = (lambda_reg / m) * theta\n reg_gradient[0] = 0\n cost = J_base + reg_cost\n return cost, grad + reg_gradient","def update(\r\n params: hk.Params,\r\n opt_state: OptState,\r\n batch, label, agreement\r\n ) -> Tuple[hk.Params, OptState]:\r\n # grads = jax.grad(loss)(params, batch, label)\r\n # grads_masked = (gradient_per_sample if use_ilc else gradient)(params, batch, label) # (gradient_per_sample)(params, batch, label)\r\n # sum_grad_masked_regularized = jax.tree_multimap(lambda x,y:x+y,grads_masked,gradient_reg(params))\r\n # grads = sum_grad_masked_regularized\r\n # updates, opt_state = opt.update(grads, opt_state)\r\n # new_params = optax.apply_updates(params, updates)\r\n\r\n grads_samples = gradient_per_sample(params, batch, label)\r\n ANDmask = and_mask(agreement)\r\n\r\n masked_grads,_ = ANDmask.update(grads_samples, opt_state)\r\n reg_grads = gradient_reg(params)\r\n\r\n sum_grad_masked_regularized = jax.tree_multimap(lambda x,y:x+y,masked_grads,reg_grads)\r\n \r\n updates,_ = opt.update(sum_grad_masked_regularized, opt_state)\r\n\r\n new_params = optax.apply_updates(params, updates)\r\n\r\n return new_params, opt_state","def batchGradientDescent(x,y,theta,alpha):\n m,n = np.shape(x)\n xTran = x.transpose()\n convergence = 0.000000001\n lastCost = 0\n cost = -1 \n recurseCount = 0\n while abs(lastCost - cost) > convergence: # rcurse until converge\n lastCost = cost\n hypothesis = np.dot(x,theta)\n loss = hypothesis - y\n cost = np.sum(loss**2)/(2*m)\n gradient = np.dot(xTran,loss)/m\n theta = theta - alpha*gradient\n recurseCount += 1\n return recurseCount,theta","def gradient(self, theta):\n a = -(6 * self.scale ** 2)\n b = 3 * self.scale ** 2 + np.exp(2 * theta)\n b *= np.log(3 * self.scale ** 2 * np.exp(-2 * theta) + 1)\n return a / b","def run_gradient_descent_iteration(X, Y, theta, alpha, lambda_factor, temp_parameter):\n delta = sparse.coo_matrix(theta.shape).toarray()\n\n h = compute_probabilities(X, theta, temp_parameter)\n\n for j in range(delta.shape[0]):\n y = Y\n y = np.where(y != j, 0, 1)\n p = y - h[j]\n\n x = X.T * p\n x = x.T\n x = x.sum(axis=0)\n\n grad = -x / (temp_parameter * X.shape[0]) + lambda_factor * theta[j]\n\n delta[j] += grad\n\n theta -= alpha * delta\n\n return theta","def gradient_descent(features, values, theta, alpha, num_iterations):\r\n \r\n m = len(values)\r\n cost_history = []\r\n\r\n for i in range(num_iterations):\r\n # your code here\r\n cost = compute_cost(features, values, theta)/(2.0*m)\r\n cost_history.append([cost])\r\n \r\n error = features.dot(theta) - values\r\n error = np.reshape(error,(error.shape[0], 1))\r\n errorWeighted = features*error\r\n errorSum = (np.sum(errorWeighted,0))/(m*1.0)\r\n theta = theta - alpha*errorSum \r\n \r\n return theta, pandas.Series(cost_history)","def learning_by_gradient_descent(y, tx, w, gamma):\n loss = calculate_loss(y,tx,w)\n grad = calculate_gradient(y,tx,w)\n w_new = w - gamma*grad\n #grad is for debugging purpose\n return loss, w_new,grad","def learning_by_penalized_gradient(y, tx, w, gamma, lambda_):\n\n #on test avec Newton\n\n loss,gradient,_ = penalized_logistic_regression(y,tx,w,lambda_)\n\n w = w - gamma*gradient\n return loss, w,gradient","def approx_grad(theta, X, y):\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","def GradientDescent(x, y, theta, alpha, tolerate, maxiterate, epsilon):\n i = 0 # set the iteration counting index\n tolerate_rule = 1 # set the initial tolerate rate\n n = x.shape[0]\n current_theta = theta\n scost_vector = np.empty([0, 1])\n lcost_vector = np.empty([0, 1])\n hcost_vector = np.empty([0, 1])\n\n # iterate\n while tolerate_rule >= tolerate and i <= maxiterate:\n sl = np.array(SquareLoss(x, y, current_theta)).reshape([1, 1])\n scost_vector = np.append(scost_vector, sl, axis=0) # store cost\n abs = np.array(AbsoluteLoss(x, y, current_theta)).reshape([1, 1])\n lcost_vector = np.append(lcost_vector, abs, axis=0) # store cost\n hbs = np.array(HuberLoss(x, y, current_theta, epsilon)).reshape([1, 1])\n hcost_vector = np.append(hcost_vector, hbs, axis=0) # store cost\n fx = x @ current_theta\n update_theta = current_theta - alpha * (1/n) * x.transpose() @ (fx - y)\n tolerate_rule = np.minimum(np.abs(update_theta - current_theta))\n i += 1\n current_theta = update_theta\n\n cost_matrix = np.asmatrix(np.stack((scost_vector, lcost_vector,\n hcost_vector),\n axis=-1))\n cost_dataframe = pd.DataFrame(cost_matrix, columns=['AbsoluteLoss',\n 'SquareLoss',\n 'HuberLoss'])\n return(current_theta, cost_dataframe)","def theta(self, theta):\n self.kernel.theta = theta","def update(self, x, y, theta):\n self.x = x\n self.y = y\n self.theta = theta\n self.theta = wrap_angles(self.theta)","def gradientDescent(self,X, y, theta): \n # number of instances\n m = len(y)\n J_history = np.zeros((self.NUM_ITERS,1))\n for i in range(self.NUM_ITERS):\n h = self.sigmoid(X@theta)\n grad = 1 / m * X.T @ (h - y)\n theta = theta - self.ALPHA * grad \n J_history[i] = self.costFunction(theta, X, y)\n \n \n return theta, J_history","def lr_cost_function(theta, X, y, learning_rate):\n m = len(y) # number of training examples\n # You need to return the following variables correctly \n J = 0\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta))\n\n #Compute cost:\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n \n #Compute gradient\n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return float(J), grad","def optimizer(self):\n \n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\n # I believe this is a work around to get keras to learn **given a gradient**\n # As opposed to bunch of x_train, y_trains?\n \n #Inputs\n state_pl = self.model.input\n action_grads_pl = K.placeholder(shape=(None,1)) \n \n #Find grad_(pars) mu(state)\n mu_pl = self.model.output\n pars = self.model.trainable_weights\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\n \n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\n\n # The gradients as defined above work on my mac, but not ubuntu.\n # Below I am trying a workaround. I changed the keras source code \n # To get this working. Specifically, I make the optimizer.get_updates()\n # function accept custom gradients. It was easy to do.\n \n opt = Adam(self.lr)\n loss = pars_grad_mu #placeholder, I won't use it\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\n\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])","def apply_gradient(params: torch.Tensor, grads: torch.Tensor, lr: float) -> torch.Tensor:\n params_prime = params + lr * grads\n return params_prime","def compute_cost(features, values, theta):\r\n \r\n # your code here\r\n error = (values - features.dot(theta))\r\n cost = error.dot(error) \r\n return cost","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return grad","def gradient_update(self, states, Q_target):\n params = [self.w1, self.w2, self.w3, self.b1, self.b2, self.b3]\n loss = self.get_loss(states, Q_target)\n gradients = nn.gradients(loss, params)\n self.w1.update(gradients[0], -self.learning_rate)\n self.w2.update(gradients[1], -self.learning_rate)\n self.w3.update(gradients[2], -self.learning_rate)\n self.b1.update(gradients[3], -self.learning_rate)\n self.b2.update(gradients[4], -self.learning_rate)\n self.b3.update(gradients[5], -self.learning_rate)","def update_parameters_with_gd(parameters, grads, learning_rate):\n\n L = len(parameters) // 2 # number of layers in the neural networks\n\n # Update rule for each parameter\n for l in range(L):\n ### START CODE HERE ### (approx. 2 lines)\n parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)]-learning_rate* grads[\"dW\" + str(l+1)]\n parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)]-learning_rate* grads[\"db\" + str(l+1)]\n ### END CODE HERE ###\n \n return parameters","def run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta):\n n = len_data\n # WE NEED TO transpose data_x into (p+1) *n ,theta is 1*(p+1)\n prod = np.dot(theta, data_x.transpose())\n\n prod -= data_y\n print(\"pro: data_x\", prod.shape, data_x.shape)\n #prod represent the loss of the hypothesis and true label\n sum_grad = np.dot(prod, data_x)\n print(\"总梯度的值：\",sum_grad.shape)\n\n # batch-gradient descent\n theta = theta -(alpha / n) * sum_grad\n return theta","def _update(self, x: np.ndarray, y: int):\n decision = self.weights.dot(x)\n v_t = x @ np.diag(np.diag(self._sigma)) @ x.T\n m_t = y * decision\n loss = (self._phi * math.sqrt(v_t) - m_t)\n #print(loss)\n if loss > 0:\n # We scale our learning rate (alpha) using the weight/cost\n alpha_t = self.class_weight_[y] * self._get_alpha(m_t, v_t)\n u_t = 0.25 * (-alpha_t * v_t * self._phi + math.sqrt(\n alpha_t ** 2 * v_t ** 2 * self._phi ** 2 + 4 * v_t)) ** 2\n beta_t = alpha_t * self._phi / (math.sqrt(u_t) +\n alpha_t * self._phi * v_t)\n sigma = np.expand_dims(x @ self._sigma, axis=0)\n self.weights += alpha_t * y * np.squeeze(sigma)\n self._sigma -= beta_t * sigma.T @ sigma","def update_weights(x_train, y_train, weights, learning_rate):\r\n predictions = compute_prediction(x_train, weights)\r\n weights_delta = np.dot(x_train.T, y_train - predictions)\r\n m = y_train.shape[0]\r\n weights += learning_rate / float(m) * weights_delta\r\n return weights","def _update_parameters(self, curr_state, reward, next_state):\n phi = self._features.vector(curr_state)\n phi_dash = self._features.vector(next_state)\n\n self._A += np.outer(phi, (phi - self._gamma * phi_dash))\n self._b += reward * phi","def differential_of_minimized_cost_function_theta_1(m = no_of_training_examples, x, y, theta_0, theta_1, initial_theta1):\r\n initial_val = initial_theta1\r\n compute_1 = [val cost_function(val, theta_0, theta_1)] # computes the corresponding value of x given theta_0 and theta_1(list comprehension)\r\n compute_2 = [var_x-var_y for var_x, var_y in zip(compute_1,y)] # subtracts the corresponding values of x and y (list comprehension)\r\n theta = sum(compute_2)/m\r\n if initial_theta == updated_theta:\r\n return updated_theta\r\n else:\r\n differential_of_minimized_cost_function(m = no_of_training_examples, x, y, theta_0, theta_1 = theta, initial_theta1 = initial_val) # returns itself (recursion)\r","def update_parameters(parameters, grads, learning_rate):\n L = len(parameters) // 2\n\n for i in range(L):\n parameters[\"W\"+str(i+1)] = parameters[\"W\"+str(i+1)] - learning_rate * grads[\"dW\"+str(i+1)]\n parameters[\"b\"+str(i+1)] = parameters[\"b\"+str(i+1)] - learning_rate * grads[\"db\"+str(i+1)]\n\n return parameters","def update_theta_beta(data, lr, theta, beta):\n #####################################################################\n # TODO: #\n # Implement the function as described in the docstring. #\n #####################################################################\n dtheta = []\n dbeta = []\n \n N = len(theta)\n M = len(beta)\n \n theta_mid = {x: [] for x in range(N)}\n beta_mid = {x: [] for x in range(M)}\n \n assert len(data[\"user_id\"]) == len(data[\"question_id\"])\n assert len(data[\"user_id\"]) == len(data[\"is_correct\"])\n \n length = len(data[\"user_id\"])\n for s in range(length):\n i = data[\"user_id\"][s]\n j = data[\"question_id\"][s]\n cij = data[\"is_correct\"][s]\n theta_i = theta[i]\n beta_j = beta[j]\n theta_mid[i].append(cij - sigmoid(theta_i-beta_j))\n beta_mid[j].append(-1*cij+sigmoid(theta_i-beta_j))\n \n for i in range(N):\n dtheta.append(-1*sum(theta_mid[i]))\n for j in range(M):\n dbeta.append(-1*sum(beta_mid[j]))\n\n theta -= lr * np.array(dtheta, dtype=np.float32)\n beta -= lr * np.array(dbeta, dtype=np.float32)\n\n #####################################################################\n # END OF YOUR CODE #\n #####################################################################\n return theta, beta","def update(self, gradient, optimizer=None, relink=None):\n # Recover the defaults, if missing\n optimizer = self._resolve_defaults(optimizer=optimizer)[0]\n # Set the gradient\n self.set_gradient(gradient, relink=(self._config.relink if relink is None else relink))\n # Perform the update step\n optimizer.step()","def optimize(self, learning_rate=0.0002, beta1=0.5, global_step=None):\n opt = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=beta1)\n return opt.apply_gradients(self.gradients, global_step=global_step)","def learning_by_gradient_descent(y, tx, w, gamma):\n\tgrad = calculate_gradient(y, tx, w)\n\n\tw = w - gamma * grad\n\treturn w","def update(self,parameters, grads):\n \n L = len(parameters) // 2 # number of layers in the neural network\n #print(L)\n\n # Update rule for each parameter. Use a for loop.\n for l in range(L):\n \n parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)] - self.alpha * grads[\"dW\" + str(l+1)]\n \n parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)] - self.alpha * grads[\"db\" + str(l+1)]\n \n parameters[\"W\" + str(l+1)][np.isnan(parameters[\"W\" + str(l+1)])] = 0\n parameters[\"b\" + str(l+1)][np.isnan(parameters[\"b\" + str(l+1)])] = 0\n \n return parameters","def _UpdateGradient(self):\n self.mol.GetGradient('analytic')","def learning_by_penalized_gradient(y, tx, w, gamma, lambda_):\n\tgrad, H = penalized_logistic_regression(y, tx, w, lambda_)\n\n\thgrad = np.linalg.inv(H).dot(grad)\n\n\tw = w - gamma * hgrad\n\n\treturn w","def updateW(self, trj_Sp_theta, W_0):\n def fun(x):\n global trj_Sp_theta_z\n\n W_0 = x\n r_0 = self.reward_trj(trj_Sp_theta, W_0)\n return -1*r_0 \n import numpy as np\n from scipy.optimize import minimize\n \n global trj_Sp_theta_z \n trj_Sp_theta_z = trj_Sp_theta\n alpha = 0.2\n delta = alpha\n cons = ({'type': 'eq',\n 'fun' : lambda x: np.array([np.sum(x)-1])},\n {'type': 'ineq',\n 'fun' : lambda x: np.array([np.min(x)])},\n {'type': 'ineq',\n 'fun' : lambda x: np.array([np.abs(np.sum(x-x0))+delta])})\n\n x0 = W_0\n res = minimize(fun, x0, constraints=cons)\n\n x = res.x\n\n W = x/(np.sum(x)) # changed\n return W","def update_parameters(parameters: Dict,\n grads: Dict, learning_rate: float) -> Dict:\n L = len(parameters)//2 # number of layers\n\n for l in range(1, L+1):\n parameters['W'+str(l)] -= learning_rate * grads['dW'+str(l)]\n parameters['b'+str(l)] -= learning_rate * grads['db'+str(l)]\n\n return parameters","def gradient_descent_step(self, x, y, learning_rate):\n # compute derivative of loss wrt Z\n dZ = self.derivative_loss(y, self.predict(x))\n dW = np.dot(dZ, x)\n # subtract average derivative from weights\n self.w -= learning_rate * 1.0/dW.shape[0] * dW\n if self.fit_b:\n self.b -= learning_rate * (1.0/x.shape[0] * np.sum(dZ))","def update_weights(self, X, Y, learning_rate):\n grads = self.calculate_gradients(X, Y)\n #update weights and biases\n self.weights[0] = self.weights[0] - learning_rate * grads[\"dW1\"]\n self.weights[1] = self.weights[1] - learning_rate * grads[\"dW2\"]\n self.biases[0] = self.biases[0] - learning_rate * grads[\"db1\"]\n self.biases[1] = self.biases[1] - learning_rate * grads[\"db2\"]","def approx_grad_reg(theta, X, y, _lambda):\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","def cost_derivation(update_param: np.ndarray,\n dependent_param: np.ndarray,\n label: int\n ) -> np.ndarray:\n return (sigmoid(update_param @ dependent_param) - label)*dependent_param","def test_update_parameters(model):\n train_inputs = torch.tensor([[1., 2., 3.]])\n train_loss = 0.5 * (model(train_inputs) ** 2)\n\n params = gradient_update_parameters(model,\n train_loss,\n params=None,\n step_size=0.5,\n first_order=False)\n\n assert train_loss.item() == 264.5\n assert list(params.keys()) == ['weight']\n assert torch.all(params['weight'].data == torch.tensor([[-9.5, -20., -29.5]]))\n\n \"\"\"\n The new loss function (still with respect to the weights of the model w) is\n defined as:\n g(w) = 0.5 * (4 * w'_1 + 5 * w'_2 + 6 * w'_3) ** 2\n = 0.5 * (4 * (w_1 - 0.5 * df / dw_1)\n + 5 * (w_2 - 0.5 * df / dw_2)\n + 6 * (w_3 - 0.5 * df / dw_3)) ** 2\n = 0.5 * (4 * (w_1 - 0.5 * 1 * (1 * w_1 + 2 * w_2 + 3 * w_3))\n + 5 * (w_2 - 0.5 * 2 * (1 * w_1 + 2 * w_2 + 3 * w_3))\n + 6 * (w_3 - 0.5 * 3 * (1 * w_1 + 2 * w_2 + 3 * w_3))) ** 2\n = 0.5 * ((4 - 4 * 0.5 - 5 * 1.0 - 6 * 1.5) * w_1\n + (5 - 4 * 1.0 - 5 * 2.0 - 6 * 3.0) * w_2\n + (6 - 4 * 1.5 - 5 * 3.0 - 6 * 4.5) * w_3) ** 2\n = 0.5 * (-12 * w_1 - 27 * w_2 - 42 * w_3) ** 2\n\n Therefore the gradient of the function g with respect to w (and evaluated\n at w = [2, 3, 5]) is:\n dg / dw_1 = -12 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 3780\n dg / dw_2 = -27 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 8505\n dg / dw_3 = -42 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 13230\n \"\"\"\n test_inputs = torch.tensor([[4., 5., 6.]])\n test_loss = 0.5 * (model(test_inputs, params=params) ** 2)\n\n grads = torch.autograd.grad(test_loss, model.parameters())\n\n assert test_loss.item() == 49612.5\n assert len(grads) == 1\n assert torch.all(grads[0].data == torch.tensor([[3780., 8505., 13230.]]))","def gradient(theta, X, y, Lambda=0.0):\n m = X.shape[0] # number of samples\n\n h = hypothesis(theta, X)\n\n if Lambda:\n g_0 = (1/m)*(X.T@(h - y))[0]\n g_1 = (1/m)*(X.T@(h - y))[1:] + (Lambda/m)*theta[1:] # skip theta-0\n \n return np.append(g_0, g_1)\n else:\n return (1/m)*(X.T@(h - y))","def update_b(self, theta, force=False):\n self.b = self.eval_b(self.theta)\n self.b_eval_cnt += 1","def updateWeights(inputs, outputs, learning_rate, y, weights):\n for i in range(len(weights)):\n weights[i] = weights[i] + learning_rate * (outputs - y) * inputs[i]\n return weights","def update_model_parameters(parameters, grads, learning_rate):\n L = len(parameters) /2 # number of layers in the neural network\n\n for l in range(int(L)):\n parameters[\"W\" + str(l + 1)] = parameters[\"W\" + str(l + 1)] - learning_rate * grads[\"dW\" + str(l + 1)]\n parameters[\"b\" + str(l + 1)] = parameters[\"b\" + str(l + 1)] - learning_rate * grads[\"db\" + str(l + 1)]\n return parameters\n # raise NotImplementedError","def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\n\n # Cost history\n cost_tracking = np.zeros(nb_iterations)\n\n for _i in range(nb_iterations):\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\n # recording the cost for each iteration\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\n\n return parameters, cost_tracking","def gradient_descent(regression_type, trainingData, theta,\n maxIter, learningRate):\n regression = None\n\n if(regression_type == 1):\n regression = LinearRegression()\n\n all_costs = zeros(maxIter)\n\n for num_iter in range(maxIter):\n\n gradient = regression.calculateGradient(trainingData, theta)\n gradient = gradient*learningRate\n\n theta = theta - gradient\n\n all_costs[num_iter] = regression.calculateCost(trainingData, theta)\n\n return (all_costs, theta)","def optimize_parameters(self):\n self.loss_total.backward() # calculate gradients\n self.optimizer.step()\n self.optimizer.zero_grad()\n torch.cuda.empty_cache()"],"string":"[\n \"def add_grad_updates(self):\\n \\n gradients = T.grad(self.cost, self.theta)\\n \\n for target_param, grad in zip(self.theta, gradients):\\n \\n if target_param.name ==\\\"W\\\" and self.num_hidden ==0\\\\\\n and self.zero_diag:\\n \\n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\\n # for all i = 1, ..., D\\n ##############################################################\\n if target_param.name ==\\\"b\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n elif target_param.name ==\\\"bhid\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n else:\\n \\n if self.use_momentum:\\n \\n # alternative definition (mostly seen):\\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n #self.updates[target_param] = target_param + g_tilda\\n \\n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n (1-self.momentum)*grad\\n \\n self.updates[target_param] = target_param +\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\\n \\n # store g_tilda for next iteration:\\n self.updates[self.grad_vec[target_param.name]] = g_tilda\\n \\n else:\\n \\n self.updates[target_param] = target_param -\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n \\n if (\\\"PCD\\\" in self.algorithm) and self.num_hidden > 0:\\n \\n self.updates[self.persistent_gibbs] = self.hid_samples\",\n \"def gradient(self, theta):\\n pass\",\n \"def gradient(self, theta):\\n pass\",\n \"def theta(self, theta):\\n n_theta_avail = self.n_theta\\n n_theta_suggest = len(theta)\\n if(n_theta_avail != n_theta_suggest):\\n raise ValueError(\\\"theta has not the correct number of entries.\\\"\\n \\\" Should be %d; given are %d\\\"\\n % (n_theta_avail, n_theta_suggest)) \\n\\n i = 0\\n if(self._FLAG_TYPE == 'base'): \\n params = self.get_params(bounds = False)\\n for p_name in self._LIST_PARAMETERS:\\n mask_free = self._get_one_free_mask(p_name)\\n nb_to_update = np.sum(mask_free)\\n if nb_to_update > 0: \\n params[p_name][mask_free] = np.array(theta[i:i + nb_to_update])\\n i += nb_to_update\\n\\n #That's wehere the updates really happen\\n self.set_params(**params)\\n\\n elif(self._FLAG_TYPE == 'collection'):\\n #Delegate updates to subobj\\n for sub in self.list_func_free:\\n nb_to_update_sub = sub.n_theta\\n if(nb_to_update_sub > 0):\\n sub.theta = theta[i:i + nb_to_update_sub]\\n i += nb_to_update_sub\\n\\n # check all the values in theta have been used\\n if i != len(theta):\\n raise ValueError(\\\"Something went wrong with nb of theta updated. \\\"\\n \\\" Should be %d; but it is only %d\\\"\\n % (n_theta_avail, i))\\n\\n self._check_integrity()\",\n \"def update_thetas(self, X, y, theta_list, bias, learning_rate):\\n total_samples = len(X)\\n theta_derivative = [0]*len(theta_list)\\n bias_derivative = 0\\n\\n for i in range(total_samples): #update the thetas and bias by gradient descent\\n hypothesis = 0\\n\\n hypothesis = hypothesis+bias\\n\\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\\n\\n sigmoidhypothesis = 1./(1.+np.exp(-hypothesis))\\n\\n sigmoidhypothesis = sigmoidhypothesis - y[i]\\n\\n bias_derivative += sigmoidhypothesis\\n\\n\\n feature_index=0\\n for feature_index in range(len(theta_list)):\\n theta_derivative[feature_index] += sigmoidhypothesis*X[i][feature_index]\\n\\n \\n bias -= (bias_derivative/total_samples) * learning_rate\\n\\n for j in range(len(theta_list)):\\n theta_list[j] -= (theta_derivative[j]/total_samples) * learning_rate\\n\\n return bias, theta_list\",\n \"def gradient_function(theta, X, y):\\n\\n grad = None\\n #######################################################################\\n # TODO: #\\n # Compute the gradient for a particular choice of theta. #\\n # Compute the partial derivatives and set grad to the partial #\\n # derivatives of the cost w.r.t. each parameter in theta #\\n # #\\n #######################################################################\\n \\n theta = theta[:, np.newaxis]\\n \\n thetatrans = theta.T\\n Xtrans = X.T\\n \\n MulThetaX = np.dot(thetatrans, Xtrans)\\n \\n h = sigmoid(MulThetaX)\\n \\n grad = (y - h) * Xtrans\\n\\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return grad\",\n \"def update_parameters(parameters, grads, learning_rate):\\n pass\",\n \"def get_updates(self, theta, cost=None, gtheta=None):\\n updates = []\\n if gtheta is None:\\n assert cost is not None\\n gtheta = T.grad(cost, theta)\\n\\n g2_sum = theano.shared(theta.get_value() * 0.)\\n g2_sum_upd = g2_sum + T.sqr(gtheta) \\n theta_upd = theta - self.learning_rate * gtheta/T.sqrt(g2_sum_upd + self.epsilon) \\n \\n updates.append((g2_sum, g2_sum_upd))\\n updates.append((theta, theta_upd))\\n return updates\",\n \"def gradientFunctionReg(theta, X, y, Lambda):\\n m = len(y) # number of training examples\\n grad = np.zeros(theta.shape[0])\\n theta = np.transpose(theta)\\n sum_1 = 0\\n X = X.values\\n y = y.values\\n #calcuate the theta_0 \\n# ====================== YOUR CODE HERE ======================\\n# Instructions: Compute the gradient of a particular choice of theta.\\n# Compute the partial derivatives and set grad to the partial\\n# derivatives of the cost w.r.t. each parameter in theta\\n for i in range(theta.shape[0]):\\n if i == 0:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\\n else:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\\n grad[i] = sum_1/m\\n sum_1 = 0\\n\\n# =============================================================\\n\\n return grad\",\n \"def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\\n # Initialize some useful values\\n m = len(y) # number of training examples\\n\\n # You need to return the following variable correctly.\\n grad = np.zeros(theta.shape)\\n\\n # ====================== YOUR CODE HERE ======================\\n # Instructions: Compute the partial derivatives and set grad to the partial\\n # derivatives of the cost w.r.t. each parameter in theta.\\n\\n # =============================================================\\n return grad\",\n \"def fit(self, X, y):\\n\\n n, m = X.shape[0], X.shape[1]\\n\\n # theta is (nx1) (one theta per dimension)\\n self.theta = np.random.uniform(-10, 10, (n, 1))\\n\\n for i in range(self.epochs):\\n # Get predictions\\n y_pred = self.predict(X)\\n\\n # calculate cost\\n # cost = ...\\n cost = self._cost_function(y_pred, y, m)\\n \\n\\n # gradient is an (n) x 1 array, it refers to the derivate per theta\\n gradient = self._cost_function_derivative(y_pred, y, X, m)\\n\\n # delta/update rule\\n self.theta = gradient\\n\\n self.costs.append(cost)\\n pass\\n\\n print(\\\"Final theta is {} (cost: {})\\\".format(self.theta.T, cost))\",\n \"def logit_cost_grad(self, theta, X, y):\\n\\n grad = np.zeros(len(theta))\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n # sig = np.subtract(sig, y)\\n sig = sig - y\\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\\n ### END YOUR CODE\\n\\n return grad\",\n \"def get_updates(self, theta, cost=None, gtheta=None):\\n if gtheta is None:\\n assert cost is not None\\n #Gradient of weights\\n gtheta = T.grad(cost, theta)\\n\\n i = theano.shared(np.asarray(0., dtype=theano.config.floatX))#floatX(0.))\\n i_t = i + 1.\\n\\n l_r = self.lr_update(i_t)\\n mom = self.momentum_update(i_t) # momentum\\n\\n updates = []\\n #Previous update needed for momentum. Initalized to 0.\\n v = theano.shared(value=np.zeros(theta.size.eval(), dtype=theano.config.floatX))\\n v_upd = mom * v - l_r * gtheta\\n\\n if self.momentum_type == self.momentum_types[0]:\\n theta_new = theta + v_upd\\n elif self.momentum_type == self.momentum_types[1]:\\n theta_new = theta + mom * v_upd - l_r * gtheta\\n else:\\n raise NotImplementedError\\n\\n updates.append((v, v_upd))\\n updates.append((theta, theta_new))\\n self.opt_parameters['lr'] = l_r\\n self.opt_parameters['mom'] = mom\\n\\n return updates\",\n \"def gradient(theta, X, y, learning_rate):\\n m = len(y)\\n\\n theta = theta.reshape((-1,1))\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta)) \\n \\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return grad\",\n \"def update_parameters(self, learning_rate):\\n for i in range(self.L - 1):\\n self.W[i] -= learning_rate * self.dW[i]\\n self.b[i] -= learning_rate * self.db[i]\",\n \"def update_params(self, learning_rate):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\t\\tself._W = self._W - learning_rate * self._grad_W_current\\n\\t\\tself._b = self._b - learning_rate * self._grad_b_current\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def update(params: hk.Params, opt_state: OptState, batch, labels, xent_weight=self.weights, l1_coeff=self.l1_coef, l2_coeff=self.l2_coef) -> Tuple[hk.Params, OptState]:\\n grads = jax.grad(loss)(params, batch, labels, xent_weight, l1_coeff, l2_coeff)\\n updates, opt_state = opt.update(grads, opt_state)\\n new_params = optax.apply_updates(params, updates)\",\n \"def _update_parameters(self, loss):\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\",\n \"def solution_update(self, theta, force=False):\\n \\n self.x = self.eval(theta, force)\\n \\n return\",\n \"def __update_weights_grad_desc(self, x_train, y_train):\\n\\n predictions = self.__compute_prediction(x_train)\\n weights_delta = np.dot(x_train.T, y_train - predictions)\\n\\n m = y_train.shape[0]\\n self.__weights += self.__learning_rate / float(m) * weights_delta\",\n \"def gradientdescent(cost_func, theta, args=(), delta_func = 0):\\n step = 1\\n old_cost = 0\\n while True:\\n theta_old = theta.copy()\\n cost = cost_func(theta, *args)\\n delta = delta_func(theta, *args)\\n theta = theta - step * delta\\n if cost > old_cost and old_cost != 0:\\n step = step*0.7\\n if np.allclose(theta_old, theta):\\n break\\n old_cost = cost\\n return theta\",\n \"def update_param(self, lr):\\n\\n\\n self.W=self.W-lr*self.W_grad\\n self.b = self.b - lr*self.b_grad\",\n \"def updateParams(self,gradients):\\n for i in xrange(len(self.params)):\\n self.params[i].set_value(self.params[i].get_value()-gradients[i]/(1/self.learning_rate+self.iterations))\",\n \"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\\n thetas = [theta]\\n cost = np.zeros(num_iters)\\n\\n J = mean_cross_entropy_costs(X, y, lambda_reg)\\n cost[0] = J(thetas[0])\\n for i in range(1, num_iters):\\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\\n cost[i] = J(thetas[i])\\n return cost, thetas\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\n \\n # number of points\\n npoints = len(values)\\n \\n # intialize cost history\\n cost_history = []\\n \\n # num_interations iterations\\n for iiter in range(num_iterations):\\n \\n # compute and store cost\\n cost = compute_cost(features, values, theta)\\n cost_history.append(cost)\\n \\n # update values of theta\\n values_predicted = np.dot(features, theta)\\n theta = theta + (alpha/npoints)*(np.dot(values - values_predicted,features))\\n \\n return theta, pandas.Series(cost_history)\",\n \"def _set_weights(self, theta):\\n self.rnn.theta.set_value(theta)\",\n \"def update_parameters(parameters, grads, learning_rate=0.01):\\n # Retrieve each parameter from the dictionary \\\"parameters\\\"\\n ### START CODE HERE ### (≈ 4 lines of code)\\n W1 = parameters[\\\"W1\\\"]\\n b1 = parameters[\\\"b1\\\"]\\n W2 = parameters[\\\"W2\\\"]\\n b2 = parameters[\\\"b2\\\"]\\n W3 = parameters[\\\"W3\\\"]\\n b3 = parameters[\\\"b3\\\"]\\n ### END CODE HERE ###\\n\\n # Retrieve each gradient from the dictionary \\\"grads\\\"\\n ### START CODE HERE ### (≈ 4 lines of code)\\n dW1 = grads[\\\"dW1\\\"]\\n db1 = grads[\\\"db1\\\"]\\n dW2 = grads[\\\"dW2\\\"]\\n db2 = grads[\\\"db2\\\"]\\n dW3 = grads[\\\"dW3\\\"]\\n db3 = grads[\\\"db3\\\"]\\n ## END CODE HERE ###\\n\\n # Update rule for each parameter\\n ### START CODE HERE ### (≈ 4 lines of code)\\n W1 = W1 - (learning_rate * dW1)\\n b1 = b1 - (learning_rate * db1)\\n W2 = W2 - (learning_rate * dW2)\\n b2 = b2 - (learning_rate * db2)\\n W3 = W3 - (learning_rate * dW3)\\n b3 = b3 - (learning_rate * db3)\\n ### END CODE HERE ###\\n\\n parameters = {\\\"W1\\\": W1,\\n \\\"b1\\\": b1,\\n \\\"W2\\\": W2,\\n \\\"b2\\\": b2,\\n \\\"W3\\\": W3,\\n \\\"b3\\\": b3}\\n\\n return parameters\",\n \"def call(self, y_true, theta):\\n\\n @tf.custom_gradient\\n def forward(theta):\\n diff = self.perturbed(theta) - tf.cast(y_true, dtype=theta.dtype)\\n if not self._maximize:\\n diff = -diff\\n\\n def grad(dy):\\n if self._batched: # dy has shape (batch_size,) in this case.\\n dy = tf.reshape(dy, [tf.shape(dy)[0]] + (diff.shape.rank - 1) * [1])\\n return dy * diff\\n\\n # Computes per-example loss for batched inputs. If the total loss for the\\n # batch is the desired output, use `SUM` or `SUM_OVER_BATCH` as reduction.\\n if self._batched:\\n loss = tf.reduce_sum(\\n tf.reshape(diff, [tf.shape(diff)[0], -1]) ** 2, axis=-1)\\n else: # Computes loss for unbatched inputs.\\n loss = tf.reduce_sum(diff ** 2)\\n\\n return loss, grad\\n\\n return forward(theta)\",\n \"def update_weights(self):\\n\\n\\n self.w += self.learn_rate * (self.X.T.dot(self.T - self.Y)\\n - self.reg_L1 * np.sign(self.w)\\n - self.reg_L2 * 2*self.w)\",\n \"def reg_autograd(alpha,X,theta,y):\\n g=grad(func)\\n for i in range(0,20):\\n theta=theta- alpha * g(theta)\\n print(\\\"cost\\\", func(theta))\\n print(\\\"final theta\\\",theta)\",\n \"def gradientDescent(X, y, theta, alpha, num_iters):\\n\\n # Initialize some useful values\\n J_history = []\\n m = y.size # number of training examples\\n\\n for i in range(num_iters):\\n # ====================== YOUR CODE HERE ======================\\n # Instructions: Perform a single gradient step on the parameter vector\\n # theta.\\n #\\n # Hint: While debugging, it can be useful to print out the values\\n # of the cost function (computeCost) and gradient here.\\n #\\n # Calculate the gradient step according to the equation for theta1:\\n g_step1 = (alpha / m * np.sum( (np.dot(X,theta) - y) * X[:,1]) )\\n # Gradient step for theta knot:\\n g_step0 = (alpha / m * np.sum( (np.dot(X,theta) - y) ) )\\n \\n #update theta\\n theta[0] = (theta[0] - g_step0)\\n theta[1] = (theta[1] - g_step1)\\n \\n #print([theta , g_step1, g_step0])\\n\\n # ============================================================\\n\\n # Save the cost J in every iteration\\n J_history.append(computeCost(X, y, theta))\\n\\n return theta, J_history\",\n \"def get_updates(self, theta, cost=None, gtheta=None):\\n updates = []\\n if gtheta is None:\\n assert cost is not None\\n gtheta = T.grad(cost, theta)\\n i = theano.shared(np.asarray(0., dtype=theano.config.floatX))#floatX(0.))\\n i_t = i + 1.\\n fix1 = 1. - self.b1**i_t\\n fix2 = 1. - self.b2**i_t\\n lr_t = self.step_size * (T.sqrt(fix2) / fix1)\\n\\n m = theano.shared(theta.get_value() * 0.)\\n v = theano.shared(theta.get_value() * 0.)\\n m_t = self.b1 * m + (1-self.b1) * gtheta\\n v_t = self.b2 * v + (1-self.b2) * T.sqr(gtheta)\\n g_t = m_t / (T.sqrt(v_t) + self.e)\\n theta_t = theta - (lr_t * g_t)\\n updates.append((m, m_t))\\n updates.append((v, v_t))\\n updates.append((theta, theta_t))\\n updates.append((i, i_t))\\n return updates\",\n \"def apply_gradient(self, learning_rate):\\n raise NotImplementedError()\",\n \"def update_params(self, learning_rate=0.1):\\n\\n self.params['W'] = self.params['W'] - learning_rate * self.dW # update weights\\n self.params['b'] = self.params['b'] - learning_rate * self.db # update bias(es)\",\n \"def perform_update(self, gradient):\\n w = sys.modules[self.shared_mem_name].__dict__[\\\"w\\\"]\\n w -= self.learning_rate * gradient\",\n \"def gradient_descent(X, y, theta, alpha, total_iterations, hypothesis):\\n len_theta = len(theta)\\n m = len(y)\\n one_over_m = (1.0 / float(m))\\n\\n for _ in range(0, total_iterations):\\n temp_theta = numpy.zeros(len_theta)\\n\\n X_by_theta_minus_y = numpy.subtract(hypothesis(numpy.matrix(theta), X), y)\\n\\n for j in range(0, len_theta):\\n jth_column_of_X = X[:,j]\\n derivative_j = one_over_m * numpy.multiply(X_by_theta_minus_y, jth_column_of_X).sum()\\n temp_theta[j] = theta[j] - alpha*derivative_j\\n\\n theta = temp_theta\\n\\n return numpy.matrix(theta)\",\n \"def train_fn_grad(self, theta_value, theta):\\n theta.set_value(theta_value, borrow=True)\\n\\n train_grads = [self.batch_grad(i, self.n_train)\\n for i in xrange(self.n_train_batches)]\\n train_batch_sizes = [self.get_batch_size(i, self.n_train)\\n for i in xrange(self.n_train_batches)]\\n\\n return np.average(train_grads, weights=train_batch_sizes,\\n axis=0)\",\n \"def update(self, max_norm=1.0):\\n \\n theta_prime = []\\n\\n for i, batch in enumerate(self.tasks):\\n y_hat = self.constraint(self.theta, self.f(batch)) # gather predictions to single dimension\\n loss = self.criteon( y_hat, self.y )\\n #compute gradients\\n grad = torch.autograd.grad(loss, self.theta)\\n #update params\\n theta_prime.append( self.theta - self.alpha * grad[0] )\\n\\n del loss\\n\\n #perform meta-update\\n m_loss = torch.tensor(0.0, requires_grad=True)\\n for i in range(len(self.tasks)):\\n theta = theta_prime[i]\\n batch = self.tasks[i]\\n y_hat = self.constraint(theta, self.f(batch)) # gather predictions to single dimension\\n m_loss = m_loss + self.criteon( y_hat, self.y ) # updating meta-loss\\n \\n #zero gradient before running backward pass\\n self.meta_optim.zero_grad()\\n\\n #backward pass\\n m_loss.backward(retain_graph=True)\\n\\n #clip gradients\\n nn.utils.clip_grad_norm_([self.theta], max_norm)\\n \\n #one-step gradient descent\\n self.meta_optim.step()\",\n \"def update_parameters(parameters, grads, learning_rate = 1.2):\\n\\t# Retrieve each parameter from the dictionary \\\"parameters\\\"\\n\\tW1 = parameters['W1']\\n\\tb1 = parameters['b1']\\n\\tW2 = parameters['W2']\\n\\tb2 = parameters['b2']\\n\\n\\t# Retrieve each gradient from the dictionary \\\"grads\\\"\\n\\tdW1 = grads['dW1']\\n\\tdb1 = grads['db1']\\n\\tdW2 = grads['dW2']\\n\\tdb2 = grads['db2']\\n\\n\\t# Update rule for each parameter\\n\\tW1 = W1 - learning_rate*dW1\\n\\tb1 = b1 - learning_rate*db1\\n\\tW2 = W2 - learning_rate*dW2\\n\\tb2 = b2 - learning_rate*db2\\n\\n\\tparameters = {\\\"W1\\\": W1,\\n\\t\\t\\t\\t\\t\\\"b1\\\": b1,\\n\\t\\t\\t\\t\\t\\\"W2\\\": W2,\\n\\t\\t\\t\\t\\t\\\"b2\\\": b2}\\n\\n\\treturn parameters\",\n \"def with_params(self, theta):\\n self.params = theta\\n return self\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\r\\n\\r\\n m = len(values)\\r\\n cost_history = []\\r\\n\\r\\n for i in range (num_iterations):\\r\\n \\r\\n h = numpy.dot(features, theta)\\r\\n \\r\\n theta = theta - alpha / m * numpy.dot((h-values),features)\\r\\n \\r\\n cost = compute_cost(features, values, theta)\\r\\n \\r\\n cost_history.append(cost)\\r\\n\\r\\n return theta, pandas.Series(cost_history) # leave this line for the grader\\r\",\n \"def _update_params(self, gradients: dict, learning_rate: float):\\n L = len(self.activations)\\n\\n for l in range(L):\\n self.params[\\\"W_\\\" + str(l + 1)] = self.params[\\\"W_\\\" + str(l + 1)] - learning_rate * gradients[\\n \\\"dW\\\" + str(l + 1)]\\n\\n self.params[\\\"b_\\\" + str(l + 1)] = self.params[\\\"b_\\\" + str(l + 1)] - learning_rate * gradients[\\n \\\"db\\\" + str(l + 1)]\",\n \"def gradient_descent(initial_theta, X, y, niter, alpha, Lambda=0.0):\\n theta_list = []\\n cost_list = []\\n\\n theta = initial_theta\\n for i in range(0, niter):\\n theta -= alpha*gradient(theta, X, y, Lambda)\\n theta_list.append(theta)\\n cost_list.append(cost(theta, X, y, Lambda))\\n\\n return theta_list, cost_list\",\n \"def _learn_using_GD(self, y, tx, w, fn, gamma, lambda_, regularization):\\n loss, grad = fn(y, tx, w, lambda_)\\n loss, grad = self.apply_regularization(w, loss, grad, regularization, lambda_, tx.shape[0])\\n w = w - gamma * grad\\n return loss, w\",\n \"def grad(X, y, nn_params, _lambda, input_layer_size,\\n hidden_layer_size, num_labels, n_hidden_layers=1):\\n theta = unravel_params(nn_params, input_layer_size, hidden_layer_size,\\n num_labels, n_hidden_layers)\\n\\n # Initi gradient with zeros\\n theta_grad = empty((n_hidden_layers + 1), dtype=object)\\n for i in range(len(theta)):\\n theta_grad[i] = zeros(shape=theta[i].shape, dtype=float64)\\n\\n m, n = X.shape\\n intercept = ones((m, 1), dtype=float64)\\n X = append(intercept, X, axis=1)\\n\\n for t in range(m):\\n\\n z, a = feed_forward(X[[t], :], theta, n_hidden_layers)\\n delta = back_propagation(y[t, :], theta, a, z,\\n num_labels, n_hidden_layers)\\n\\n for l in range(len(theta_grad)):\\n theta_grad[l] = theta_grad[l] + dot(delta[l + 1].T, a[l])\\n\\n for i in range(len(theta_grad)):\\n theta_grad[i] = (1 / m) * theta_grad[i]\\n\\n # regularization\\n for i in range(len(theta_grad)):\\n theta_grad[i][:, 1:] = theta_grad[i][:, 1:] + \\\\\\n (_lambda / m) * theta[i][:, 1:]\\n\\n flat_theta_grad = append(theta_grad[0].flatten(), theta_grad[1].flatten())\\n for i in range(2, len(theta_grad)):\\n flat_theta_grad = append(flat_theta_grad, theta_grad[i].flatten())\\n\\n return flat_theta_grad\",\n \"def weights_update(self, previous_layer_output, learning_rate, l2_lambda, batch_size):\\n theta, b, delta, alpha = self.theta, self.b, self.delta, learning_rate\\n dc_dtheta = np.dot(previous_layer_output, delta.T).transpose()\\n dc_dtheta = np.divide(1, batch_size) * dc_dtheta\\n new_theta = theta*(1 - l2_lambda * alpha) - alpha * dc_dtheta\\n b_prime = np.sum(delta, axis=1).reshape(b.shape)\\n b_prime = b_prime * np.divide(1, batch_size)\\n new_b = b - alpha * b_prime\\n self.theta, self.b = new_theta, new_b\",\n \"def update(self, X, y):\\n proba = self.predict_proba(X)\\n top_loss = proba - y\\n bias_gradient = np.sum(top_loss)\\n weight_gradient = (top_loss).T.dot(X)\\n\\n # the gradient update\\n self.b = self.b - self.lrate * bias_gradient\\n self.W = self.W - self.lrate * weight_gradient\",\n \"def assign_value_to_theta(self, sess):\\n import tensorflow as tf\\n\\n assert self.initialised, \\\"This model must be initialised (self.initialisation()).\\\"\\n\\n keys = sorted(self.variables.keys())\\n keys = [ key for key in keys if critere_keys(key)]\\n\\n diff = 0\\n for i, key in enumerate(keys):\\n diff_temp = sess.run(self.variables[key]) - self.theta_copy[i]\\n settings.l_theta[i] += diff_temp\\n diff += np.linalg.norm(diff_temp)\\n return diff\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\n m = len(values)\\n cost_history = []\\n\\n for i in range(num_iterations):\\n predicted_values = np.dot(features, theta)\\n delta = alpha / m * np.dot((predicted_values - values), features)\\n theta = theta - delta\\n cost = compute_cost(features, values, theta)\\n cost_history.append(cost)\\n return theta, pandas.Series(cost_history)\",\n \"def gradientFunctionReg(theta, X, y, Lambda): \\n y = np.squeeze(y)\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad[1:] = grad[1:] + Lambda*theta[1:]\\n grad /= m\\n\\n return grad\",\n \"def jacobian(theta, event, parameters_to_fit):\\n for (key, val) in enumerate(parameters_to_fit):\\n setattr(event.model.parameters, val, theta[key])\\n return event.chi2_gradient(parameters_to_fit)\",\n \"def update_target(self):\\n with torch.no_grad():\\n for target_q_param, q_param in zip(self.target_q_funcs.parameters(), self.q_funcs.parameters()):\\n target_q_param.data.copy_(self.tau * q_param.data + (1.0 - self.tau) * target_q_param.data)\\n for target_pi_param, pi_param in zip(self.target_policy.parameters(), self.policy.parameters()):\\n target_pi_param.data.copy_(self.tau * pi_param.data + (1.0 - self.tau) * target_pi_param.data)\",\n \"def stochasticGradientDescent(x,y,theta,alpha):\\n m,n = np.shape(x)\\n convergence = 0.000000001\\n lastCost = 0\\n cost = -1 \\n recurseCount = 0\\n while abs(lastCost - cost) > convergence: # rcurse until converge\\n lastCost = cost\\n hypothesis = np.dot(x,theta) \\n for i in range(m):\\n # alpha = 4.0 / (1.0 + i) + 0.01 \\n loss = hypothesis[i] - y[i]\\n # gradient = np.dot(x[i],loss)\\n gradient = x[i,:].transpose() * loss \\n theta = theta - alpha * gradient\\n cost = np.sum((hypothesis-y)**2)/(2*m)\\n recurseCount += 1\\n return recurseCount,theta\",\n \"def lrCostFunction(theta,X,y, lambda_reg):\\n m = np.size(y)\\n grad = np.zeros(np.size((theta)))\\n J_base, grad = costFunction(theta, X, y)\\n \\n\\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\\n \\n reg_gradient = (lambda_reg / m) * theta\\n reg_gradient[0] = 0\\n cost = J_base + reg_cost\\n return cost, grad + reg_gradient\",\n \"def update(\\r\\n params: hk.Params,\\r\\n opt_state: OptState,\\r\\n batch, label, agreement\\r\\n ) -> Tuple[hk.Params, OptState]:\\r\\n # grads = jax.grad(loss)(params, batch, label)\\r\\n # grads_masked = (gradient_per_sample if use_ilc else gradient)(params, batch, label) # (gradient_per_sample)(params, batch, label)\\r\\n # sum_grad_masked_regularized = jax.tree_multimap(lambda x,y:x+y,grads_masked,gradient_reg(params))\\r\\n # grads = sum_grad_masked_regularized\\r\\n # updates, opt_state = opt.update(grads, opt_state)\\r\\n # new_params = optax.apply_updates(params, updates)\\r\\n\\r\\n grads_samples = gradient_per_sample(params, batch, label)\\r\\n ANDmask = and_mask(agreement)\\r\\n\\r\\n masked_grads,_ = ANDmask.update(grads_samples, opt_state)\\r\\n reg_grads = gradient_reg(params)\\r\\n\\r\\n sum_grad_masked_regularized = jax.tree_multimap(lambda x,y:x+y,masked_grads,reg_grads)\\r\\n \\r\\n updates,_ = opt.update(sum_grad_masked_regularized, opt_state)\\r\\n\\r\\n new_params = optax.apply_updates(params, updates)\\r\\n\\r\\n return new_params, opt_state\",\n \"def batchGradientDescent(x,y,theta,alpha):\\n m,n = np.shape(x)\\n xTran = x.transpose()\\n convergence = 0.000000001\\n lastCost = 0\\n cost = -1 \\n recurseCount = 0\\n while abs(lastCost - cost) > convergence: # rcurse until converge\\n lastCost = cost\\n hypothesis = np.dot(x,theta)\\n loss = hypothesis - y\\n cost = np.sum(loss**2)/(2*m)\\n gradient = np.dot(xTran,loss)/m\\n theta = theta - alpha*gradient\\n recurseCount += 1\\n return recurseCount,theta\",\n \"def gradient(self, theta):\\n a = -(6 * self.scale ** 2)\\n b = 3 * self.scale ** 2 + np.exp(2 * theta)\\n b *= np.log(3 * self.scale ** 2 * np.exp(-2 * theta) + 1)\\n return a / b\",\n \"def run_gradient_descent_iteration(X, Y, theta, alpha, lambda_factor, temp_parameter):\\n delta = sparse.coo_matrix(theta.shape).toarray()\\n\\n h = compute_probabilities(X, theta, temp_parameter)\\n\\n for j in range(delta.shape[0]):\\n y = Y\\n y = np.where(y != j, 0, 1)\\n p = y - h[j]\\n\\n x = X.T * p\\n x = x.T\\n x = x.sum(axis=0)\\n\\n grad = -x / (temp_parameter * X.shape[0]) + lambda_factor * theta[j]\\n\\n delta[j] += grad\\n\\n theta -= alpha * delta\\n\\n return theta\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\r\\n \\r\\n m = len(values)\\r\\n cost_history = []\\r\\n\\r\\n for i in range(num_iterations):\\r\\n # your code here\\r\\n cost = compute_cost(features, values, theta)/(2.0*m)\\r\\n cost_history.append([cost])\\r\\n \\r\\n error = features.dot(theta) - values\\r\\n error = np.reshape(error,(error.shape[0], 1))\\r\\n errorWeighted = features*error\\r\\n errorSum = (np.sum(errorWeighted,0))/(m*1.0)\\r\\n theta = theta - alpha*errorSum \\r\\n \\r\\n return theta, pandas.Series(cost_history)\",\n \"def learning_by_gradient_descent(y, tx, w, gamma):\\n loss = calculate_loss(y,tx,w)\\n grad = calculate_gradient(y,tx,w)\\n w_new = w - gamma*grad\\n #grad is for debugging purpose\\n return loss, w_new,grad\",\n \"def learning_by_penalized_gradient(y, tx, w, gamma, lambda_):\\n\\n #on test avec Newton\\n\\n loss,gradient,_ = penalized_logistic_regression(y,tx,w,lambda_)\\n\\n w = w - gamma*gradient\\n return loss, w,gradient\",\n \"def approx_grad(theta, X, y):\\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\n \"def GradientDescent(x, y, theta, alpha, tolerate, maxiterate, epsilon):\\n i = 0 # set the iteration counting index\\n tolerate_rule = 1 # set the initial tolerate rate\\n n = x.shape[0]\\n current_theta = theta\\n scost_vector = np.empty([0, 1])\\n lcost_vector = np.empty([0, 1])\\n hcost_vector = np.empty([0, 1])\\n\\n # iterate\\n while tolerate_rule >= tolerate and i <= maxiterate:\\n sl = np.array(SquareLoss(x, y, current_theta)).reshape([1, 1])\\n scost_vector = np.append(scost_vector, sl, axis=0) # store cost\\n abs = np.array(AbsoluteLoss(x, y, current_theta)).reshape([1, 1])\\n lcost_vector = np.append(lcost_vector, abs, axis=0) # store cost\\n hbs = np.array(HuberLoss(x, y, current_theta, epsilon)).reshape([1, 1])\\n hcost_vector = np.append(hcost_vector, hbs, axis=0) # store cost\\n fx = x @ current_theta\\n update_theta = current_theta - alpha * (1/n) * x.transpose() @ (fx - y)\\n tolerate_rule = np.minimum(np.abs(update_theta - current_theta))\\n i += 1\\n current_theta = update_theta\\n\\n cost_matrix = np.asmatrix(np.stack((scost_vector, lcost_vector,\\n hcost_vector),\\n axis=-1))\\n cost_dataframe = pd.DataFrame(cost_matrix, columns=['AbsoluteLoss',\\n 'SquareLoss',\\n 'HuberLoss'])\\n return(current_theta, cost_dataframe)\",\n \"def theta(self, theta):\\n self.kernel.theta = theta\",\n \"def update(self, x, y, theta):\\n self.x = x\\n self.y = y\\n self.theta = theta\\n self.theta = wrap_angles(self.theta)\",\n \"def gradientDescent(self,X, y, theta): \\n # number of instances\\n m = len(y)\\n J_history = np.zeros((self.NUM_ITERS,1))\\n for i in range(self.NUM_ITERS):\\n h = self.sigmoid(X@theta)\\n grad = 1 / m * X.T @ (h - y)\\n theta = theta - self.ALPHA * grad \\n J_history[i] = self.costFunction(theta, X, y)\\n \\n \\n return theta, J_history\",\n \"def lr_cost_function(theta, X, y, learning_rate):\\n m = len(y) # number of training examples\\n # You need to return the following variables correctly \\n J = 0\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta))\\n\\n #Compute cost:\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n \\n #Compute gradient\\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return float(J), grad\",\n \"def optimizer(self):\\n \\n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\\n # I believe this is a work around to get keras to learn **given a gradient**\\n # As opposed to bunch of x_train, y_trains?\\n \\n #Inputs\\n state_pl = self.model.input\\n action_grads_pl = K.placeholder(shape=(None,1)) \\n \\n #Find grad_(pars) mu(state)\\n mu_pl = self.model.output\\n pars = self.model.trainable_weights\\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\\n \\n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\\n\\n # The gradients as defined above work on my mac, but not ubuntu.\\n # Below I am trying a workaround. I changed the keras source code \\n # To get this working. Specifically, I make the optimizer.get_updates()\\n # function accept custom gradients. It was easy to do.\\n \\n opt = Adam(self.lr)\\n loss = pars_grad_mu #placeholder, I won't use it\\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\\n\\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])\",\n \"def apply_gradient(params: torch.Tensor, grads: torch.Tensor, lr: float) -> torch.Tensor:\\n params_prime = params + lr * grads\\n return params_prime\",\n \"def compute_cost(features, values, theta):\\r\\n \\r\\n # your code here\\r\\n error = (values - features.dot(theta))\\r\\n cost = error.dot(error) \\r\\n return cost\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return grad\",\n \"def gradient_update(self, states, Q_target):\\n params = [self.w1, self.w2, self.w3, self.b1, self.b2, self.b3]\\n loss = self.get_loss(states, Q_target)\\n gradients = nn.gradients(loss, params)\\n self.w1.update(gradients[0], -self.learning_rate)\\n self.w2.update(gradients[1], -self.learning_rate)\\n self.w3.update(gradients[2], -self.learning_rate)\\n self.b1.update(gradients[3], -self.learning_rate)\\n self.b2.update(gradients[4], -self.learning_rate)\\n self.b3.update(gradients[5], -self.learning_rate)\",\n \"def update_parameters_with_gd(parameters, grads, learning_rate):\\n\\n L = len(parameters) // 2 # number of layers in the neural networks\\n\\n # Update rule for each parameter\\n for l in range(L):\\n ### START CODE HERE ### (approx. 2 lines)\\n parameters[\\\"W\\\" + str(l+1)] = parameters[\\\"W\\\" + str(l+1)]-learning_rate* grads[\\\"dW\\\" + str(l+1)]\\n parameters[\\\"b\\\" + str(l+1)] = parameters[\\\"b\\\" + str(l+1)]-learning_rate* grads[\\\"db\\\" + str(l+1)]\\n ### END CODE HERE ###\\n \\n return parameters\",\n \"def run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta):\\n n = len_data\\n # WE NEED TO transpose data_x into (p+1) *n ,theta is 1*(p+1)\\n prod = np.dot(theta, data_x.transpose())\\n\\n prod -= data_y\\n print(\\\"pro: data_x\\\", prod.shape, data_x.shape)\\n #prod represent the loss of the hypothesis and true label\\n sum_grad = np.dot(prod, data_x)\\n print(\\\"总梯度的值：\\\",sum_grad.shape)\\n\\n # batch-gradient descent\\n theta = theta -(alpha / n) * sum_grad\\n return theta\",\n \"def _update(self, x: np.ndarray, y: int):\\n decision = self.weights.dot(x)\\n v_t = x @ np.diag(np.diag(self._sigma)) @ x.T\\n m_t = y * decision\\n loss = (self._phi * math.sqrt(v_t) - m_t)\\n #print(loss)\\n if loss > 0:\\n # We scale our learning rate (alpha) using the weight/cost\\n alpha_t = self.class_weight_[y] * self._get_alpha(m_t, v_t)\\n u_t = 0.25 * (-alpha_t * v_t * self._phi + math.sqrt(\\n alpha_t ** 2 * v_t ** 2 * self._phi ** 2 + 4 * v_t)) ** 2\\n beta_t = alpha_t * self._phi / (math.sqrt(u_t) +\\n alpha_t * self._phi * v_t)\\n sigma = np.expand_dims(x @ self._sigma, axis=0)\\n self.weights += alpha_t * y * np.squeeze(sigma)\\n self._sigma -= beta_t * sigma.T @ sigma\",\n \"def update_weights(x_train, y_train, weights, learning_rate):\\r\\n predictions = compute_prediction(x_train, weights)\\r\\n weights_delta = np.dot(x_train.T, y_train - predictions)\\r\\n m = y_train.shape[0]\\r\\n weights += learning_rate / float(m) * weights_delta\\r\\n return weights\",\n \"def _update_parameters(self, curr_state, reward, next_state):\\n phi = self._features.vector(curr_state)\\n phi_dash = self._features.vector(next_state)\\n\\n self._A += np.outer(phi, (phi - self._gamma * phi_dash))\\n self._b += reward * phi\",\n \"def differential_of_minimized_cost_function_theta_1(m = no_of_training_examples, x, y, theta_0, theta_1, initial_theta1):\\r\\n initial_val = initial_theta1\\r\\n compute_1 = [val cost_function(val, theta_0, theta_1)] # computes the corresponding value of x given theta_0 and theta_1(list comprehension)\\r\\n compute_2 = [var_x-var_y for var_x, var_y in zip(compute_1,y)] # subtracts the corresponding values of x and y (list comprehension)\\r\\n theta = sum(compute_2)/m\\r\\n if initial_theta == updated_theta:\\r\\n return updated_theta\\r\\n else:\\r\\n differential_of_minimized_cost_function(m = no_of_training_examples, x, y, theta_0, theta_1 = theta, initial_theta1 = initial_val) # returns itself (recursion)\\r\",\n \"def update_parameters(parameters, grads, learning_rate):\\n L = len(parameters) // 2\\n\\n for i in range(L):\\n parameters[\\\"W\\\"+str(i+1)] = parameters[\\\"W\\\"+str(i+1)] - learning_rate * grads[\\\"dW\\\"+str(i+1)]\\n parameters[\\\"b\\\"+str(i+1)] = parameters[\\\"b\\\"+str(i+1)] - learning_rate * grads[\\\"db\\\"+str(i+1)]\\n\\n return parameters\",\n \"def update_theta_beta(data, lr, theta, beta):\\n #####################################################################\\n # TODO: #\\n # Implement the function as described in the docstring. #\\n #####################################################################\\n dtheta = []\\n dbeta = []\\n \\n N = len(theta)\\n M = len(beta)\\n \\n theta_mid = {x: [] for x in range(N)}\\n beta_mid = {x: [] for x in range(M)}\\n \\n assert len(data[\\\"user_id\\\"]) == len(data[\\\"question_id\\\"])\\n assert len(data[\\\"user_id\\\"]) == len(data[\\\"is_correct\\\"])\\n \\n length = len(data[\\\"user_id\\\"])\\n for s in range(length):\\n i = data[\\\"user_id\\\"][s]\\n j = data[\\\"question_id\\\"][s]\\n cij = data[\\\"is_correct\\\"][s]\\n theta_i = theta[i]\\n beta_j = beta[j]\\n theta_mid[i].append(cij - sigmoid(theta_i-beta_j))\\n beta_mid[j].append(-1*cij+sigmoid(theta_i-beta_j))\\n \\n for i in range(N):\\n dtheta.append(-1*sum(theta_mid[i]))\\n for j in range(M):\\n dbeta.append(-1*sum(beta_mid[j]))\\n\\n theta -= lr * np.array(dtheta, dtype=np.float32)\\n beta -= lr * np.array(dbeta, dtype=np.float32)\\n\\n #####################################################################\\n # END OF YOUR CODE #\\n #####################################################################\\n return theta, beta\",\n \"def update(self, gradient, optimizer=None, relink=None):\\n # Recover the defaults, if missing\\n optimizer = self._resolve_defaults(optimizer=optimizer)[0]\\n # Set the gradient\\n self.set_gradient(gradient, relink=(self._config.relink if relink is None else relink))\\n # Perform the update step\\n optimizer.step()\",\n \"def optimize(self, learning_rate=0.0002, beta1=0.5, global_step=None):\\n opt = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=beta1)\\n return opt.apply_gradients(self.gradients, global_step=global_step)\",\n \"def learning_by_gradient_descent(y, tx, w, gamma):\\n\\tgrad = calculate_gradient(y, tx, w)\\n\\n\\tw = w - gamma * grad\\n\\treturn w\",\n \"def update(self,parameters, grads):\\n \\n L = len(parameters) // 2 # number of layers in the neural network\\n #print(L)\\n\\n # Update rule for each parameter. Use a for loop.\\n for l in range(L):\\n \\n parameters[\\\"W\\\" + str(l+1)] = parameters[\\\"W\\\" + str(l+1)] - self.alpha * grads[\\\"dW\\\" + str(l+1)]\\n \\n parameters[\\\"b\\\" + str(l+1)] = parameters[\\\"b\\\" + str(l+1)] - self.alpha * grads[\\\"db\\\" + str(l+1)]\\n \\n parameters[\\\"W\\\" + str(l+1)][np.isnan(parameters[\\\"W\\\" + str(l+1)])] = 0\\n parameters[\\\"b\\\" + str(l+1)][np.isnan(parameters[\\\"b\\\" + str(l+1)])] = 0\\n \\n return parameters\",\n \"def _UpdateGradient(self):\\n self.mol.GetGradient('analytic')\",\n \"def learning_by_penalized_gradient(y, tx, w, gamma, lambda_):\\n\\tgrad, H = penalized_logistic_regression(y, tx, w, lambda_)\\n\\n\\thgrad = np.linalg.inv(H).dot(grad)\\n\\n\\tw = w - gamma * hgrad\\n\\n\\treturn w\",\n \"def updateW(self, trj_Sp_theta, W_0):\\n def fun(x):\\n global trj_Sp_theta_z\\n\\n W_0 = x\\n r_0 = self.reward_trj(trj_Sp_theta, W_0)\\n return -1*r_0 \\n import numpy as np\\n from scipy.optimize import minimize\\n \\n global trj_Sp_theta_z \\n trj_Sp_theta_z = trj_Sp_theta\\n alpha = 0.2\\n delta = alpha\\n cons = ({'type': 'eq',\\n 'fun' : lambda x: np.array([np.sum(x)-1])},\\n {'type': 'ineq',\\n 'fun' : lambda x: np.array([np.min(x)])},\\n {'type': 'ineq',\\n 'fun' : lambda x: np.array([np.abs(np.sum(x-x0))+delta])})\\n\\n x0 = W_0\\n res = minimize(fun, x0, constraints=cons)\\n\\n x = res.x\\n\\n W = x/(np.sum(x)) # changed\\n return W\",\n \"def update_parameters(parameters: Dict,\\n grads: Dict, learning_rate: float) -> Dict:\\n L = len(parameters)//2 # number of layers\\n\\n for l in range(1, L+1):\\n parameters['W'+str(l)] -= learning_rate * grads['dW'+str(l)]\\n parameters['b'+str(l)] -= learning_rate * grads['db'+str(l)]\\n\\n return parameters\",\n \"def gradient_descent_step(self, x, y, learning_rate):\\n # compute derivative of loss wrt Z\\n dZ = self.derivative_loss(y, self.predict(x))\\n dW = np.dot(dZ, x)\\n # subtract average derivative from weights\\n self.w -= learning_rate * 1.0/dW.shape[0] * dW\\n if self.fit_b:\\n self.b -= learning_rate * (1.0/x.shape[0] * np.sum(dZ))\",\n \"def update_weights(self, X, Y, learning_rate):\\n grads = self.calculate_gradients(X, Y)\\n #update weights and biases\\n self.weights[0] = self.weights[0] - learning_rate * grads[\\\"dW1\\\"]\\n self.weights[1] = self.weights[1] - learning_rate * grads[\\\"dW2\\\"]\\n self.biases[0] = self.biases[0] - learning_rate * grads[\\\"db1\\\"]\\n self.biases[1] = self.biases[1] - learning_rate * grads[\\\"db2\\\"]\",\n \"def approx_grad_reg(theta, X, y, _lambda):\\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\n \"def cost_derivation(update_param: np.ndarray,\\n dependent_param: np.ndarray,\\n label: int\\n ) -> np.ndarray:\\n return (sigmoid(update_param @ dependent_param) - label)*dependent_param\",\n \"def test_update_parameters(model):\\n train_inputs = torch.tensor([[1., 2., 3.]])\\n train_loss = 0.5 * (model(train_inputs) ** 2)\\n\\n params = gradient_update_parameters(model,\\n train_loss,\\n params=None,\\n step_size=0.5,\\n first_order=False)\\n\\n assert train_loss.item() == 264.5\\n assert list(params.keys()) == ['weight']\\n assert torch.all(params['weight'].data == torch.tensor([[-9.5, -20., -29.5]]))\\n\\n \\\"\\\"\\\"\\n The new loss function (still with respect to the weights of the model w) is\\n defined as:\\n g(w) = 0.5 * (4 * w'_1 + 5 * w'_2 + 6 * w'_3) ** 2\\n = 0.5 * (4 * (w_1 - 0.5 * df / dw_1)\\n + 5 * (w_2 - 0.5 * df / dw_2)\\n + 6 * (w_3 - 0.5 * df / dw_3)) ** 2\\n = 0.5 * (4 * (w_1 - 0.5 * 1 * (1 * w_1 + 2 * w_2 + 3 * w_3))\\n + 5 * (w_2 - 0.5 * 2 * (1 * w_1 + 2 * w_2 + 3 * w_3))\\n + 6 * (w_3 - 0.5 * 3 * (1 * w_1 + 2 * w_2 + 3 * w_3))) ** 2\\n = 0.5 * ((4 - 4 * 0.5 - 5 * 1.0 - 6 * 1.5) * w_1\\n + (5 - 4 * 1.0 - 5 * 2.0 - 6 * 3.0) * w_2\\n + (6 - 4 * 1.5 - 5 * 3.0 - 6 * 4.5) * w_3) ** 2\\n = 0.5 * (-12 * w_1 - 27 * w_2 - 42 * w_3) ** 2\\n\\n Therefore the gradient of the function g with respect to w (and evaluated\\n at w = [2, 3, 5]) is:\\n dg / dw_1 = -12 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 3780\\n dg / dw_2 = -27 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 8505\\n dg / dw_3 = -42 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 13230\\n \\\"\\\"\\\"\\n test_inputs = torch.tensor([[4., 5., 6.]])\\n test_loss = 0.5 * (model(test_inputs, params=params) ** 2)\\n\\n grads = torch.autograd.grad(test_loss, model.parameters())\\n\\n assert test_loss.item() == 49612.5\\n assert len(grads) == 1\\n assert torch.all(grads[0].data == torch.tensor([[3780., 8505., 13230.]]))\",\n \"def gradient(theta, X, y, Lambda=0.0):\\n m = X.shape[0] # number of samples\\n\\n h = hypothesis(theta, X)\\n\\n if Lambda:\\n g_0 = (1/m)*(X.T@(h - y))[0]\\n g_1 = (1/m)*(X.T@(h - y))[1:] + (Lambda/m)*theta[1:] # skip theta-0\\n \\n return np.append(g_0, g_1)\\n else:\\n return (1/m)*(X.T@(h - y))\",\n \"def update_b(self, theta, force=False):\\n self.b = self.eval_b(self.theta)\\n self.b_eval_cnt += 1\",\n \"def updateWeights(inputs, outputs, learning_rate, y, weights):\\n for i in range(len(weights)):\\n weights[i] = weights[i] + learning_rate * (outputs - y) * inputs[i]\\n return weights\",\n \"def update_model_parameters(parameters, grads, learning_rate):\\n L = len(parameters) /2 # number of layers in the neural network\\n\\n for l in range(int(L)):\\n parameters[\\\"W\\\" + str(l + 1)] = parameters[\\\"W\\\" + str(l + 1)] - learning_rate * grads[\\\"dW\\\" + str(l + 1)]\\n parameters[\\\"b\\\" + str(l + 1)] = parameters[\\\"b\\\" + str(l + 1)] - learning_rate * grads[\\\"db\\\" + str(l + 1)]\\n return parameters\\n # raise NotImplementedError\",\n \"def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\\n\\n # Cost history\\n cost_tracking = np.zeros(nb_iterations)\\n\\n for _i in range(nb_iterations):\\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\\n # recording the cost for each iteration\\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\\n\\n return parameters, cost_tracking\",\n \"def gradient_descent(regression_type, trainingData, theta,\\n maxIter, learningRate):\\n regression = None\\n\\n if(regression_type == 1):\\n regression = LinearRegression()\\n\\n all_costs = zeros(maxIter)\\n\\n for num_iter in range(maxIter):\\n\\n gradient = regression.calculateGradient(trainingData, theta)\\n gradient = gradient*learningRate\\n\\n theta = theta - gradient\\n\\n all_costs[num_iter] = regression.calculateCost(trainingData, theta)\\n\\n return (all_costs, theta)\",\n \"def optimize_parameters(self):\\n self.loss_total.backward() # calculate gradients\\n self.optimizer.step()\\n self.optimizer.zero_grad()\\n torch.cuda.empty_cache()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70289654","0.694744","0.694744","0.6826142","0.66292876","0.6610046","0.65948474","0.6546575","0.652195","0.65193623","0.65162325","0.65117294","0.65025204","0.64622724","0.64474326","0.641127","0.63753605","0.63573223","0.63517094","0.63488644","0.6333687","0.6325458","0.6321377","0.631835","0.6314213","0.6304784","0.6302093","0.6282471","0.62747234","0.6274461","0.6244336","0.624301","0.62393326","0.62294763","0.6224028","0.62213784","0.6203939","0.61765754","0.61657834","0.6159153","0.6156834","0.61432755","0.6141783","0.6134198","0.6120543","0.61108327","0.60980475","0.6060437","0.6056708","0.6054659","0.6053061","0.60519147","0.6051645","0.60466504","0.6042461","0.6021724","0.60210896","0.60198975","0.6015945","0.60146457","0.6013878","0.60043484","0.6000046","0.5998511","0.5994986","0.59914386","0.59897625","0.5980031","0.5975198","0.59613293","0.59415275","0.59405506","0.59261626","0.59248394","0.59193134","0.5918863","0.5916965","0.5916855","0.5901306","0.58984154","0.58854866","0.5885227","0.58758223","0.5874873","0.5872212","0.5864724","0.58625185","0.5854088","0.58448577","0.5842754","0.58408415","0.5837701","0.5836593","0.58345366","0.583343","0.58309346","0.5814127","0.5810938","0.5809343","0.5800682"],"string":"[\n \"0.70289654\",\n \"0.694744\",\n \"0.694744\",\n \"0.6826142\",\n \"0.66292876\",\n \"0.6610046\",\n \"0.65948474\",\n \"0.6546575\",\n \"0.652195\",\n \"0.65193623\",\n \"0.65162325\",\n \"0.65117294\",\n \"0.65025204\",\n \"0.64622724\",\n \"0.64474326\",\n \"0.641127\",\n \"0.63753605\",\n \"0.63573223\",\n \"0.63517094\",\n \"0.63488644\",\n \"0.6333687\",\n \"0.6325458\",\n \"0.6321377\",\n \"0.631835\",\n \"0.6314213\",\n \"0.6304784\",\n \"0.6302093\",\n \"0.6282471\",\n \"0.62747234\",\n \"0.6274461\",\n \"0.6244336\",\n \"0.624301\",\n \"0.62393326\",\n \"0.62294763\",\n \"0.6224028\",\n \"0.62213784\",\n \"0.6203939\",\n \"0.61765754\",\n \"0.61657834\",\n \"0.6159153\",\n \"0.6156834\",\n \"0.61432755\",\n \"0.6141783\",\n \"0.6134198\",\n \"0.6120543\",\n \"0.61108327\",\n \"0.60980475\",\n \"0.6060437\",\n \"0.6056708\",\n \"0.6054659\",\n \"0.6053061\",\n \"0.60519147\",\n \"0.6051645\",\n \"0.60466504\",\n \"0.6042461\",\n \"0.6021724\",\n \"0.60210896\",\n \"0.60198975\",\n \"0.6015945\",\n \"0.60146457\",\n \"0.6013878\",\n \"0.60043484\",\n \"0.6000046\",\n \"0.5998511\",\n \"0.5994986\",\n \"0.59914386\",\n \"0.59897625\",\n \"0.5980031\",\n \"0.5975198\",\n \"0.59613293\",\n \"0.59415275\",\n \"0.59405506\",\n \"0.59261626\",\n \"0.59248394\",\n \"0.59193134\",\n \"0.5918863\",\n \"0.5916965\",\n \"0.5916855\",\n \"0.5901306\",\n \"0.58984154\",\n \"0.58854866\",\n \"0.5885227\",\n \"0.58758223\",\n \"0.5874873\",\n \"0.5872212\",\n \"0.5864724\",\n \"0.58625185\",\n \"0.5854088\",\n \"0.58448577\",\n \"0.5842754\",\n \"0.58408415\",\n \"0.5837701\",\n \"0.5836593\",\n \"0.58345366\",\n \"0.583343\",\n \"0.58309346\",\n \"0.5814127\",\n \"0.5810938\",\n \"0.5809343\",\n \"0.5800682\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62909085"},"document_rank":{"kind":"string","value":"27"}}},{"rowIdx":90793,"cells":{"query":{"kind":"string","value":"Minimize theta values of a logistic model based on crossentropy cost function"},"document":{"kind":"string","value":"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def logit_cost(self, theta, X, y):\n\n cost = 0.0\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n \n for i in range(0, X.shape[0]):\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\n ### END YOUR CODE\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\n return cost","def cost(self, X=None, y=None, theta=None):\n X = self.X_train if X is None else X\n y = self.y_train if y is None else y\n m = X.shape[1]\n\n prob_mat = self.softmax_mat(X, theta)\n cost = -(y * np.log(prob_mat)).sum() / m\n return cost","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def _softmax_cost(self, theta, *args):\n epsilon = 1e-32\n wd, PHI, y = args\n N, P = PHI.shape\n W = np.reshape(theta, [P, -1])\n t = softmax(np.matmul(PHI, W)) + epsilon\n grad = (1. / N) * np.matmul(PHI.T, t - y) + wd * W\n grad = grad.flatten()\n cost = -(1. / N) * np.dot(y.flatten().T, np.log(t.flatten())) \\\n + 0.5 * wd * np.sum(W.flatten() ** 2)\n return cost, grad","def costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def cost(self, logits, labels, weights):\n return tf.multiply(\n tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels),\n weights)","def costFunction(theta,X,y):\n m = X.shape[0]\n J = 0\n h = sigmoid (np.dot(X,theta))\n \n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\n \n #grad = (1/m) * np.dot(X.T,(h-y))\n grad = (1/m) * np.dot((h.T - y), X).T\n \n return J, grad","def softmax_cross_entropy(y, label):\r\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\r\n return losses\r\n pass","def cost_function(x, params, y, m):\n\n x_theta = np.matmul(x, params)\n hypothesis = vectorized_sigmoid_function(x_theta)\n\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)","def cross_entropy_cost(m, A, L):\n\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\n\n\n\t# Sanity checks\n\tcost = np.squeeze(cost) \t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\n\tassert(cost.shape == ()) \t#checks if cost value is a scalar\n\n\treturn cost","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def cost_function(X, y, theta, _lambda, num_labels, n_hidden_layers=1):\n m, n = X.shape\n intercept = ones((m, 1), dtype=float64)\n X = append(intercept, X, axis=1)\n\n _h = h(X, theta, n_hidden_layers) # model hypothesis\n\n J = 0\n for c in range(num_labels):\n _J = dot(1 - (y == c).T, log(1 - _h[:, c]))\n _J = _J + dot((y == c).T, log(_h[:, c]))\n J = J - (1 / m) * sum(_J)\n\n theta_squared_term = 0\n for j in range(len(theta)):\n theta_squared_term += sum(power(theta[j][:, 1:], 2))\n\n J = J + (_lambda / (2 * m)) * theta_squared_term\n\n return J","def cost(self, h_theta, y):\n \n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)","def logit_cost_grad(self, theta, X, y):\n\n grad = np.zeros(len(theta))\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n # sig = np.subtract(sig, y)\n sig = sig - y\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\n ### END YOUR CODE\n\n return grad","def cost(theta, X, y, learning_rate):\n m = len(y) \n theta = theta.reshape((-1,1))\n h = sigmoid(np.dot(X, theta))\n\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n return float(J)","def logistic_regression(y, tx, initial_w, max_iters, gamma):\n return least_squares_SGD(y, tx, initial_w, max_iters, gamma, loss_function=logistic_loss, gradient=logistic_grad)","def prediction_cost(a, y):\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))","def grad_softmax_cross_entropy_loss(logit, labels):\n return softmax(logit) - labels","def cost(h, y):\n\tm = y.shape[0]\n\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\n\treturn cost","def objective_function(theta, X, y):\n # m number of training instances\n m = X.shape[0]\n jtheta = sum((np.dot(X, theta) - y)**2) / (2.0*m)\n return jtheta","def softmax_cross_entropy_loss(logit, labels):\n p = softmax(logit)\n loss_i = - labels * np.log(p + 1e-8)\n return np.mean(loss_i)","def calculate_entropic_cost(self, log_prediction):\n\n log_prediction = tf.squeeze(log_prediction)\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\n\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\n\n return tf.reduce_sum(penalty)","def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)","def get_cross_entropy(self):\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\n potential = 0.0\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\n return potential","def loss(logits, labels):\n labels = tf.to_int64(labels)\n# labels = tf.to_float(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\n# y_conv = tf.nn.softmax(logits)\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def sigmoid_cross_entropy(y, label):\r\n losses = - np.log(y + g_epsilon) * label - np.log(1.0 - y + g_epsilon) * (1.0 - label)\r\n return losses","def cost(theta, X, y, Lambda=0.0):\n m = X.shape[0] # number of samples\n\n h = hypothesis(theta, X) \n \n suma = (-y*np.log(h) - (1 - y)*np.log(1 - h)).sum() \n\n reg_term = 0.0\n if Lambda:\n reg_term = (Lambda/(2*m))*((theta[1:]**2).sum()) # skip theta-0\n\n return (1/m)*suma + reg_term","def cost(self, Y, A):\n loss1 = Y * np.log(A)\n m = Y.shape[1]\n cost = -1 * np.sum(loss1) / m\n return cost","def calculate_cost(x, y, weights):\r\n predictions = compute_prediction(x, weights)\r\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\r\n return cost","def cross_entropy(y_observed, p):\n\n pass","def feature_mapped_logistic_regression(power, l):\n df = pd.read_csv('ex2data2.txt', names=['test1', 'test2', 'accepted'])\n x1 = np.array(df.test1)\n x2 = np.array(df.test2)\n y = general.get_y(df)\n\n X = feature_mapping(x1, x2, power, as_ndarray=True)\n theta = np.zeros(X.shape[1])\n\n res = opt.minimize(fun=regularized_cost,\n x0=theta,\n args=(X, y, l),\n method='TNC',\n jac=regularized_gradient)\n final_theta = res.x\n\n return final_theta","def logistic_regression(y, tx, initial_w, max_iters, gamma, verbose=False):\n return gradient_descent(y, tx, initial_w, max_iters, gamma, \n compute_logistic_loss, compute_logistic_gradient, verbose=verbose)","def get_reconstruction_cost(self, nv):\n cross_entropy = T.mean(\n T.sum(\n self.input * T.log(nv) +\n (1 - self.input) * T.log(1 - nv),\n axis=1\n )\n )\n return cross_entropy","def cost_function(self, X, y, theta_list, bias):\n total_samples = len(y)\n loss = 0\n\n for i in range(total_samples):\n hypothesis = bias\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\n \n de = 1.0 + np.exp(-hypothesis)\n sigmoidhypothesis = 1.0/de\n\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\n\n return -1 * (loss/total_samples) #loss calculation","def soft_cross_entropy(input, targets):\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\n return (- targets_prob * student_likelihood).sum(dim=-1).mean()","def ovo_crossentropy_loss(y_true, y_pred):\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\n y_true_scaled = (y_true + 1.0) / 2.0\n y_pred_scaled = (y_pred + 1.0) / 2.0\n\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\n\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\n\n # J_{OvO} aus Pawara et al. anwenden\n log_function = tf.log if tf.__version__ == \"1.13.1\" else tf.math.log # flexibel für neue / alte Version\n loss = - tf.reduce_mean(\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\n return loss","def logistic_loss(x, y):\n N = x.shape[0]\n x = np.squeeze(x)\n y_prime = (y + 1)/2\n h = 1 /(1 + np.exp(-x))\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\n return loss, dx","def reg_logistic_regression(y, tx, lambda_, initial_w, max_iters, gamma, verbose=False): \n reg_loss, reg_grad = add_l2_reg(compute_logistic_loss, \n compute_logistic_gradient,\n lambda_)\n \n return gradient_descent(y, tx, initial_w, max_iters, gamma, reg_loss, reg_grad)","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def nn_cost_function(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, l):\n Theta_1 = np.reshape(nn_params[0:(hidden_layer_size * (input_layer_size + 1)), ],\n (hidden_layer_size, input_layer_size + 1))\n Theta_2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):, ],\n (num_labels, hidden_layer_size + 1))\n\n m, n = X.shape\n X = np.hstack((np.ones((m, 1)), X))\n\n Z_2 = X.dot(Theta_1.T)\n A_2 = sigmoid(Z_2)\n A_2 = np.hstack((np.ones((m, 1)), A_2))\n\n Z_3 = A_2.dot(Theta_2.T)\n A_3 = sigmoid(Z_3)\n\n Y = np.zeros((m, num_labels))\n for i in range(m):\n Y[i, y[i] - 1] = 1\n\n j = 0.0\n for i in range(m):\n j += np.log(A_3[i, ]).dot(-Y[i, ].T) - np.log(1 - A_3[i, ]).dot(1 - Y[i, ].T)\n j /= m\n\n Theta_1_square = np.square(Theta_1[:, 1:])\n Theta_2_square = np.square(Theta_2[:, 1:])\n reg = 1.0 * l / (2 * m) * (np.sum(Theta_1_square) + np.sum(Theta_2_square))\n j += reg\n\n d_3 = A_3 - Y\n D_2 = d_3.T.dot(A_2)\n\n Z_2 = np.hstack((np.ones((m, 1)), Z_2))\n d_2 = d_3.dot(Theta_2) * sigmoid_gradient(Z_2)\n d_2 = d_2[:, 1:]\n D_1 = d_2.T.dot(X)\n\n Theta_1_grad = 1.0 * D_1 / m\n Theta_1_grad[:, 1:] = Theta_1_grad[:, 1:] + 1.0 * l / m * Theta_1[:, 1:]\n\n Theta_2_grad = 1.0 * D_2 / m\n Theta_2_grad[:, 1:] = Theta_2_grad[:, 1:] + 1.0 * l / m * Theta_2[:, 1:]\n\n grad = np.hstack((Theta_1_grad.ravel(), Theta_2_grad.ravel()))\n\n return j, grad","def cross_entropy_loss(logits, labels, label_smoothing=0., dtype=jnp.float32):\n num_classes = logits.shape[-1]\n labels = jax.nn.one_hot(labels, num_classes, dtype=dtype)\n if label_smoothing > 0:\n labels = labels * (1 - label_smoothing) + label_smoothing / num_classes\n logp = jax.nn.log_softmax(logits.astype(dtype))\n return -jnp.mean(jnp.sum(logp * labels, axis=-1))","def cost_function(theta, X, y):\n\n l = None\n #######################################################################\n # TODO: #\n # Compute and return the cost l of a particular choice of #\n # theta. #\n # #\n #######################################################################\n thetaX = np.dot(X, theta)\n g = tanh(thetaX)-y\n l = np.sum(g*g) / X.shape[0]\n \n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return l","def logistic_hypothesis(theta):\n return lambda X: sigmoid(np.dot(x_strich(X), theta))","def my_softmax_cross_entropy(preds, labels):\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\n return tf.reduce_mean(loss)","def get_reconstruction_cost(self, pre_sigmoid_nv):\n y = self.input\n a = T.nnet.sigmoid(pre_sigmoid_nv)\n\n cross_entropy = -T.mean(\n T.sum(y * T.log(a) + (1 - y) * T.log(1 - a), axis=1)\n )\n\n return cross_entropy","def logistic_pen(weights, data, targets, hyperparameters):\n\n # TODO: Finish this function\n\n return f, df, y","def cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -Y / Y_hat\n \n return cost, dY_hat","def logistic_regression_vec(theta, trainX, trainY):\n # Add column of ones for bias\n trainX = np.hstack((np.ones((trainX.shape[0], 1)), trainX))\n h = sigmoid(np.inner(trainX, theta))\n # np.log(1-h) can lead to problems for h = 1.0\n h = np.where(h == 1.0, 1 - 1e-12, h)\n fval = -(trainY * np.log(h) + (1 - trainY) * np.log(1 - h)).sum()\n error = h - trainY\n # Negative gradient for a minimization, must be flattened for np.minimize\n grad = np.dot(trainX.T, error).flatten()\n return fval, grad","def lr_cost_function(theta, X, y, learning_rate):\n m = len(y) # number of training examples\n # You need to return the following variables correctly \n J = 0\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta))\n\n #Compute cost:\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n \n #Compute gradient\n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return float(J), grad","def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\n h = compute_probabilities(X, theta, temp_parameter)\n\n cost = 0\n for i in range(X.shape[0]):\n for j in range(theta.shape[0]):\n if Y[i] == j:\n cost += np.log(h[j,i])\n\n cost = -cost / X.shape[0]\n\n theta = np.power(theta, 2)\n\n cost += lambda_factor / 2 * theta.sum()\n\n return cost","def softmax_cross_entropy(logits, target, weight=None, reduce=True):\n target = target.long()\n # Convert 5d input to 4d, because it is faster in functional.cross_entropy\n if logits.dim() == 5:\n logits = compress_3d_to_2d(logits)\n target = compress_3d_to_2d(target)\n\n return nn.functional.cross_entropy(logits, target, weight=weight, reduce=reduce)","def cross_entropy(y, y_hat):\n return -tf.math.log(\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\n )","def lr_cost_function(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> float:\n\n # Initialize some useful values\n m = len(y) # number of training examples\n\n # You need to return the following variable correctly.\n J = 0\n\n # ====================== YOUR CODE HERE ======================\n # Instructions: Compute the cost of a particular choice of theta.\n # You should set J to the cost.\n\n # =============================================================\n return J","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def cost(self, x, y):\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()","def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))","def compute_cost(X, y, theta, lambd):\n assert(theta.shape[0] == X.shape[1])\n \n m = X.shape[0]\n grad = np.zeros(y.shape)\n J = 0\n \n output = sigmoid(np.dot(X, theta))\n\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\n\n grad = np.dot(X.T, (output - y)) / m\n \n grad[1:] = grad[1:] + lambd / m * theta[1:]\n\n return J, grad","def cost(self, Y, A):\n m = Y.shape[1]\n cost = - (1 / m) * np.sum(\n np.multiply(\n Y, np.log(A)) + np.multiply(\n 1 - Y, np.log(1.0000001 - A)))\n return cost","def lrCostFunction(theta, X, y, lambda_):\n if X.ndim == 1:\n X = X.reshape(1, -1)\n\n if y.dtype == bool:\n y = y.astype(int)\n\n # Initialize some useful values\n m = len(y) # number of training examples\n\n # ====================== YOUR CODE HERE ======================\n # Instructions: Compute the cost of a particular choice of theta.\n # You should set J to the cost.\n #\n # Hint: The computation of the cost function and gradients can be\n # efficiently vectorized. For example, consider the computation\n #\n # sigmoid(X * theta)\n #\n # Each row of the resulting matrix will contain the value of the\n # prediction for that example. You can make use of this to vectorize\n # the cost function and gradient computations.\n #\n\n z = X @ theta\n h = sigmoid(z)\n\n theta_ = np.r_[0, theta[1:]]\n\n J = (-y @ np.log(h) - (1 - y) @ np.log(1 - h)) / m\n J += lambda_ * sum(theta_**2) / (2 * m)\n\n grad = (h - y) @ X / m\n grad += lambda_ * theta_ / m\n\n # =============================================================\n\n return J, grad","def logistic_loss(x, y):\n N = x.shape[0]\n x_flat = np.squeeze(x)\n ex = np.exp(x_flat)\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\n dx = (-y+ex/(1+ex))/N\n # dx = np.reshape(dx,(len(dx),1))\n return loss, dx","def logistic_pen(weights, data, targets, hyperparameters):\n\n wr = hyperparameters['weight_regularization']\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\n df = np.reshape(df, ((len(df), 1)))\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\n\n f += (weights[-1, 0] ** 2) * wr / 2\n df[-1] += weights[-1,0] * wr \n\n return f, df, np.reshape(y, (len(y), 1))","def cross_entropy_loss(labels_tensor, logits_tensor, pos_weights):\n diff = tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_tensor, logits=logits_tensor, pos_weight= pos_weights)\n loss = tf.reduce_mean(diff)\n return loss","def weighted_cross_entropy_with_logits(pos_weight=1., label_smoothing=0):\n\n # @tf.function\n def loss(y_true, y_pred):\n labels = tf.cast(y_true, tf.float32)\n logits = tf.cast(y_pred, tf.float32)\n\n if label_smoothing > 0:\n # label smoothing between binary classes (Szegedy et al. 2015)\n labels *= 1.0 - label_smoothing\n labels += 0.5 * label_smoothing\n\n return tf.reduce_mean(\n tf.nn.weighted_cross_entropy_with_logits(\n labels=labels, logits=logits, pos_weight=pos_weight),\n axis=-1)\n\n return loss","def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]","def cross_entropy_loss(self, logits, labels):\n return F.cross_entropy(logits, labels)","def logistic_regression_SGD(y, tx, initial_w, max_iters, gamma, batch_size=10, verbose=False):\n return stochastic_gradient_descent(y, tx, initial_w, max_iters, gamma, compute_logistic_loss, \n compute_logistic_gradient, batch_size=10, verbose=verbose)","def loss(logits, labels):\r\n labels = tf.to_int64(labels)\r\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\r\n labels=labels, logits=logits, name='xentropy')\r\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def loss(logits, labels):\r\n labels = tf.to_int64(labels)\r\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\r\n labels=labels, logits=logits, name='xentropy')\r\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def logistic(self, X, w):\n g = 1 / (1 + np.exp(-X.dot(w)))\n return g","def logistic(weights, data, targets, hyperparameters):\n y = logistic_predict(weights, data)\n\n #####################################################################\n # TODO: #\n # Given weights and data, return the averaged loss over all data #\n # points, gradient of parameters, and the probabilities given by #\n # logistic regression. #\n #####################################################################\n f = None\n df = None\n\n f = evaluate(targets, y)[0]\n\n N = len(data)\n M = len(weights) - 1 \n temp = np.ones([N, M + 1])\n temp[: N, : M] = np.array(data)\n\n\n df = np.zeros([M+1, 1])\n\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n #####################################################################\n # END OF YOUR CODE #\n #####################################################################\n return f, df, y","def log_target(self, x):\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def compute_cost(Z6, Y):\n\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\n\n return cost","def cost_(self, y_hat, y, eps=1e-15):\n\t\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))","def loss_op(logits, labels):\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels, name='xentropy_eval')\n\n loss = math_ops.reduce_mean(cross_entropy)\n return loss","def mean_cross_entropy_costs(X, y, lambda_reg=0.0):\n return lambda theta: np.mean(cross_entropy(X, y)(theta)) + L2_regularization_cost(\n X, theta, lambda_reg\n )","def loss(logits, labels):\n labels = tf.to_int64(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n logits, labels, name='xentropy')\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def logistic_pen(weights, data, targets, hyperparameters):\n\n # get regularizer and original logistic return values\n regularizer = hyperparameters['weight_regularization']\n\n E, df, y = logistic(weights, data, targets, hyperparameters)\n\n # sum of all weights squared multiplied by lambda/2. Add on top of logistic\n pen_1 = regularizer * 0.5 * (reduce(lambda x,y: x + y * y, weights))\n f = E + pen_1\n\n # calculat pen for dL/dwi - dE/dwi, add the difference to df\n df = df + regularizer * weights\n\n return f, df, y","def get_reconstruction_cost(self, updates, pre_sigmoid_nv):\r\n\r\n cross_entropy = T.mean(\r\n T.sum(self.input * T.log(T.nnet.sigmoid(pre_sigmoid_nv)) +\r\n (1 - self.input) * T.log(1 - T.nnet.sigmoid(pre_sigmoid_nv)),\r\n axis=1))\r\n\r\n return cross_entropy","def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n return -torch.log2(probability_fn(args))","def cross_entropy(X, y, using_onehot=True):\n\tM = y.shape[0]\n\tif using_onehot :\n\t\tlog_likelihood = -np.log(np.max(X * y, -1))\n\telse:\n\t\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\n\tloss = np.sum(log_likelihood) / M\n\treturn loss","def setup_loss(logits, labels):\n predictions = tf.nn.softmax(logits)\n cost = tf.losses.softmax_cross_entropy(onehot_labels=labels,\n logits=logits,\n )\n return predictions, cost","def softmax(x, theta=1):\n\n # print x\n # Multiplication by theta to make the values of np.exp(.) more reasonable\n # y = np.copy(x) * theta\n y = (np.copy(x)/60.0 * -0.086) * theta\n\n # print y\n p = np.minimum(np.maximum(np.exp(y), 1e-20), 1e20) / np.sum(np.minimum(np.maximum(np.exp(y), 1e-20), 1e20), axis=0)\n # print p\n # If any element of p is Nan, return equal probablity for all the paths\n if np.isnan(p).any():\n p = np.ones(len(x)) / len(x)\n return p","def fit(self, x, y):\n # *** START CODE HERE ***\n num_examples = x.shape[0]\n num_features = x.shape[1]\n iteration = 1\n if self.theta == None:\n self.theta = np.zeros((num_features,))\n while iteration <= self.max_iter:\n h_theta = np.dot(x, self.theta)\n g_theta = self.sigmoid(h_theta)\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\n d_theta = - np.linalg.solve(H, J_prime)\n self.theta += d_theta\n if np.linalg.norm(d_theta, 1) < self.eps:\n break\n if self.verbose:\n print(\"Loss value: \", J_cost)\n iteration += 1\n # *** END CODE HERE ***","def penalized_logistic_regression(y, tx, w, lambda_):\n penality = lambda_*np.linalg.norm(w)**2\n diag = np.diag(np.repeat(2*lambda_, len(w)))\n return calculate_loss(y,tx,w) + penality, calculate_gradient(y,tx,w) + lambda_*2*w, calculate_hessian(y,tx,w) + diag","def add_cost(self):\n \n # Get Pij, probability j will be i's neighbor\n self._get_Pij()\n \n def _add_to_cumSum(Idx, cumsum):\n \n \"\"\"Add patient to log partial likelihood sum \"\"\"\n \n # Get survival of current patient and corresponding at-risk cases\n # i.e. those with higher survival or last follow-up time\n Pred_thisPatient = self.T[Idx]\n Pred_atRisk = self.T[self.At_Risk[Idx]:tf.size(self.T)-1]\n \n # Get Pij of at-risk cases from this patient's perspective\n Pij_thisPatient = self.Pij[Idx, self.At_Risk[Idx]:tf.size(self.T)-1]\n \n # exponentiate and weigh Pred_AtRisk\n Pij_thisPatient = tf.pow(Pij_thisPatient, self.KAPPA)\n Pred_atRisk = tf.multiply(tf.exp(Pred_atRisk), Pij_thisPatient)\n \n # Get log partial sum of prediction for those at risk\n LogPartialSum = tf.log(tf.reduce_sum(Pred_atRisk))\n \n # Get difference\n Diff_ThisPatient = tf.subtract(Pred_thisPatient, LogPartialSum)\n \n # Add to cumulative log partial likeliood sum\n cumsum = tf.add(cumsum, Diff_ThisPatient)\n \n return cumsum\n \n def _add_if_observed(Idx, cumsum):\n \n \"\"\" Add to cumsum if current patient'd death time is observed \"\"\"\n \n with tf.name_scope(\"add_if_observed\"):\n cumsum = tf.cond(tf.equal(self.O[Idx], 1), \n lambda: _add_to_cumSum(Idx, cumsum),\n lambda: tf.cast(cumsum, tf.float32)) \n \n Idx = tf.cast(tf.add(Idx, 1), tf.int32)\n \n return Idx, cumsum\n \n def _penalty(W):\n \n \"\"\"\n Elastic net penalty. Inspired by: \n https://github.com/glm-tools/pyglmnet/blob/master/pyglmnet/pyglmnet.py\n \"\"\"\n \n with tf.name_scope(\"Elastic_net\"):\n \n # Lasso-like penalty\n L1penalty = self.LAMBDA * tf.reduce_sum(tf.abs(W))\n \n # Compute the L2 penalty (ridge-like)\n L2penalty = self.LAMBDA * tf.reduce_sum(W ** 2)\n \n # Combine L1 and L2 penalty terms\n P = 0.5 * (self.ALPHA * L1penalty + (1 - self.ALPHA) * L2penalty)\n \n return P\n \n \n with tf.variable_scope(\"loss\"):\n \n cumSum = tf.cast(tf.Variable([0.0]), tf.float32)\n Idx = tf.cast(tf.Variable(0), tf.int32)\n \n # Go through all uncensored cases and add to cumulative sum\n c = lambda Idx, cumSum: tf.less(Idx, tf.cast(tf.size(self.T)-1, tf.int32))\n b = lambda Idx, cumSum: _add_if_observed(Idx, cumSum)\n Idx, cumSum = tf.while_loop(c, b, [Idx, cumSum])\n \n # cost is negative weighted log likelihood\n self.cost = -cumSum\n \n # Add elastic-net penalty\n self.cost = self.cost + _penalty(self.W)","def comp_cost(y_hat, y, activation, epsilon=1e-15):\n if activation == 'sigmoid':\n m = y.shape[1]\n cost = np.dot(y, np.log(y_hat).T) + np.dot((1 - y), np.log(1 - y_hat).T)\n cost = (-1. / m) * cost\n cost = np.squeeze(cost) # turns [[17]] into 17).\n assert (cost.shape == ())\n elif activation == 'softmax':\n \"\"\"\n Computes x-entropy between y (encoded as one-hot vectors) and y_hat.\n \n Arguments:\n y_hat -- predictions, array (n, k), (# of examples, # of categories)\n y -- true 'label' np.array (n, k) (# of examples, # of categories)\n \n Returns:\n cost -- categorical cross entropy cost\n \n Algorithm:\n -1./N * sum_i(sum_j t_ij * log(p_ij)), i=1..len(y), j=1..k\n \n y_hat = np.clip(y_hat, epsilon, 1. - epsilon)\n -np.sum(y * np.log(y_hat + epsilog)) / y_hat.shape[0] \n \"\"\"\n cost = log_loss(y, y_hat)\n else:\n raise AttributeError('Unexpected activation function:', activation)\n return cost","def optimization(logits, y, population, embedding, alpha):\n if FLAGS.uniform_weights:\n weights = tf.ones(shape=tf.shape(population))\n else:\n weights = tf.where(\n tf.greater(population, 0.01), tf.fill(tf.shape(population), 0.16),\n tf.fill(tf.shape(population), 2.5))\n if not FLAGS.propensity_weights:\n weights = tf.sigmoid(tf.matmul(embedding, alpha)) * weights\n weights /= tf.reduce_mean(weights)\n loss = tf.losses.hinge_loss(labels=y, logits=logits, weights=weights)\n optimizer = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss)\n return optimizer, loss","def logistic(weights, data, targets, hyperparameters):\n # TODO: Finish this function\n n_data = len(data)\n dim_data = len(data[0])\n\n f = 0\n y = logistic_predict(weights, data)\n\n data = mod_data(data)\n\n # dl/dw_j = SUM(x_ij * (t_i - (1 - sigmoid(z))))\n df = np.dot(data.T, (1.0 * targets) - (1 - y))\n\n # to calculate f, we need to sum the negative log of all y iff target is 0 and (1-y) iff target is 1\n f = -1.0 * np.dot(targets.T, np.log(1 - y)) - 1.0 * np.dot(1 - targets.T, np.log(y))\n\n # calculate P(C=0|x_i) for all x_i \n return f[0,0], df, y","def softmax_cross_entropy(logits,\n labels,\n label_smoothing = 0.0,\n weights = 1.0,\n loss_reduction = LossReductionType\n .SUM_BY_NONZERO_WEIGHTS,\n **kwargs):\n del kwargs\n check_shape_equal(logits, labels)\n\n labels = labels.astype(logits.dtype)\n if label_smoothing > 0:\n num_classes = labels.shape[-1]\n smooth_weight = label_smoothing / num_classes\n smooth_weight = jnp.array(smooth_weight, dtype=logits.dtype)\n labels = (1. - label_smoothing) * labels + smooth_weight\n\n logits = jax.nn.log_softmax(logits)\n loss = -labels * logits\n loss = jnp.sum(loss, axis=-1)\n\n return compute_weighted_loss(loss, weights, logits.dtype, loss_reduction)","def objective(self,w):\n l = 0\n for i in range(len(self.x)):\n # Each example contributes log(sigma(y_i * x_i . w))\n l -= log(sigmoid(self.y[i] * np.dot(w, self.x[i,:])))\n # regularisation 1/2 * alpha * ||w||^2\n l += 0.5 * self.alpha * np.dot(w,w)\n return l","def loss(labels,q,M,a,b):\n x=-(labels*np.log(s.expit(z(q,M,a,b)))+(1-labels)*np.log(1-s.expit(z(q,M,a,b))))\n return np.sum(x)+l/2*(np.sum(M**2)+b**2)","def cost(self, Y, A):\n\n m = Y.shape[1]\n C = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) *\n (np.log(1.0000001 - A)))\n return C","def train_logisticRegression(data: np.array, labels: np.array)->None:\n\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n n_categories = np.size(labels, 1)\n\n data = np.hstack((np.ones((n_examples, 1)), data))\n\n print(data[0:5, :])\n\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\n\n convergence_goal = 1e-3\n learning_rate = 0.01\n\n theta = np.random.uniform(size=((n_features+1, n_categories)))\n\n for i in range(n_categories):\n\n cost_var = 1\n\n previous_cost = 1e6\n iterations = 0\n cost_to_plot = []\n\n while cost_var > convergence_goal:\n iterations += 1\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\n cost_var = previous_cost - cost\n previous_cost = cost\n if iterations == 1: cost_var = 1\n cost_to_plot.append(cost)\n # print(cost)\n\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\n plt.xlabel('iterations')\n plt.ylabel('cost')\n # plt.show()\n\n predictions = lrPredict(theta, X_test)\n\n print(predictions[0:5, :])\n print(y_test[0:5, :])\n\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def loss(params: hk.Params, batch, label) -> jnp.ndarray:\r\n logits = net.apply(params, batch)\r\n labels = jax.nn.one_hot(label, n_classes)\r\n\r\n # Cross Entropy Loss\r\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\r\n softmax_xent /= labels.shape[0]\r\n return softmax_xent","def minimize_cost_function(m = no_of_training_exammples, x, y, theta_0, theta_1):\r\n var_x, var_y = np.array(x), np.array(y)\r\n compute_1, compute_2, compute_3 = (0,0,0)\r\n minimized_solution = []\r\n for i in range(m):\r\n compute_1 = var_y[i] - cost_function(var_x[i],theta_0, theta_1) # finds the computed Euclidean distance between\r\n # x and its corresponding value y\r\n compute_2 = pow(compute_1,2) # square of the distance\r\n minimized_solution.append(compute_2) # appends the corresponding solution to a list minimized_solution\r\n compute_3 = sum(minimized_solution)/ (2 * m) # compute the minimized cost function of x and y by dividing by\r\n # twice the number of training examples\r\n return compute_3","def logistic_regression(y, tx, initial_w, max_iters, gamma, debug = False):\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_logistic.loss, grad_f = model_logistic.grad, debug = debug)\n return get_last_ans(ws, losses)","def compute_cost(AL, Y):\n m = Y.shape[1]\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\n cost = np.sum(log_val) * (-1/m)\n cost = np.squeeze(cost)\n return cost","def compute_cost(AL, Y):\n m = AL.shape[1]\n cost = 1./m*(-Y*np.log(AL)-(1.0 - Y)*np.log(1.0 - AL))\n cost = np.squeeze(cost)\n return cost","def logistic(weights, data, targets, hyperparameters):\n\n # TODO: Finish this function\n\n return f, df, y","def compute_logistic_loss(y, tx, w):\n pred = tx.dot(w)\n y = np.asarray(y)\n logsig = -np.logaddexp(0, -pred) # == np.log(sigmoid(pred))\n\n return np.mean((1 - y) * pred - logsig)"],"string":"[\n \"def logit_cost(self, theta, X, y):\\n\\n cost = 0.0\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n \\n for i in range(0, X.shape[0]):\\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\\n ### END YOUR CODE\\n cost = cost #+ 0.01 * self.regularizer[0](self.weights)\\n return cost\",\n \"def cost(self, X=None, y=None, theta=None):\\n X = self.X_train if X is None else X\\n y = self.y_train if y is None else y\\n m = X.shape[1]\\n\\n prob_mat = self.softmax_mat(X, theta)\\n cost = -(y * np.log(prob_mat)).sum() / m\\n return cost\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def _softmax_cost(self, theta, *args):\\n epsilon = 1e-32\\n wd, PHI, y = args\\n N, P = PHI.shape\\n W = np.reshape(theta, [P, -1])\\n t = softmax(np.matmul(PHI, W)) + epsilon\\n grad = (1. / N) * np.matmul(PHI.T, t - y) + wd * W\\n grad = grad.flatten()\\n cost = -(1. / N) * np.dot(y.flatten().T, np.log(t.flatten())) \\\\\\n + 0.5 * wd * np.sum(W.flatten() ** 2)\\n return cost, grad\",\n \"def costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def cost(self, logits, labels, weights):\\n return tf.multiply(\\n tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels),\\n weights)\",\n \"def costFunction(theta,X,y):\\n m = X.shape[0]\\n J = 0\\n h = sigmoid (np.dot(X,theta))\\n \\n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\\n \\n #grad = (1/m) * np.dot(X.T,(h-y))\\n grad = (1/m) * np.dot((h.T - y), X).T\\n \\n return J, grad\",\n \"def softmax_cross_entropy(y, label):\\r\\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\\r\\n return losses\\r\\n pass\",\n \"def cost_function(x, params, y, m):\\n\\n x_theta = np.matmul(x, params)\\n hypothesis = vectorized_sigmoid_function(x_theta)\\n\\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)\",\n \"def cross_entropy_cost(m, A, L):\\n\\tcost = (-1 / m) * np.sum(L * np.log(A) + (1 - L) * (np.ma.log(1 - A))) #Note: Using numpy masked array np.ma for values of log(0)\\n\\n\\n\\t# Sanity checks\\n\\tcost = np.squeeze(cost) \\t#squeeze() removes single dimensional elements from the array: e.g. (1, 3, 1) -> (3,)\\n\\tassert(cost.shape == ()) \\t#checks if cost value is a scalar\\n\\n\\treturn cost\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def cost_function(X, y, theta, _lambda, num_labels, n_hidden_layers=1):\\n m, n = X.shape\\n intercept = ones((m, 1), dtype=float64)\\n X = append(intercept, X, axis=1)\\n\\n _h = h(X, theta, n_hidden_layers) # model hypothesis\\n\\n J = 0\\n for c in range(num_labels):\\n _J = dot(1 - (y == c).T, log(1 - _h[:, c]))\\n _J = _J + dot((y == c).T, log(_h[:, c]))\\n J = J - (1 / m) * sum(_J)\\n\\n theta_squared_term = 0\\n for j in range(len(theta)):\\n theta_squared_term += sum(power(theta[j][:, 1:], 2))\\n\\n J = J + (_lambda / (2 * m)) * theta_squared_term\\n\\n return J\",\n \"def cost(self, h_theta, y):\\n \\n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)\",\n \"def logit_cost_grad(self, theta, X, y):\\n\\n grad = np.zeros(len(theta))\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n # sig = np.subtract(sig, y)\\n sig = sig - y\\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\\n ### END YOUR CODE\\n\\n return grad\",\n \"def cost(theta, X, y, learning_rate):\\n m = len(y) \\n theta = theta.reshape((-1,1))\\n h = sigmoid(np.dot(X, theta))\\n\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n return float(J)\",\n \"def logistic_regression(y, tx, initial_w, max_iters, gamma):\\n return least_squares_SGD(y, tx, initial_w, max_iters, gamma, loss_function=logistic_loss, gradient=logistic_grad)\",\n \"def prediction_cost(a, y):\\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))\",\n \"def grad_softmax_cross_entropy_loss(logit, labels):\\n return softmax(logit) - labels\",\n \"def cost(h, y):\\n\\tm = y.shape[0]\\n\\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\\n\\treturn cost\",\n \"def objective_function(theta, X, y):\\n # m number of training instances\\n m = X.shape[0]\\n jtheta = sum((np.dot(X, theta) - y)**2) / (2.0*m)\\n return jtheta\",\n \"def softmax_cross_entropy_loss(logit, labels):\\n p = softmax(logit)\\n loss_i = - labels * np.log(p + 1e-8)\\n return np.mean(loss_i)\",\n \"def calculate_entropic_cost(self, log_prediction):\\n\\n log_prediction = tf.squeeze(log_prediction)\\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\\n\\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\\n\\n return tf.reduce_sum(penalty)\",\n \"def cross_entropy(t,y):\\r\\n #print(-1*t*np.log(y))\\r\\n #print(np.shape(np.log(y)))\\r\\n #print(np.shape(t))\\r\\n return t*np.log(y)*(-1)\",\n \"def get_cross_entropy(self):\\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\\n potential = 0.0\\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\\n return potential\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n# labels = tf.to_float(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\\n# y_conv = tf.nn.softmax(logits)\\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def sigmoid_cross_entropy(y, label):\\r\\n losses = - np.log(y + g_epsilon) * label - np.log(1.0 - y + g_epsilon) * (1.0 - label)\\r\\n return losses\",\n \"def cost(theta, X, y, Lambda=0.0):\\n m = X.shape[0] # number of samples\\n\\n h = hypothesis(theta, X) \\n \\n suma = (-y*np.log(h) - (1 - y)*np.log(1 - h)).sum() \\n\\n reg_term = 0.0\\n if Lambda:\\n reg_term = (Lambda/(2*m))*((theta[1:]**2).sum()) # skip theta-0\\n\\n return (1/m)*suma + reg_term\",\n \"def cost(self, Y, A):\\n loss1 = Y * np.log(A)\\n m = Y.shape[1]\\n cost = -1 * np.sum(loss1) / m\\n return cost\",\n \"def calculate_cost(x, y, weights):\\r\\n predictions = compute_prediction(x, weights)\\r\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\r\\n return cost\",\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def feature_mapped_logistic_regression(power, l):\\n df = pd.read_csv('ex2data2.txt', names=['test1', 'test2', 'accepted'])\\n x1 = np.array(df.test1)\\n x2 = np.array(df.test2)\\n y = general.get_y(df)\\n\\n X = feature_mapping(x1, x2, power, as_ndarray=True)\\n theta = np.zeros(X.shape[1])\\n\\n res = opt.minimize(fun=regularized_cost,\\n x0=theta,\\n args=(X, y, l),\\n method='TNC',\\n jac=regularized_gradient)\\n final_theta = res.x\\n\\n return final_theta\",\n \"def logistic_regression(y, tx, initial_w, max_iters, gamma, verbose=False):\\n return gradient_descent(y, tx, initial_w, max_iters, gamma, \\n compute_logistic_loss, compute_logistic_gradient, verbose=verbose)\",\n \"def get_reconstruction_cost(self, nv):\\n cross_entropy = T.mean(\\n T.sum(\\n self.input * T.log(nv) +\\n (1 - self.input) * T.log(1 - nv),\\n axis=1\\n )\\n )\\n return cross_entropy\",\n \"def cost_function(self, X, y, theta_list, bias):\\n total_samples = len(y)\\n loss = 0\\n\\n for i in range(total_samples):\\n hypothesis = bias\\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\\n \\n de = 1.0 + np.exp(-hypothesis)\\n sigmoidhypothesis = 1.0/de\\n\\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\\n\\n return -1 * (loss/total_samples) #loss calculation\",\n \"def soft_cross_entropy(input, targets):\\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\\n return (- targets_prob * student_likelihood).sum(dim=-1).mean()\",\n \"def ovo_crossentropy_loss(y_true, y_pred):\\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\\n y_true_scaled = (y_true + 1.0) / 2.0\\n y_pred_scaled = (y_pred + 1.0) / 2.0\\n\\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\\n\\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\\n\\n # J_{OvO} aus Pawara et al. anwenden\\n log_function = tf.log if tf.__version__ == \\\"1.13.1\\\" else tf.math.log # flexibel für neue / alte Version\\n loss = - tf.reduce_mean(\\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\\n return loss\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x = np.squeeze(x)\\n y_prime = (y + 1)/2\\n h = 1 /(1 + np.exp(-x))\\n loss = np.sum(-np.log( (h**y_prime) * ((1-h)**(1-y_prime)) ))/N\\n dx = np.exp(-y*x)*(-y)/(1+np.exp(-y*x))/N\\n return loss, dx\",\n \"def reg_logistic_regression(y, tx, lambda_, initial_w, max_iters, gamma, verbose=False): \\n reg_loss, reg_grad = add_l2_reg(compute_logistic_loss, \\n compute_logistic_gradient,\\n lambda_)\\n \\n return gradient_descent(y, tx, initial_w, max_iters, gamma, reg_loss, reg_grad)\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def nn_cost_function(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, l):\\n Theta_1 = np.reshape(nn_params[0:(hidden_layer_size * (input_layer_size + 1)), ],\\n (hidden_layer_size, input_layer_size + 1))\\n Theta_2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):, ],\\n (num_labels, hidden_layer_size + 1))\\n\\n m, n = X.shape\\n X = np.hstack((np.ones((m, 1)), X))\\n\\n Z_2 = X.dot(Theta_1.T)\\n A_2 = sigmoid(Z_2)\\n A_2 = np.hstack((np.ones((m, 1)), A_2))\\n\\n Z_3 = A_2.dot(Theta_2.T)\\n A_3 = sigmoid(Z_3)\\n\\n Y = np.zeros((m, num_labels))\\n for i in range(m):\\n Y[i, y[i] - 1] = 1\\n\\n j = 0.0\\n for i in range(m):\\n j += np.log(A_3[i, ]).dot(-Y[i, ].T) - np.log(1 - A_3[i, ]).dot(1 - Y[i, ].T)\\n j /= m\\n\\n Theta_1_square = np.square(Theta_1[:, 1:])\\n Theta_2_square = np.square(Theta_2[:, 1:])\\n reg = 1.0 * l / (2 * m) * (np.sum(Theta_1_square) + np.sum(Theta_2_square))\\n j += reg\\n\\n d_3 = A_3 - Y\\n D_2 = d_3.T.dot(A_2)\\n\\n Z_2 = np.hstack((np.ones((m, 1)), Z_2))\\n d_2 = d_3.dot(Theta_2) * sigmoid_gradient(Z_2)\\n d_2 = d_2[:, 1:]\\n D_1 = d_2.T.dot(X)\\n\\n Theta_1_grad = 1.0 * D_1 / m\\n Theta_1_grad[:, 1:] = Theta_1_grad[:, 1:] + 1.0 * l / m * Theta_1[:, 1:]\\n\\n Theta_2_grad = 1.0 * D_2 / m\\n Theta_2_grad[:, 1:] = Theta_2_grad[:, 1:] + 1.0 * l / m * Theta_2[:, 1:]\\n\\n grad = np.hstack((Theta_1_grad.ravel(), Theta_2_grad.ravel()))\\n\\n return j, grad\",\n \"def cross_entropy_loss(logits, labels, label_smoothing=0., dtype=jnp.float32):\\n num_classes = logits.shape[-1]\\n labels = jax.nn.one_hot(labels, num_classes, dtype=dtype)\\n if label_smoothing > 0:\\n labels = labels * (1 - label_smoothing) + label_smoothing / num_classes\\n logp = jax.nn.log_softmax(logits.astype(dtype))\\n return -jnp.mean(jnp.sum(logp * labels, axis=-1))\",\n \"def cost_function(theta, X, y):\\n\\n l = None\\n #######################################################################\\n # TODO: #\\n # Compute and return the cost l of a particular choice of #\\n # theta. #\\n # #\\n #######################################################################\\n thetaX = np.dot(X, theta)\\n g = tanh(thetaX)-y\\n l = np.sum(g*g) / X.shape[0]\\n \\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return l\",\n \"def logistic_hypothesis(theta):\\n return lambda X: sigmoid(np.dot(x_strich(X), theta))\",\n \"def my_softmax_cross_entropy(preds, labels):\\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\\n return tf.reduce_mean(loss)\",\n \"def get_reconstruction_cost(self, pre_sigmoid_nv):\\n y = self.input\\n a = T.nnet.sigmoid(pre_sigmoid_nv)\\n\\n cross_entropy = -T.mean(\\n T.sum(y * T.log(a) + (1 - y) * T.log(1 - a), axis=1)\\n )\\n\\n return cross_entropy\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n # TODO: Finish this function\\n\\n return f, df, y\",\n \"def cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -Y / Y_hat\\n \\n return cost, dY_hat\",\n \"def logistic_regression_vec(theta, trainX, trainY):\\n # Add column of ones for bias\\n trainX = np.hstack((np.ones((trainX.shape[0], 1)), trainX))\\n h = sigmoid(np.inner(trainX, theta))\\n # np.log(1-h) can lead to problems for h = 1.0\\n h = np.where(h == 1.0, 1 - 1e-12, h)\\n fval = -(trainY * np.log(h) + (1 - trainY) * np.log(1 - h)).sum()\\n error = h - trainY\\n # Negative gradient for a minimization, must be flattened for np.minimize\\n grad = np.dot(trainX.T, error).flatten()\\n return fval, grad\",\n \"def lr_cost_function(theta, X, y, learning_rate):\\n m = len(y) # number of training examples\\n # You need to return the following variables correctly \\n J = 0\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta))\\n\\n #Compute cost:\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n \\n #Compute gradient\\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return float(J), grad\",\n \"def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\\n h = compute_probabilities(X, theta, temp_parameter)\\n\\n cost = 0\\n for i in range(X.shape[0]):\\n for j in range(theta.shape[0]):\\n if Y[i] == j:\\n cost += np.log(h[j,i])\\n\\n cost = -cost / X.shape[0]\\n\\n theta = np.power(theta, 2)\\n\\n cost += lambda_factor / 2 * theta.sum()\\n\\n return cost\",\n \"def softmax_cross_entropy(logits, target, weight=None, reduce=True):\\n target = target.long()\\n # Convert 5d input to 4d, because it is faster in functional.cross_entropy\\n if logits.dim() == 5:\\n logits = compress_3d_to_2d(logits)\\n target = compress_3d_to_2d(target)\\n\\n return nn.functional.cross_entropy(logits, target, weight=weight, reduce=reduce)\",\n \"def cross_entropy(y, y_hat):\\n return -tf.math.log(\\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\\n )\",\n \"def lr_cost_function(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> float:\\n\\n # Initialize some useful values\\n m = len(y) # number of training examples\\n\\n # You need to return the following variable correctly.\\n J = 0\\n\\n # ====================== YOUR CODE HERE ======================\\n # Instructions: Compute the cost of a particular choice of theta.\\n # You should set J to the cost.\\n\\n # =============================================================\\n return J\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def cost(self, x, y):\\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()\",\n \"def cross_entropy(y_pred,y):\\n \\n epsilon = 0.001 # To prevent overflow and ensure numerical stability\\n return sum(-y*np.log(y_pred+epsilon))\",\n \"def compute_cost(X, y, theta, lambd):\\n assert(theta.shape[0] == X.shape[1])\\n \\n m = X.shape[0]\\n grad = np.zeros(y.shape)\\n J = 0\\n \\n output = sigmoid(np.dot(X, theta))\\n\\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\\n\\n grad = np.dot(X.T, (output - y)) / m\\n \\n grad[1:] = grad[1:] + lambd / m * theta[1:]\\n\\n return J, grad\",\n \"def cost(self, Y, A):\\n m = Y.shape[1]\\n cost = - (1 / m) * np.sum(\\n np.multiply(\\n Y, np.log(A)) + np.multiply(\\n 1 - Y, np.log(1.0000001 - A)))\\n return cost\",\n \"def lrCostFunction(theta, X, y, lambda_):\\n if X.ndim == 1:\\n X = X.reshape(1, -1)\\n\\n if y.dtype == bool:\\n y = y.astype(int)\\n\\n # Initialize some useful values\\n m = len(y) # number of training examples\\n\\n # ====================== YOUR CODE HERE ======================\\n # Instructions: Compute the cost of a particular choice of theta.\\n # You should set J to the cost.\\n #\\n # Hint: The computation of the cost function and gradients can be\\n # efficiently vectorized. For example, consider the computation\\n #\\n # sigmoid(X * theta)\\n #\\n # Each row of the resulting matrix will contain the value of the\\n # prediction for that example. You can make use of this to vectorize\\n # the cost function and gradient computations.\\n #\\n\\n z = X @ theta\\n h = sigmoid(z)\\n\\n theta_ = np.r_[0, theta[1:]]\\n\\n J = (-y @ np.log(h) - (1 - y) @ np.log(1 - h)) / m\\n J += lambda_ * sum(theta_**2) / (2 * m)\\n\\n grad = (h - y) @ X / m\\n grad += lambda_ * theta_ / m\\n\\n # =============================================================\\n\\n return J, grad\",\n \"def logistic_loss(x, y):\\n N = x.shape[0]\\n x_flat = np.squeeze(x)\\n ex = np.exp(x_flat)\\n loss = np.sum(-y*x_flat+np.log(1+ex))/N\\n dx = (-y+ex/(1+ex))/N\\n # dx = np.reshape(dx,(len(dx),1))\\n return loss, dx\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n wr = hyperparameters['weight_regularization']\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n\\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\\n df = np.reshape(df, ((len(df), 1)))\\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\\n\\n f += (weights[-1, 0] ** 2) * wr / 2\\n df[-1] += weights[-1,0] * wr \\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def cross_entropy_loss(labels_tensor, logits_tensor, pos_weights):\\n diff = tf.nn.sigmoid_cross_entropy_with_logits(labels=labels_tensor, logits=logits_tensor, pos_weight= pos_weights)\\n loss = tf.reduce_mean(diff)\\n return loss\",\n \"def weighted_cross_entropy_with_logits(pos_weight=1., label_smoothing=0):\\n\\n # @tf.function\\n def loss(y_true, y_pred):\\n labels = tf.cast(y_true, tf.float32)\\n logits = tf.cast(y_pred, tf.float32)\\n\\n if label_smoothing > 0:\\n # label smoothing between binary classes (Szegedy et al. 2015)\\n labels *= 1.0 - label_smoothing\\n labels += 0.5 * label_smoothing\\n\\n return tf.reduce_mean(\\n tf.nn.weighted_cross_entropy_with_logits(\\n labels=labels, logits=logits, pos_weight=pos_weight),\\n axis=-1)\\n\\n return loss\",\n \"def cross_entropy(predictions, targets):\\n likelihood = targets * np.log(predictions)\\n return -np.sum(likelihood) / predictions.shape[0]\",\n \"def cross_entropy_loss(self, logits, labels):\\n return F.cross_entropy(logits, labels)\",\n \"def logistic_regression_SGD(y, tx, initial_w, max_iters, gamma, batch_size=10, verbose=False):\\n return stochastic_gradient_descent(y, tx, initial_w, max_iters, gamma, compute_logistic_loss, \\n compute_logistic_gradient, batch_size=10, verbose=verbose)\",\n \"def loss(logits, labels):\\r\\n labels = tf.to_int64(labels)\\r\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\r\\n labels=labels, logits=logits, name='xentropy')\\r\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def loss(logits, labels):\\r\\n labels = tf.to_int64(labels)\\r\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\r\\n labels=labels, logits=logits, name='xentropy')\\r\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def logistic(self, X, w):\\n g = 1 / (1 + np.exp(-X.dot(w)))\\n return g\",\n \"def logistic(weights, data, targets, hyperparameters):\\n y = logistic_predict(weights, data)\\n\\n #####################################################################\\n # TODO: #\\n # Given weights and data, return the averaged loss over all data #\\n # points, gradient of parameters, and the probabilities given by #\\n # logistic regression. #\\n #####################################################################\\n f = None\\n df = None\\n\\n f = evaluate(targets, y)[0]\\n\\n N = len(data)\\n M = len(weights) - 1 \\n temp = np.ones([N, M + 1])\\n temp[: N, : M] = np.array(data)\\n\\n\\n df = np.zeros([M+1, 1])\\n\\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n #####################################################################\\n # END OF YOUR CODE #\\n #####################################################################\\n return f, df, y\",\n \"def log_target(self, x):\\n return self.log_likelihood_exp(x) + self.log_prior_parameters(x) + self.log_prior_wilson_coeffs(x)\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def compute_cost(Z6, Y):\\n\\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z6, labels=Y))\\n\\n return cost\",\n \"def cost_(self, y_hat, y, eps=1e-15):\\n\\t\\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))\",\n \"def loss_op(logits, labels):\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels, name='xentropy_eval')\\n\\n loss = math_ops.reduce_mean(cross_entropy)\\n return loss\",\n \"def mean_cross_entropy_costs(X, y, lambda_reg=0.0):\\n return lambda theta: np.mean(cross_entropy(X, y)(theta)) + L2_regularization_cost(\\n X, theta, lambda_reg\\n )\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n logits, labels, name='xentropy')\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n # get regularizer and original logistic return values\\n regularizer = hyperparameters['weight_regularization']\\n\\n E, df, y = logistic(weights, data, targets, hyperparameters)\\n\\n # sum of all weights squared multiplied by lambda/2. Add on top of logistic\\n pen_1 = regularizer * 0.5 * (reduce(lambda x,y: x + y * y, weights))\\n f = E + pen_1\\n\\n # calculat pen for dL/dwi - dE/dwi, add the difference to df\\n df = df + regularizer * weights\\n\\n return f, df, y\",\n \"def get_reconstruction_cost(self, updates, pre_sigmoid_nv):\\r\\n\\r\\n cross_entropy = T.mean(\\r\\n T.sum(self.input * T.log(T.nnet.sigmoid(pre_sigmoid_nv)) +\\r\\n (1 - self.input) * T.log(1 - T.nnet.sigmoid(pre_sigmoid_nv)),\\r\\n axis=1))\\r\\n\\r\\n return cross_entropy\",\n \"def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n return -torch.log2(probability_fn(args))\",\n \"def cross_entropy(X, y, using_onehot=True):\\n\\tM = y.shape[0]\\n\\tif using_onehot :\\n\\t\\tlog_likelihood = -np.log(np.max(X * y, -1))\\n\\telse:\\n\\t\\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\\n\\tloss = np.sum(log_likelihood) / M\\n\\treturn loss\",\n \"def setup_loss(logits, labels):\\n predictions = tf.nn.softmax(logits)\\n cost = tf.losses.softmax_cross_entropy(onehot_labels=labels,\\n logits=logits,\\n )\\n return predictions, cost\",\n \"def softmax(x, theta=1):\\n\\n # print x\\n # Multiplication by theta to make the values of np.exp(.) more reasonable\\n # y = np.copy(x) * theta\\n y = (np.copy(x)/60.0 * -0.086) * theta\\n\\n # print y\\n p = np.minimum(np.maximum(np.exp(y), 1e-20), 1e20) / np.sum(np.minimum(np.maximum(np.exp(y), 1e-20), 1e20), axis=0)\\n # print p\\n # If any element of p is Nan, return equal probablity for all the paths\\n if np.isnan(p).any():\\n p = np.ones(len(x)) / len(x)\\n return p\",\n \"def fit(self, x, y):\\n # *** START CODE HERE ***\\n num_examples = x.shape[0]\\n num_features = x.shape[1]\\n iteration = 1\\n if self.theta == None:\\n self.theta = np.zeros((num_features,))\\n while iteration <= self.max_iter:\\n h_theta = np.dot(x, self.theta)\\n g_theta = self.sigmoid(h_theta)\\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\\n d_theta = - np.linalg.solve(H, J_prime)\\n self.theta += d_theta\\n if np.linalg.norm(d_theta, 1) < self.eps:\\n break\\n if self.verbose:\\n print(\\\"Loss value: \\\", J_cost)\\n iteration += 1\\n # *** END CODE HERE ***\",\n \"def penalized_logistic_regression(y, tx, w, lambda_):\\n penality = lambda_*np.linalg.norm(w)**2\\n diag = np.diag(np.repeat(2*lambda_, len(w)))\\n return calculate_loss(y,tx,w) + penality, calculate_gradient(y,tx,w) + lambda_*2*w, calculate_hessian(y,tx,w) + diag\",\n \"def add_cost(self):\\n \\n # Get Pij, probability j will be i's neighbor\\n self._get_Pij()\\n \\n def _add_to_cumSum(Idx, cumsum):\\n \\n \\\"\\\"\\\"Add patient to log partial likelihood sum \\\"\\\"\\\"\\n \\n # Get survival of current patient and corresponding at-risk cases\\n # i.e. those with higher survival or last follow-up time\\n Pred_thisPatient = self.T[Idx]\\n Pred_atRisk = self.T[self.At_Risk[Idx]:tf.size(self.T)-1]\\n \\n # Get Pij of at-risk cases from this patient's perspective\\n Pij_thisPatient = self.Pij[Idx, self.At_Risk[Idx]:tf.size(self.T)-1]\\n \\n # exponentiate and weigh Pred_AtRisk\\n Pij_thisPatient = tf.pow(Pij_thisPatient, self.KAPPA)\\n Pred_atRisk = tf.multiply(tf.exp(Pred_atRisk), Pij_thisPatient)\\n \\n # Get log partial sum of prediction for those at risk\\n LogPartialSum = tf.log(tf.reduce_sum(Pred_atRisk))\\n \\n # Get difference\\n Diff_ThisPatient = tf.subtract(Pred_thisPatient, LogPartialSum)\\n \\n # Add to cumulative log partial likeliood sum\\n cumsum = tf.add(cumsum, Diff_ThisPatient)\\n \\n return cumsum\\n \\n def _add_if_observed(Idx, cumsum):\\n \\n \\\"\\\"\\\" Add to cumsum if current patient'd death time is observed \\\"\\\"\\\"\\n \\n with tf.name_scope(\\\"add_if_observed\\\"):\\n cumsum = tf.cond(tf.equal(self.O[Idx], 1), \\n lambda: _add_to_cumSum(Idx, cumsum),\\n lambda: tf.cast(cumsum, tf.float32)) \\n \\n Idx = tf.cast(tf.add(Idx, 1), tf.int32)\\n \\n return Idx, cumsum\\n \\n def _penalty(W):\\n \\n \\\"\\\"\\\"\\n Elastic net penalty. Inspired by: \\n https://github.com/glm-tools/pyglmnet/blob/master/pyglmnet/pyglmnet.py\\n \\\"\\\"\\\"\\n \\n with tf.name_scope(\\\"Elastic_net\\\"):\\n \\n # Lasso-like penalty\\n L1penalty = self.LAMBDA * tf.reduce_sum(tf.abs(W))\\n \\n # Compute the L2 penalty (ridge-like)\\n L2penalty = self.LAMBDA * tf.reduce_sum(W ** 2)\\n \\n # Combine L1 and L2 penalty terms\\n P = 0.5 * (self.ALPHA * L1penalty + (1 - self.ALPHA) * L2penalty)\\n \\n return P\\n \\n \\n with tf.variable_scope(\\\"loss\\\"):\\n \\n cumSum = tf.cast(tf.Variable([0.0]), tf.float32)\\n Idx = tf.cast(tf.Variable(0), tf.int32)\\n \\n # Go through all uncensored cases and add to cumulative sum\\n c = lambda Idx, cumSum: tf.less(Idx, tf.cast(tf.size(self.T)-1, tf.int32))\\n b = lambda Idx, cumSum: _add_if_observed(Idx, cumSum)\\n Idx, cumSum = tf.while_loop(c, b, [Idx, cumSum])\\n \\n # cost is negative weighted log likelihood\\n self.cost = -cumSum\\n \\n # Add elastic-net penalty\\n self.cost = self.cost + _penalty(self.W)\",\n \"def comp_cost(y_hat, y, activation, epsilon=1e-15):\\n if activation == 'sigmoid':\\n m = y.shape[1]\\n cost = np.dot(y, np.log(y_hat).T) + np.dot((1 - y), np.log(1 - y_hat).T)\\n cost = (-1. / m) * cost\\n cost = np.squeeze(cost) # turns [[17]] into 17).\\n assert (cost.shape == ())\\n elif activation == 'softmax':\\n \\\"\\\"\\\"\\n Computes x-entropy between y (encoded as one-hot vectors) and y_hat.\\n \\n Arguments:\\n y_hat -- predictions, array (n, k), (# of examples, # of categories)\\n y -- true 'label' np.array (n, k) (# of examples, # of categories)\\n \\n Returns:\\n cost -- categorical cross entropy cost\\n \\n Algorithm:\\n -1./N * sum_i(sum_j t_ij * log(p_ij)), i=1..len(y), j=1..k\\n \\n y_hat = np.clip(y_hat, epsilon, 1. - epsilon)\\n -np.sum(y * np.log(y_hat + epsilog)) / y_hat.shape[0] \\n \\\"\\\"\\\"\\n cost = log_loss(y, y_hat)\\n else:\\n raise AttributeError('Unexpected activation function:', activation)\\n return cost\",\n \"def optimization(logits, y, population, embedding, alpha):\\n if FLAGS.uniform_weights:\\n weights = tf.ones(shape=tf.shape(population))\\n else:\\n weights = tf.where(\\n tf.greater(population, 0.01), tf.fill(tf.shape(population), 0.16),\\n tf.fill(tf.shape(population), 2.5))\\n if not FLAGS.propensity_weights:\\n weights = tf.sigmoid(tf.matmul(embedding, alpha)) * weights\\n weights /= tf.reduce_mean(weights)\\n loss = tf.losses.hinge_loss(labels=y, logits=logits, weights=weights)\\n optimizer = tf.train.AdamOptimizer(LEARNING_RATE).minimize(loss)\\n return optimizer, loss\",\n \"def logistic(weights, data, targets, hyperparameters):\\n # TODO: Finish this function\\n n_data = len(data)\\n dim_data = len(data[0])\\n\\n f = 0\\n y = logistic_predict(weights, data)\\n\\n data = mod_data(data)\\n\\n # dl/dw_j = SUM(x_ij * (t_i - (1 - sigmoid(z))))\\n df = np.dot(data.T, (1.0 * targets) - (1 - y))\\n\\n # to calculate f, we need to sum the negative log of all y iff target is 0 and (1-y) iff target is 1\\n f = -1.0 * np.dot(targets.T, np.log(1 - y)) - 1.0 * np.dot(1 - targets.T, np.log(y))\\n\\n # calculate P(C=0|x_i) for all x_i \\n return f[0,0], df, y\",\n \"def softmax_cross_entropy(logits,\\n labels,\\n label_smoothing = 0.0,\\n weights = 1.0,\\n loss_reduction = LossReductionType\\n .SUM_BY_NONZERO_WEIGHTS,\\n **kwargs):\\n del kwargs\\n check_shape_equal(logits, labels)\\n\\n labels = labels.astype(logits.dtype)\\n if label_smoothing > 0:\\n num_classes = labels.shape[-1]\\n smooth_weight = label_smoothing / num_classes\\n smooth_weight = jnp.array(smooth_weight, dtype=logits.dtype)\\n labels = (1. - label_smoothing) * labels + smooth_weight\\n\\n logits = jax.nn.log_softmax(logits)\\n loss = -labels * logits\\n loss = jnp.sum(loss, axis=-1)\\n\\n return compute_weighted_loss(loss, weights, logits.dtype, loss_reduction)\",\n \"def objective(self,w):\\n l = 0\\n for i in range(len(self.x)):\\n # Each example contributes log(sigma(y_i * x_i . w))\\n l -= log(sigmoid(self.y[i] * np.dot(w, self.x[i,:])))\\n # regularisation 1/2 * alpha * ||w||^2\\n l += 0.5 * self.alpha * np.dot(w,w)\\n return l\",\n \"def loss(labels,q,M,a,b):\\n x=-(labels*np.log(s.expit(z(q,M,a,b)))+(1-labels)*np.log(1-s.expit(z(q,M,a,b))))\\n return np.sum(x)+l/2*(np.sum(M**2)+b**2)\",\n \"def cost(self, Y, A):\\n\\n m = Y.shape[1]\\n C = (-1 / m) * np.sum(Y * np.log(A) + (1 - Y) *\\n (np.log(1.0000001 - A)))\\n return C\",\n \"def train_logisticRegression(data: np.array, labels: np.array)->None:\\n\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n n_categories = np.size(labels, 1)\\n\\n data = np.hstack((np.ones((n_examples, 1)), data))\\n\\n print(data[0:5, :])\\n\\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\\n\\n convergence_goal = 1e-3\\n learning_rate = 0.01\\n\\n theta = np.random.uniform(size=((n_features+1, n_categories)))\\n\\n for i in range(n_categories):\\n\\n cost_var = 1\\n\\n previous_cost = 1e6\\n iterations = 0\\n cost_to_plot = []\\n\\n while cost_var > convergence_goal:\\n iterations += 1\\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\\n cost_var = previous_cost - cost\\n previous_cost = cost\\n if iterations == 1: cost_var = 1\\n cost_to_plot.append(cost)\\n # print(cost)\\n\\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\\n plt.xlabel('iterations')\\n plt.ylabel('cost')\\n # plt.show()\\n\\n predictions = lrPredict(theta, X_test)\\n\\n print(predictions[0:5, :])\\n print(y_test[0:5, :])\\n\\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def loss(params: hk.Params, batch, label) -> jnp.ndarray:\\r\\n logits = net.apply(params, batch)\\r\\n labels = jax.nn.one_hot(label, n_classes)\\r\\n\\r\\n # Cross Entropy Loss\\r\\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\\r\\n softmax_xent /= labels.shape[0]\\r\\n return softmax_xent\",\n \"def minimize_cost_function(m = no_of_training_exammples, x, y, theta_0, theta_1):\\r\\n var_x, var_y = np.array(x), np.array(y)\\r\\n compute_1, compute_2, compute_3 = (0,0,0)\\r\\n minimized_solution = []\\r\\n for i in range(m):\\r\\n compute_1 = var_y[i] - cost_function(var_x[i],theta_0, theta_1) # finds the computed Euclidean distance between\\r\\n # x and its corresponding value y\\r\\n compute_2 = pow(compute_1,2) # square of the distance\\r\\n minimized_solution.append(compute_2) # appends the corresponding solution to a list minimized_solution\\r\\n compute_3 = sum(minimized_solution)/ (2 * m) # compute the minimized cost function of x and y by dividing by\\r\\n # twice the number of training examples\\r\\n return compute_3\",\n \"def logistic_regression(y, tx, initial_w, max_iters, gamma, debug = False):\\n losses, ws = gradient_descent(y, tx, initial_w, max_iters, gamma, loss_f = model_logistic.loss, grad_f = model_logistic.grad, debug = debug)\\n return get_last_ans(ws, losses)\",\n \"def compute_cost(AL, Y):\\n m = Y.shape[1]\\n log_val = np.multiply(Y,np.log(AL)) + np.multiply(1-Y,np.log(1-AL))\\n cost = np.sum(log_val) * (-1/m)\\n cost = np.squeeze(cost)\\n return cost\",\n \"def compute_cost(AL, Y):\\n m = AL.shape[1]\\n cost = 1./m*(-Y*np.log(AL)-(1.0 - Y)*np.log(1.0 - AL))\\n cost = np.squeeze(cost)\\n return cost\",\n \"def logistic(weights, data, targets, hyperparameters):\\n\\n # TODO: Finish this function\\n\\n return f, df, y\",\n \"def compute_logistic_loss(y, tx, w):\\n pred = tx.dot(w)\\n y = np.asarray(y)\\n logsig = -np.logaddexp(0, -pred) # == np.log(sigmoid(pred))\\n\\n return np.mean((1 - y) * pred - logsig)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75096697","0.7109986","0.7026688","0.69945616","0.6948253","0.68546367","0.6719014","0.6706194","0.66798836","0.6674309","0.6670411","0.6663733","0.6650096","0.6644245","0.6628111","0.6595147","0.6570327","0.6524744","0.6518117","0.6495512","0.6472702","0.6444862","0.6443278","0.6441488","0.6435619","0.6429442","0.64247465","0.6423268","0.6406501","0.6396946","0.6390508","0.6383032","0.6376","0.63592017","0.6349093","0.6336","0.62969744","0.6296858","0.6284693","0.62714523","0.62676036","0.6266033","0.6251294","0.624856","0.6240744","0.6231389","0.6230054","0.6229043","0.62123984","0.62059325","0.6198362","0.61854947","0.61770153","0.61761826","0.61626124","0.61601114","0.6153944","0.6152588","0.6151395","0.61457336","0.61420804","0.6133363","0.61247236","0.6121346","0.6117221","0.61031187","0.61012673","0.61012673","0.6092554","0.6088784","0.6075403","0.60746515","0.60735595","0.6072273","0.606731","0.60657895","0.60656554","0.6065048","0.6062763","0.6056738","0.603447","0.6031636","0.6031326","0.6028389","0.6026668","0.6022271","0.6022118","0.6021217","0.60039854","0.600304","0.60003126","0.59973794","0.599691","0.59920716","0.59889","0.5983124","0.5981461","0.59789044","0.5976942","0.59725356","0.59697086"],"string":"[\n \"0.75096697\",\n \"0.7109986\",\n \"0.7026688\",\n \"0.69945616\",\n \"0.6948253\",\n \"0.68546367\",\n \"0.6719014\",\n \"0.6706194\",\n \"0.66798836\",\n \"0.6674309\",\n \"0.6670411\",\n \"0.6663733\",\n \"0.6650096\",\n \"0.6644245\",\n \"0.6628111\",\n \"0.6595147\",\n \"0.6570327\",\n \"0.6524744\",\n \"0.6518117\",\n \"0.6495512\",\n \"0.6472702\",\n \"0.6444862\",\n \"0.6443278\",\n \"0.6441488\",\n \"0.6435619\",\n \"0.6429442\",\n \"0.64247465\",\n \"0.6423268\",\n \"0.6406501\",\n \"0.6396946\",\n \"0.6390508\",\n \"0.6383032\",\n \"0.6376\",\n \"0.63592017\",\n \"0.6349093\",\n \"0.6336\",\n \"0.62969744\",\n \"0.6296858\",\n \"0.6284693\",\n \"0.62714523\",\n \"0.62676036\",\n \"0.6266033\",\n \"0.6251294\",\n \"0.624856\",\n \"0.6240744\",\n \"0.6231389\",\n \"0.6230054\",\n \"0.6229043\",\n \"0.62123984\",\n \"0.62059325\",\n \"0.6198362\",\n \"0.61854947\",\n \"0.61770153\",\n \"0.61761826\",\n \"0.61626124\",\n \"0.61601114\",\n \"0.6153944\",\n \"0.6152588\",\n \"0.6151395\",\n \"0.61457336\",\n \"0.61420804\",\n \"0.6133363\",\n \"0.61247236\",\n \"0.6121346\",\n \"0.6117221\",\n \"0.61031187\",\n \"0.61012673\",\n \"0.61012673\",\n \"0.6092554\",\n \"0.6088784\",\n \"0.6075403\",\n \"0.60746515\",\n \"0.60735595\",\n \"0.6072273\",\n \"0.606731\",\n \"0.60657895\",\n \"0.60656554\",\n \"0.6065048\",\n \"0.6062763\",\n \"0.6056738\",\n \"0.603447\",\n \"0.6031636\",\n \"0.6031326\",\n \"0.6028389\",\n \"0.6026668\",\n \"0.6022271\",\n \"0.6022118\",\n \"0.6021217\",\n \"0.60039854\",\n \"0.600304\",\n \"0.60003126\",\n \"0.59973794\",\n \"0.599691\",\n \"0.59920716\",\n \"0.59889\",\n \"0.5983124\",\n \"0.5981461\",\n \"0.59789044\",\n \"0.5976942\",\n \"0.59725356\",\n \"0.59697086\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":90794,"cells":{"query":{"kind":"string","value":"Implements mean crossentropy as a function J(theta) on given traning data"},"document":{"kind":"string","value":"def mean_cross_entropy_costs(X, y, lambda_reg=0.0):\n return lambda theta: np.mean(cross_entropy(X, y)(theta)) + L2_regularization_cost(\n X, theta, lambda_reg\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def cross_entropy(y_observed, p):\n\n pass","def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)","def objective_function(theta, X, y):\n # m number of training instances\n m = X.shape[0]\n jtheta = sum((np.dot(X, theta) - y)**2) / (2.0*m)\n return jtheta","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]","def cross_entropy(y, y_hat):\n return -tf.math.log(\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\n )","def obj_mix(Y_true,Y_pred):\n y_true = K.mean(Y_true,axis=0)\n if y_true == 1:\n y_pred = K.max(Y_pred,axis=0)\n return(K.mean(K.binary_crossentropy(y_pred, y_true)))\n elif y_true == 0:\n return(K.mean(K.binary_crossentropy(Y_pred,Y_true)))\n else:\n print('unexpected value of y_true',y_true)\n return(K.mean(K.binary_crossentropy(Y_pred,Y_true)))","def mean_posterior(g: to.Tensor, lpj: to.Tensor) -> to.Tensor:\n if tvo.get_device().type == \"cpu\":\n means = _mean_post_einsum(g, lpj)\n else:\n means = _mean_post_mul(g, lpj)\n\n assert means.shape == (g.shape[0], *g.shape[2:])\n assert not to.isnan(means).any() and not to.isinf(means).any()\n return means","def test_cross_entropy(self):\n loss = losses.cross_entropy_with_logits(\n logits=self.logits, targets=self.targets)\n kl = loss.mean()\n\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\n\n self.assertAlmostEqual(kl, expected_loss)","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def cross_entropy(\n **kwargs\n) -> Callable:\n return categorical_crossentropy","def mean(self):\n return self.k * self.theta","def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))","def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\n log_pred = ivy.log(pred)\n # noinspection PyUnresolvedReferences\n return -ivy.reduce_sum(log_pred * true, axis)","def cross_entropy(self, yhat):\n n = len(self._y)\n c = 0.0\n for i in range(0, n):\n c += self._y[i] * log(\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\n\n return c","def J(theta, x, y):\n m = len(y)\n z = theta.dot(x.T) #argument for hypothesis function\n return 1. / m * np.sum(-y * np.log(g(z)) - (1. - y) * np.log(1 - g(z)))","def loss_fn(y_true,y_pred): \n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\n y_pred,\n axis=-1,\n )\n loss = tf.reduce_mean(loss,name=\"loss\")\n return loss","def delta_cross_entropy_softmax(outputs, labels):\n \n m = labels.shape[0]\n grad = outputs\n \n grad[range(m),labels] -= torch.tensor(1.)\n\n grad = grad/m\n avg_grads = grad\n return avg_grads","def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def logcosh(y_true, y_pred):\n\n def _logcosh(x):\n return x + nn.softplus(-2. * x) - math_ops.log(2.)\n\n return K.mean(_logcosh(y_pred - y_true), axis=-1)","def costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def cross_entropy(X, y, using_onehot=True):\n\tM = y.shape[0]\n\tif using_onehot :\n\t\tlog_likelihood = -np.log(np.max(X * y, -1))\n\telse:\n\t\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\n\tloss = np.sum(log_likelihood) / M\n\treturn loss","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def softmax_cross_entropy(y, label):\r\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\r\n return losses\r\n pass","def tent(x: torch.Tensor) -> torch.Tensor:\n return -(x.softmax(1) * x.log_softmax(1)).sum(1).mean(0)","def cross_entropy(input1, target, size_average=True):\n logsoftmax = nn.LogSoftmax(dim=0)\n return torch.sum(-target * logsoftmax(input1))\n # if size_average:\n # return torch.mean(torch.sum(-target * logsoftmax(input), dim=1))\n # else:\n # return torch.sum(torch.sum(-target * logsoftmax(input), dim=1))","def cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -Y / Y_hat\n \n return cost, dY_hat","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return grad","def cross_entropoy_loss_naive(W, X, y, reg):\n # pylint: disable=too-many-locals\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n \n\n C = W.shape[1]\n# print(\"no. of classes {}\".format(C))\n N,D = X.shape\n# print(\"no. of data {} and dimension {}\".format(N,D))\n for i in range(N):\n xi = X[i,:]\n# print(\"one record shape: {}\".format(xi.shape))\n scores = np.zeros(C)\n for c in range(C):\n w = W[:,c]\n# print(\"weight for one record {}\".format(w.shape))\n scores[c] = xi.dot(w)\n scores -= np.max(scores)\n actual_y = y[i]\n total_score = np.sum(np.exp(scores)) \n loss_i = -scores[actual_y] + np.log(total_score)\n# print('naive score : {}'.format(scores[actual_y]))\n loss += loss_i\n \n #gradient\n probability = np.exp(scores)/total_score\n for j in range(C):\n dW[:,j] += probability[j]*xi\n \n dW[:,actual_y] -= xi\n loss = loss/N\n reg_loss = 0.5*reg*np.sum(W*W)\n loss = loss + reg_loss\n print(\"loss : {}\".format(loss))\n dW = dW/N\n dW += reg*W\n \n \n \n \n\n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def _mean_post_einsum(g: to.Tensor, lpj: to.Tensor) -> to.Tensor:\n return to.einsum(\"ns...,ns->n...\", (g, lpj2pjc(lpj)))","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def __call__(self, A, Z, sample_weight=None):\n check_tensor(Z, ndim=2)\n logpi = log_softmax_tf(Z)\n pi = K.exp(logpi)\n entropy = -tf.einsum('ij,ij->i', pi, logpi)\n return K.mean(entropy)","def entropy(data):\n n, m = np.shape(data)\n data = np.tanh(data)\n data = data / np.sum(data, axis=0)\n a = data * 1.0\n a[np.where(data == 0)] = 0.000001\n\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\n w = (1 - e) / np.sum(1 - e)\n return w","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def loss(logits, targets):\n targets = tf.to_int64(targets)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=targets, logits=logits, name='Crossentropy')\n return tf.reduce_mean(cross_entropy, name='Crossentropy_mean')","def loss_function(self, targets, outputs):\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\n return tf.reduce_mean(cross_entropy)","def soft_cross_entropy(input, targets):\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\n return (- targets_prob * student_likelihood).sum(dim=-1).mean()","def cross_entropy_gradient(self, yhat):\n n = len(self._y)\n p = len(self.beta)\n g = np.zeros(p)\n for i in range(0, n):\n g = g + (self._y[i] - yhat[i]) * np.array(\n [1.0, *self._feat_mtx[i, :]])\n\n return g","def cross_entropy_fn(fc8, ground_truth_input):\n with tf.name_scope('cross_entropy') as scope:\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=fc8, labels=ground_truth_input)\n cross_entropy_mean = tf.reduce_mean(cross_entropy)\n\n tf.summary.scalar(scope + '/loss', cross_entropy_mean)\n\n return cross_entropy_mean","def ovo_crossentropy_loss(y_true, y_pred):\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\n y_true_scaled = (y_true + 1.0) / 2.0\n y_pred_scaled = (y_pred + 1.0) / 2.0\n\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\n\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\n\n # J_{OvO} aus Pawara et al. anwenden\n log_function = tf.log if tf.__version__ == \"1.13.1\" else tf.math.log # flexibel für neue / alte Version\n loss = - tf.reduce_mean(\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\n return loss","def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\n y_pred = tf.cast(y_pred, 'float64')\n y_true = tf.cast(y_true, 'float64')\n # deduce weights based on true pixel value\n class_weights = weights * y_true\n # compute your (unweighted) softmax cross entropy loss\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\n ##print(unweighted_losses.dtype, weights.dtype)\n weighted_losses = unweighted_losses * class_weights\n # reduce the result to get your final loss\n loss = -tf.reduce_sum(weighted_losses)\n return loss","def cross_entropy_loss(self, y, y_hat):\n if y.ndim == 1:\n batch_size = 1\n else:\n batch_size = y.shape[0]\n delta = 1e-7\n return -np.sum(y * np.log(y_hat + delta)) / batch_size","def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def cross_entropy(self):\n return self._cross_entropy_func","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def loss(logits, labels):\n labels = tf.to_int64(labels)\n# labels = tf.to_float(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\n# y_conv = tf.nn.softmax(logits)\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def loss_sce(y_pred, y_true):\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)\n\n return tf.reduce_mean(loss)","def loss(logits, labels):\r\n labels = tf.to_int64(labels)\r\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\r\n labels=labels, logits=logits, name='xentropy')\r\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def loss(logits, labels):\r\n labels = tf.to_int64(labels)\r\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\r\n labels=labels, logits=logits, name='xentropy')\r\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def _mean_prediction(op, g_td, y_train):\n fl, ufl = _make_flatten_uflatten(g_td, y_train)\n\n mean_pred = op(fl(y_train))\n mean_pred = np.dot(g_td, mean_pred)\n return ufl(mean_pred)","def cross_entropy_loss():\n return nn.CrossEntropyLoss()","def cross_entropoy_loss_naive(W, X, y, reg):\n # pylint: disable=too-many-locals\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n\n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n num_train_sample = X.shape[0] #row of train data\n num_class = W.shape[1] #column of weight, plane,horse..\n for i in range(num_train_sample):\n p_score = X[i].dot(W) #a row of score corresponding to each class\n p_score -= np.max(p_score) #normalize, highest is 1\n\n ###compute softmax loss\n # sum of scores corresponding to different classes of a sample \n sum_score = np.sum(np.exp(p_score)) \n # each class's score over sum_score of a sample \n score_i = lambda k: np.exp(p_score[k]) / sum_score\n # for the correct label in each sample, find softmax loss over sum\n # iteration make loss sum up all samples\n loss = loss - np.log(score_i(y[i]))\n\n for k in range(num_class):\n p_k = score_i(k)\n # gradient of softmax\n dW[:, k] += (p_k - (k == y[i])) * X[i]\n\n loss /= num_train_sample\n loss += 0.5 * reg * np.sum(W * W)\n dW /= num_train_sample\n dW += reg*W\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def my_softmax_cross_entropy(preds, labels):\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\n return tf.reduce_mean(loss)","def dJ(theta, x_b, y):\n return x_b.T.dot(self._sigmoid(x_b.dot(theta)) - y) / len(x_b)","def _Apply(self, c, p):\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\n entropy = tf.reduce_mean(entropy)\n return entropy","def classification_loss(self, logit, target):\n return F.cross_entropy(logit, target)","def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(predicted)\n x_n_offset = predicted - a\n\n exp_xn_offset = x_n_offset.exp()\n\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\n denominator = a + log_sum_exp_xn_offset\n log_softmax = log_e_x - denominator\n\n labels = to_one_hot(target, num_classes)\n prod = log_softmax*labels\n total = prod.sum()\n batch_size = tensor.Tensor(-batch_size)\n\n total = total / batch_size\n\n return total","def loss(logits, labels):\n labels = tf.to_int64(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n logits, labels, name='xentropy')\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def transform(self, sess, xs):\n return sess.run([self.z_mean_original, self.z_mean_original],\n feed_dict={self.x: xs})","def cross_entropy(targets, predictions, epsilon=1e-12):\n\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n\n N = predictions.shape[0]\n\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\n\n return ce","def cost(theta, X, y, learning_rate):\n m = len(y) \n theta = theta.reshape((-1,1))\n h = sigmoid(np.dot(X, theta))\n\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n return float(J)","def updateMeanAndVar(X, log_gamma):\n\n gamma_shape = log_gamma.shape\n x_shape = X.shape\n gamma = np.exp(log_gamma);\n\n mu = np.zeros([gamma_shape[1],x_shape[1]])\n covar = np.zeros([gamma_shape[1],x_shape[1]])\n\n for j in range(gamma_shape[1]): #state\n temp = 0;\n for n in range(x_shape[0]): #dim\n temp = temp + gamma[n,j]*X[n,:]\n\n mu[j,:] = temp/np.sum(gamma[:,j])\n #print(gamma_shape[1])\n #print(x_shape[0])\n u=0\n if (u == 0):\n for j in range(gamma_shape[1]): #state\n temp = 0;\n for n in range(x_shape[0]): #dim\n sig= np.dot(gamma[n,j]*X[n,:]-mu[j,:],X[n,:]-mu[j,:])\n print(sig.shape)\n temp=temp+sig\n #temp = temp + gamma[n,j]*(X[n,:] - mu[j,:])*(X[n,:] - mu[j,:])\n covar[j,:] = np.diagonal(temp)/np.sum(gamma[:,j])\n #print(covar[j,:])\n #print(mu[1,:])\n\n return mu, covar","def grad_softmax_cross_entropy_loss(logit, labels):\n return softmax(logit) - labels","def nll(y_true, y_pred):\n return K.sum(K.binary_crossentropy(y_true, y_pred), axis=-1)","def cross_entropy(m_true, alpha, alpha0, m_probs, lambd=1.0):\n\n loss = tf.reduce_sum(input_tensor=m_true * (tf.math.digamma(alpha0) - tf.math.digamma(alpha)), axis=1, keepdims=True)\n loss = tf.reduce_mean(input_tensor=loss)\n if lambd > 0:\n kl = kullback_leibler_dirichlet(m_true, alpha)\n loss = loss + lambd * kl\n return loss","def log_pseudo_joint(self, data: Tensor, states: Tensor) -> Tensor: # type: ignore\n K = states\n Y = data\n assert K.dtype == to.uint8 and Y.dtype == to.uint8\n pi = self.theta[\"pies\"]\n W = self.theta[\"W\"]\n batch_size, S, H = K.shape\n D = W.shape[0]\n dev = pi.device\n\n logPriors = to.matmul(K.type_as(pi), to.log(pi / (1 - pi)))\n\n logPy = to.empty((batch_size, S), device=dev, dtype=self.precision)\n # We will manually set the lpjs of all-zero states to the appropriate value.\n # For now, transform all-zero states in all-one states, to avoid computation of log(0).\n zeroStatesInd = to.nonzero((K == 0).all(dim=2))\n # https://discuss.pytorch.org/t/use-torch-nonzero-as-index/33218\n zeroStatesInd = (zeroStatesInd[:, 0], zeroStatesInd[:, 1])\n K[zeroStatesInd] = 1\n # prods_nsd = prod{h}{1-W_dh*K_nkh}\n prods = (W * K.type_as(W).unsqueeze(2)).neg_().add_(1).prod(dim=-1)\n to.clamp(prods, self.eps, 1 - self.eps, out=prods)\n # logPy_nk = sum{d}{y_nd*log(1/prods_nkd - 1) + log(prods_nkd)}\n f1 = to.log(1.0 / prods - 1.0)\n indeces = 1 - Y[:, None, :].expand(batch_size, S, D)\n # convert to BoolTensor in pytorch>=1.2, leave it as ByteTensor in earlier versions\n indeces = indeces.type_as(to.empty(0) < 0)\n f1[indeces] = 0.0\n logPy[:, :] = to.sum(f1, dim=-1) + to.sum(to.log(prods), dim=2)\n K[zeroStatesInd] = 0\n\n lpj = logPriors + logPy\n # for all-zero states, set lpj to arbitrary very low value if y!=0, 0 otherwise\n # in the end we want exp(lpj(y,s=0)) = 1 if y=0, 0 otherwise\n lpj[zeroStatesInd] = -1e30 * data[zeroStatesInd[0]].any(dim=1).type_as(lpj)\n assert (\n not to.isnan(lpj).any() and not to.isinf(lpj).any()\n ), \"some NoisyOR lpj values are invalid!\"\n return lpj.to(device=states.device) # (N, S)","def get_mean_iou(y_true, y_pred):\n \n threshold = tf.math.reduce_max(y_pred, axis=-1, keepdims=True)\n # make sure [0, 0, 0] doesn't become [1, 1, 1]\n # Use abs(x) > eps, instead of x != 0 to check for zero\n y_pred = tf.logical_and(y_pred >= threshold, tf.abs(y_pred) > 1e-12)\n\n y_true = tf.cast(y_true, tf.float32)\n y_pred = tf.cast(y_pred, tf.float32)\n\n TP = tf.math.reduce_sum(y_pred[:,:,:,1:] * y_true[:,:,:,1:])\n FN = tf.math.reduce_sum(y_true[:,:,:,1:] * (1 - y_pred[:,:,:,1:])) \n FP = tf.math.reduce_sum(y_pred[:,:,:,1:] * (1 - y_true[:,:,:,1:]))\n \n mean_iou_micro = tf.math.divide_no_nan(TP, TP + FN + FP)\n \n iou_class = np.zeros((n_classes-1,))\n iou_class_weighted = np.zeros((n_classes-1,))\n \n for i in range(1, n_classes):\n tp = tf.math.reduce_sum(y_pred[:,:,:,i] * y_true[:,:,:,i])\n fn = tf.math.reduce_sum(y_true[:,:,:,i] * (1 - y_pred[:,:,:,i])) \n fp = tf.math.reduce_sum(y_pred[:,:,:,i] * (1 - y_true[:,:,:,i])) \n denominator = tp+fn+fp\n # The mean is only computed over classes that appear in the\n # label or prediction tensor. If the denominator is 0, we need to\n # ignore the class. \n if denominator != 0:\n iou = tf.math.divide_no_nan(tp, denominator)\n iou_class[i-1] = iou\n iou_class_weighted[i-1] = iou * class_weights[i-1]\n else:\n # We need to differentiate between the class scores that are\n # zero because the IoU is zero, and the class scores that \n # we are ignoring\n iou_class[i-1] = -1\n \n mean_iou_macro = np.mean(iou_class[iou_class != -1])\n mean_iou_weighted = np.mean(iou_class_weighted[iou_class_weighted != -1])\n \n return iou_class, mean_iou_micro.numpy(), mean_iou_macro, mean_iou_weighted","def loss(params: hk.Params, batch, label) -> jnp.ndarray:\r\n logits = net.apply(params, batch)\r\n labels = jax.nn.one_hot(label, n_classes)\r\n\r\n # Cross Entropy Loss\r\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\r\n softmax_xent /= labels.shape[0]\r\n return softmax_xent","def cross_entropy_loss(outputs, labels): \n# works properly\n \n m = labels.shape[0]\n p = outputs\n log_likelihood = -1*torch.log(p[range(m),labels])\n loss = torch.sum(log_likelihood) / m\n return loss.item()","def soft_cross_entropy_tinybert(input, targets):\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\n return (- targets_prob * student_likelihood).mean()","def identity_pred(y_true, y_pred):\n return K.mean(K.flatten(y_pred))","def my_loss(y_pred,y_true,n_outputs):\n y_true = tf.one_hot(tf.cast(y_true,tf.int64), n_outputs, dtype=tf.float32)\n return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_true,y_pred))","def sigmoid_cross_entropy(y, label):\r\n losses = - np.log(y + g_epsilon) * label - np.log(1.0 - y + g_epsilon) * (1.0 - label)\r\n return losses","def J(W1, b1, W2, b2, x, y):\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\n return crossEntropy(y, yhat)","def entropy_matrix(training):\n shape = training.shape[1]\n e = np.zeros((shape, shape))\n for i, j in product(*map(range, (shape, shape))):\n a = training[:, [i, j]]\n e[i, j] = pairwise_entropy(a)\n return e","def cross_entropy_loss(logits, labels, label_smoothing=0., dtype=jnp.float32):\n num_classes = logits.shape[-1]\n labels = jax.nn.one_hot(labels, num_classes, dtype=dtype)\n if label_smoothing > 0:\n labels = labels * (1 - label_smoothing) + label_smoothing / num_classes\n logp = jax.nn.log_softmax(logits.astype(dtype))\n return -jnp.mean(jnp.sum(logp * labels, axis=-1))","def binary_cross_entropy(y_true, y_pred, eps=1e-15):\n assert y_true.shape == y_pred.shape\n y_pred = np.clip(y_pred, eps, 1 - eps) # Avoid log(0)\n return - np.mean(\n y_true * np.log(y_pred) + \n (1 - y_true) * (np.log(1 - y_pred))\n )","def cross_entropy3(input, target, weight):\n loss = 0\n batch_size = target.data.shape[1]\n target = target.max(2)[1]\n input = input.transpose(0, 1)\n target = target.transpose(0, 1)\n weight = weight.transpose(0, 1)\n for i in range(batch_size):\n partial_loss = F.cross_entropy(input[i], target[i], size_average=False, reduce=False)\n partial_loss = torch.mul(partial_loss, weight[i])\n loss = loss + torch.sum(partial_loss)\n return loss / batch_size","def theta(self):\n self.eigenvalues()","def calculate_loss(self, y, y_hat):\r\n return tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=y_hat))","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def binary_crossentropy(output, target):\r\n return -(target * tensor.log(output) + (1.0 - target) * tensor.log(1.0 - output))","def svm_loss_naive(theta, X, y, reg):\n\n K = theta.shape[1] # number of classes\n m = X.shape[0] # number of examples\n\n J = 0.0\n dtheta = np.zeros(theta.shape) # initialize the gradient as zero\n delta = 1.0\n\n #############################################################################\n # TODO: #\n # Compute the loss function and store it in J. #\n # Do not forget the regularization term! #\n # code above to compute the gradient. #\n # 8-10 lines of code expected #\n #############################################################################\n\n for i in xrange(m):\n h = np.dot(X[i,:], theta)\n hy = h[y[i]]\n for j in xrange(K):\n if j == y[i]:\n continue\n l = h[j] - hy + delta\n if l > 0:\n J += l\n dtheta[:, j] += X[i, :]\n dtheta[:, y[i]] -= X[i, :]\n\n J /= m\n dtheta /= m\n J += 0.5 * reg * np.sum(theta * theta)\n dtheta += reg * theta\n\n\n #############################################################################\n # TODO: #\n # Compute the gradient of the loss function and store it dtheta. #\n # Rather that first computing the loss and then computing the derivative, #\n # it may be simpler to compute the derivative at the same time that the #\n # loss is being computed. As a result you may need to modify some of the #\n # code above to compute the gradient. #\n #############################################################################\n\n return J, dtheta","def test_weighted_sequence_cross_entropy(self):\n kl_loss = losses.cross_entropy_with_logits(\n logits=self.logits, targets=self.targets)\n loss, weights = losses.weighted_mean(kl_loss, weights=self.targets >= 0)\n\n expected_loss = -(jnp.log(0.9) + jnp.log(0.9) + jnp.log(0.2)) / 3\n\n self.assertEqual(weights, 3)\n self.assertAlmostEqual(loss / weights, expected_loss)","def sparse_cross_entropy(y_true, y_pred):\n\n # Calculate the loss. This outputs a\n # 2-rank tensor of shape [batch_size, sequence_length]\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true,\n logits=y_pred)\n\n # Keras may reduce this across the first axis (the batch)\n # but the semantics are unclear, so to be sure we use\n # the loss across the entire 2-rank tensor, we reduce it\n # to a single scalar with the mean function.\n loss_mean = tf.reduce_mean(loss)\n\n return loss_mean","def binary_cross_entropy(y_true, y_preds):\n return np.sum(y_true * np.log(y_preds) + (1 - y_true) * np.log(1 - y_preds))","def test_weighted_cross_entropy(self):\n kl_loss = losses.cross_entropy_with_logits(\n logits=self.logits, targets=self.targets)\n loss, weights = losses.weighted_mean(kl_loss, self.targets >= 0)\n\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\n\n self.assertEqual(weights, 3)\n self.assertAlmostEqual(loss / weights, expected_loss)","def compute_theta(tx, index_theta, mean=[],std=[]):\n tx_new = np.cos(tx[:,index_theta])\n return standardize(tx_new,mean,std)","def costFunction(theta,X,y):\n m = X.shape[0]\n J = 0\n h = sigmoid (np.dot(X,theta))\n \n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\n \n #grad = (1/m) * np.dot(X.T,(h-y))\n grad = (1/m) * np.dot((h.T - y), X).T\n \n return J, grad","def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\n norm_log = log_softmax(input, 1)\n\n np_one_hot = np.eye(input.shape[1])[target.data]\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\n\n mask = -norm_log * tensor_one_hot\n mask_sum = sum(mask, 1)\n loss = sum(mask_sum, 0)\n\n return loss / input.shape[0]","def test_asymptotic_32():\r\n\r\n #TODO: consider adding the optimization of crossentropy into the current\r\n # mode for the purpose of running this test\r\n\r\n for dtype in 'float32', 'float64':\r\n if dtype == 'float32':\r\n x = tensor.fmatrix()\r\n x2 = tensor.fvector()\r\n else:\r\n x = tensor.dmatrix()\r\n x2 = tensor.dvector()\r\n y = tensor.lvector()\r\n\r\n c = categorical_crossentropy(softmax(x + x2), y)\r\n f = theano.function([x, y, x2], [c.sum(),\r\n tensor.grad(c.sum(), x)], mode='FAST_RUN')\r\n if 0:\r\n for i, n in enumerate(f.maker.fgraph.toposort()):\r\n print i, n\r\n\r\n xval = numpy.zeros((5, 5), dtype=dtype).astype(dtype)\r\n x2val = numpy.zeros(5, dtype=xval.dtype).astype(dtype)\r\n for i in xrange(100):\r\n cval, gxval = f(xval, numpy.arange(5), x2val)\r\n xval -= 100.3 * gxval\r\n #print cval, gxval\r\n assert cval == 0 # no problem going to zero error\r\n\r\n #what about when x gets really big?\r\n\r\n xval = numpy.zeros((5, 5), dtype=dtype)\r\n x2val = numpy.zeros(5, dtype=xval.dtype)\r\n for i in xrange(100):\r\n\r\n cval, gxval = f(xval, numpy.arange(5), x2val)\r\n xval += 100000.3 * gxval\r\n #print cval, gxval\r\n\r\n assert cval > 61750000\r\n assert gxval[0, 0] == -1.0\r\n assert gxval[0, 1] == 0.25","def svm_loss_naive(theta, X, y, reg):\n\n delta = 1.0\n dtheta = np.zeros(theta.shape) # initialize the gradient as zero\n\n # compute the loss function\n\n K = theta.shape[1]\n m = X.shape[0]\n J = 0.0\n for i in xrange(m):\n\tscores = X[i,:].dot(theta)\n\tcorrect_class_score = scores[y[i]]\n\tfor j in xrange(K):\n\t\tif j == y[i]:\n\t\t\tcontinue\n\t\tmargin = max(0,scores[j] - correct_class_score + delta)\n\t\tJ += margin\n\t\tif margin > 0 and j!=y[i]:\t\t\n\t\t\tdtheta[:,j] = dtheta[:,j]+X[i,:]\n\t\t\tdtheta[:,y[i]] = dtheta[:,y[i]]-X[i,:]\n\n\n # Right now the loss is a sum over all training examples, but we want it\n # To be an average instead so we divide by num_train.\n J /= m\n dtheta = dtheta/m\n # Add regularization to the loss.\n J += 0.5 * reg * np.sum(theta * theta)\n dtheta =dtheta + reg*theta\n\n #############################################################################\n # TODO: #\n # Compute the gradient of the loss function and store it dtheta. #\n # Rather that first computing the loss and then computing the derivative, #\n # it may be simpler to compute the derivative at the same time that the #\n # loss is being computed. As a result you may need to modify some of the #\n # code above to compute the gradient. #\n #############################################################################\n\n\n return J, dtheta","def sparse_cross_entropy(true, pred, axis=-1, epsilon=1e-7):\n true = ivy.one_hot(true, pred.shape[axis])\n return cross_entropy(true, pred, axis, epsilon)","def softmax_mat(self, X, theta=None):\n theta = self.theta if theta is None else theta\n # Numerator for each class\n softmax_vals = np.exp(theta.T @ X)\n # Normalization factor\n onesvect = np.ones((1, self.nclasses))\n softmax_norm = onesvect @ softmax_vals\n\n return softmax_vals / softmax_norm","def sigmoid(x, theta):\n\tz = x @ theta\n\th = 1/(1+np.exp(-z))\n\treturn h, z","def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\n if type(y_pred) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_pred)))\n if type(y_true) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_true)))\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\n # y_pred = clip(y_pred)\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\n loss = -1 * np.sum(l).item()\n if normalize:\n loss = loss / len(y_pred)\n return loss","def _mean_post_mul(g: to.Tensor, lpj: to.Tensor) -> to.Tensor:\n # reshape lpj from (N,S) to (N,S,1,...), to match dimensionality of g\n lpj = lpj.view(*lpj.shape, *(1 for _ in range(g.ndimension() - 2)))\n return lpj2pjc(lpj).mul(g).sum(dim=1)","def cross_entropy_loss(self, logits, labels):\n return F.cross_entropy(logits, labels)","def crossEntropy(obs, actual, offset=1e-7):\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\n # bound by clipping to avoid nan\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\n return -tf.reduce_sum(actual * tf.log(obs_) +\n (1 - actual) * tf.log(1 - obs_), 1)"],"string":"[\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def cross_entropy(t,y):\\r\\n #print(-1*t*np.log(y))\\r\\n #print(np.shape(np.log(y)))\\r\\n #print(np.shape(t))\\r\\n return t*np.log(y)*(-1)\",\n \"def objective_function(theta, X, y):\\n # m number of training instances\\n m = X.shape[0]\\n jtheta = sum((np.dot(X, theta) - y)**2) / (2.0*m)\\n return jtheta\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def cross_entropy(predictions, targets):\\n likelihood = targets * np.log(predictions)\\n return -np.sum(likelihood) / predictions.shape[0]\",\n \"def cross_entropy(y, y_hat):\\n return -tf.math.log(\\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\\n )\",\n \"def obj_mix(Y_true,Y_pred):\\n y_true = K.mean(Y_true,axis=0)\\n if y_true == 1:\\n y_pred = K.max(Y_pred,axis=0)\\n return(K.mean(K.binary_crossentropy(y_pred, y_true)))\\n elif y_true == 0:\\n return(K.mean(K.binary_crossentropy(Y_pred,Y_true)))\\n else:\\n print('unexpected value of y_true',y_true)\\n return(K.mean(K.binary_crossentropy(Y_pred,Y_true)))\",\n \"def mean_posterior(g: to.Tensor, lpj: to.Tensor) -> to.Tensor:\\n if tvo.get_device().type == \\\"cpu\\\":\\n means = _mean_post_einsum(g, lpj)\\n else:\\n means = _mean_post_mul(g, lpj)\\n\\n assert means.shape == (g.shape[0], *g.shape[2:])\\n assert not to.isnan(means).any() and not to.isinf(means).any()\\n return means\",\n \"def test_cross_entropy(self):\\n loss = losses.cross_entropy_with_logits(\\n logits=self.logits, targets=self.targets)\\n kl = loss.mean()\\n\\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\\n\\n self.assertAlmostEqual(kl, expected_loss)\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def cross_entropy(\\n **kwargs\\n) -> Callable:\\n return categorical_crossentropy\",\n \"def mean(self):\\n return self.k * self.theta\",\n \"def cross_entropy(y_pred,y):\\n \\n epsilon = 0.001 # To prevent overflow and ensure numerical stability\\n return sum(-y*np.log(y_pred+epsilon))\",\n \"def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\\n log_pred = ivy.log(pred)\\n # noinspection PyUnresolvedReferences\\n return -ivy.reduce_sum(log_pred * true, axis)\",\n \"def cross_entropy(self, yhat):\\n n = len(self._y)\\n c = 0.0\\n for i in range(0, n):\\n c += self._y[i] * log(\\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\\n\\n return c\",\n \"def J(theta, x, y):\\n m = len(y)\\n z = theta.dot(x.T) #argument for hypothesis function\\n return 1. / m * np.sum(-y * np.log(g(z)) - (1. - y) * np.log(1 - g(z)))\",\n \"def loss_fn(y_true,y_pred): \\n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\\n y_pred,\\n axis=-1,\\n )\\n loss = tf.reduce_mean(loss,name=\\\"loss\\\")\\n return loss\",\n \"def delta_cross_entropy_softmax(outputs, labels):\\n \\n m = labels.shape[0]\\n grad = outputs\\n \\n grad[range(m),labels] -= torch.tensor(1.)\\n\\n grad = grad/m\\n avg_grads = grad\\n return avg_grads\",\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def logcosh(y_true, y_pred):\\n\\n def _logcosh(x):\\n return x + nn.softplus(-2. * x) - math_ops.log(2.)\\n\\n return K.mean(_logcosh(y_pred - y_true), axis=-1)\",\n \"def costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def cross_entropy(X, y, using_onehot=True):\\n\\tM = y.shape[0]\\n\\tif using_onehot :\\n\\t\\tlog_likelihood = -np.log(np.max(X * y, -1))\\n\\telse:\\n\\t\\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\\n\\tloss = np.sum(log_likelihood) / M\\n\\treturn loss\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def softmax_cross_entropy(y, label):\\r\\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\\r\\n return losses\\r\\n pass\",\n \"def tent(x: torch.Tensor) -> torch.Tensor:\\n return -(x.softmax(1) * x.log_softmax(1)).sum(1).mean(0)\",\n \"def cross_entropy(input1, target, size_average=True):\\n logsoftmax = nn.LogSoftmax(dim=0)\\n return torch.sum(-target * logsoftmax(input1))\\n # if size_average:\\n # return torch.mean(torch.sum(-target * logsoftmax(input), dim=1))\\n # else:\\n # return torch.sum(torch.sum(-target * logsoftmax(input), dim=1))\",\n \"def cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -Y / Y_hat\\n \\n return cost, dY_hat\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return grad\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n \\n\\n C = W.shape[1]\\n# print(\\\"no. of classes {}\\\".format(C))\\n N,D = X.shape\\n# print(\\\"no. of data {} and dimension {}\\\".format(N,D))\\n for i in range(N):\\n xi = X[i,:]\\n# print(\\\"one record shape: {}\\\".format(xi.shape))\\n scores = np.zeros(C)\\n for c in range(C):\\n w = W[:,c]\\n# print(\\\"weight for one record {}\\\".format(w.shape))\\n scores[c] = xi.dot(w)\\n scores -= np.max(scores)\\n actual_y = y[i]\\n total_score = np.sum(np.exp(scores)) \\n loss_i = -scores[actual_y] + np.log(total_score)\\n# print('naive score : {}'.format(scores[actual_y]))\\n loss += loss_i\\n \\n #gradient\\n probability = np.exp(scores)/total_score\\n for j in range(C):\\n dW[:,j] += probability[j]*xi\\n \\n dW[:,actual_y] -= xi\\n loss = loss/N\\n reg_loss = 0.5*reg*np.sum(W*W)\\n loss = loss + reg_loss\\n print(\\\"loss : {}\\\".format(loss))\\n dW = dW/N\\n dW += reg*W\\n \\n \\n \\n \\n\\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def _mean_post_einsum(g: to.Tensor, lpj: to.Tensor) -> to.Tensor:\\n return to.einsum(\\\"ns...,ns->n...\\\", (g, lpj2pjc(lpj)))\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def __call__(self, A, Z, sample_weight=None):\\n check_tensor(Z, ndim=2)\\n logpi = log_softmax_tf(Z)\\n pi = K.exp(logpi)\\n entropy = -tf.einsum('ij,ij->i', pi, logpi)\\n return K.mean(entropy)\",\n \"def entropy(data):\\n n, m = np.shape(data)\\n data = np.tanh(data)\\n data = data / np.sum(data, axis=0)\\n a = data * 1.0\\n a[np.where(data == 0)] = 0.000001\\n\\n e = (-1.0 / np.log(n)) * np.sum(data * np.log(a), axis=0)\\n w = (1 - e) / np.sum(1 - e)\\n return w\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def loss(logits, targets):\\n targets = tf.to_int64(targets)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=targets, logits=logits, name='Crossentropy')\\n return tf.reduce_mean(cross_entropy, name='Crossentropy_mean')\",\n \"def loss_function(self, targets, outputs):\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\\n return tf.reduce_mean(cross_entropy)\",\n \"def soft_cross_entropy(input, targets):\\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\\n return (- targets_prob * student_likelihood).sum(dim=-1).mean()\",\n \"def cross_entropy_gradient(self, yhat):\\n n = len(self._y)\\n p = len(self.beta)\\n g = np.zeros(p)\\n for i in range(0, n):\\n g = g + (self._y[i] - yhat[i]) * np.array(\\n [1.0, *self._feat_mtx[i, :]])\\n\\n return g\",\n \"def cross_entropy_fn(fc8, ground_truth_input):\\n with tf.name_scope('cross_entropy') as scope:\\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=fc8, labels=ground_truth_input)\\n cross_entropy_mean = tf.reduce_mean(cross_entropy)\\n\\n tf.summary.scalar(scope + '/loss', cross_entropy_mean)\\n\\n return cross_entropy_mean\",\n \"def ovo_crossentropy_loss(y_true, y_pred):\\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\\n y_true_scaled = (y_true + 1.0) / 2.0\\n y_pred_scaled = (y_pred + 1.0) / 2.0\\n\\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\\n\\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\\n\\n # J_{OvO} aus Pawara et al. anwenden\\n log_function = tf.log if tf.__version__ == \\\"1.13.1\\\" else tf.math.log # flexibel für neue / alte Version\\n loss = - tf.reduce_mean(\\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\\n return loss\",\n \"def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\\n y_pred = tf.cast(y_pred, 'float64')\\n y_true = tf.cast(y_true, 'float64')\\n # deduce weights based on true pixel value\\n class_weights = weights * y_true\\n # compute your (unweighted) softmax cross entropy loss\\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\\n ##print(unweighted_losses.dtype, weights.dtype)\\n weighted_losses = unweighted_losses * class_weights\\n # reduce the result to get your final loss\\n loss = -tf.reduce_sum(weighted_losses)\\n return loss\",\n \"def cross_entropy_loss(self, y, y_hat):\\n if y.ndim == 1:\\n batch_size = 1\\n else:\\n batch_size = y.shape[0]\\n delta = 1e-7\\n return -np.sum(y * np.log(y_hat + delta)) / batch_size\",\n \"def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def cross_entropy(self):\\n return self._cross_entropy_func\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n# labels = tf.to_float(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\\n# y_conv = tf.nn.softmax(logits)\\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def loss_sce(y_pred, y_true):\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)\\n\\n return tf.reduce_mean(loss)\",\n \"def loss(logits, labels):\\r\\n labels = tf.to_int64(labels)\\r\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\r\\n labels=labels, logits=logits, name='xentropy')\\r\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def loss(logits, labels):\\r\\n labels = tf.to_int64(labels)\\r\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\r\\n labels=labels, logits=logits, name='xentropy')\\r\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def _mean_prediction(op, g_td, y_train):\\n fl, ufl = _make_flatten_uflatten(g_td, y_train)\\n\\n mean_pred = op(fl(y_train))\\n mean_pred = np.dot(g_td, mean_pred)\\n return ufl(mean_pred)\",\n \"def cross_entropy_loss():\\n return nn.CrossEntropyLoss()\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n num_train_sample = X.shape[0] #row of train data\\n num_class = W.shape[1] #column of weight, plane,horse..\\n for i in range(num_train_sample):\\n p_score = X[i].dot(W) #a row of score corresponding to each class\\n p_score -= np.max(p_score) #normalize, highest is 1\\n\\n ###compute softmax loss\\n # sum of scores corresponding to different classes of a sample \\n sum_score = np.sum(np.exp(p_score)) \\n # each class's score over sum_score of a sample \\n score_i = lambda k: np.exp(p_score[k]) / sum_score\\n # for the correct label in each sample, find softmax loss over sum\\n # iteration make loss sum up all samples\\n loss = loss - np.log(score_i(y[i]))\\n\\n for k in range(num_class):\\n p_k = score_i(k)\\n # gradient of softmax\\n dW[:, k] += (p_k - (k == y[i])) * X[i]\\n\\n loss /= num_train_sample\\n loss += 0.5 * reg * np.sum(W * W)\\n dW /= num_train_sample\\n dW += reg*W\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def my_softmax_cross_entropy(preds, labels):\\n loss = tf.nn.softmax_cross_entropy_with_logits(logits=preds, labels=labels)\\n # loss = tf.nn.weighted_cross_entropy_with_logits(logits=preds, targets=labels, pos_weight=0.1)\\n return tf.reduce_mean(loss)\",\n \"def dJ(theta, x_b, y):\\n return x_b.T.dot(self._sigmoid(x_b.dot(theta)) - y) / len(x_b)\",\n \"def _Apply(self, c, p):\\n entropy = ((1.0 - c) * tf.log(1.0 - p) + c * tf.log(p)) / (-math.log(2))\\n entropy = tf.reduce_mean(entropy)\\n return entropy\",\n \"def classification_loss(self, logit, target):\\n return F.cross_entropy(logit, target)\",\n \"def cross_entropy(predicted, target):\\n batch_size, num_classes = predicted.shape\\n\\n e_x = predicted.exp()\\n log_e_x = e_x.log()\\n a = log_sum_x_trick(predicted)\\n x_n_offset = predicted - a\\n\\n exp_xn_offset = x_n_offset.exp()\\n\\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\\n denominator = a + log_sum_exp_xn_offset\\n log_softmax = log_e_x - denominator\\n\\n labels = to_one_hot(target, num_classes)\\n prod = log_softmax*labels\\n total = prod.sum()\\n batch_size = tensor.Tensor(-batch_size)\\n\\n total = total / batch_size\\n\\n return total\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n logits, labels, name='xentropy')\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def transform(self, sess, xs):\\n return sess.run([self.z_mean_original, self.z_mean_original],\\n feed_dict={self.x: xs})\",\n \"def cross_entropy(targets, predictions, epsilon=1e-12):\\n\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n\\n N = predictions.shape[0]\\n\\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\\n\\n return ce\",\n \"def cost(theta, X, y, learning_rate):\\n m = len(y) \\n theta = theta.reshape((-1,1))\\n h = sigmoid(np.dot(X, theta))\\n\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n return float(J)\",\n \"def updateMeanAndVar(X, log_gamma):\\n\\n gamma_shape = log_gamma.shape\\n x_shape = X.shape\\n gamma = np.exp(log_gamma);\\n\\n mu = np.zeros([gamma_shape[1],x_shape[1]])\\n covar = np.zeros([gamma_shape[1],x_shape[1]])\\n\\n for j in range(gamma_shape[1]): #state\\n temp = 0;\\n for n in range(x_shape[0]): #dim\\n temp = temp + gamma[n,j]*X[n,:]\\n\\n mu[j,:] = temp/np.sum(gamma[:,j])\\n #print(gamma_shape[1])\\n #print(x_shape[0])\\n u=0\\n if (u == 0):\\n for j in range(gamma_shape[1]): #state\\n temp = 0;\\n for n in range(x_shape[0]): #dim\\n sig= np.dot(gamma[n,j]*X[n,:]-mu[j,:],X[n,:]-mu[j,:])\\n print(sig.shape)\\n temp=temp+sig\\n #temp = temp + gamma[n,j]*(X[n,:] - mu[j,:])*(X[n,:] - mu[j,:])\\n covar[j,:] = np.diagonal(temp)/np.sum(gamma[:,j])\\n #print(covar[j,:])\\n #print(mu[1,:])\\n\\n return mu, covar\",\n \"def grad_softmax_cross_entropy_loss(logit, labels):\\n return softmax(logit) - labels\",\n \"def nll(y_true, y_pred):\\n return K.sum(K.binary_crossentropy(y_true, y_pred), axis=-1)\",\n \"def cross_entropy(m_true, alpha, alpha0, m_probs, lambd=1.0):\\n\\n loss = tf.reduce_sum(input_tensor=m_true * (tf.math.digamma(alpha0) - tf.math.digamma(alpha)), axis=1, keepdims=True)\\n loss = tf.reduce_mean(input_tensor=loss)\\n if lambd > 0:\\n kl = kullback_leibler_dirichlet(m_true, alpha)\\n loss = loss + lambd * kl\\n return loss\",\n \"def log_pseudo_joint(self, data: Tensor, states: Tensor) -> Tensor: # type: ignore\\n K = states\\n Y = data\\n assert K.dtype == to.uint8 and Y.dtype == to.uint8\\n pi = self.theta[\\\"pies\\\"]\\n W = self.theta[\\\"W\\\"]\\n batch_size, S, H = K.shape\\n D = W.shape[0]\\n dev = pi.device\\n\\n logPriors = to.matmul(K.type_as(pi), to.log(pi / (1 - pi)))\\n\\n logPy = to.empty((batch_size, S), device=dev, dtype=self.precision)\\n # We will manually set the lpjs of all-zero states to the appropriate value.\\n # For now, transform all-zero states in all-one states, to avoid computation of log(0).\\n zeroStatesInd = to.nonzero((K == 0).all(dim=2))\\n # https://discuss.pytorch.org/t/use-torch-nonzero-as-index/33218\\n zeroStatesInd = (zeroStatesInd[:, 0], zeroStatesInd[:, 1])\\n K[zeroStatesInd] = 1\\n # prods_nsd = prod{h}{1-W_dh*K_nkh}\\n prods = (W * K.type_as(W).unsqueeze(2)).neg_().add_(1).prod(dim=-1)\\n to.clamp(prods, self.eps, 1 - self.eps, out=prods)\\n # logPy_nk = sum{d}{y_nd*log(1/prods_nkd - 1) + log(prods_nkd)}\\n f1 = to.log(1.0 / prods - 1.0)\\n indeces = 1 - Y[:, None, :].expand(batch_size, S, D)\\n # convert to BoolTensor in pytorch>=1.2, leave it as ByteTensor in earlier versions\\n indeces = indeces.type_as(to.empty(0) < 0)\\n f1[indeces] = 0.0\\n logPy[:, :] = to.sum(f1, dim=-1) + to.sum(to.log(prods), dim=2)\\n K[zeroStatesInd] = 0\\n\\n lpj = logPriors + logPy\\n # for all-zero states, set lpj to arbitrary very low value if y!=0, 0 otherwise\\n # in the end we want exp(lpj(y,s=0)) = 1 if y=0, 0 otherwise\\n lpj[zeroStatesInd] = -1e30 * data[zeroStatesInd[0]].any(dim=1).type_as(lpj)\\n assert (\\n not to.isnan(lpj).any() and not to.isinf(lpj).any()\\n ), \\\"some NoisyOR lpj values are invalid!\\\"\\n return lpj.to(device=states.device) # (N, S)\",\n \"def get_mean_iou(y_true, y_pred):\\n \\n threshold = tf.math.reduce_max(y_pred, axis=-1, keepdims=True)\\n # make sure [0, 0, 0] doesn't become [1, 1, 1]\\n # Use abs(x) > eps, instead of x != 0 to check for zero\\n y_pred = tf.logical_and(y_pred >= threshold, tf.abs(y_pred) > 1e-12)\\n\\n y_true = tf.cast(y_true, tf.float32)\\n y_pred = tf.cast(y_pred, tf.float32)\\n\\n TP = tf.math.reduce_sum(y_pred[:,:,:,1:] * y_true[:,:,:,1:])\\n FN = tf.math.reduce_sum(y_true[:,:,:,1:] * (1 - y_pred[:,:,:,1:])) \\n FP = tf.math.reduce_sum(y_pred[:,:,:,1:] * (1 - y_true[:,:,:,1:]))\\n \\n mean_iou_micro = tf.math.divide_no_nan(TP, TP + FN + FP)\\n \\n iou_class = np.zeros((n_classes-1,))\\n iou_class_weighted = np.zeros((n_classes-1,))\\n \\n for i in range(1, n_classes):\\n tp = tf.math.reduce_sum(y_pred[:,:,:,i] * y_true[:,:,:,i])\\n fn = tf.math.reduce_sum(y_true[:,:,:,i] * (1 - y_pred[:,:,:,i])) \\n fp = tf.math.reduce_sum(y_pred[:,:,:,i] * (1 - y_true[:,:,:,i])) \\n denominator = tp+fn+fp\\n # The mean is only computed over classes that appear in the\\n # label or prediction tensor. If the denominator is 0, we need to\\n # ignore the class. \\n if denominator != 0:\\n iou = tf.math.divide_no_nan(tp, denominator)\\n iou_class[i-1] = iou\\n iou_class_weighted[i-1] = iou * class_weights[i-1]\\n else:\\n # We need to differentiate between the class scores that are\\n # zero because the IoU is zero, and the class scores that \\n # we are ignoring\\n iou_class[i-1] = -1\\n \\n mean_iou_macro = np.mean(iou_class[iou_class != -1])\\n mean_iou_weighted = np.mean(iou_class_weighted[iou_class_weighted != -1])\\n \\n return iou_class, mean_iou_micro.numpy(), mean_iou_macro, mean_iou_weighted\",\n \"def loss(params: hk.Params, batch, label) -> jnp.ndarray:\\r\\n logits = net.apply(params, batch)\\r\\n labels = jax.nn.one_hot(label, n_classes)\\r\\n\\r\\n # Cross Entropy Loss\\r\\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\\r\\n softmax_xent /= labels.shape[0]\\r\\n return softmax_xent\",\n \"def cross_entropy_loss(outputs, labels): \\n# works properly\\n \\n m = labels.shape[0]\\n p = outputs\\n log_likelihood = -1*torch.log(p[range(m),labels])\\n loss = torch.sum(log_likelihood) / m\\n return loss.item()\",\n \"def soft_cross_entropy_tinybert(input, targets):\\n student_likelihood = torch.nn.functional.log_softmax(input, dim=-1)\\n targets_prob = torch.nn.functional.softmax(targets, dim=-1)\\n return (- targets_prob * student_likelihood).mean()\",\n \"def identity_pred(y_true, y_pred):\\n return K.mean(K.flatten(y_pred))\",\n \"def my_loss(y_pred,y_true,n_outputs):\\n y_true = tf.one_hot(tf.cast(y_true,tf.int64), n_outputs, dtype=tf.float32)\\n return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_true,y_pred))\",\n \"def sigmoid_cross_entropy(y, label):\\r\\n losses = - np.log(y + g_epsilon) * label - np.log(1.0 - y + g_epsilon) * (1.0 - label)\\r\\n return losses\",\n \"def J(W1, b1, W2, b2, x, y):\\n yhat = forwardPropagate(W1, b1, W2, b2, x) # OLD: yhat = softmax(x.dot(w))\\n return crossEntropy(y, yhat)\",\n \"def entropy_matrix(training):\\n shape = training.shape[1]\\n e = np.zeros((shape, shape))\\n for i, j in product(*map(range, (shape, shape))):\\n a = training[:, [i, j]]\\n e[i, j] = pairwise_entropy(a)\\n return e\",\n \"def cross_entropy_loss(logits, labels, label_smoothing=0., dtype=jnp.float32):\\n num_classes = logits.shape[-1]\\n labels = jax.nn.one_hot(labels, num_classes, dtype=dtype)\\n if label_smoothing > 0:\\n labels = labels * (1 - label_smoothing) + label_smoothing / num_classes\\n logp = jax.nn.log_softmax(logits.astype(dtype))\\n return -jnp.mean(jnp.sum(logp * labels, axis=-1))\",\n \"def binary_cross_entropy(y_true, y_pred, eps=1e-15):\\n assert y_true.shape == y_pred.shape\\n y_pred = np.clip(y_pred, eps, 1 - eps) # Avoid log(0)\\n return - np.mean(\\n y_true * np.log(y_pred) + \\n (1 - y_true) * (np.log(1 - y_pred))\\n )\",\n \"def cross_entropy3(input, target, weight):\\n loss = 0\\n batch_size = target.data.shape[1]\\n target = target.max(2)[1]\\n input = input.transpose(0, 1)\\n target = target.transpose(0, 1)\\n weight = weight.transpose(0, 1)\\n for i in range(batch_size):\\n partial_loss = F.cross_entropy(input[i], target[i], size_average=False, reduce=False)\\n partial_loss = torch.mul(partial_loss, weight[i])\\n loss = loss + torch.sum(partial_loss)\\n return loss / batch_size\",\n \"def theta(self):\\n self.eigenvalues()\",\n \"def calculate_loss(self, y, y_hat):\\r\\n return tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=y_hat))\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def binary_crossentropy(output, target):\\r\\n return -(target * tensor.log(output) + (1.0 - target) * tensor.log(1.0 - output))\",\n \"def svm_loss_naive(theta, X, y, reg):\\n\\n K = theta.shape[1] # number of classes\\n m = X.shape[0] # number of examples\\n\\n J = 0.0\\n dtheta = np.zeros(theta.shape) # initialize the gradient as zero\\n delta = 1.0\\n\\n #############################################################################\\n # TODO: #\\n # Compute the loss function and store it in J. #\\n # Do not forget the regularization term! #\\n # code above to compute the gradient. #\\n # 8-10 lines of code expected #\\n #############################################################################\\n\\n for i in xrange(m):\\n h = np.dot(X[i,:], theta)\\n hy = h[y[i]]\\n for j in xrange(K):\\n if j == y[i]:\\n continue\\n l = h[j] - hy + delta\\n if l > 0:\\n J += l\\n dtheta[:, j] += X[i, :]\\n dtheta[:, y[i]] -= X[i, :]\\n\\n J /= m\\n dtheta /= m\\n J += 0.5 * reg * np.sum(theta * theta)\\n dtheta += reg * theta\\n\\n\\n #############################################################################\\n # TODO: #\\n # Compute the gradient of the loss function and store it dtheta. #\\n # Rather that first computing the loss and then computing the derivative, #\\n # it may be simpler to compute the derivative at the same time that the #\\n # loss is being computed. As a result you may need to modify some of the #\\n # code above to compute the gradient. #\\n #############################################################################\\n\\n return J, dtheta\",\n \"def test_weighted_sequence_cross_entropy(self):\\n kl_loss = losses.cross_entropy_with_logits(\\n logits=self.logits, targets=self.targets)\\n loss, weights = losses.weighted_mean(kl_loss, weights=self.targets >= 0)\\n\\n expected_loss = -(jnp.log(0.9) + jnp.log(0.9) + jnp.log(0.2)) / 3\\n\\n self.assertEqual(weights, 3)\\n self.assertAlmostEqual(loss / weights, expected_loss)\",\n \"def sparse_cross_entropy(y_true, y_pred):\\n\\n # Calculate the loss. This outputs a\\n # 2-rank tensor of shape [batch_size, sequence_length]\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true,\\n logits=y_pred)\\n\\n # Keras may reduce this across the first axis (the batch)\\n # but the semantics are unclear, so to be sure we use\\n # the loss across the entire 2-rank tensor, we reduce it\\n # to a single scalar with the mean function.\\n loss_mean = tf.reduce_mean(loss)\\n\\n return loss_mean\",\n \"def binary_cross_entropy(y_true, y_preds):\\n return np.sum(y_true * np.log(y_preds) + (1 - y_true) * np.log(1 - y_preds))\",\n \"def test_weighted_cross_entropy(self):\\n kl_loss = losses.cross_entropy_with_logits(\\n logits=self.logits, targets=self.targets)\\n loss, weights = losses.weighted_mean(kl_loss, self.targets >= 0)\\n\\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\\n\\n self.assertEqual(weights, 3)\\n self.assertAlmostEqual(loss / weights, expected_loss)\",\n \"def compute_theta(tx, index_theta, mean=[],std=[]):\\n tx_new = np.cos(tx[:,index_theta])\\n return standardize(tx_new,mean,std)\",\n \"def costFunction(theta,X,y):\\n m = X.shape[0]\\n J = 0\\n h = sigmoid (np.dot(X,theta))\\n \\n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\\n \\n #grad = (1/m) * np.dot(X.T,(h-y))\\n grad = (1/m) * np.dot((h.T - y), X).T\\n \\n return J, grad\",\n \"def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\\n norm_log = log_softmax(input, 1)\\n\\n np_one_hot = np.eye(input.shape[1])[target.data]\\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\\n\\n mask = -norm_log * tensor_one_hot\\n mask_sum = sum(mask, 1)\\n loss = sum(mask_sum, 0)\\n\\n return loss / input.shape[0]\",\n \"def test_asymptotic_32():\\r\\n\\r\\n #TODO: consider adding the optimization of crossentropy into the current\\r\\n # mode for the purpose of running this test\\r\\n\\r\\n for dtype in 'float32', 'float64':\\r\\n if dtype == 'float32':\\r\\n x = tensor.fmatrix()\\r\\n x2 = tensor.fvector()\\r\\n else:\\r\\n x = tensor.dmatrix()\\r\\n x2 = tensor.dvector()\\r\\n y = tensor.lvector()\\r\\n\\r\\n c = categorical_crossentropy(softmax(x + x2), y)\\r\\n f = theano.function([x, y, x2], [c.sum(),\\r\\n tensor.grad(c.sum(), x)], mode='FAST_RUN')\\r\\n if 0:\\r\\n for i, n in enumerate(f.maker.fgraph.toposort()):\\r\\n print i, n\\r\\n\\r\\n xval = numpy.zeros((5, 5), dtype=dtype).astype(dtype)\\r\\n x2val = numpy.zeros(5, dtype=xval.dtype).astype(dtype)\\r\\n for i in xrange(100):\\r\\n cval, gxval = f(xval, numpy.arange(5), x2val)\\r\\n xval -= 100.3 * gxval\\r\\n #print cval, gxval\\r\\n assert cval == 0 # no problem going to zero error\\r\\n\\r\\n #what about when x gets really big?\\r\\n\\r\\n xval = numpy.zeros((5, 5), dtype=dtype)\\r\\n x2val = numpy.zeros(5, dtype=xval.dtype)\\r\\n for i in xrange(100):\\r\\n\\r\\n cval, gxval = f(xval, numpy.arange(5), x2val)\\r\\n xval += 100000.3 * gxval\\r\\n #print cval, gxval\\r\\n\\r\\n assert cval > 61750000\\r\\n assert gxval[0, 0] == -1.0\\r\\n assert gxval[0, 1] == 0.25\",\n \"def svm_loss_naive(theta, X, y, reg):\\n\\n delta = 1.0\\n dtheta = np.zeros(theta.shape) # initialize the gradient as zero\\n\\n # compute the loss function\\n\\n K = theta.shape[1]\\n m = X.shape[0]\\n J = 0.0\\n for i in xrange(m):\\n\\tscores = X[i,:].dot(theta)\\n\\tcorrect_class_score = scores[y[i]]\\n\\tfor j in xrange(K):\\n\\t\\tif j == y[i]:\\n\\t\\t\\tcontinue\\n\\t\\tmargin = max(0,scores[j] - correct_class_score + delta)\\n\\t\\tJ += margin\\n\\t\\tif margin > 0 and j!=y[i]:\\t\\t\\n\\t\\t\\tdtheta[:,j] = dtheta[:,j]+X[i,:]\\n\\t\\t\\tdtheta[:,y[i]] = dtheta[:,y[i]]-X[i,:]\\n\\n\\n # Right now the loss is a sum over all training examples, but we want it\\n # To be an average instead so we divide by num_train.\\n J /= m\\n dtheta = dtheta/m\\n # Add regularization to the loss.\\n J += 0.5 * reg * np.sum(theta * theta)\\n dtheta =dtheta + reg*theta\\n\\n #############################################################################\\n # TODO: #\\n # Compute the gradient of the loss function and store it dtheta. #\\n # Rather that first computing the loss and then computing the derivative, #\\n # it may be simpler to compute the derivative at the same time that the #\\n # loss is being computed. As a result you may need to modify some of the #\\n # code above to compute the gradient. #\\n #############################################################################\\n\\n\\n return J, dtheta\",\n \"def sparse_cross_entropy(true, pred, axis=-1, epsilon=1e-7):\\n true = ivy.one_hot(true, pred.shape[axis])\\n return cross_entropy(true, pred, axis, epsilon)\",\n \"def softmax_mat(self, X, theta=None):\\n theta = self.theta if theta is None else theta\\n # Numerator for each class\\n softmax_vals = np.exp(theta.T @ X)\\n # Normalization factor\\n onesvect = np.ones((1, self.nclasses))\\n softmax_norm = onesvect @ softmax_vals\\n\\n return softmax_vals / softmax_norm\",\n \"def sigmoid(x, theta):\\n\\tz = x @ theta\\n\\th = 1/(1+np.exp(-z))\\n\\treturn h, z\",\n \"def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\\n if type(y_pred) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_pred)))\\n if type(y_true) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_true)))\\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\\n # y_pred = clip(y_pred)\\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\\n loss = -1 * np.sum(l).item()\\n if normalize:\\n loss = loss / len(y_pred)\\n return loss\",\n \"def _mean_post_mul(g: to.Tensor, lpj: to.Tensor) -> to.Tensor:\\n # reshape lpj from (N,S) to (N,S,1,...), to match dimensionality of g\\n lpj = lpj.view(*lpj.shape, *(1 for _ in range(g.ndimension() - 2)))\\n return lpj2pjc(lpj).mul(g).sum(dim=1)\",\n \"def cross_entropy_loss(self, logits, labels):\\n return F.cross_entropy(logits, labels)\",\n \"def crossEntropy(obs, actual, offset=1e-7):\\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\\n # bound by clipping to avoid nan\\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\\n return -tf.reduce_sum(actual * tf.log(obs_) +\\n (1 - actual) * tf.log(1 - obs_), 1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6527088","0.6297951","0.6211556","0.61678755","0.6018695","0.596516","0.59576994","0.5953384","0.59498775","0.59448695","0.59320253","0.5895446","0.58729154","0.58721983","0.5862694","0.5858808","0.5858743","0.5858007","0.583182","0.58312905","0.5809158","0.5806023","0.5803389","0.57981706","0.5787419","0.5786681","0.5786419","0.5770665","0.5746737","0.57331085","0.57254255","0.5712621","0.5704901","0.5667203","0.5661609","0.5655289","0.5652862","0.5643299","0.5640883","0.56301695","0.5618457","0.5617575","0.56107646","0.55979633","0.5586388","0.55775833","0.55775833","0.55724984","0.5570385","0.55658","0.55658","0.556578","0.5564667","0.5561216","0.5551466","0.5545171","0.5541804","0.55366987","0.5524972","0.5519082","0.55131155","0.55112374","0.5510939","0.55083376","0.55072284","0.5503887","0.5497679","0.548892","0.548688","0.54781246","0.5472913","0.546922","0.54596","0.5454907","0.5451323","0.54485965","0.5447022","0.5443125","0.5437263","0.5436763","0.54318964","0.5431198","0.542868","0.54277855","0.5419421","0.54193103","0.54179364","0.54156244","0.54139304","0.54060155","0.5405073","0.54000115","0.5389047","0.53890157","0.537874","0.5374339","0.53733104","0.5371515","0.536765","0.535786","0.5352403"],"string":"[\n \"0.6527088\",\n \"0.6297951\",\n \"0.6211556\",\n \"0.61678755\",\n \"0.6018695\",\n \"0.596516\",\n \"0.59576994\",\n \"0.5953384\",\n \"0.59498775\",\n \"0.59448695\",\n \"0.59320253\",\n \"0.5895446\",\n \"0.58729154\",\n \"0.58721983\",\n \"0.5862694\",\n \"0.5858808\",\n \"0.5858743\",\n \"0.5858007\",\n \"0.583182\",\n \"0.58312905\",\n \"0.5809158\",\n \"0.5806023\",\n \"0.5803389\",\n \"0.57981706\",\n \"0.5787419\",\n \"0.5786681\",\n \"0.5786419\",\n \"0.5770665\",\n \"0.5746737\",\n \"0.57331085\",\n \"0.57254255\",\n \"0.5712621\",\n \"0.5704901\",\n \"0.5667203\",\n \"0.5661609\",\n \"0.5655289\",\n \"0.5652862\",\n \"0.5643299\",\n \"0.5640883\",\n \"0.56301695\",\n \"0.5618457\",\n \"0.5617575\",\n \"0.56107646\",\n \"0.55979633\",\n \"0.5586388\",\n \"0.55775833\",\n \"0.55775833\",\n \"0.55724984\",\n \"0.5570385\",\n \"0.55658\",\n \"0.55658\",\n \"0.556578\",\n \"0.5564667\",\n \"0.5561216\",\n \"0.5551466\",\n \"0.5545171\",\n \"0.5541804\",\n \"0.55366987\",\n \"0.5524972\",\n \"0.5519082\",\n \"0.55131155\",\n \"0.55112374\",\n \"0.5510939\",\n \"0.55083376\",\n \"0.55072284\",\n \"0.5503887\",\n \"0.5497679\",\n \"0.548892\",\n \"0.548688\",\n \"0.54781246\",\n \"0.5472913\",\n \"0.546922\",\n \"0.54596\",\n \"0.5454907\",\n \"0.5451323\",\n \"0.54485965\",\n \"0.5447022\",\n \"0.5443125\",\n \"0.5437263\",\n \"0.5436763\",\n \"0.54318964\",\n \"0.5431198\",\n \"0.542868\",\n \"0.54277855\",\n \"0.5419421\",\n \"0.54193103\",\n \"0.54179364\",\n \"0.54156244\",\n \"0.54139304\",\n \"0.54060155\",\n \"0.5405073\",\n \"0.54000115\",\n \"0.5389047\",\n \"0.53890157\",\n \"0.537874\",\n \"0.5374339\",\n \"0.53733104\",\n \"0.5371515\",\n \"0.536765\",\n \"0.535786\",\n \"0.5352403\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":90795,"cells":{"query":{"kind":"string","value":"Plots the costs over the iterations"},"document":{"kind":"string","value":"def plot_progress(fig, costs, learning_rate, lambda_reg):\n ax = fig.add_subplot(111)\n ax.plot(\n np.arange(len(costs)),\n costs,\n alpha=0.8,\n label=\"LR: \" + str(learning_rate) + \" __ Lambda: \" + str(lambda_reg),\n )\n\n ax.legend(\n bbox_to_anchor=(0.0, 1.02, 1.0, 0.102),\n loc=\"best\",\n ncol=4,\n mode=\"expand\",\n borderaxespad=0.0,\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def plot_costs(j_history):\n plt.figure(figsize=(14, 8))\n plt.plot(range(len(j_history)), j_history)\n plt.grid(True)\n plt.title('J (Cost)')\n plt.xlabel('Iteration')\n plt.ylabel('Cost function')\n plt.xlim([0, 1.05 * ITERATIONS])\n plt.ylim([4, 7])\n plt.show()\n plt.close()","def plot_cost(self):\n steps = np.arange(len(self.cost_values))\n plt.plot(steps, self.cost_values, '-o')\n plt.xlabel(\"Steps\")\n plt.ylabel(\"Cost value\")\n plt.title(\"Cost value per step using Gradient Descent\")\n plt.show()","def plot_graph(costs):\n plt.figure()\n for i in range(len(np.array(costs).T)):\n plt.plot(np.array(costs)[:, i])\n plt.title(\"Costs\")\n plt.show()","def plot_costs(self, threshold=0):\n epochs_range = np.arange(threshold, len(self.costs), 1)\n plt.plot(epochs_range, self.costs[threshold:], color='green', marker='o')\n plt.title('Cost function plot. Eta={:.2f} Lambda={:2.2f}'.format(self.eta, self.lambda_r))\n plt.xlabel('Epochs')\n plt.ylabel('Cost')\n plt.grid(True)\n plt.show()","def plot_stop_and_cost(opt_res, scale='log'):\n nplots=len(opt_res)\n ncols=2\n nrows=int(np.ceil(nplots/ncols))\n _, axes = plt.subplots(nrows, ncols, figsize=(20, 5*nrows))\n for n in range(nplots):\n i = int(np.floor(n / ncols))\n j=n % ncols\n axes[i,j].plot(opt_res[n]['stop'], label='stopping criterion', color='b')\n axes[i,j].set_title('Outer loop # '+ str(n))\n axes[i,j].set_yscale(scale)\n # axes[i,j].set_xscale('log')\n axes[i,j].grid(True)\n axes[i,j].set_ylabel('stop crit')\n ax_2=axes[i,j].twinx()\n ax_2.plot(opt_res[n]['obj'], label='Total cost', color='g')\n ax_2.set_ylabel('total cost')\n ax_2.set_yscale(scale)\n ax_2.set_yticks([np.min(opt_res[n]['obj']), np.max(opt_res[n]['obj'])])\n # axes[i,j].set_ylim([10**2,10**8])\n # axes[i,j].set_xlim([0,100])\n axes[i,j].legend()\n ax_2.legend()","def plot_stop_and_cost_output(opt_res, path, scale='log', nframes=4):\n import matplotlib\n font = {'size' : 15, 'weight': 'normal'}\n matplotlib.rc('font', **font)\n\n nplots=len(opt_res)\n ncols=2\n nrows=int(np.ceil(nframes/ncols))\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\n for n in range(nframes):\n i = int(np.floor(n / ncols))\n j=n % ncols\n axes[i,j].plot(opt_res[n]['stop'], label='Stopping criterion', color='b')\n axes[i,j].set_title('Outer loop # '+ str(n))\n axes[i,j].set_yscale(scale)\n # axes[i,j].set_xscale('log')\n axes[i,j].grid(True)\n axes[i,j].set_ylabel('Stopping Criterion')\n ax_2=axes[i,j].twinx()\n ax_2.plot(opt_res[n]['obj'], label='Total cost', color='g')\n ax_2.set_ylabel('Total cost')\n ax_2.set_yscale(scale)\n # axes[i,j].set_ylim([10**2,10**8])\n # axes[i,j].set_xlim([0,100])\n axes[i,j].legend(loc=1)\n ax_2.legend(loc=2)\n plt.savefig(path,transparent=True, dpi=400)","def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()","def plot_cost(c_v, c_t, save_plots_path):\n\n plt.figure()\n plt.plot(c_v, label='Validation loss')\n plt.plot(c_t, label='Training loss')\n plt.legend()\n title = 'Loss per epoch'\n plt.title(title)\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.savefig(save_plots_path + \"swag_loss_plot.png\")","def plot_cost_vs_clusters(cost,num_clusters,filename):\n fig, ax = plt.subplots()\n ax.plot(num_clusters,cost)\n ax.grid()\n ax.set_xlabel(\"Number of clusters\")\n ax.set_ylabel(\"Cost of dropping off TAs\")\n fig.savefig(filename)\n plt.close()","def plot_cost(self, cost_tr_data: [[int]], cost_test_data: [[int]], title: str=\"Cost\"):\n plot_title, img_title = self.prep_titles(title)\n test_legend = ['training data', 'test data']\n\n # Data for plotting x- and y-axis\n x = np.arange(1, CFG.EPOCHS + 1)\n y = [cost_tr_data, cost_test_data]\n\n # prints x and y-axis values\n print(f'COST:')\n print(f'x: {x}')\n print(f'y: {y}')\n max_y1 = np.amax(y[0]) + 0.1\n max_y2 = np.amax(y[1]) + 0.1\n max_y = max(max_y1, max_y2)\n\n plt.figure(figsize=(CFG.FIG_WIDTH, CFG.FIG_HEIGHT))\n\n # Create the lineplot\n for line in range(2):\n ax = sns.lineplot(x=x, y=y[line], color=CFG.COLOR_COST[line], label=test_legend[line])\n\n ax.legend(loc='best')\n ax.set(xlabel='Epochs',\n ylabel='Cost',\n title=plot_title,\n xlim=(1, CFG.EPOCHS),\n ylim=(0, max_y))\n\n self.save_plot(img_title)\n plt.show()","def _show_learning_rate():\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6.4 * 2, 4.8))\n\n # Visualize c_prime\n c_prime_list = np.linspace(1, 100, num=11)\n x_label = f\"c'\"\n y_label = \"Minimum Clusters Size\"\n title = \"\"\n\n ax = axes[0]\n x_list = c_prime_list\n\n # MNIST\n y_list = [161, 16, 14, 15, 20, 21, 24, 27, 30, 30, 35]\n ax.plot(x_list, y_list, label=\"MNIST\")\n\n # Fashion MNIST\n y_list = [63, 12, 12, 15, 18, 19, 22, 25, 26, 28, 30]\n ax.plot(x_list, y_list, label=\"Fashion MNIST\")\n\n # 20 news groups\n y_list = [1297, 724, 221, 80, 52, 51, 54, 54, 52, 60, 60]\n ax.plot(x_list, y_list, label=\"Newsgroups\")\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n ax.set_title(title)\n ax.legend()\n ax.set_yscale('log')\n\n # Visualize t0\n t0_list = np.linspace(1, 100, num=11)\n x_label = f\"t0\"\n y_label = \"Minimum Clusters Size\"\n title = \"\"\n\n ax = axes[1]\n x_list = t0_list\n\n # MNIST\n y_list = [16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16]\n ax.plot(x_list, y_list, label=\"MNIST\")\n\n # Fashion MNIST\n y_list = [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]\n ax.plot(x_list, y_list, label=\"Fashion MNIST\")\n\n # 20 news groups\n y_list = [765, 765, 767, 772, 772, 773, 789, 789, 793, 796, 799]\n ax.plot(x_list, y_list, label=\"Newsgroups\")\n\n ax.set_xlabel(x_label)\n ax.set_ylabel(y_label)\n ax.set_title(title)\n ax.legend()\n ax.set_yscale('log')\n\n plt.show()","def arrr_starrr_graph(self):\n\n plt.figure()\n total_cost = 0\n\n # plot batteries\n counter = 0\n for batt in self.grid.batteries:\n plt.plot(batt.x, batt.y, marker='x',\n color=colors[counter], markersize=10)\n counter += 1\n\n # iterate over houses and path\n for house in self.grid.houses:\n battery = self.grid.batteries[house.connection]\n\n # get path coordinates\n path_data = house.path\n\n # plot path and house\n plt.plot(path_data[0][0], path_data[0][1],\n color=colors[house.connection], linewidth=.3)\n plt.plot(house.x, house.y, marker='p',\n color=colors[house.connection])\n total_cost += path_data[1]\n plt.draw()\n plt.pause(0.000000001)\n\n plt.title(f\"total cost = {total_cost}\")","def plot_progress(self):\n plt.plot(-self.training_average_reward, label='negative average reward')\n plt.plot(self.training_average_electricity_cost_in_euros, label='electricity cost in euros')\n plt.legend()\n plt.xlabel('Epoch')\n plt.ylabel('cost in euros')\n plt.title('Average electricity cost in euros and reward')\n plt.show()","def costovertime(endclasses, app, costtype='expected cost'):\n costovertime = cost_table(endclasses, app)\n plt.plot(list(costovertime.index), costovertime[costtype])\n plt.title('Total '+costtype+' of all faults over time.')\n plt.ylabel(costtype)\n plt.xlabel(\"Time (\"+str(app.units)+\")\")\n plt.grid()","def draw_simple_pp(taus, solver_vals, solvers, filename):\n fig = plt.figure(figsize=(10, 10))\n ax = fig.add_subplot(111)\n for n, solver in enumerate(solvers):\n ax.step(taus, solver_vals[n, :], label=solver)\n ax.set_xscale('log')\n plt.legend(loc=4)\n plt.xlim(1, taus.max())\n ax.set_xlabel('Performance Ratio')\n ax.set_ylabel('Fraction of problems')\n plt.title('cost in size')\n plt.savefig(filename, dpi=300)\n plt.plot()","def visualization(obj_value):\n for n in range(3):\n plt.loglog(obj_value[n],\".\");\n\n plt.ylabel('objective values');\n plt.xlabel('iteration counter');\n plt.title('objective values for each pair against iterations');\n plt.legend();\n plt.show();","def draw_lists_pyplot(y_array, line_weight=3, learnig_rate=1):\n y = y_array\n plt.plot(y, lw=line_weight, label='cost(a={:})'.format(learnig_rate))\n plt.legend()\n\n plt.title(\"Gradient Descent Optimizing Method\\nminimize cost function\")\n plt.xlabel('time-itoration')\n plt.ylabel('cost-function')\n plt.xlim(0,)\n plt.ylim(0,)\n\n plt.grid(b=None, which='major', axis='both')\n plt.show()","def draw_lists_pyplot(y_array, line_weight=3, learnig_rate=1):\n y = y_array\n plt.plot(y, lw=line_weight, label='cost(a={:})'.format(learnig_rate))\n plt.legend()\n\n plt.title(\"Gradient Descent Optimizing Method\\nminimize cost function\")\n plt.xlabel('time-itoration')\n plt.ylabel('cost-function')\n\n plt.xlim(0,)\n plt.ylim(0,)\n\n plt.grid(b=None, which='major', axis='both')\n plt.show()","def Traffic_Perform_Plot(performance, hurricanes):\n fig = plt.figure(figsize = (8, 6))\n for i in range(len(performance)):\n temp1 = performance[i]\n temp2 = hurricanes[i]\n perform = sf.Normalize(temp1, Type = 'max')\n plt.plot(np.arange(0, len(perform), 1), perform, color = temp2.c, label = temp2.name, marker = 'o')\n plt.xlabel('Time Step')\n plt.xticks(np.arange(0, len(perform), 1))\n plt.ylabel('Performance')\n plt.legend(bbox_to_anchor=(1, 1), loc='upper left', ncol=1, frameon = 0)\n plt.grid(True)","def _plot(self, step, rewards, losses):\n plt.figure(figsize=(20, 5))\n plt.subplot(131)\n plt.title('Total Episode Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('MSE Loss')\n plt.plot(losses)\n plt.show()","def cost_profile_plot(cost_values):\n \n ax = plt.figure(figsize = (7.5,4.5)).gca()\n cost_values = np.array(cost_values)\n span = np.arange(1,len(cost_values)+1)\n ax.plot(span,cost_values, color = 'k', alpha = 0.7)\n ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n ax.set_xlabel('Epoch')\n ax.set_ylabel('Cost (MSE) value')\n plt.show()\n plt.close('all')","def visualize_raw_dat_cost(self, dat):\n print('Cost of Games')\n\n plt.hist(dat['Price'].dropna())\n plt.xlabel('Price')\n plt.ylabel('Count')\n plt.title('Price Histogram')\n plt.show()\n\n print('Previous graph also has a long-tail. Will narrow the scope again')\n print('~99% of results in following graph')\n\n plt.hist(dat[(dat['Price'] < 15)]['Price'].dropna())\n plt.xlabel('Price')\n plt.ylabel('Count')\n plt.title('Price of Apps')\n plt.show()\n\n print('''84% of apps are free, skewing the results further. \n Looking into only non-free apps for a clearer picture on what remains''')\n\n plt.hist(dat[(dat['Price'] < 15) & (dat['Price'] != 0)]['Price'].dropna())\n plt.xlabel('Price')\n plt.ylabel('Count')\n plt.title('Price of non-free Apps')\n plt.show()","def graph_results(loss, acc):\n N = len(loss)\n x = np.linspace(0, N, N)\n plt.subplot(1,2,1)\n plt.plot(x, loss)\n plt.subplot(1,2,2)\n plt.plot(x,acc)\n plt.show()","def plot_learning(self):\n plt.plot([i for i in range(len(self.fitness_list))], self.fitness_list)\n plt.ylabel(\"Fitness\")\n plt.xlabel(\"Iteration\")\n plt.show()","def draw_cost_plot(hori, verts, iic=False):\n plot.figure().clear()\n if not iic: title = \"Network cost\"\n else: title = \"Network cost with IIC\"\n plot.title(title)\n plot.xticks(range(-1, 100, 1))\n\n # normally only draw inter-cost, intra-cost, door matt effect and total cost.\n _draw_line(plot, hori, verts[0], 'g', 'IEC')\n _draw_line(plot, hori, verts[1], 'b', 'IAC')\n _draw_line(plot, hori, verts[2], 'r', 'DMC')\n _draw_line(plot, hori, verts[3], 'k', 'TOTAL')\n\n # if want to watch inter-intra cost\n if iic:\n v = map(lambda iec, iac: iec + iac, verts[0], verts[1])\n _draw_line(plot, hori, v, 'm', 'IIC')\n \n plot.grid(True)\n if iic:\n plot.savefig(\"./\" + str(datetime.datetime.now()) + \"iic.png\", format='png')\n else:\n plot.savefig(\"./\" + str(datetime.datetime.now()) + \"normal.png\", format='png')\n #plot.show()","def results_plot_fuel_reactor(self):\n \n import matplotlib.pyplot as plt \n\n # Total pressure profile\n P = []\n for z in self.MB_fuel.z:\n P.append(value(self.MB_fuel.P[z]))\n fig_P = plt.figure(1)\n plt.plot(self.MB_fuel.z, P)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total Pressure [bar]\") \n\n # Temperature profile\n Tg = []\n Ts = []\n# Tw = []\n for z in self.MB_fuel.z:\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\n# Tw.append(value(self.MB_fuel.Tw[z]))\n fig_T = plt.figure(2)\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Temperature [C]\") \n \n # Superficial gas velocity and minimum fluidization velocity\n vg = []\n umf = []\n for z in self.MB_fuel.z:\n vg.append(value(self.MB_fuel.vg[z]))\n umf.append(value(self.MB_fuel.umf[z]))\n fig_vg = plt.figure(3)\n plt.plot(self.MB_fuel.z, vg, label='vg')\n plt.plot(self.MB_fuel.z, umf, label='umf')\n plt.legend(loc=0,ncol=2)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Superficial gas velocity [m/s]\")\n \n # Gas components molar flow rate\n for j in self.MB_fuel.GasList:\n F = []\n for z in self.MB_fuel.z:\n F.append(value(self.MB_fuel.F[z,j]))\n fig_F = plt.figure(4)\n plt.plot(self.MB_fuel.z, F, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Gas component molar flow rate, F [mol/s]\") \n \n # Bulk gas phase total molar flow rate\n Ftotal = []\n for z in self.MB_fuel.z:\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\n fig_Ftotal = plt.figure(5)\n plt.plot(self.MB_fuel.z, Ftotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total molar gas flow rate [mol/s]\") \n\n # Solid components mass flow rate\n for j in self.MB_fuel.SolidList:\n M = []\n for z in self.MB_fuel.z:\n M.append(value(self.MB_fuel.Solid_M[z,j]))\n fig_M = plt.figure(6)\n plt.plot(self.MB_fuel.z, M, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid components mass flow rate [kg/s]\")\n \n # Bulk solid phase total molar flow rate\n Mtotal = []\n for z in self.MB_fuel.z:\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\n fig_Mtotal = plt.figure(7)\n plt.plot(self.MB_fuel.z, Mtotal)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Solid total mass flow rate [kg/s]\") \n \n # Gas phase concentrations\n for j in self.MB_fuel.GasList:\n Cg = []\n for z in self.MB_fuel.z:\n Cg.append(value(self.MB_fuel.Cg[z,j]))\n fig_Cg = plt.figure(8)\n plt.plot(self.MB_fuel.z, Cg, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Concentration [mol/m3]\") \n \n # Gas phase mole fractions\n for j in self.MB_fuel.GasList:\n y = []\n for z in self.MB_fuel.z:\n y.append(value(self.MB_fuel.y[z,j]))\n fig_y = plt.figure(9)\n plt.plot(self.MB_fuel.z, y, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"y [-]\") \n \n # Solid phase mass fractions\n for j in self.MB_fuel.SolidList:\n x = []\n for z in self.MB_fuel.z:\n x.append(value(self.MB_fuel.x[z,j]))\n fig_x = plt.figure(10)\n plt.plot(self.MB_fuel.z, x, label=j)\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"x [-]\") \n\n # Total mass fraction\n xtot = []\n for z in self.MB_fuel.z:\n xtot.append(value(self.MB_fuel.xtot[z]))\n fig_xtot = plt.figure(11)\n plt.plot(self.MB_fuel.z, xtot)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Total mass fraction [-]\") \n \n # # Gas mix density\n # rhog = []\n # for z in self.MB_fuel.z:\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\n # fig_rhog = plt.figure(23)\n # plt.plot(self.MB_fuel.z, rhog)\n # plt.grid()\n # plt.xlabel(\"Bed height [-]\")\n # plt.ylabel(\"Gas mix density [kg/m3]\") \n \n # Fe conversion\n X_Fe = []\n for z in self.MB_fuel.z:\n X_Fe.append(value(self.MB_fuel.X[z])*100)\n fig_X_Fe = plt.figure(13)\n plt.plot(self.MB_fuel.z, X_Fe)\n plt.grid()\n plt.xlabel(\"Bed height [-]\")\n plt.ylabel(\"Fraction of metal oxide converted [%]\")","def line_figure(self, title):\n\n plt.figure()\n counter = 0\n\n # plot the x and y for each house and battery\n for battery in self.grid.batteries:\n x = []\n y = []\n for house in battery.connections:\n x.append(house.x)\n y.append(house.y)\n plt.plot([house.x, battery.x], [house.y, battery.y],\n color=colors[counter], linewidth=.25)\n plt.scatter(x, y, marker='p', color=colors[counter])\n plt.plot(battery.x, battery.y, marker='x', color=colors[counter],\n markersize=10)\n counter += 1\n plt.title(f\"{title}. Cost: {self.cost()}\")","def plot_metrics(couplings, cost_func, cost_func_name, epsilons, log = False, points=False, scale=1.0, label_font_size=18, tick_font_size=12):\n zero_offset = epsilons[0]/2\n all_ys = []\n if \"lineageOT\" in couplings.keys():\n ys = np.array([cost_func(c) for c in [couplings['lineage entropic rna ' + str(e)] for e in epsilons]])\n plt.plot(epsilons, ys/scale, label = \"LineageOT, true tree\")\n if points:\n plt.scatter([zero_offset], [cost_func(couplings[\"lineageOT\"])/scale])\n all_ys.append(ys)\n if \"OT\" in couplings.keys():\n ys = np.array([cost_func(c) for c in [couplings['entropic rna ' + str(e)] for e in epsilons]])\n plt.plot(epsilons, ys/scale, label = \"Entropic OT\")\n if points:\n plt.scatter([zero_offset], [cost_func(couplings[\"OT\"])/scale])\n all_ys.append(ys)\n if \"lineageOT, fitted\" in couplings.keys():\n ys = np.array([cost_func(c) for c in [couplings['fitted lineage rna ' + str(e)] for e in epsilons]])\n plt.plot(epsilons, ys/scale, label = \"LineageOT, fitted tree\")\n if points:\n plt.scatter([zero_offset], [cost_func(couplings[\"lineageOT, fitted\"])/scale])\n all_ys.append(ys)\n\n plt.ylabel(cost_func_name, fontsize=label_font_size)\n plt.xlabel(\"Entropy parameter\", fontsize=label_font_size)\n plt.xscale(\"log\")\n\n plt.xticks(fontsize=tick_font_size)\n plt.yticks(fontsize=tick_font_size)\n\n if points:\n plt.xlim([0.9*zero_offset, epsilons[-1]])\n else:\n plt.xlim([epsilons[0], epsilons[-1]])\n\n ylims = plt.ylim([0, None])\n # upper limit should be at least 1\n plt.ylim([0, max(ylims[1], 1)])\n\n plt.legend(fontsize=tick_font_size)\n return all_ys","def plot_results(outputs_table_totals, elec_benefits, gas_benefits):\n summer_months = [6, 7, 8, 9]\n shoulder_months = [3, 4, 5, 10]\n winter_months = [11, 12, 1, 2]\n peak_hours = [16, 17, 18, 19, 20]\n pct_hours_in_summer = 2928 / 8760\n pct_hours_in_shoulder = 2952 / 8760\n pct_hours_in_winter = 2880 / 8760\n\n trc_costs_record = outputs_table_totals[\"TRC Costs ($)\"]\n pac_costs_record = outputs_table_totals[\"PAC Costs ($)\"]\n trc_record = outputs_table_totals[\"TRC\"]\n pac_record = outputs_table_totals[\"PAC\"]\n lifecycle_net_mwh = outputs_table_totals[\"Electricity Lifecycle Net Savings (MWh)\"]\n lifecycle_net_therms = outputs_table_totals[\"Gas Lifecycle Net Savings (Therms)\"]\n lifecycle_net_ghg = outputs_table_totals[\"Total Lifecycle GHG Savings (Tons)\"]\n\n # Getting variables for plots\n elec_benefits_cols = (\n [\"hourly_savings\"] + ACC_COMPONENTS_ELECTRICITY + [\"av_csts_levelized\"]\n )\n\n elec_benefits_hour_month_year = (\n elec_benefits.groupby([\"hour_of_day\", \"year\", \"month\"])\n .agg(\n {\n **{component: \"sum\" for component in ACC_COMPONENTS_ELECTRICITY},\n **{\n \"hourly_savings\": \"sum\",\n \"marginal_ghg\": \"sum\",\n \"av_csts_levelized\": \"mean\",\n },\n }\n )\n .reset_index()\n )\n\n total_benefits = list(\n elec_benefits_hour_month_year.groupby([\"hour_of_day\"])[\"total\"].sum()\n )\n\n summer_benefits = list(\n elec_benefits_hour_month_year[\n (elec_benefits_hour_month_year[\"month\"].isin(summer_months))\n ]\n .groupby([\"hour_of_day\"])[\"total\"]\n .sum()\n )\n summer_peak_benefits = elec_benefits_hour_month_year[\"total\"][\n (elec_benefits_hour_month_year[\"month\"].isin(summer_months))\n & (elec_benefits_hour_month_year[\"hour_of_day\"].isin(peak_hours))\n ].sum()\n shoulder_benefits = list(\n elec_benefits_hour_month_year[\n (elec_benefits_hour_month_year[\"month\"].isin(shoulder_months))\n ]\n .groupby([\"hour_of_day\"])[\"total\"]\n .sum()\n )\n winter_benefits = list(\n elec_benefits_hour_month_year[\n (elec_benefits_hour_month_year[\"month\"].isin(winter_months))\n ]\n .groupby([\"hour_of_day\"])[\"total\"]\n .sum()\n )\n total_savings = list(\n elec_benefits_hour_month_year.groupby([\"hour_of_day\"])[\"hourly_savings\"].sum()\n )\n summer_savings = list(\n elec_benefits_hour_month_year[\n (elec_benefits_hour_month_year[\"month\"].isin(summer_months))\n ]\n .groupby([\"hour_of_day\"])[\"hourly_savings\"]\n .sum()\n )\n shoulder_savings = list(\n elec_benefits_hour_month_year[\n ((elec_benefits_hour_month_year[\"month\"].isin(shoulder_months)))\n ]\n .groupby([\"hour_of_day\"])[\"hourly_savings\"]\n .sum()\n )\n summer_peak_savings = elec_benefits_hour_month_year[\"hourly_savings\"][\n (elec_benefits_hour_month_year[\"month\"].isin(summer_months))\n & (elec_benefits_hour_month_year[\"hour_of_day\"].isin(peak_hours))\n ].sum()\n winter_savings = list(\n elec_benefits_hour_month_year[\n (elec_benefits_hour_month_year[\"month\"].isin(winter_months))\n ]\n .groupby([\"hour_of_day\"])[\"hourly_savings\"]\n .sum()\n )\n total_av_csts_avg = list(\n elec_benefits_hour_month_year.groupby([\"hour_of_day\"])[\n \"av_csts_levelized\"\n ].mean()\n )\n summer_av_csts_avg = list(\n pct_hours_in_summer\n * elec_benefits_hour_month_year[\n (elec_benefits_hour_month_year[\"month\"].isin(summer_months))\n ]\n .groupby([\"hour_of_day\"])[\"av_csts_levelized\"]\n .mean()\n )\n summer_peak_av_csts_avg = elec_benefits_hour_month_year[\"av_csts_levelized\"][\n (elec_benefits_hour_month_year[\"month\"].isin(summer_months))\n & (elec_benefits_hour_month_year[\"hour_of_day\"].isin(peak_hours))\n ].mean()\n shoulder_av_csts_avg = list(\n pct_hours_in_shoulder\n * elec_benefits_hour_month_year[\n ((elec_benefits_hour_month_year[\"month\"].isin(shoulder_months)))\n ]\n .groupby([\"hour_of_day\"])[\"av_csts_levelized\"]\n .mean()\n )\n winter_av_csts_avg = list(\n pct_hours_in_winter\n * elec_benefits_hour_month_year[\n (elec_benefits_hour_month_year[\"month\"].isin(winter_months))\n ]\n .groupby([\"hour_of_day\"])[\"av_csts_levelized\"]\n .mean()\n )\n\n elec_benefits_sum_by_hod = (\n elec_benefits[elec_benefits_cols].groupby(elec_benefits[\"hour_of_day\"]).sum()\n )\n elec_benefits_hoy = (\n elec_benefits[elec_benefits_cols]\n .groupby(elec_benefits[\"hour_of_year\"])\n .sum()\n .cumsum()\n .reset_index()\n )\n sav_avcsts_288 = (\n elec_benefits.groupby([\"hour_of_day\", \"month\"])\n .agg(\n {\n **{component: \"sum\" for component in ACC_COMPONENTS_ELECTRICITY},\n **{\n \"hourly_savings\": \"sum\",\n \"marginal_ghg\": \"sum\",\n \"av_csts_levelized\": \"mean\",\n },\n }\n )\n .reset_index()\n )\n sav_avcsts_288 = sav_avcsts_288[\n [\"hour_of_day\", \"month\", \"hourly_savings\", \"total\", \"marginal_ghg\"]\n ]\n ghgsav = sav_avcsts_288.pivot(\"hour_of_day\", \"month\", \"marginal_ghg\")\n sav = sav_avcsts_288.pivot(\"hour_of_day\", \"month\", \"hourly_savings\")\n avcsts = sav_avcsts_288.pivot(\"hour_of_day\", \"month\", \"total\")\n\n # savings load shape plot\n fig0, (ax1, ax2, ax3) = plt.subplots(\n 1, 3, figsize=(18, 5), sharex=True, sharey=True\n )\n plt.subplots_adjust(wspace=0, hspace=0)\n axs = [ax1, ax2, ax3]\n hod = elec_benefits_sum_by_hod.index\n legend_labels1 = [\"Summer\"]\n legend_labels2 = [\"Shoulder\"]\n legend_labels3 = [\"Winter\"]\n\n ax1.plot(\n hod,\n summer_savings,\n c=\"firebrick\",\n linewidth=5,\n marker=\"$\\u25EF$\",\n markersize=13,\n linestyle=\"-\",\n )\n ax2.plot(\n hod,\n shoulder_savings,\n c=\"royalblue\",\n linewidth=5,\n marker=\"$\\u2206$\",\n markersize=13,\n linestyle=\"-\",\n )\n ax3.plot(\n hod,\n winter_savings,\n c=\"green\",\n linewidth=5,\n marker=\"$\\u25A1$\",\n markersize=13,\n linestyle=\"-\",\n )\n ax1.axhline(y=0, color=\"gray\", linewidth=1, linestyle=\"--\")\n ax2.axhline(y=0, color=\"gray\", linewidth=1, linestyle=\"--\")\n ax3.axhline(y=0, color=\"gray\", linewidth=1, linestyle=\"--\")\n # Shade peak region\n ax1.axvspan(16, 21, alpha=0.2, color=\"grey\")\n\n leg1 = ax1.legend(legend_labels1, fontsize=14, loc=\"upper left\", frameon=False)\n for line, text in zip(leg1.get_lines(), leg1.get_texts()):\n text.set_color(line.get_color())\n leg2 = ax2.legend(legend_labels2, fontsize=14, loc=\"upper left\", frameon=False)\n for line, text in zip(leg2.get_lines(), leg2.get_texts()):\n text.set_color(line.get_color())\n leg3 = ax3.legend(legend_labels3, fontsize=14, loc=\"upper left\", frameon=False)\n for line, text in zip(leg3.get_lines(), leg3.get_texts()):\n text.set_color(line.get_color())\n\n ax1.set_ylabel(\"Savings (MWh/hr)\", size=16)\n ax2.set_xlabel(\"Hour of Day\", size=16)\n\n if max(summer_savings + shoulder_savings + winter_savings) < 0:\n ymax = 0\n else:\n ymax = max(summer_savings + shoulder_savings + winter_savings)\n if min(summer_savings + shoulder_savings + winter_savings) > 0:\n ymin = 0\n else:\n ymin = min(summer_savings + shoulder_savings + winter_savings)\n\n # Tick and lebel parameters\n ax1.set_ylim(ymin * 1.08, ymax * 1.08)\n ax1.set_yticks(\n np.arange(\n ymin * 1.08,\n ymax * 1.08,\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax2.set_yticks(\n np.arange(\n ymin * 1.08,\n ymax * 1.08,\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax3.set_yticks(\n np.arange(\n ymin * 1.08,\n ymax * 1.08,\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax1.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax2.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax3.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax1.yaxis.set_minor_locator(AutoMinorLocator())\n ax1.set_xticks(np.arange(0, 24, step=4))\n ax1.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=7, width=2, labelsize=14\n )\n ax1.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax1.xaxis.set_minor_locator(AutoMinorLocator())\n ax2.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=7, width=2, labelsize=14\n )\n ax2.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax2.xaxis.set_minor_locator(AutoMinorLocator())\n ax3.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=7, width=2, labelsize=14\n )\n ax3.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax3.xaxis.set_minor_locator(AutoMinorLocator())\n\n # Set plot title, size, and position\n ax1.set_title(\"Seasonal Savings Load Shapes\", size=18, loc=\"left\").set_position(\n [0, 1.03]\n )\n\n # benefits_seasonal_shape_plot\n fig1, (ax1, ax2, ax3) = plt.subplots(\n 1, 3, figsize=(18, 5), sharex=True, sharey=True\n )\n plt.subplots_adjust(wspace=0, hspace=0)\n axs = [ax1, ax2, ax3]\n hod = elec_benefits_sum_by_hod.index\n legend_labels1 = [\"Summer\"]\n legend_labels2 = [\"Shoulder\"]\n legend_labels3 = [\"Winter\"]\n\n ax1.plot(\n hod,\n summer_benefits,\n c=\"firebrick\",\n linewidth=5,\n marker=\"$\\u2B24$\",\n markersize=13,\n linestyle=\":\",\n )\n ax2.plot(\n hod,\n shoulder_benefits,\n c=\"royalblue\",\n linewidth=5,\n marker=\"$\\u25B2$\",\n markersize=13,\n linestyle=\":\",\n )\n ax3.plot(\n hod,\n winter_benefits,\n c=\"green\",\n linewidth=5,\n marker=\"$\\u25A0$\",\n markersize=13,\n linestyle=\":\",\n )\n ax1.axhline(y=0, color=\"gray\", linewidth=1, linestyle=\"--\")\n ax2.axhline(y=0, color=\"gray\", linewidth=1, linestyle=\"--\")\n ax3.axhline(y=0, color=\"gray\", linewidth=1, linestyle=\"--\")\n # Shade peak region\n ax1.axvspan(16, 21, alpha=0.2, color=\"grey\")\n\n leg1 = ax1.legend(legend_labels1, fontsize=15, loc=\"upper left\", frameon=False)\n for line, text in zip(leg1.get_lines(), leg1.get_texts()):\n text.set_color(line.get_color())\n leg2 = ax2.legend(legend_labels2, fontsize=15, loc=\"upper left\", frameon=False)\n for line, text in zip(leg2.get_lines(), leg2.get_texts()):\n text.set_color(line.get_color())\n leg3 = ax3.legend(legend_labels3, fontsize=15, loc=\"upper left\", frameon=False)\n for line, text in zip(leg3.get_lines(), leg3.get_texts()):\n text.set_color(line.get_color())\n\n ax1.set_ylabel(\"TRC Benefits ($/hr)\", size=16)\n ax2.set_xlabel(\"Hour of Day\", size=16)\n\n if max(summer_benefits + shoulder_benefits + winter_benefits) < 0:\n ymax = 0\n else:\n ymax = max(summer_benefits + shoulder_benefits + winter_benefits)\n if min(summer_benefits + shoulder_benefits + winter_benefits) > 0:\n ymin = 0\n else:\n ymin = min(summer_benefits + shoulder_benefits + winter_benefits)\n\n # Tick and label parameters\n ax1.set_ylim(ymin * 1.08, ymax * 1.08)\n ax1.set_yticks(\n np.arange(\n ymin * 1.08,\n ymax * 1.08,\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax2.set_yticks(\n np.arange(\n ymin * 1.08,\n ymax * 1.08,\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax3.set_yticks(\n np.arange(\n ymin * 1.08,\n ymax * 1.08,\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax1.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax2.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax3.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax1.yaxis.set_minor_locator(AutoMinorLocator())\n ax1.set_xticks(np.arange(0, 24, step=4))\n ax1.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=7, width=2, labelsize=14\n )\n ax1.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax1.xaxis.set_minor_locator(AutoMinorLocator())\n ax2.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=7, width=2, labelsize=14\n )\n ax2.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax2.xaxis.set_minor_locator(AutoMinorLocator())\n ax3.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=7, width=2, labelsize=14\n )\n ax3.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax3.xaxis.set_minor_locator(AutoMinorLocator())\n\n # Set plot title, size, and position\n ax1.set_title(\n \"Seasonal TRC Benefits by Hour ($)\", size=18, loc=\"left\"\n ).set_position([0, 1.03])\n\n # sum_hourly_plot\n fig2 = plt.figure(figsize=(12, 7), dpi=250)\n ax = fig2.gca()\n colors = [\n \"royalblue\",\n \"black\",\n \"pink\",\n \"firebrick\",\n \"gray\",\n \"darkviolet\",\n \"darkorange\",\n \"green\",\n \"saddlebrown\",\n ]\n legend_labels = []\n x = 1\n while x <= len(ACC_COMPONENTS_ELECTRICITY[1:]):\n if x == 1:\n ax.bar(\n hod,\n elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]],\n color=colors[x - 1],\n )\n legend_labels.append(\n re.findall(\n \".*Name: (.*),\",\n str(elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]]),\n )[0]\n )\n x += 1\n else:\n ax.bar(\n hod,\n elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]],\n bottom=elec_benefits_sum_by_hod.iloc[:, 2 : x + 1].sum(axis=1),\n color=colors[x - 1],\n )\n legend_labels.append(\n re.findall(\n \".*Name: (.*),\",\n str(elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]]),\n )[0]\n )\n x += 1\n\n # Set x and y limits based on min and max values\n ymax = elec_benefits_sum_by_hod.iloc[:, 2:x].sum(axis=1).max()\n if elec_benefits_sum_by_hod.iloc[:, 2:x].sum(axis=1).min() > 0:\n ymin = 0\n else:\n ymin = elec_benefits_sum_by_hod.iloc[:, 2:x].sum(axis=1).min()\n\n ax.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax.set_ylim(ymin * 1.1, ymax * 1.08)\n\n # Set x and y axis labels\n ax.set_xlabel(\"Hour of Day\", size=17, labelpad=5)\n ax.set_ylabel(\"$ Avoided Costs\", size=17)\n\n # Set plot title, size, and position\n ax.set_title(\n \"Sum of Electric Avoided Costs by Component and Hour of Day\",\n size=17,\n loc=\"left\",\n )\n\n # Tick and lebel parameters\n ax.tick_params(bottom=True, top=False, left=True, right=False)\n ax.set_xticks(np.arange(0, 24, step=4))\n ax.set_yticks(\n np.arange(\n int(round(ymin * 1.1, 0)),\n ymax * 1.08,\n step=max(round(ymax - ymin, 2) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n\n # Minor ticks\n ax.xaxis.set_minor_locator(AutoMinorLocator())\n ax.yaxis.set_minor_locator(AutoMinorLocator())\n\n # Legend\n plt.legend(\n legend_labels,\n bbox_to_anchor=(1, 1),\n fontsize=12,\n loc=\"upper left\",\n frameon=False,\n )\n\n # avoided_cost_summary_plot\n fig3, (ax1, ax2, ax3) = plt.subplots(\n 3, 1, figsize=(6, 10), sharex=True, sharey=False\n )\n axs = [ax1, ax2, ax3]\n hod = elec_benefits_sum_by_hod.index\n legend_labels = [\"Total\", \"Summer\", \"Shoulder\", \"Winter\"]\n\n ax1.plot(\n hod,\n total_benefits,\n c=\"royalblue\",\n marker=\"$\\u25EF$\",\n markersize=10,\n linewidth=3,\n linestyle=\"-\",\n )\n ax1.plot(hod, summer_benefits, c=\"darkorchid\", linewidth=1, linestyle=\"--\")\n ax1.plot(hod, shoulder_benefits, c=\"olivedrab\", linewidth=1, linestyle=\":\")\n ax1.plot(hod, winter_benefits, c=\"teal\", linewidth=1, linestyle=\"-\")\n ax2.plot(\n hod,\n total_savings,\n c=\"firebrick\",\n marker=\"$\\u2206$\",\n markersize=10,\n linewidth=3,\n linestyle=\"-\",\n )\n ax2.plot(hod, summer_savings, c=\"darkorchid\", linewidth=1, linestyle=\"--\")\n ax2.plot(hod, shoulder_savings, c=\"olivedrab\", linewidth=1, linestyle=\":\")\n ax2.plot(hod, winter_savings, c=\"teal\", linewidth=1, linestyle=\"-\")\n ax3.plot(\n hod,\n total_av_csts_avg,\n c=\"green\",\n marker=\"$\\u25A0$\",\n markersize=10,\n linewidth=3,\n linestyle=\"-\",\n )\n ax3.plot(hod, summer_av_csts_avg, c=\"darkorchid\", linewidth=1, linestyle=\"--\")\n ax3.plot(hod, shoulder_av_csts_avg, c=\"olivedrab\", linewidth=1, linestyle=\":\")\n ax3.plot(hod, winter_av_csts_avg, c=\"teal\", linewidth=1, linestyle=\"-\")\n\n leg1 = ax1.legend(legend_labels, fontsize=11, loc=\"upper left\", frameon=False)\n for line, text in zip(leg1.get_lines(), leg1.get_texts()):\n text.set_color(line.get_color())\n leg2 = ax2.legend(legend_labels, fontsize=11, loc=\"upper left\", frameon=False)\n for line, text in zip(leg2.get_lines(), leg2.get_texts()):\n text.set_color(line.get_color())\n leg3 = ax3.legend(legend_labels, fontsize=11, loc=\"upper left\", frameon=False)\n for line, text in zip(leg3.get_lines(), leg3.get_texts()):\n text.set_color(line.get_color())\n\n ax3.set_xticks(np.arange(0, 24, step=4))\n ax3.set_xlabel(\"Hour of Day\", size=14, labelpad=5)\n ax3.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=12\n )\n ax3.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\n ax3.xaxis.set_minor_locator(AutoMinorLocator())\n\n ax1.set_ylabel(\"TRC Benefits ($)\", size=14)\n ax2.set_ylabel(\"Savings (MWh)\", size=14)\n ax3.set_ylabel(\"Av. Cost ($/MWh)\", size=14)\n\n if max(total_benefits + summer_benefits + shoulder_benefits + winter_benefits) < 0:\n ymax1 = 0\n else:\n ymax1 = max(\n total_benefits + summer_benefits + shoulder_benefits + winter_benefits\n )\n if min(total_benefits + summer_benefits + shoulder_benefits + winter_benefits) > 0:\n ymin1 = 0\n else:\n ymin1 = min(\n total_benefits + summer_benefits + shoulder_benefits + winter_benefits\n )\n if max(total_savings + summer_savings + shoulder_savings + winter_savings) < 0:\n ymax2 = 0\n else:\n ymax2 = max(total_savings + summer_savings + shoulder_savings + winter_savings)\n if min(total_savings + summer_savings + shoulder_savings + winter_savings) > 0:\n ymin2 = 0\n else:\n ymin2 = min(total_savings + summer_savings + shoulder_savings + winter_savings)\n if (\n max(\n total_av_csts_avg\n + summer_av_csts_avg\n + shoulder_av_csts_avg\n + winter_av_csts_avg\n )\n < 0\n ):\n ymax3 = 0\n else:\n ymax3 = max(\n total_av_csts_avg\n + summer_av_csts_avg\n + shoulder_av_csts_avg\n + winter_av_csts_avg\n )\n if (\n min(\n total_av_csts_avg\n + summer_av_csts_avg\n + shoulder_av_csts_avg\n + winter_av_csts_avg\n )\n > 0\n ):\n ymin3 = 0\n else:\n ymin3 = min(\n total_av_csts_avg\n + summer_av_csts_avg\n + shoulder_av_csts_avg\n + winter_av_csts_avg\n )\n\n # Tick and lebel parameters\n ax1.set_ylim(ymin1 * 1.08, ymax1 * 1.08)\n ax2.set_ylim(ymin2 * 1.08, ymax2 * 1.08)\n ax3.set_ylim(ymin3 * 1.08, ymax3 * 1.08)\n\n ax1.set_yticks(\n np.arange(\n ymin1 * 1.08,\n ymax1 * 1.08,\n step=max(round(ymax1 - ymin1, 3) / 5, int((round(ymax1 - ymin1, 0)) / 4)),\n )\n )\n ax2.set_yticks(\n np.arange(\n ymin2 * 1.08,\n ymax2 * 1.08,\n step=max(round(ymax2 - ymin2, 3) / 5, int((round(ymax2 - ymin2, 0)) / 4)),\n )\n )\n ax3.set_yticks(\n np.arange(\n ymin3 * 1.08,\n ymax3 * 1.08,\n step=max(round(ymax3 - ymin3, 3) / 5, int((round(ymax3 - ymin3, 0)) / 4)),\n )\n )\n\n ax1.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=12\n )\n ax2.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=12\n )\n ax3.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=12\n )\n\n # Shade peak region\n ax1.axvspan(16, 21, alpha=0.2, color=\"grey\")\n ax2.axvspan(16, 21, alpha=0.2, color=\"grey\")\n ax3.axvspan(16, 21, alpha=0.2, color=\"grey\")\n\n # Print key information\n plt.annotate(\n \"Electric Benefits = $\" + str(round(elec_benefits[\"total\"].sum(), 2)),\n xy=(350, 530),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"Gas Benefits = $\" + str(round(gas_benefits, 2)),\n xy=(350, 505),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"Total Benefits = $\"\n + str(round(elec_benefits[\"total\"].sum() + gas_benefits, 2)),\n xy=(350, 480),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"TRC Costs = $\" + str(trc_costs_record),\n xy=(350, 455),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"PAC Costs = $\" + str(pac_costs_record),\n xy=(350, 430),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"TRC = \" + str(trc_record),\n xy=(350, 405),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"PAC = \" + str(pac_record),\n xy=(350, 380),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"Net Lifecycle Electric Savings = \" + str(lifecycle_net_mwh) + \" MWh\",\n xy=(350, 335),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"Net Lifecycle Gas Savings = \" + str(lifecycle_net_therms) + \" Therms\",\n xy=(350, 310),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"Net Lifecycle GHG Savings = \" + str(lifecycle_net_ghg) + \" Tons\",\n xy=(350, 285),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n str(round(100 * ((summer_peak_savings) / sum(total_savings)), 1))\n + \"% MWh savings during summer peak period\",\n xy=(350, 260),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n str(round(100 * ((summer_peak_benefits) / sum(total_benefits)), 1))\n + \"% Electric TRC benefits from summer peak period\",\n xy=(350, 235),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"Electric Benefits per MWh = $\"\n + str(round(elec_benefits[\"total\"].sum() / lifecycle_net_mwh, 2)),\n xy=(350, 210),\n xycoords=\"axes points\",\n fontsize=18,\n )\n plt.annotate(\n \"Typical Avoided Cost per MWh = $\"\n + str(round(elec_benefits[\"av_csts_levelized\"].mean(), 2)),\n xy=(350, 145),\n xycoords=\"axes points\",\n fontsize=18,\n )\n\n # Set plot title, size, and position\n ax1.set_title(\n \"Savings and Avoided Cost Profiles\", size=16, loc=\"left\"\n ).set_position([0, 1.03])\n\n # marginal_ghg_savings_plot\n cmp = sns.diverging_palette(16, 260, l=35, n=25, as_cmap=True)\n\n fig4 = plt.figure(figsize=(8, 6), dpi=100)\n ax1 = fig4.gca()\n y_ticks = [\n 0,\n \"\",\n 2,\n \"\",\n 4,\n \"\",\n 6,\n \"\",\n 8,\n \"\",\n 10,\n \"\",\n 12,\n \"\",\n 14,\n \"\",\n 16,\n \"\",\n 18,\n \"\",\n 20,\n \"\",\n 22,\n ]\n hmp = sns.heatmap(ghgsav, cmap=cmp, ax=ax1, yticklabels=y_ticks, center=0.00)\n ax1.set_xlabel(\"Month\", size=15)\n ax1.set_ylabel(\"Hour of Day\", size=15)\n ax1.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=13\n )\n ax1.tick_params(\n which=\"major\",\n axis=\"y\",\n direction=\"out\",\n length=6,\n width=2,\n labelsize=13,\n rotation=0,\n )\n ax1.set_title(\"Electric GHG Savings by Month and Hour\", size=15, loc=\"left\", pad=8)\n cbar1 = hmp.collections[0].colorbar\n cbar1.ax.tick_params(labelsize=14)\n plt.annotate(\"Sum GHG\", xy=(370, 352), xycoords=\"axes points\", fontsize=12)\n plt.annotate(\"Savings (Tons)\", xy=(370, 336), xycoords=\"axes points\", fontsize=12)\n\n # month_hour_savings_benefits_plot\n fig5, (ax1, ax2) = plt.subplots(1, 2, figsize=(21, 10), dpi=200)\n y_ticks = [\n 0,\n \"\",\n 2,\n \"\",\n 4,\n \"\",\n 6,\n \"\",\n 8,\n \"\",\n 10,\n \"\",\n 12,\n \"\",\n 14,\n \"\",\n 16,\n \"\",\n 18,\n \"\",\n 20,\n \"\",\n 22,\n ]\n fleft = sns.heatmap(sav, cmap=cmp, ax=ax1, yticklabels=y_ticks, center=0.00)\n fright = sns.heatmap(avcsts, cmap=cmp, ax=ax2, yticklabels=y_ticks, center=0.00)\n ax1.set_xlabel(\"Month\", size=22)\n ax1.set_ylabel(\"Hour of Day\", size=22)\n ax2.set_xlabel(\"Month\", size=22)\n ax2.set_ylabel(\"Hour of Day\", size=22)\n ax1.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=18\n )\n ax1.tick_params(\n which=\"major\",\n axis=\"y\",\n direction=\"out\",\n length=6,\n width=2,\n labelsize=18,\n rotation=0,\n )\n ax2.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=18\n )\n ax2.tick_params(\n which=\"major\",\n axis=\"y\",\n direction=\"out\",\n length=6,\n width=2,\n labelsize=18,\n rotation=0,\n )\n ax1.set_title(\n \"MWh Savings by Month and Hour\", size=24, loc=\"left\", pad=15\n ).set_position([0, 1.1])\n ax2.set_title(\"$ Benefits by Month and Hour\", size=24, loc=\"left\", pad=15)\n fig4.tight_layout(pad=2.0)\n cbar1 = fleft.collections[0].colorbar\n cbar1.ax.tick_params(labelsize=18)\n cbar2 = fright.collections[0].colorbar\n cbar2.ax.tick_params(labelsize=18)\n plt.annotate(\"Sum MWh\", xy=(-200, 585), xycoords=\"axes points\", fontsize=20)\n plt.annotate(\"Savings\", xy=(-193, 560), xycoords=\"axes points\", fontsize=20)\n plt.annotate(\"Sum TRC\", xy=(435, 585), xycoords=\"axes points\", fontsize=20)\n plt.annotate(\"Benefits\", xy=(442, 560), xycoords=\"axes points\", fontsize=20)\n\n # savings_benefits_cumulative_sum_plot\n fig6 = plt.figure(figsize=(12, 7), dpi=250)\n ax1 = fig6.gca()\n ax1.plot(\n elec_benefits_hoy[\"hour_of_year\"],\n elec_benefits_hoy[\"hourly_savings\"],\n color=\"royalblue\",\n linewidth=3,\n )\n ax2 = ax1.twinx()\n ax2.plot(\n elec_benefits_hoy[\"hour_of_year\"],\n elec_benefits_hoy[\"total\"],\n color=\"firebrick\",\n linewidth=3,\n linestyle=\"--\",\n )\n ax2.axhline(y=0, color=\"gray\", linewidth=0.7, linestyle=\"--\")\n\n # Set x and y limits based on min and max values\n\n if (\n elec_benefits_hoy[\"hourly_savings\"].max() >= 0\n and elec_benefits_hoy[\"total\"].max() >= 0\n ):\n ymax1 = elec_benefits_hoy[\"hourly_savings\"].max()\n ymax2 = elec_benefits_hoy[\"total\"].max()\n elif (\n elec_benefits_hoy[\"hourly_savings\"].max() < 0\n and elec_benefits_hoy[\"total\"].max() < 0\n ):\n ymax1 = 0\n ymax2 = 0\n elif (\n elec_benefits_hoy[\"hourly_savings\"].max() < 0\n and elec_benefits_hoy[\"total\"].max() > 0\n ):\n ymax1 = (\n -1\n * elec_benefits_hoy[\"hourly_savings\"].min()\n * (\n elec_benefits_hoy[\"total\"].max()\n / (elec_benefits_hoy[\"total\"].max() - elec_benefits_hoy[\"total\"].min())\n )\n / (\n 1\n - elec_benefits_hoy[\"total\"].max()\n / (elec_benefits_hoy[\"total\"].max() - elec_benefits_hoy[\"total\"].min())\n )\n )\n ymax2 = elec_benefits_hoy[\"total\"].max()\n else:\n ymax1 = 0\n ymax2 = (\n -1\n * elec_benefits_hoy[\"total\"].min()\n * (\n elec_benefits_hoy[\"hourly_savings\"].max()\n / (\n elec_benefits_hoy[\"hourly_savings\"].max()\n - elec_benefits_hoy[\"hourly_savings\"].min()\n )\n )\n )\n\n if (\n elec_benefits_hoy[\"hourly_savings\"].min() <= 0\n and elec_benefits_hoy[\"total\"].min() <= 0\n ):\n ymin1 = elec_benefits_hoy[\"hourly_savings\"].min()\n ymin2 = elec_benefits_hoy[\"total\"].min()\n elif (\n elec_benefits_hoy[\"hourly_savings\"].min() > 0\n and elec_benefits_hoy[\"total\"].min() > 0\n ):\n ymin1 = 0\n ymin2 = 0\n elif (\n elec_benefits_hoy[\"hourly_savings\"].min() > 0\n and elec_benefits_hoy[\"total\"].min() < 0\n ):\n ymin1 = (\n -1\n * elec_benefits_hoy[\"hourly_savings\"].max()\n * (\n elec_benefits_hoy[\"total\"].min()\n / (elec_benefits_hoy[\"total\"].min() - elec_benefits_hoy[\"total\"].max())\n )\n / (\n 1\n - elec_benefits_hoy[\"total\"].min()\n / (elec_benefits_hoy[\"total\"].min() - elec_benefits_hoy[\"total\"].max())\n )\n )\n ymin2 = elec_benefits_hoy[\"total\"].min()\n else:\n ymin1 = 0\n ymin2 = (\n -1\n * elec_benefits_hoy[\"total\"].min()\n * (\n elec_benefits_hoy[\"hourly_savings\"].min()\n / (\n elec_benefits_hoy[\"hourly_savings\"].min()\n - elec_benefits_hoy[\"hourly_savings\"].min()\n )\n )\n )\n\n # Set x and y axis limits\n ax1.set_xlim(-340, 9000)\n ax1.set_ylim(ymin1 * 1.08, ymax1 * 1.08)\n ax2.set_ylim(ymin2 * 1.08, ymax2 * 1.08)\n\n # Set x and y axis labels\n ax1.set_xlabel(\"Hour of Year\", size=17, labelpad=5)\n ax1.set_ylabel(\"Net Lifecycle Savings (MWh)\", size=17)\n ax2.set_ylabel(\"$ TRC Benefits\", size=17, rotation=-90, labelpad=20)\n\n # Set plot title, size, and position\n ax1.set_title(\n \"Cumulative Savings and TRC Benefits by Hour of Year\",\n size=17,\n loc=\"left\",\n pad=8,\n )\n\n # Tick and lebel parameters\n ax1.set_xticks(np.arange(0, 8760, step=1000))\n ax1.set_yticks(\n np.arange(\n int(round(ymin1 * 1.1, 0)),\n ymax1 * 1.08,\n step=max(round(ymax1 - ymin1, 2) / 5, int((round(ymax1 - ymin1, 0)) / 4)),\n )\n )\n ax1.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax1.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n\n ax2.set_xticks(np.arange(0, 8760, step=1000))\n ax2.set_yticks(\n np.arange(\n int(round(ymin2 * 1.1, 0)),\n ymax2 * 1.08,\n step=max(round(ymax2 - ymin2, 2) / 5, int((round(ymax2 - ymin2, 0)) / 4)),\n )\n )\n ax2.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax2.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n\n # Minor ticks\n ax1.xaxis.set_minor_locator(AutoMinorLocator())\n ax1.yaxis.set_minor_locator(AutoMinorLocator())\n ax2.yaxis.set_minor_locator(AutoMinorLocator())\n\n # Legend\n ax1.legend(\n [\"Savings\"],\n fontsize=12,\n bbox_to_anchor=(0.02, 1),\n loc=\"upper left\",\n frameon=False,\n )\n ax2.legend(\n [\"TRC Beneftis\"],\n fontsize=12,\n bbox_to_anchor=(0.02, 0.95),\n loc=\"upper left\",\n frameon=False,\n )\n\n fig7 = plt.figure(figsize=(12, 7), dpi=250)\n ax = fig7.gca()\n colors1 = [\n \"black\",\n \"royalblue\",\n \"black\",\n \"pink\",\n \"firebrick\",\n \"gray\",\n \"darkviolet\",\n \"darkorange\",\n \"green\",\n \"saddlebrown\",\n ]\n legend_labels2 = []\n\n ax.plot(\n elec_benefits_hoy[\"hour_of_year\"],\n elec_benefits_hoy[ACC_COMPONENTS_ELECTRICITY[0]],\n color=colors1[0],\n linewidth=3,\n )\n legend_labels2.append(ACC_COMPONENTS_ELECTRICITY[0])\n x = 1\n while x <= len(ACC_COMPONENTS_ELECTRICITY) - 2:\n ax.plot(\n elec_benefits_hoy[\"hour_of_year\"],\n elec_benefits_hoy[ACC_COMPONENTS_ELECTRICITY[x]],\n color=colors1[x],\n )\n legend_labels2.append(ACC_COMPONENTS_ELECTRICITY[x])\n x += 1\n\n # Set x and y limits based on min and max values\n if max(elec_benefits_hoy.iloc[:, 2:x].max()) < 0:\n ymax = 0\n else:\n ymax = max(elec_benefits_hoy.iloc[:, 2:x].max())\n if min(elec_benefits_hoy.iloc[:, 2:x].min()) > 0:\n ymin = 0\n else:\n ymin = min(elec_benefits_hoy.iloc[:, 2:x].min())\n\n ax.set_xlim(-340, 9000)\n ax.set_ylim(ymin * 1.1, ymax * 1.08)\n\n # Set x and y axis labels\n ax.set_xlabel(\"Hour of Year\", size=17, labelpad=5)\n ax.set_ylabel(\"$ TRC Benefits\", size=17)\n\n # Set plot title, size, and position\n ax.set_title(\n \"Sum of Avoided Costs by Component and Hour of Day\", size=17, loc=\"left\"\n )\n\n # Tick and lebel parameters\n ax.set_xticks(np.arange(0, 8760, step=1000))\n ax.set_yticks(\n np.arange(\n int(round(ymin * 1.1, 0)),\n ymax * 1.08,\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\n )\n )\n ax.tick_params(\n which=\"major\", axis=\"x\", direction=\"out\", length=6, width=2, labelsize=14\n )\n ax.tick_params(\n which=\"major\", axis=\"y\", direction=\"out\", length=6, width=2, labelsize=14\n )\n\n # Minor ticks\n ax.xaxis.set_minor_locator(AutoMinorLocator())\n ax.yaxis.set_minor_locator(AutoMinorLocator())\n\n # Legend\n plt.legend(\n legend_labels2,\n bbox_to_anchor=(1, 1),\n fontsize=12,\n loc=\"upper left\",\n frameon=False,\n )","def plot(self, n_confs):\n \n import pandas as pd\n import numpy as np\n import matplotlib as mpl\n mpl.use('Agg')\n import matplotlib.pyplot as plt\n import csv\n \n n_iter = len(self.plot_data)\n \n data = np.ndarray((n_iter, n_confs+1))\n data[:,0] = [i[0] for i in self.plot_data]\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\n\n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n df.to_csv(f\"{self.plot_name}.tab\", sep=\"\\t\", quoting=csv.QUOTE_NONE) \n\n d = data[:,1:].reshape(-1)\n d = d[~np.isnan(d)]\n mine = d.min() - 0.01\n for i in range(n_confs): \n data[:,i+1] -= mine\n \n df=pd.DataFrame(data)\n names = ['iter']\n for i in range(n_confs): names.append(f'c{i+1}')\n df.columns = names\n \n colors = (0,0,0)\n area = 10\n \n # Plot\n fig = plt.figure(figsize=(15, 15))\n ax = fig.add_subplot(1,1,1)\n for i in range(n_confs):\n ax.plot('iter', f'c{i+1}', data=df)\n ax.set_yscale('log')\n\n plt.xlabel('iter')\n plt.ylabel('loss')\n plt.savefig(f'{self.plot_name}.png')","def H_perform_plot(performance, hurricane):\n fig = plt.figure(figsize = (15, 10))\n for i in range(len(performance)):\n temp1 = performance[i]\n temp2 = hurricane[i]\n plt.plot(np.arange(0, len(temp1), 1), temp1, color = temp2.c, label = temp2.name)\n plt.xlabel('Time Step')\n plt.xticks(np.arange(0, len(temp1), 30))\n plt.ylabel('Performance')\n plt.legend(bbox_to_anchor=(1, 1), loc='upper left', ncol=1, frameon = 0)\n plt.grid(True)","def plot_results(delaytype):\n \n if delaytype == 'Polynomial':\n # results for ind_obs=graph.indlinks.keys()\n tolls_collected1 = [[164.76921455176952, 690.919364787199, 1003.9715271443032], [164.76920846294715, 690.9196375266908, 1003.971503332828]]\n so_costs1 = [[1952.813985915695, 2991.422528084584, 4716.77478205995], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs1 = [[1961.4088544768533, 3035.621746689017, 4751.282035585294], [1961.4088092322784, 3035.619283467948, 4751.282202058287]]\n ue_costs1 = [[1993.9477013089333, 3087.4591784440836, 4889.555908205202], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected2 = [[165.05685117271955, 354.1634370314711, 1015.9141858070569], [165.0567022829941, 354.1917223859498, 1015.9119098321756]]\n so_costs2 = [[1952.4102665477528, 2990.2968764530697, 4714.092736177128], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs2 = [[1961.0182151023969, 3019.353015234613, 4750.051821659878], [1961.4090940730164, 3020.4668352547183, 4752.675436210774]]\n ue_costs2 = [[1993.5324364880598, 3086.401670312004, 4886.656461616093], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected3 = [[122.37203827953705, 369.5962596851687, 993.1260548913893], [124.00144138458633, 375.65796385498777, 1018.6147484597942]]\n so_costs3 = [[1819.720988976306, 2777.3939885366685, 4677.595258102356], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs3 = [[1834.6351015726038, 2802.3016403566235, 4714.102145227426], [1965.8049083549738, 3020.126090534662, 4750.071391283308]]\n ue_costs3 = [[1872.3492340077084, 2897.9834368843217, 4886.769726452165], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\n tolls_collected4 = [[602.0313412901077, 596.7300601881633, 833.3678073460065], [609.094482012133, 542.8579545671112, 843.1817520139325]]\n so_costs4 = [[13252.728980891832, 20178.927282098706, 28549.614451166774], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\n costs4 = [[13254.342842900576, 20239.30287102026, 28549.614731411177], [1992.3969007442322, 3130.0522527298062, 4805.6728306302175]]\n ue_costs4 = [[13259.433117552415, 20185.90937054816, 28556.779443740656], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\n \n \n if delaytype == 'Hyperbolic':\n # results for ind_obs=graph.indlinks.keys() \n tolls_collected1 = [[161.15742640370462, 416.80264009965265, 948.124688583883], [161.4013529462645, 417.25218843773354, 950.1674351402539]]\n so_costs1 = [[2519.5329969919685, 3679.4257321044365, 5325.940489651684], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs1 = [[2525.7590340322095, 3679.4261220632625, 5356.8071818038225], [2551.0113714206195, 3718.3028736461647, 5412.310857035818]]\n ue_costs1 = [[2548.8303153671195, 3736.67165067958, 5444.499035875823], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected2 = [[355.56391097372205, 701.3544774585599, 806.6640717434449], [374.34816990991186, 736.3763770517197, 842.0768966826593]]\n so_costs2 = [[2174.1387842065237, 3306.974167934956, 4969.5560792612605], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs2 = [[2201.273656230071, 3338.7536674213156, 4988.732654672769], [2564.0153714222406, 3746.115605602468, 5398.046518880896]]\n ue_costs2 = [[2209.622435372754, 3380.7186533697286, 5104.755602389524], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\n tolls_collected3 = [[339.37838703976513, 737.9887571945254, 930.0531221139565], [353.28118085588176, 763.3708450755438, 955.644104623869]]\n so_costs3 = [[2520.1983680076073, 3833.234908857907, 5645.320052639795], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs3 = [[2536.138622203524, 3862.614483834193, 5668.430527845267], [2562.897499637454, 3750.9322754235955, 5406.402328441233]]\n ue_costs3 = [[2556.0266644367803, 3903.9758481975805, 5741.545038028959], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\n tolls_collected4 = [[443.85669649193784, 837.5428841560781, 1380.117295219297], [479.57423528502, 931.2309202734045, 1499.6972922042573]]\n so_costs4 = [[2158.995768390798, 3843.4202195503713, 7595.092411648515], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\n costs4 = [[2192.900868595389, 3888.0172745668465, 7626.17585256234], [2575.5748442305207, 3755.844017718783, 5450.304046277645]]\n ue_costs4 = [[2231.1674179937672, 3999.772800567613, 7867.415688946321], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\n \n # effects of toll pricing\n opacity = 0.4\n width = 0.2\n index = np.arange(4)\n plt.xticks(index, ('all', '10', '4 good', '4 bad') )\n colors = ['y', 'r', 'b']\n demands = ['94', '118', '142']\n for i in [0,1,2]:\n so = so_costs1[1][i]\n ue = ue_costs1[1][i]\n delta = ue-so\n plt.bar(index-width/2+(i-1)*width,\n [100.0*(costs1[1][i]-so)/delta, \n 100.0*(costs2[1][i]-so)/delta, \n 100.0*(costs3[1][i]-so)/delta, \n 100.0*(costs4[1][i]-so)/delta],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative loss (%)')\n plt.title('Effects of toll pricing with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()\n \n # error in predicted UE\n for i in [0,1,2]:\n ue = ue_costs1[1][i]\n plt.bar(index-width/2+(i-1)*width,\n [100.0*abs(ue_costs1[0][i]-ue)/ue,\n 100.0*abs(ue_costs2[0][i]-ue)/ue,\n 100.0*abs(ue_costs3[0][i]-ue)/ue,\n 100.0*abs(ue_costs4[0][i]-ue)/ue],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative error (%)')\n plt.title('Error in predicted UE with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()\n \n # error in predicted SO\n for i in [0,1,2]:\n so = so_costs1[1][i]\n plt.bar(index-width/2+(i-1)*width,\n [100.0*abs(so_costs1[0][i]-so)/so,\n 100.0*abs(so_costs2[0][i]-so)/so,\n 100.0*abs(so_costs3[0][i]-so)/so,\n 100.0*abs(so_costs4[0][i]-so)/so],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative error (%)')\n plt.title('Error in predicted SO with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()\n \n # error in predicted tolled ue\n for i in [0,1,2]:\n plt.bar(index-width/2+(i-1)*width,\n [100.0*abs(costs1[0][i]-costs1[1][i])/costs1[1][i],\n 100.0*abs(costs2[0][i]-costs2[1][i])/costs2[1][i],\n 100.0*abs(costs3[0][i]-costs3[1][i])/costs3[1][i],\n 100.0*abs(costs4[0][i]-costs4[1][i])/costs4[1][i]],\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\n plt.xlabel('Sets of observed links')\n plt.ylabel('Relative error (%)')\n plt.title('Error in predicted tooled UE with '+delaytype+' delay function')\n plt.legend(loc=0)\n plt.show()","def plot_convergence(\n optimizers: list = [\"COBYLA\", \"SLSQP\", \"L-BFGS-B\", \"NELDER-MEAD\"],\n g2N: float = 0.2,\n maxit: int = 10000,\n varform: list = [\"ry\"],\n depth: int = 3,\n nrep: int = 10,\n dataprefix: str = \"data/miniBMN\",\n datasuffix: str = \"h5\",\n figprefix: str = \"figures/miniBMN\",\n ht: float = 0.0,\n up: int = 1000,\n):\n # setup parameters\n params = dict()\n params[\"l\"] = str(g2N).replace(\".\", \"\")\n params[\"d\"] = depth\n params[\"v\"] = \"-\".join(varform)\n params[\"m\"] = maxit\n params[\"n\"] = nrep\n params[\"f\"] = dataprefix\n params[\"s\"] = datasuffix\n assert type(optimizers).__name__ == \"list\"\n # collect data\n result = collect_data(optimizers, params)\n # get best runs\n gs = dict()\n for r in optimizers:\n gs[r] = result.loc[r].groupby(\"rep\").apply(min).energy\n gsdf = pd.DataFrame.from_dict(gs, dtype=float)\n print(gsdf.describe().T[[\"min\", \"max\", \"mean\", \"std\"]])\n # Plot\n # select the best runs for each optimizer\n fig, ax = plt.subplots()\n for o in optimizers:\n result.loc[o, gsdf[o].idxmin()].plot(\n x=\"counts\", y=\"energy\", xlim=[0, up], label=o, ax=ax\n )\n ax.axhline(ht, c=\"k\", ls=\"--\", lw=\"2\", label=\"HT\")\n ax.set_xlabel(\"iterations\")\n ax.set_ylabel(\"VQE energy\")\n ax.legend(loc=\"upper right\")\n filename = f\"{figprefix}_l{params['l']}_convergence_{params['v']}_depth{params['d']}_nr{params['n']}_max{params['m']}_xlim{up}\"\n plt.savefig(f\"{filename}.pdf\")\n plt.savefig(f\"{filename}.png\")\n plt.savefig(f\"{filename}.svg\")\n plt.close()","def plot_schedulability_rates_monte_carlo():\n modes = [\n # name, color, linestyle, marker\n ('pSMC (Monte Carlo)', 'cyan', 'solid', 'D'),\n ('pSMC', 'blue', 'dashed', 's'),\n ('pAMC-BB (Monte Carlo)', 'purple', 'solid', 'v'),\n ('pAMC-BB', 'red', 'dashed', '^')\n ]\n\n rates = {}\n task_sets_list = pickle.load(open(task_sets_path + 'task_sets_fairgen', 'rb'))\n fig = plt.figure(figsize=(12, 6), dpi=300)\n fig.suptitle('Evaluation: Monte Carlo Schemes (n=%d)' % len(task_sets_list[0]))\n ax1 = fig.add_subplot(111)\n for name, color, linestyle, marker in modes:\n rates[name] = pickle.load(open(eval_monte_carlo_path + name, 'rb'))\n ax1.plot(utils, rates[name], label=name, color=color, linestyle=linestyle, marker=marker)\n ax1.set_xlabel('LO mode utilization')\n ax1.set_ylabel('Percentage of task sets schedulable')\n ax1.set_xticks([k * 0.5 for k in range(5)])\n ax1.set_yticks([k * 20 for k in range(6)])\n ax1.xaxis.set_minor_locator(ticker.AutoMinorLocator(5))\n ax1.yaxis.set_minor_locator(ticker.AutoMinorLocator(1))\n ax1.minorticks_on()\n ax1.grid(which='both', linestyle='dashed')\n\n plt.axvline(1.0, color='black', linewidth=0.8)\n plt.legend(loc='center left')\n plt.xlim(0.1, 2.1)\n plt.ylim(-5, 105)\n plt.savefig('./figures/schedulability_rates_monte_carlo.png')\n # plt.show()","def visualization(positive_weights_dict, negative_weights_dict, l2_list):\n plt.figure()\n cmap_positive = plt.get_cmap('Reds')\n cmap_negative = plt.get_cmap('Blues')\n xx = l2_list\n plt.plot(xx, [0.]*len(xx), '--', lw=1, color='k')\n i, j = 0, 0\n for key, value in positive_weights_dict.items():\n color = cmap_positive(0.8*((i+1)/(5*1.2)+0.15))\n plt.plot(l2_list, value, '-', label=key, linewidth=4.0, color=color)\n i += 1\n for key, value in negative_weights_dict.items():\n color = cmap_negative(0.8*((j+1)/(5*1.2)+0.15))\n plt.plot(l2_list, value, '-', label=key, linewidth=4.0, color=color)\n j += 1\n \n plt.legend(loc='best', ncol=3, prop={'size':16}, columnspacing=0.5)\n plt.axis([1, 1e5, -1, 2])\n plt.title('Coefficient path')\n plt.xlabel('L2 penalty ($\\lambda$)')\n plt.ylabel('Coefficient value')\n plt.xscale('log')\n plt.rcParams.update({'font.size': 18})\n plt.tight_layout()","def plot_graph(self) -> None:","def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\n df_decomposed = df.loc[df['block'] == 'decomposed']\n df_joint = df.loc[df['block'] == 'joint']\n ticklabels = []\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\n for i in range(len(num_sweeps)):\n ticklabels.append('K=%d\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\n fig = plt.figure(figsize=(fs*2.5, fs))\n ax1 = fig.add_subplot(1, 2, 1)\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax1.set_xticks(num_sweeps)\n ax1.set_xticklabels(ticklabels)\n ax1.tick_params(labelsize=fontsize)\n ax1.grid(alpha=0.4)\n ax2 = fig.add_subplot(1, 2, 2)\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\{\\mu, \\tau\\}, \\{c\\}$')\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\{\\mu, \\tau, c\\}$')\n ax2.set_xticks(num_sweeps)\n ax2.set_xticklabels(ticklabels)\n ax2.tick_params(labelsize=fontsize)\n ax2.grid(alpha=0.4)\n ax2.legend(fontsize=fontsize)\n ax1.legend(fontsize=fontsize)\n ax1.set_ylabel(r'$\\log \\: p_\\theta(x, \\: z)$', fontsize=35)\n ax2.set_ylabel('ESS / L', fontsize=35)","def plot_price_evolution_for_nr_run(nr_log):\n plt.figure(figsize=(10, 5))\n\n plt.plot(nr_log['time'], nr_log['virtual_price'], '.', label='NR')\n\n plt.legend()\n\n plt.grid()\n\n plt.title('Network Relaxation run - Grid price evolution')\n\n plt.xlabel('time [s]')\n\n plt.ylabel('price [$]')\n\n plt.show()","def draw_costs_by_requests(costs, **kwargs):\n\n if 'title' in kwargs:\n title = kwargs['title']\n else:\n title = 'Monthy cost by number of reqs/s'\n data = []\n\n color = iter([\n BBVAcolors['light'],\n BBVAcolors['aqua'],\n BBVAcolors['navy'],\n BBVAcolors['coral']\n ])\n\n for flavor in costs.keys():\n x = list()\n y = list()\n for reqs, price in costs[flavor].items():\n x.append(reqs)\n y.append(price)\n\n trace = go.Scatter(\n x=x,\n y=y,\n name=flavor,\n marker=next(color)\n )\n data.append(trace)\n\n layout = go.Layout(\n title=title,\n legend=dict(\n orientation=\"h\",\n y=-.2,\n ),\n width=950,\n height=500,\n xaxis=dict(\n title='reqs/sec',\n type='log'\n ),\n yaxis=dict(\n title='Monthly cost ($)',\n type='log'\n )\n )\n\n return go.Figure(data=data, layout=layout)","def bench_plotter(self):\n\n # plot random as histogram, upper en lower bound as a red line\n minima = []\n for i in range(1, 4):\n cost_list = []\n with open(f\"../output_runs/text_info_random{i}_10k.txt\", \"r\") as f:\n text = f.read().split('\\n')\n counter = 0\n for number in text:\n counter += 1\n if number is not \"\":\n cost_list.append(int(number))\n if counter == 1000:\n break\n minim = min(cost_list)\n minima.append(minim)\n maxim = max(cost_list)\n print(\"random:\", minim, maxim)\n plt.axvline(x=53188, color='r')\n plt.axvline(x=103030, color=\"r\")\n plt.hist(cost_list, bins=20, alpha=0.5, label=f\"Random walk\")\n\n # plot histogram of priority and hillclimber\n cost_list = []\n with open(f\"../output_runs/text_info_prior_hill{i}_\\\n 1k.txt\", \"r\") as f:\n text = f.read().split('\\n')\n for number in text:\n if number is not \"\":\n cost_list.append(int(number))\n minim = min(cost_list)\n minima.append(minim)\n maxim = max(cost_list)\n print(\"prior hill:\", minim, maxim)\n plt.hist(cost_list, bins=20, alpha=0.5, label=f\"Priority + Hill\")\n\n # plot histogram of simulated annealing\n cost_list = []\n with open(f\"../output_runs/simulated_annealing{i}_1000.txt\",\n \"r\") as f:\n text = f.read().split('\\n')\n for number in text:\n if number is not \"\":\n cost_list.append(int(number))\n minim = min(cost_list)\n minima.append(minim)\n maxim = max(cost_list)\n print(\"random+anneal:\", minim, maxim)\n plt.hist(cost_list, bins=20, alpha=0.5,\n label=f\"Random + sim anneal\")\n\n # plot histogram of random plus hillclimber\n cost_list = []\n with open(f\"../output_runs/random_hill{i}_1000.txt\", \"r\") as f:\n text = f.read().split('\\n')\n for number in text:\n if number is not \"\":\n cost_list.append(int(number))\n minim = min(cost_list)\n minima.append(minim)\n maxim = max(cost_list)\n print(\"random+hill:\", minim, maxim)\n plt.hist(cost_list, bins=100, alpha=0.5,\n label=f\"Random + Hillclimber\")\n\n # plot histogram of kmeans plus hillclimber\n cost_list = []\n with open(f\"../output_runs/text_k-means_hill{i}_\\\n 1000.txt\", \"r\") as f:\n text = f.read().split('\\n')\n for number in text:\n if number is not \"\":\n cost_list.append(int(number))\n plt.hist(cost_list, bins=20, alpha=0.5,\n label=f\"Kmean and hill {i}\")\n totalmin = min(minima)\n plt.axvline(x=totalmin, color=\"g\")\n plt.title(f\"4 algorithms Wijk {i}, lowest cost: {totalmin}\")\n plt.xlabel(\"Cost\")\n plt.ylabel(\"Frequency\")\n plt.legend(loc='upper right')\n plt.show()","def plot_cost_history(alpha, cost_history):\n \n cost_df = pandas.DataFrame({\n 'Cost_History': cost_history,\n 'Iteration': range(len(cost_history))\n })\n \n return ggplot(cost_df, aes('Iteration', 'Cost_History')) + geom_point() + ggtitle('Cost History for alpha = %.3f' % alpha )","def plot_iterations(iters):\n axes = [plt.plot(lin.X, lin.Y, color='k', alpha=.15) for lin in iters]\n return axes","def plot_fig(dict_cycle, number):\n\n for i in range(number):\n print(i+1)\n data = data_frame(dict_cycle, i+1)\n plt.plot(data.Potential, data.Current, label=\"Cycle{}\".format(i+1))\n\n print(data.head())\n plt.xlabel('Voltage')\n plt.ylabel('Current')\n plt.legend()\n plt.savefig('cycle.png')\n print('executed')","def visualize(self, time, pred, true):\n plt.plot(time, true, label='Actual')\n plt.plot(time, pred, label='Predicted')\n plt.xlabel('Time')\n plt.ylabel('Price ($)')\n plt.legend(bbox_to_anchor=(0.1, 1), loc=2, borderaxespad=0.,\n prop={'size': 14})\n plt.show()","def visualize(dcf_prices, current_share_prices, regress = True):\n # TODO: implement\n return NotImplementedError","def plot_results(epochs: int = 20, segments: int = 5, plot: bool = True):\n \"\"\"\n plt.figure(0)\n plot_approximation(\"product\", modelSetProd, 1, epochs, gpus=0)\n \"\"\"\n\n data = [\n {\n \"title\": \"Piecewise Discontinuous Function Approximation\",\n \"layer\": \"discontinuous\",\n \"model_set\": modelSetD,\n },\n {\n \"title\": \"Piecewise Continuous Function Approximation\",\n \"layer\": \"continuous\",\n \"model_set\": modelSetC,\n },\n {\n \"title\": \"Polynomial function approximation\",\n \"layer\": \"polynomial\",\n \"model_set\": modelSetP,\n },\n {\n \"title\": \"Fourier function approximation\",\n \"layer\": \"fourier\",\n \"model_set\": modelSetF,\n },\n ]\n\n for index, element in enumerate(data):\n if plot is True:\n plt.figure(index)\n plot_approximation(\n element[\"layer\"],\n element[\"model_set\"],\n 5,\n epochs,\n accelerator=\"cpu\",\n periodicity=2,\n )\n\n if plot is True:\n plt.title(\"Piecewise Discontinuous Function Approximation\")\n\n if plot is True:\n plt.show()","def plot_loss_curve(num_epochs, losses):\n plt.xlabel('Epochs')\n plt.ylabel('Loss') \n plt.title('Loss Curve') \n plt.plot(range(num_epochs), losses)\n plt.show()","def updatePlot(self,cost):\r\n timer = time.clock() - self.start_timer\r\n # Add new values to plot data set \r\n self.lines.set_xdata(np.append(self.lines.get_xdata(), timer))\r\n self.lines.set_ydata(np.append(self.lines.get_ydata(), cost))\r\n # Re-scale\r\n self.axCost.relim()\r\n self.axCost.autoscale_view()\r\n # Update plot\r\n self.canvasPlot.draw()\r\n self.canvasPlot.flush_events()","def plot(self, epochs, title=\"Learning Rate Schedule\"):\n lrs = [self(i) for i in epochs]\n\n # plot the learning rate schedule\n plt.style.use(\"ggplot\")\n plt.figure()\n plt.plot(epochs, lrs)\n plt.title(title)\n plt.xlabel(\"Epoch #\")\n plt.ylabel(\"Learning Rate\")\n plt.close()","def plot_qlearning_smooth(reward_cache):\n mean_rev = (np.array(reward_cache[0:11]).sum())/10\n # initialize with cache mean\n cum_rewards = [mean_rev] * 10\n idx = 0\n for cache in reward_cache:\n cum_rewards[idx] = cache\n idx += 1\n smooth_reward = (np.array(cum_rewards).mean())\n cum_rewards.append(smooth_reward)\n if(idx == 10):\n idx = 0\n \n plt.plot(cum_rewards)\n plt.ylabel('Cumulative Rewards')\n plt.xlabel('Batches of Episodes (sample size 10) ')\n plt.title(\"Q-Learning Convergence of Cumulative Reward\")\n plt.legend(loc='lower left', ncol=2, mode=\"expand\", borderaxespad=0.)\n plt.show()","def _plot(self, rewards, losses, epsilons):\n plt.figure(figsize=(20,5))\n plt.subplot(131)\n plt.title('Episodic Reward')\n plt.plot(rewards)\n plt.subplot(132)\n plt.title('TD Loss')\n plt.plot(losses)\n plt.subplot(133)\n plt.title('Epsilon')\n plt.plot(epsilons)\n plt.tight_layout()\n plt.show()","def plot(self):\n\t\tplot_chain(self.database_path, self.temp_folder)\n\t\tplot_density(self.database_path, self.temp_folder, self.cal_params)","def plot(self):\n pass","def plot(self, iteration):\n plt.cla()\n self.plot_function()\n x = self._population[:,0]\n y = self._population[:,1]\n z = self._last_evaluation\n max_x, max_y = self._global_optimal_position\n max_z = self._global_optimal_value\n self._axes.scatter3D(x, y, z, c=\"r\")\n self._axes.scatter(max_x, max_y, max_z, marker=\"*\", s=500, c=\"b\")\n\n self._axes.set_xlabel(f\"x (best={max_x})\")\n self._axes.set_ylabel(f\"y (best={max_y})\")\n self._axes.set_zlabel(f\"z (best={max_z})\")\n self._axes.text(self._lower_bound, self._lower_bound, 1.5*max_z, f\"#Iteration {iteration}\")\n\n plt.gcf().canvas.mpl_connect(\"key_press_event\", self.key_press_handler)\n if self._wait_for_key:\n while not plt.waitforbuttonpress():\n pass\n else:\n plt.pause(0.5)","def visualize(self, network, f):\n import matplotlib\n matplotlib.use('Agg',warn=False)\n import matplotlib.pyplot as plt\n # Convert to a network if it is not.\n if not isinstance(network, NeuralNetwork):\n network = NeuralNetwork(network)\n \n fig = plt.figure()\n steps, states, actions = self._loop(network, max_steps=1000)\n # TEMP STUFF\n actions = np.array(actions)\n print((actions.size, np.histogram(actions)[0]))\n ##\n x, dx, theta, dtheta = list(zip(*states))\n theta = np.vstack(theta).T\n dtheta = np.vstack(dtheta).T\n # The top plot (cart position)\n top = fig.add_subplot(211)\n top.fill_between(list(range(len(x))), -self.h, self.h, facecolor='green', alpha=0.3)\n top.plot(x, label=r'$x$') \n top.plot(dx, label=r'$\\delta x$')\n top.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\n # The bottom plot (pole angles)\n bottom = fig.add_subplot(212)\n bottom.fill_between(list(range(theta.shape[1])), -self.r, self.r, facecolor='green', alpha=0.3)\n for i, (t, dt) in enumerate(zip(theta, dtheta)):\n bottom.plot(t, label=r'$\\theta_%d$'%i)\n bottom.plot(dt, ls='--', label=r'$\\delta \\theta_%d$'%i)\n bottom.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\n fig.savefig(f)","def quick_plot(solution):\n plt.suptitle('GNLSE solution')\n\n plt.subplot(1, 2, 1)\n plot_wavelength_vs_distance(solution)\n\n plt.subplot(1, 2, 2)\n plot_delay_vs_distance(solution)\n\n plt.show()","def plot(self) -> None:\n if self.__fig is None:\n self.__fig = plt.figure()\n\n xv = []\n yv = []\n for x in np.arange(self.state_min(), self.state_max(), self.state_step()):\n xv.append(x)\n yv.append(self.reward(x))\n ax = self.__fig.gca()\n ax.set_xlabel('X (State)')\n ax.set_ylabel('Y (Reward)')\n ax.set_title('Reward Function')\n ax.plot(xv, yv)\n plt.pause(self.__plot_pause)\n plt.show(block=False)\n return","def plot(self):\n\n fig, ax = plt.subplots()\n\n for run in self.runs:\n # Load datasets\n data_measure = run.get_dataset(\"stats-collect_link_congestion-raw-*.csv\")\n data_sp = run.get_dataset(\"stats-collect_link_congestion-sp-*.csv\")\n\n # Extract link congestion information\n data_measure = data_measure['msgs']\n data_sp = data_sp['msgs']\n\n # Compute ECDF and plot it\n ecdf_measure = sm.distributions.ECDF(data_measure)\n ecdf_sp = sm.distributions.ECDF(data_sp)\n\n variable_label = \"\"\n size = run.orig.settings.get('size', None)\n if size is not None:\n variable_label = \" (n=%d)\" % size\n\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\n label=\"U-Sphere%s\" % variable_label)\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\n label=u\"Klasični usmerjevalni protokol%s\" % variable_label)\n\n ax.set_xlabel('Obremenjenost povezave')\n ax.set_ylabel('Kumulativna verjetnost')\n ax.grid()\n ax.axis((28, None, 0.99, 1.0005))\n self.convert_axes_to_bw(ax)\n\n legend = ax.legend(loc='lower right')\n if self.settings.GRAPH_TRANSPARENCY:\n legend.get_frame().set_alpha(0.8)\n fig.savefig(self.get_figure_filename())","def plot_grating_coupler_sweep_efficiency(matlab_file_path, function=log):\n d = loadmat(matlab_file_path)\n print(d.keys())\n\n N = len(d[\"M_sweep\"][0])\n parameter = np.zeros(N)\n efficiency = np.zeros(N)\n\n for i in range(N):\n parameter[i] = 1e9 * d[\"M_sweep\"][0][i]\n # x = d[\"WL\"][0] * 1e9\n y = function(d[\"M_T\"][i])\n efficiency[i] = np.max(y)\n\n plt.figure()\n plt.xlabel(\"waveguide height (nm)\")\n plt.ylabel(\"Eficiency (dB)\")\n plt.plot(parameter, efficiency, \".\")\n plt.legend()","def show():\n\tplt.show()","def plot_progression(weights, bhs, bvs):\n\tweights_plot = []\n\tfor i in range(40):\n\t\tweights_plot.append(weights[i][0][0])\t# only plots the first value in the matrix every time\n\tplt.plot(weights_plot)\n\n\tplt.show()","def plot_associative_learning_progress(ax, df):\n\n num_objects_list = sorted(df.curr_num_objects.unique())\n legend_list = []\n for idx in num_objects_list:\n ax.plot(df[df.curr_num_objects == idx].groupby('objects_iter').rewards.mean())\n legend_list.append(f'ns={idx}')\n ax.set_xlabel('Stimulus iteration')\n ax.set_ylabel('P(correct)')\n ax.set_ylim([0.4, 1])\n ax.legend(legend_list)","def convergence():\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\n\n # label names\n label1 = str(league.lambda1)\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\n\n # point spread and point total subplots\n subplots = [\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\n (True, [200.5], league.totals, 'probability total > 200.5'),\n ]\n\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\n\n # train margin-dependent Elo model\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\n melo.fit(league.times, league.labels1, league.labels2, values)\n\n line = lines[-1]\n\n for label2 in label2_list:\n\n # evaluation times and labels\n times = np.arange(league.times.size)[::1000]\n labels1 = times.size * [label1]\n labels2 = times.size * [label2]\n\n # observed win probability\n prob = melo.probability(times, labels1, labels2, lines=line)\n ax.plot(times, prob)\n\n # true (analytic) win probability\n if ax.is_first_row():\n prob = skellam.sf(line, int(label1), int(label2))\n ax.axhline(prob, color='k')\n else:\n prob = poisson.sf(line, int(label1) + int(label2))\n ax.axhline(prob, color='k')\n\n # axes labels\n if ax.is_last_row():\n ax.set_xlabel('Iterations')\n ax.set_ylabel(ylabel)\n\n set_tight(w_pad=.5)","def plot_returns(self):\n strategy = self.equity_curve['equity_curve']\n benchmark, index = benchmark_return()\n fig, ax = plt.subplots()\n ax.plot(strategy.index.astype('datetime64'), strategy, label='strategy')\n ax.plot(benchmark.index.astype('datetime64'), benchmark, label=index)\n ax.plot(benchmark.index.astype('datetime64'), (1+strategy-benchmark),\n label='excess earnings', linestyle='--', linewidth=0.5)\n ax.grid(True)\n\n plt.xlabel('Year-Month')\n plt.ylabel('Return (%)')\n plt.title('Equity curve')\n plt.legend()","def samplecost(app, endclasses, fxnmode, samptype='std', title=\"\"):\n associated_scens=[]\n for phase in app.phases:\n associated_scens = associated_scens + app.scenids.get((fxnmode, phase), [])\n costs = np.array([endclasses[scen]['cost'] for scen in associated_scens])\n times = np.array([time for phase, timemodes in app.sampletimes.items() if timemodes for time in timemodes if fxnmode in timemodes.get(time)] ) \n rates = np.array(list(app.rates_timeless[fxnmode].values()))\n \n tPlot, axes = plt.subplots(2, 1, sharey=False, gridspec_kw={'height_ratios': [3, 1]})\n phasetimes_start =[times[0] for phase, times in app.phases.items()]\n phasetimes_end =[times[1] for phase, times in app.phases.items()]\n ratetimes =[]\n ratesvect =[]\n phaselocs = []\n for (ind, phasetime) in enumerate(phasetimes_start):\n axes[0].axvline(phasetime, color=\"black\") \n phaselocs= phaselocs +[(phasetimes_end[ind]-phasetimes_start[ind])/2 + phasetimes_start[ind]]\n\n axes[1].axvline(phasetime, color=\"black\") \n ratetimes = ratetimes + [phasetimes_start[ind]] + [phasetimes_end[ind]]\n ratesvect = ratesvect + [rates[ind]] + [rates[ind]]\n #axes[1].text(middletime, 0.5*max(rates), list(app.phases.keys())[ind], ha='center', backgroundcolor=\"white\")\n #rate plots\n axes[1].set_xticks(phaselocs)\n axes[1].set_xticklabels(list(app.phases.keys()))\n \n axes[1].plot(ratetimes, ratesvect)\n axes[1].set_xlim(phasetimes_start[0], phasetimes_end[-1])\n axes[1].set_ylim(0, np.max(ratesvect)*1.2 )\n axes[1].set_ylabel(\"Rate\")\n axes[1].set_xlabel(\"Time (\"+str(app.units)+\")\")\n axes[1].grid()\n #cost plots\n axes[0].set_xlim(phasetimes_start[0], phasetimes_end[-1])\n axes[0].set_ylim(0, 1.2*np.max(costs))\n if samptype=='fullint':\n axes[0].plot(times, costs, label=\"cost\")\n else:\n if samptype=='quadrature' or samptype=='pruned piecewise-linear': \n sizes = 1000*np.array([weight if weight !=1/len(timeweights) else 0.0 for phase, timeweights in app.weights[fxnmode].items() for time, weight in timeweights.items() if time in times])\n axes[0].scatter(times, costs,s=sizes, label=\"cost\", alpha=0.5)\n axes[0].stem(times, costs, label=\"cost\", markerfmt=\",\", use_line_collection=True)\n \n axes[0].set_ylabel(\"Cost\")\n axes[0].grid()\n if title: axes[0].set_title(title)\n elif type(fxnmode[0])==tuple: axes[0].set_title(\"Cost function of \"+str(fxnmode)+\" over time\")\n else: axes[0].set_title(\"Cost function of \"+fxnmode[0]+\": \"+fxnmode[1]+\" over time\")\n #plt.subplot_adjust()\n plt.tight_layout()","def plot_running_time():\n global counter\n counter += 1\n running_time_targeted = []\n running_time_fast_targeted = []\n \n for node_number in range(10, 1000, 10):\n synthetic_undirected_graph = make_synthetic_undirected_graph(node_number, 5)\n\n start_time = time.time()\n attack_order = targeted_order(synthetic_undirected_graph)\n stop_time = time.time()\n running_time_targeted.append(stop_time - start_time)\n \n start_time = time.time()\n attack_order = fast_targeted_order(synthetic_undirected_graph)\n stop_time = time.time()\n running_time_fast_targeted.append(stop_time - start_time)\n \n plt.plot(range(10, 1000, 10), running_time_targeted, '-b', label = 'targeted_order')\n plt.plot(range(10, 1000, 10), running_time_fast_targeted, '-r', label = 'fast_targeted_order')\n \n plt.legend(loc='upper right')\n\n\n plt.title(\" plot of running time of desktop Python\")\n plt.xlabel(\"the number of nodes\")\n plt.ylabel(\"running times\")\n plt.savefig(\"running_time_\"+str(counter)+\".png\", dpi = 72)\n plt.gcf().clear() # hose-keeping","def geneticAlgorithmPlot(population, popSize, fittestSize, mutationRate, generations):\n pop = GA.initialPopulation(popSize, population)\n progress = []\n progress.append(1 / GA.rankRoutes(pop)[0][1])\n \n for i in range(0, generations):\n pop = GA.nextGeneration(pop, fittestSize, mutationRate)\n progress.append(1 / GA.rankRoutes(pop)[0][1])\n \n plt.plot(progress)\n plt.ylabel('Distance')\n plt.xlabel('Generation')\n plt.show()","def plot_resiliences(nodes, network_vals, er_vals, upa_vals):\n node_vals = range(0, nodes)\n\n plt.plot(node_vals, network_vals, '-b', label='Network')\n plt.plot(node_vals, er_vals, '-r', label='ER')\n plt.plot(node_vals, upa_vals, '-g', label='UPA')\n\n plt.legend(loc='upper right')\n plt.ylabel('Size of Largest Connected Component')\n plt.xlabel('Number of Nodes Removed')\n plt.grid(True)\n plt.title('Comparison of Graph Resilience\\nMeasured by Largest Connected Component vs Nodes Removed by Target Attack\\n')\n plt.show()","def _plot(self):\n\n #self.best_canvas.Clear()\n self.current_canvas.Clear()\n\n if len(self.results) > 0:\n x_max = self.results[-1][2]\n #self.best_canvas.xSpec = (0, x_max)\n self.current_canvas.xSpec = (0, x_max)\n\n # best_points = [(r.time, r.best.distance) for r in self.results\n # if r.best is not None and\n # isinstance(r.best.distance, int)]\n # best_line = PolyLine(best_points)\n # best_plot = PlotGraphics([best_line],\n # title='Best path distance over time',\n # xLabel='Time [ns]', yLabel='Distance')\n\n current_points = [self.TopLevelParent.solver_view.tsp_view._points[x] for x in self.results[-1][0]] if len(self.results) > 0 else []\n # current_points = [(r[2], r[0]) for r in self.results]\n if len(current_points) > 0:\n current_line = PolyLine(current_points)\n current_plot = PlotGraphics([current_line],\n title='Current path distance over time',\n xLabel='Iter', yLabel='Score')\n\n #self.best_canvas.Draw(best_plot)\n self.current_canvas.Draw(current_plot)","def plotEvaluation(results,nbr_file : int,path : str, labels = [\"\"],target_name = \"\"):\n fig,ax = plt.subplots(1,1)\n ax.set_yscale(\"log\")\n for res in range(len(results)):\n data = [np.array(p[1]) for p in results[res]]\n number_of_simulation = len(data)\n\n average_values = np.zeros(len(data[0]))\n for d in data:\n average_values =average_values + d\n average_values = np.array(average_values) / number_of_simulation\n \n error_values = [0 for i in range(len(average_values))]\n for j in range(len(error_values)):\n if j%int(len(error_values)/50)==0 :\n for i in range(len(data)):\n error_values[j] += (data[i][j] - average_values[j])**2\n error_values[j] = np.sqrt(error_values[j]/number_of_simulation)\n opt = 0\n tfile = ''\n if path == 'data/B/b':\n opt = B_opts[nbr_file-1]\n tfile = 'b'\n else:\n opt = C_opts[nbr_file-1]\n tfile = 'c'\n \n \n ax.errorbar(range(len(average_values)),average_values,yerr = error_values, ecolor = \"black\", linewidth = 1, elinewidth = 1, label = labels[res])\n \n \n #ax.ylim((opt-5,max(opt*2,average_values[-1]+10)))\n plt.title(f'{target_name} : The evolution of the best evaluation (in average) \\nfor graph {tfile}{nbr_file}.stp for {number_of_simulation} simulations')\n plt.xlabel(\"steps\")\n plt.ylabel(\"evaluation\")\n ax.legend()\n ax.axhline(opt, color='red', label = \"Optimal solution\")\n plt.savefig(f'best_{tfile}{nbr_file}_evaluation_{target_name}.png')\n plt.show()","def do_plot(self):\n years = sorted(set(self.prediction_df_without_covid19['Year']))\n predict_without_covid_country = self.prediction_df_without_covid19[\n self.prediction_df_without_covid19['Country'].isin([self.country])].sort_values(['Year'],\n ascending=[True])\n predict_with_covid_country = self.prediction_df_with_covid19[\n self.prediction_df_with_covid19['Country'].isin([self.country])].sort_values(['Year'],\n ascending=[True])\n # ------------------------------------------------------------------------------------------------------\n pa = \\\n predict_without_covid_country.loc[predict_without_covid_country['Year'] == 1990][\n 'Total_CO2_Emissions'].values[\n 0]\n x = []\n for i in range(len(years)):\n x.append(pa * 0.6)\n # ------------------------------------------------------------------------------------------------------\n fig = Figure()\n ax = fig.subplots()\n ax.grid(True, alpha=0.3)\n # plot_title = 'Total CO2 Emissions predicted from 2019-2030 for ' + self.country\n plot_title = 'Total ' + '$CO_2$' + ' Emissions predicted from 2019-2030 for ' + self.country\n label_country_without_covid = 'Total CO2 emissions without covid'\n label_country_with_covid = 'Total CO2 emissions with Covid-19'\n # ------------------------------------------------------------------------------------------------------\n params = {'mathtext.default': 'regular'}\n rcParams.update(params)\n rcParams['font.size'] = 7\n rcParams['lines.markersize'] = 4\n rcParams['figure.figsize'] = [7, 4]\n rcParams['figure.dpi'] = 150\n rcParams['font.family'] = 'Verdana'\n rcParams[\"font.weight\"] = \"normal\"\n font = {'family': 'Verdana',\n 'color': 'xkcd:darkgreen',\n 'weight': 'normal',\n 'size': 9,\n }\n colors = rcParams['axes.prop_cycle'].by_key()['color']\n l1, = ax.plot(years, predict_without_covid_country['Total_CO2_Emissions'], color='xkcd:dark blue green',\n marker='o',\n label=label_country_without_covid)\n l2, = ax.plot(years, predict_with_covid_country['Total_CO2_Emissions'], color='xkcd:neon pink', marker='.',\n label=label_country_with_covid)\n l3, = ax.plot(years, x, color='xkcd:orchid', marker='1')\n print('without covid: ', predict_without_covid_country['Total_CO2_Emissions'].values)\n print('with covid: ', predict_with_covid_country['Total_CO2_Emissions'].values)\n ax.set_xlabel('Years', fontdict=font)\n ax.set_ylabel('Emissions (Gg)', fontdict=font)\n ax.set_title(plot_title, fontsize=12, fontweight='normal')\n ax.patch.set_facecolor('xkcd:green')\n ax.set_facecolor('xkcd:pale green')\n fig.legend((l1, l2, l3), ('Prediction without Covid19', 'Prediction with Covid19', 'Paris Agreement'),\n bbox_to_anchor=(0.907, 0.89))\n fig.savefig(OUTPUT_GRAPH_PATH)","def plot(self):\n \n \n x_ibs=[] \n x_gss=[]\n y_ibs=[] \n y_gss=[]\n x_pso=[]\n x_bgd=[]\n y_bgd=[]\n y_pso=[]\n x_gd=[]\n y_gd=[]\n \n i=0.0000001\n \n # for k in range(1,51):\n # i= random.uniform(0.00000001, 1)\n # t_avg_ibs=[]\n # t_avg_gss=[]\n # for j in range(1,51):\n #L=random.randint(-100, 0)\n #U=random.randint(0, 100)\n max_iter=self.Max_iter \n L=self.Lower_bound\n U=self.Upper_bound\n \n minima=self.gss(L,U,i,1000)\n #print(\"minima at X = \",minima[1])\n x_ibs.append(self.I_bisection(L,U,minima[1],max_iter)[0])\n x_gss.append(self.gss(L,U,i,max_iter)[0])\n x_pso.append(self.particle_Swarm(self.func, L, U, 2, max_iter)[0])\n x_gd.append(self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)[0])\n x_bgd.append(self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)[0])\n #print(x_pso)\n for i in x_ibs[0]:\n #print(self.Func(i)) \n y_ibs.append(self.Func(i))\n for i in x_gss[0]:\n y_gss.append(self.Func(i)) \n for i in x_pso[0]:\n y_pso.append(self.Func(i)) \n for i in x_gd[0]:\n y_gd.append(self.Func(i)) \n for i in x_bgd[0]:\n y_bgd.append(self.Func(i)) \n #print(y_gss)\n\n plt.plot(x_ibs[0], y_ibs, 'r.')\n plt.plot(x_gss[0], y_gss, '.')\n plt.plot(x_pso[0], y_pso, 'y.')\n #plt.plot(x_gd[0], y_gd, 'y.')\n #plt.plot(x_bgd[0], y_bgd, 'k.')\n plt.xlabel('x')\n plt.ylabel('y')\n \n plt.suptitle('Interval Bisection Search (Red) vs Golden Section Search (Blue) vs Particle swarm optimization (Green)')\n #plt.axis([0, 100, 0.00000001, 1]) \n plt.show()\n plt.plot(x_gd[0], y_gd, 'r.')\n plt.plot(x_bgd[0], y_bgd, 'k.')\n plt.xlabel('x')\n plt.ylabel('y') \n plt.suptitle('Gradient Descent (Red) vs Batch Gradient Descent (Black) ')\n \n plt.show()\n \n start_time = timeit.default_timer()\n ibs=self.I_bisection(L,U,minima[1],max_iter)\n print(\" Execution time for Interval bisection Method is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n gss=self.gss(L,U,i,max_iter)\n print(\" Execution time for Golden Section Search is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n pso=self.particle_Swarm(self.func, L, U, 2, max_iter)\n print(\" Execution time for Particle swarm optimization is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n gd=self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)\n print(\" Execution time for Gradient Descent is\", timeit.default_timer() - start_time,\"s\")\n start_time = timeit.default_timer()\n bgd=self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)\n print(\" Execution time for Batch Gradient Descent is\", timeit.default_timer() - start_time,\"s\")\n plt.plot(ibs[1], ibs[2], 'r.')\n plt.text(ibs[1], ibs[2],\"IB\")\n plt.plot(gss[1], gss[2], '.')\n plt.text(gss[1], gss[2],\" GSS\")\n plt.plot(pso[1], pso[2], 'y.')\n plt.text(pso[1], pso[2],\" PSO\")\n plt.plot(gd[1], gd[2], 'g.')\n plt.text(gd[1], gd[2],\" GD \")\n plt.plot(bgd[1],bgd[2], 'k.')\n plt.text(bgd[1], bgd[2],\" Batch_GD\")\n \n plt.xlabel('Value of X')\n plt.ylabel('NUmber of iteration') \n plt.suptitle('Number of iterations vs minimum value of x')\n \n plt.show()","def plot_number_steps(step_cache_qlearning, step_cache_SARSA): \n cum_step_q = []\n steps_mean = np.array(step_cache_qlearning).mean()\n steps_std = np.array(step_cache_qlearning).std()\n count = 0 # used to determine the batches\n cur_step = 0 # accumulate reward for the batch\n for cache in step_cache_qlearning:\n count = count + 1\n cur_step += cache\n if(count == 10):\n # normalize the sample\n normalized_step = (cur_step - steps_mean)/steps_std\n cum_step_q.append(normalized_step)\n cur_step = 0\n count = 0\n \n cum_step_SARSA = []\n steps_mean = np.array(step_cache_SARSA).mean()\n steps_std = np.array(step_cache_SARSA).std()\n count = 0 # used to determine the batches\n cur_step = 0 # accumulate reward for the batch\n for cache in step_cache_SARSA:\n count = count + 1\n cur_step += cache\n if(count == 10):\n # normalize the sample\n normalized_step = (cur_step - steps_mean)/steps_std\n cum_step_SARSA.append(normalized_step)\n cur_step = 0\n count = 0 \n # prepare the graph \n plt.plot(cum_step_q, label = \"q_learning\")\n plt.plot(cum_step_SARSA, label = \"SARSA\")\n plt.ylabel('Number of iterations')\n plt.xlabel('Batches of Episodes (sample size 10) ')\n plt.title(\"Q-Learning/SARSA Iteration number untill game ends\")\n plt.legend(loc='lower right', ncol=2, mode=\"expand\", borderaxespad=0.)\n plt.show()\n plt.savefig('number_steps.png')","def plot_energies(self):\n plt.plot(self.energies[0], self.energies[1])\n plt.xlabel('Time (s)')\n plt.ylabel('Energy (J)')\n plt.show()","def plot_cost_history(alpha, cost_history):\n cost_df = pandas.DataFrame({\n 'Cost_History': cost_history,\n 'Iteration': range(len(cost_history))\n })\n return ggplot(cost_df, aes('Iteration', 'Cost_History')) + \\\n geom_point() + ggtitle('Cost History for alpha = %.3f' % alpha)","def showPlot2():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on number of robots')\n xlabel('number of robots (tiles)')\n ylabel('mean time (clocks)')\n show()","def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \n MC_runs, price_tree):\n x_values = []\n pi_M = []\n pi_M_RMSE = []\n for i in range(1,MC_runs,1):\n Mi=M*i\n x_values.append([Mi])\n paths = sample_paths(S0, N, u, d, q, Mi)\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \n barrier_type, option)\n if option == 'Call':\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\n elif option == 'Put':\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\n payoffs = list(payoffs)\n while len(payoffs) < Mi:\n payoffs.append([0])\n mean_payoff = np.mean(payoffs)[0]\n pi_M.append(mean_payoff)\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\n pi_M_RMSE.append(RMSE[0])\n \n # plotting\n plt.figure(figsize=(8,6))\n plt.subplot(2, 1, 1)\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, pi_M, 'o', label='price via MC')\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \n label='price via tree')\n plt.legend()\n plt.title('Monte Carlo price, for increasing number of paths')\n plt.ylabel('Expected Value')\n #The following will plot the root mean square error\n plt.subplot(2, 1, 2)\n plt.plot(x_values, pi_M_RMSE, '-')\n plt.xlabel('number of paths')\n plt.ylabel('Root Mean Square Error')\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\n plt.show()","def throughputLinePlot(self):\n\t\tplot(self.window_size, self.throughput, label = \"Throughput vs Window Size\")\n\t\txticks(self.window_size)\n\t\txlim(0, 21)\n\t\txlabel('Window Size (No. of Packets)')\n\t\tylabel('Throughput in Mbps')\n\t\tlegend(loc=0)\n\t\tsavefig('ThroughputLinePlot.png')","def plot_residual_vs_cpu_for_each_iteration(self,\n idx=None,\n trajectory=None,\n legend=True):\n fig, ax = plt.subplots()\n ax.set_title('Residuals of last {} steps'.format(self.p.tasks))\n ax.set_xlabel('CPU Number')\n ax.set_ylabel('Residual')\n # ax.set_ylim(bottom=1e-20)\n\n if idx is None and trajectory is None:\n trajectory = self.get_final_block(idx=0)\n elif idx:\n trajectory = self.get_final_block(idx=idx)\n else:\n trajectory = self.get_final_block(idx=0)\n\n for iteration in range(self.p.iterations):\n try:\n trajectory[(trajectory['iter'] == iteration + 1) & (trajectory[\n 'level'] == self.p.levels)].plot(\n 'rank',\n 'residual',\n logy=True,\n label='iter{}'.format(iteration + 1),\n marker='o',\n ax=ax)\n except:\n pass\n\n if not legend:\n ax.legend_.remove()\n\n return fig, ax","def plot_runtimes(num_clusters_range):\n scp_times = []\n fcp_times = []\n\n for num in range(num_clusters_range[0], num_clusters_range[1]+1):\n result = compute_runtimes(num)\n scp_times.append(result[0])\n fcp_times.append(result[1])\n\n print \"\\n\\nscp_times:\", scp_times\n print \"fcp_times:\", fcp_times\n\n # plot n(x) vs time (y) on a standard plot\n xvals = range(num_clusters_range[0], num_clusters_range[1]+1)\n yvals1 = scp_times\n yvals2 = fcp_times\n\n plt.plot(xvals, yvals1, '-b', label='slow_closest_pair')\n plt.plot(xvals, yvals2, '-r', label='fast_closest_pair')\n plt.xlabel('number of initial clusters')\n plt.ylabel('run time (seconds)')\n plt.legend(loc='upper right')\n plt.show()","def plotTotal(self, phys, forces, step): \r\n self.plotQuantity(step, forces.energies.potentialEnergy(phys)+TopologyUtilities.kineticEnergy(phys.myTop, phys.velvec), 'totalenergy')","def plot(self, fname=None):\n x = np.linspace(self.bounds[0], self.bounds[-1], 200)\n y = [self.evaluate(xi) for xi in x]\n plt.figure()\n plt.plot(x, y, label='Class func')\n plt.plot(self.bounds, self.gis, 'o', label='Algorithm')\n plt.grid(color='0.7')\n plt.xlabel('Dependent Variable')\n plt.ylabel('PP Transformed Class Value')\n if fname:\n plt.savefig(fname)\n else:\n plt.show()","def plot_loss(loss_values_dict, save_name):\n fig, ax = plt.subplots(figsize=(10, 10))\n # Add each method to the plot\n for (method_name, loss_val_array) in loss_values_dict.items():\n print(method_name, len(loss_val_array))\n ax.plot(range(len(loss_val_array)), loss_val_array, label=method_name)\n ax.legend(loc='upper right')\n plt.xlabel('iteration')\n plt.ylabel('loss')\n plt.title('Grad Descent in Hyperbolic Space')\n plt.savefig(save_name)","def plot_residual_vs_iteration_for_each_cpu(self,\n idx=0,\n trajectory=None,\n legend=True):\n fig, ax = plt.subplots()\n ax.set_title('Residuals of last {} steps'.format(self.p.tasks))\n ax.set_xlabel('Iteration Number')\n ax.set_ylabel('Residual')\n # ax.set_ylim(bottom=1e-20)\n\n if idx is None and trajectory is None:\n trajectory = self.get_final_block(idx=0)\n elif idx:\n trajectory = self.get_final_block(idx=idx)\n else:\n trajectory = self.get_final_block(idx=0)\n\n for cpu in range(self.p.tasks):\n try:\n trajectory[(trajectory['rank'] == cpu) & (trajectory[\n 'level'] == self.p.levels)].plot(\n 'iter',\n 'residual',\n logy=True,\n label='cpu{}'.format(cpu),\n marker='o',\n ax=ax)\n except:\n pass\n\n if not legend:\n ax.legend_.remove()\n\n return fig, ax","def visualize(self):\n import matplotlib.pyplot as plt\n import numpy as np\n\n plt.figure()\n sw_ = np.linspace(0.0, 1.0, 50)\n plt.plot(sw_, self.krw(sw_), label=\"Water\")\n plt.plot(sw_, self.kro(sw_), label=\"Oil\")\n plt.xlabel(\"Water saturation\")\n plt.ylabel(\"Relative permeability\")\n plt.legend()","def plot(self, iteration=None, stateVectorConv=None): \n r = [\"{0}\".format(self.__class__.__name__)]\n if iteration is not None:\n r.append(\"i: {0}\".format(iteration))\n fmt = lambda a : \", \".join([\"{0:.4g}\".format(float(v)) for v in a])\n r.append(\"stateVector: {0}\".format(fmt(self.stateVector)))\n if stateVectorConv is not None:\n r.append(\"stateVectorConv: {0:.4g}\".format(stateVectorConv))\n \n s = \"; \".join(r)\n \n if iteration is not None and self.verbose > 0:\n print(s)\n \n if self.verbose > 4:\n nplot = 2 + len(self.stateVector)\n fig = pyplot.figure()\n fig.subplots_adjust(left=0.17, bottom=0.09, right=0.98, \n top=0.92, wspace=0.12, hspace=0.2)\n ax = fig.add_subplot(nplot,1,1)\n ax.set_title(s)\n ax.set_ylabel(\"$R [sr^{-1}]$\")\n ax.plot(self.independentVariable, self.observation, 'k', \n label='measurement')\n ax.plot(self.independentVariable, self.modelCalculation, 'r', \n label='model')\n ax.legend(loc='lower right')\n \n l = fig.add_subplot(nplot,1,2)\n l.plot(self.independentVariable, \n (self.observation-self.modelCalculation)/self.observationError, \n 'k', label=\"err\")\n l.set_ylabel(\"$\\Delta R/\\sigma$\")\n \n color = ['k-', 'r-', 'b-', 'g-', 'k--', 'r--', 'b--', 'g--', 'k-.', \n 'r-.', 'b-.', 'g-.', 'k:', 'r:', 'b:', 'g:']\n for i in range(len(self.stateVector)):\n name = self.parameterNames[i]\n k = fig.add_subplot(nplot,1,3+i)\n k.plot(self.independentVariable, self.Jacobian[:, i], 'k')\n k.set_ylabel(r\"$\\partial R/\\partial ({0})$\".format(name.replace(\"_\", \" \")))\n \n k.set_xlabel(\"$\\lambda [nm]$\")\n \n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n \n if self.verbose > 1:\n fig.show()\n else:\n fig.savefig(\"{0}_{1}_{2}.pdf\".format(r[0], \n r[1].split()[1][:-1], \n (\"{0:02d}\".format(iteration) \n if iteration is not None \n else \"final\")), transparent=True)","def plot_curve(epochs, hist, list_of_metrics): \n # list_of_metrics should be one of the names shown in:\n # https://www.tensorflow.org/tutorials/structured_data/imbalanced_data#define_the_model_and_metrics \n\n plt.figure()\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Value\")\n\n for m in list_of_metrics:\n x = hist[m]\n plt.plot(epochs[1:], x[1:], label=m)\n\n plt.legend()","def plot_graph(error_rates, avg_hits):\n plt.xlabel(\"Error rates (σ)\")\n plt.ylabel(\"Average pins hit\")\n plt.plot(error_rates, avg_hits)\n plt.show()","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def show_learning_curve(self):\n\n # Loop output classes\n for c in range(1,self.n_output_classes):\n # Get data\n x_values = np.array(self.n_class_samples_list[c])\n accuracy = np.array(self.accuracy_list[c])\n precision = np.array(self.precision_list[c])\n recall = np.array(self.recall_list[c])\n F1 = np.array(self.F1_list[c])\n\n # Make plot\n with sns.axes_style(\"ticks\"):\n fig,ax = plt.subplots()\n plt.plot([np.min(x_values),np.max(x_values)],[0.5,0.5],\n color='#777777',linestyle='--')\n plt.plot([np.min(x_values),np.max(x_values)],[0.66,0.66],\n color='#777777',linestyle=':')\n plt.plot([np.min(x_values),np.max(x_values)],[0.8,0.8],\n color='#777777',linestyle=':')\n plt.plot([np.min(x_values),np.max(x_values)],[0.9,0.9],\n color='#777777',linestyle=':')\n\n plt.plot( x_values, accuracy, color='#000000',\n linewidth=1, label='Accuracy' )\n plt.plot( x_values, precision, color='#0000aa',\n linewidth=1, label='Precision' )\n plt.plot( x_values, recall, color='#00aa00',\n linewidth=1, label='Recall' )\n plt.plot( x_values, F1, color='#aa0000',\n linewidth=2, label='F1' )\n\n plt.yticks( [0, 0.5, 0.66, 0.8, 0.9, 1.0],\n ['0','0.5','0.66','0.8','0.9','1.0'], ha='right' )\n plt.xlim(np.max(x_values)*-0.02,np.max(x_values)*1.02)\n plt.ylim(-0.02,1.02)\n plt.xlabel('Number of training samples')\n plt.ylabel('Performance')\n plt.title('Learning curve, class {}'.format(c))\n sns.despine(ax=ax, offset=0, trim=True)\n lgnd = plt.legend(loc=4, ncol=1, frameon=True, fontsize=9)\n lgnd.get_frame().set_facecolor('#ffffff')\n ax.spines['left'].set_bounds(0,1)\n ax.spines['bottom'].set_bounds(np.min(x_values),np.max(x_values))","def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option,\n MC_runs, price_tree):\n x_values = []\n pi_M = []\n pi_M_RMSE = []\n for i in range(1, MC_runs, 1):\n Mi = M * i\n x_values.append([Mi])\n paths = sample_paths(S0, N, u, d, q, Mi)\n p_valid, p_invalid, p_counts = split_paths(paths, B, K,\n barrier_type, option)\n if option == 'Call':\n payoffs = np.maximum(0, p_counts[:, -1] - K) * np.exp(-1 * r * T)\n elif option == 'Put':\n payoffs = np.maximum(0, K - p_counts[:, -1]) * np.exp(-1 * r * T)\n payoffs = list(payoffs)\n while len(payoffs) < Mi:\n payoffs.append([0])\n mean_payoff = np.mean(payoffs)[0]\n pi_M.append(mean_payoff)\n RMSE = np.sqrt(np.var(payoffs, ddof=1)) / np.sqrt(Mi)\n pi_M_RMSE.append(RMSE[0])\n\n # plotting\n plt.figure(figsize=(8, 6))\n plt.subplot(2, 1, 1)\n plt.plot(x_values, price_tree - 1.96 * np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, price_tree + 1.96 * np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, pi_M, 'o', label='price via MC')\n plt.plot(x_values, [price_tree] * len(x_values), '-', lw=3,\n label='price via tree')\n plt.legend()\n plt.title('Monte Carlo price, for increasing number of paths')\n plt.ylabel('Expected Value')\n # The following will plot the root mean square error\n plt.subplot(2, 1, 2)\n plt.plot(x_values, pi_M_RMSE, '-')\n plt.xlabel('number of paths')\n plt.ylabel('Root Mean Square Error')\n # plt.savefig('MonteCarlo_variation.png', transparent=True)\n plt.show()","def visualize(self):\r\n self.aggregator.plot_loss()\r\n self.save_figure()","def graph(self):\n seq_obj = MultiSequence(self.symbol, self.__best_model.window_size,1)\n test_predict = self.__best_model.model.predict(seq_obj.X)\n\n #our data is scaled between -1 and 1 so lets scale it back up\n scaler = MinMaxScaler(feature_range=(self.__min_price ,self.__max_price))\n orig_data = seq_obj.original_data.reshape(-1,1)\n orig_prices = scaler.fit_transform(orig_data).flatten()\n \n # plot actual prices\n plt.plot(orig_prices, color='k')\n \n # plot test set prediction after scaling back up\n length = len(seq_obj.X) + self.__best_model.window_size \n test_in = np.arange(self.__best_model.window_size,length,1)\n pred_prices = scaler.fit_transform(test_predict.reshape(-1,1)).flatten()\n plt.plot(test_in,pred_prices,color = 'b')\n \n # pretty up graph\n plt.xlabel('day')\n plt.ylabel('Closing price of stock')\n plt.title(\"Price prediction for {}\".format(self.symbol))\n plt.legend(['Actual','Prediction'],loc='center left', bbox_to_anchor=(1, 0.5))\n plt.show()","def plot(self):\n self.plotsite()\n self.plotbond()\n plt.show()","def plot_loss(self):\n #x = [k for k in range(self.rep)]\n loss = self.min_list[:,0]//100 #For clarity\n #plt.plot(x,self.min_list[:,0])\n plt.hist(loss,density=True)\n plt.xlabel(self.list_name + '_loss//100')\n plt.ylabel('Frequency')\n #plt.xticks(range(8),[0,250,500,750,1000,1250,1500,1750])\n plt.title('Distribution of '+self.list_name+'_loss ('+str(self.rep)+' iterations)')\n plt.savefig('img/stats/'+self.list_name+'_lossFrequency_'+self.model_name+'.png')\n plt.show()","def plot_schedulability_rates_fairgen():\n modes = [\n # name, color, linestyle, marker\n ('dSMC', 'blue', 'dashed', 'o'),\n ('dAMC', 'red', 'dashed', 'd'),\n ('EDF-VD', 'green', 'dashed', 's'),\n ('pSMC', 'orange', 'dashed', '^'),\n ('pAMC-BB', 'magenta', 'dashed', 'D'),\n ('pAMC-BB+', 'purple', 'dashed', 'v')\n ]\n\n task_sets_list = pickle.load(open(task_sets_path + 'task_sets_fairgen', 'rb'))\n rates = {}\n fig = plt.figure(figsize=(12, 6), dpi=300)\n fig.suptitle('Evaluation: MC-Fairgen (n=%d)' % len(task_sets_list[0]))\n ax1 = fig.add_subplot(111)\n for name, color, linestyle, marker in modes:\n rates[name] = pickle.load(open(eval_fairgen_path + name, 'rb'))\n ax1.plot(utils, rates[name], label=name, color=color, linestyle=linestyle, marker=marker)\n ax1.set_xlabel('LO mode utilization')\n ax1.set_ylabel('Percentage of task sets schedulable')\n ax1.set_xticks([k * 0.5 for k in range(5)])\n ax1.set_yticks([k * 20 for k in range(6)])\n ax1.xaxis.set_minor_locator(ticker.AutoMinorLocator(5))\n ax1.yaxis.set_minor_locator(ticker.AutoMinorLocator(1))\n ax1.minorticks_on()\n ax1.grid(which='both', linestyle='dashed')\n\n # Plot average system util:\n avg_utils = []\n for i, _ in enumerate(utils):\n avg_utils.append(np.average([task_set.u_avg for task_set in task_sets_list[i]]))\n ax2 = ax1.twinx()\n ax2.plot(utils, avg_utils, label='Avg Sys Util (right scale)', color='black', linestyle='dashed',\n marker=None)\n ylim = ax1.get_ylim()\n ax2.set_ylim(ylim[0] / 100, ylim[1] / 100)\n ax2.set_ylabel('U(Avg)')\n\n plt.axvline(1.0, color='black', linewidth=0.8)\n lines1, labels1 = ax1.get_legend_handles_labels()\n lines2, labels2 = ax2.get_legend_handles_labels()\n plt.xlim(0.1, 2.1)\n plt.legend(lines1 + lines2, labels1 + labels2, loc='upper right')\n plt.savefig('./figures/schedulability_rates_fairgen.png')\n # plt.show()","def plot(self):\n\t\tself.plotOfLoopVoltage()","def plot_history(self, filename):\r\n plt.figure(figsize=(12, 9))\r\n plt.plot(self.Objective_value)\r\n plt.xlabel('Iteration')\r\n plt.ylabel('Value')\r\n plt.title('Objective Function Values')\r\n # plt.savefig(filename)\r\n plt.show()\r\n return","def plot(self):\n\n try:\n import matplotlib.pyplot as plt\n except ImportError:\n from sys import stderr\n print(\"ERROR: matplotlib.pyplot not found, matplotlib must be installed to use this function\", file=stderr)\n raise\n\n x_min = np.min(self.knot_vector)\n x_max = np.max(self.knot_vector)\n\n x = np.linspace(x_min, x_max, num=1000)\n\n ns = np.array([self(i) for i in x]).T\n\n for n in ns:\n plt.plot(x, n)\n\n return plt.show()","def plot_comparison(results):\n dfs = []\n for res in results:\n equity = (1 + res['equity']).cumprod()\n equity.name = 'equity'\n equity = equity.reset_index()\n equity['name'] = res['name']\n dfs.append(equity)\n data = pd.concat(dfs, axis=0)\n\n fig = px.line(data, x='time_idx', y='equity', color='name')\n fig.show()"],"string":"[\n \"def plot_costs(j_history):\\n plt.figure(figsize=(14, 8))\\n plt.plot(range(len(j_history)), j_history)\\n plt.grid(True)\\n plt.title('J (Cost)')\\n plt.xlabel('Iteration')\\n plt.ylabel('Cost function')\\n plt.xlim([0, 1.05 * ITERATIONS])\\n plt.ylim([4, 7])\\n plt.show()\\n plt.close()\",\n \"def plot_cost(self):\\n steps = np.arange(len(self.cost_values))\\n plt.plot(steps, self.cost_values, '-o')\\n plt.xlabel(\\\"Steps\\\")\\n plt.ylabel(\\\"Cost value\\\")\\n plt.title(\\\"Cost value per step using Gradient Descent\\\")\\n plt.show()\",\n \"def plot_graph(costs):\\n plt.figure()\\n for i in range(len(np.array(costs).T)):\\n plt.plot(np.array(costs)[:, i])\\n plt.title(\\\"Costs\\\")\\n plt.show()\",\n \"def plot_costs(self, threshold=0):\\n epochs_range = np.arange(threshold, len(self.costs), 1)\\n plt.plot(epochs_range, self.costs[threshold:], color='green', marker='o')\\n plt.title('Cost function plot. Eta={:.2f} Lambda={:2.2f}'.format(self.eta, self.lambda_r))\\n plt.xlabel('Epochs')\\n plt.ylabel('Cost')\\n plt.grid(True)\\n plt.show()\",\n \"def plot_stop_and_cost(opt_res, scale='log'):\\n nplots=len(opt_res)\\n ncols=2\\n nrows=int(np.ceil(nplots/ncols))\\n _, axes = plt.subplots(nrows, ncols, figsize=(20, 5*nrows))\\n for n in range(nplots):\\n i = int(np.floor(n / ncols))\\n j=n % ncols\\n axes[i,j].plot(opt_res[n]['stop'], label='stopping criterion', color='b')\\n axes[i,j].set_title('Outer loop # '+ str(n))\\n axes[i,j].set_yscale(scale)\\n # axes[i,j].set_xscale('log')\\n axes[i,j].grid(True)\\n axes[i,j].set_ylabel('stop crit')\\n ax_2=axes[i,j].twinx()\\n ax_2.plot(opt_res[n]['obj'], label='Total cost', color='g')\\n ax_2.set_ylabel('total cost')\\n ax_2.set_yscale(scale)\\n ax_2.set_yticks([np.min(opt_res[n]['obj']), np.max(opt_res[n]['obj'])])\\n # axes[i,j].set_ylim([10**2,10**8])\\n # axes[i,j].set_xlim([0,100])\\n axes[i,j].legend()\\n ax_2.legend()\",\n \"def plot_stop_and_cost_output(opt_res, path, scale='log', nframes=4):\\n import matplotlib\\n font = {'size' : 15, 'weight': 'normal'}\\n matplotlib.rc('font', **font)\\n\\n nplots=len(opt_res)\\n ncols=2\\n nrows=int(np.ceil(nframes/ncols))\\n _, axes = plt.subplots(nrows, ncols, figsize=(25, 5*nrows))\\n for n in range(nframes):\\n i = int(np.floor(n / ncols))\\n j=n % ncols\\n axes[i,j].plot(opt_res[n]['stop'], label='Stopping criterion', color='b')\\n axes[i,j].set_title('Outer loop # '+ str(n))\\n axes[i,j].set_yscale(scale)\\n # axes[i,j].set_xscale('log')\\n axes[i,j].grid(True)\\n axes[i,j].set_ylabel('Stopping Criterion')\\n ax_2=axes[i,j].twinx()\\n ax_2.plot(opt_res[n]['obj'], label='Total cost', color='g')\\n ax_2.set_ylabel('Total cost')\\n ax_2.set_yscale(scale)\\n # axes[i,j].set_ylim([10**2,10**8])\\n # axes[i,j].set_xlim([0,100])\\n axes[i,j].legend(loc=1)\\n ax_2.legend(loc=2)\\n plt.savefig(path,transparent=True, dpi=400)\",\n \"def plotLoss():\\n # ssr\\n ssr = np.log(gradientDescent(X, y)[1])\\n # number of iterations \\n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\\n # plot reduction of ssr\\n plt.plot(iterations, ssr)\\n # xlabel\\n plt.xlabel(\\\"Iteration\\\")\\n # ylabel\\n plt.ylabel(\\\"SSR\\\")\\n # title\\n plt.title(\\\"Reduction of SSR by number of Iterations\\\")\\n # show plot \\n plt.show()\",\n \"def plot_cost(c_v, c_t, save_plots_path):\\n\\n plt.figure()\\n plt.plot(c_v, label='Validation loss')\\n plt.plot(c_t, label='Training loss')\\n plt.legend()\\n title = 'Loss per epoch'\\n plt.title(title)\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Loss\\\")\\n plt.savefig(save_plots_path + \\\"swag_loss_plot.png\\\")\",\n \"def plot_cost_vs_clusters(cost,num_clusters,filename):\\n fig, ax = plt.subplots()\\n ax.plot(num_clusters,cost)\\n ax.grid()\\n ax.set_xlabel(\\\"Number of clusters\\\")\\n ax.set_ylabel(\\\"Cost of dropping off TAs\\\")\\n fig.savefig(filename)\\n plt.close()\",\n \"def plot_cost(self, cost_tr_data: [[int]], cost_test_data: [[int]], title: str=\\\"Cost\\\"):\\n plot_title, img_title = self.prep_titles(title)\\n test_legend = ['training data', 'test data']\\n\\n # Data for plotting x- and y-axis\\n x = np.arange(1, CFG.EPOCHS + 1)\\n y = [cost_tr_data, cost_test_data]\\n\\n # prints x and y-axis values\\n print(f'COST:')\\n print(f'x: {x}')\\n print(f'y: {y}')\\n max_y1 = np.amax(y[0]) + 0.1\\n max_y2 = np.amax(y[1]) + 0.1\\n max_y = max(max_y1, max_y2)\\n\\n plt.figure(figsize=(CFG.FIG_WIDTH, CFG.FIG_HEIGHT))\\n\\n # Create the lineplot\\n for line in range(2):\\n ax = sns.lineplot(x=x, y=y[line], color=CFG.COLOR_COST[line], label=test_legend[line])\\n\\n ax.legend(loc='best')\\n ax.set(xlabel='Epochs',\\n ylabel='Cost',\\n title=plot_title,\\n xlim=(1, CFG.EPOCHS),\\n ylim=(0, max_y))\\n\\n self.save_plot(img_title)\\n plt.show()\",\n \"def _show_learning_rate():\\n fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6.4 * 2, 4.8))\\n\\n # Visualize c_prime\\n c_prime_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"c'\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[0]\\n x_list = c_prime_list\\n\\n # MNIST\\n y_list = [161, 16, 14, 15, 20, 21, 24, 27, 30, 30, 35]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [63, 12, 12, 15, 18, 19, 22, 25, 26, 28, 30]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [1297, 724, 221, 80, 52, 51, 54, 54, 52, 60, 60]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n # Visualize t0\\n t0_list = np.linspace(1, 100, num=11)\\n x_label = f\\\"t0\\\"\\n y_label = \\\"Minimum Clusters Size\\\"\\n title = \\\"\\\"\\n\\n ax = axes[1]\\n x_list = t0_list\\n\\n # MNIST\\n y_list = [16, 16, 16, 16, 16, 17, 16, 16, 16, 16, 16]\\n ax.plot(x_list, y_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n y_list = [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]\\n ax.plot(x_list, y_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n y_list = [765, 765, 767, 772, 772, 773, 789, 789, 793, 796, 799]\\n ax.plot(x_list, y_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(x_label)\\n ax.set_ylabel(y_label)\\n ax.set_title(title)\\n ax.legend()\\n ax.set_yscale('log')\\n\\n plt.show()\",\n \"def arrr_starrr_graph(self):\\n\\n plt.figure()\\n total_cost = 0\\n\\n # plot batteries\\n counter = 0\\n for batt in self.grid.batteries:\\n plt.plot(batt.x, batt.y, marker='x',\\n color=colors[counter], markersize=10)\\n counter += 1\\n\\n # iterate over houses and path\\n for house in self.grid.houses:\\n battery = self.grid.batteries[house.connection]\\n\\n # get path coordinates\\n path_data = house.path\\n\\n # plot path and house\\n plt.plot(path_data[0][0], path_data[0][1],\\n color=colors[house.connection], linewidth=.3)\\n plt.plot(house.x, house.y, marker='p',\\n color=colors[house.connection])\\n total_cost += path_data[1]\\n plt.draw()\\n plt.pause(0.000000001)\\n\\n plt.title(f\\\"total cost = {total_cost}\\\")\",\n \"def plot_progress(self):\\n plt.plot(-self.training_average_reward, label='negative average reward')\\n plt.plot(self.training_average_electricity_cost_in_euros, label='electricity cost in euros')\\n plt.legend()\\n plt.xlabel('Epoch')\\n plt.ylabel('cost in euros')\\n plt.title('Average electricity cost in euros and reward')\\n plt.show()\",\n \"def costovertime(endclasses, app, costtype='expected cost'):\\n costovertime = cost_table(endclasses, app)\\n plt.plot(list(costovertime.index), costovertime[costtype])\\n plt.title('Total '+costtype+' of all faults over time.')\\n plt.ylabel(costtype)\\n plt.xlabel(\\\"Time (\\\"+str(app.units)+\\\")\\\")\\n plt.grid()\",\n \"def draw_simple_pp(taus, solver_vals, solvers, filename):\\n fig = plt.figure(figsize=(10, 10))\\n ax = fig.add_subplot(111)\\n for n, solver in enumerate(solvers):\\n ax.step(taus, solver_vals[n, :], label=solver)\\n ax.set_xscale('log')\\n plt.legend(loc=4)\\n plt.xlim(1, taus.max())\\n ax.set_xlabel('Performance Ratio')\\n ax.set_ylabel('Fraction of problems')\\n plt.title('cost in size')\\n plt.savefig(filename, dpi=300)\\n plt.plot()\",\n \"def visualization(obj_value):\\n for n in range(3):\\n plt.loglog(obj_value[n],\\\".\\\");\\n\\n plt.ylabel('objective values');\\n plt.xlabel('iteration counter');\\n plt.title('objective values for each pair against iterations');\\n plt.legend();\\n plt.show();\",\n \"def draw_lists_pyplot(y_array, line_weight=3, learnig_rate=1):\\n y = y_array\\n plt.plot(y, lw=line_weight, label='cost(a={:})'.format(learnig_rate))\\n plt.legend()\\n\\n plt.title(\\\"Gradient Descent Optimizing Method\\\\nminimize cost function\\\")\\n plt.xlabel('time-itoration')\\n plt.ylabel('cost-function')\\n plt.xlim(0,)\\n plt.ylim(0,)\\n\\n plt.grid(b=None, which='major', axis='both')\\n plt.show()\",\n \"def draw_lists_pyplot(y_array, line_weight=3, learnig_rate=1):\\n y = y_array\\n plt.plot(y, lw=line_weight, label='cost(a={:})'.format(learnig_rate))\\n plt.legend()\\n\\n plt.title(\\\"Gradient Descent Optimizing Method\\\\nminimize cost function\\\")\\n plt.xlabel('time-itoration')\\n plt.ylabel('cost-function')\\n\\n plt.xlim(0,)\\n plt.ylim(0,)\\n\\n plt.grid(b=None, which='major', axis='both')\\n plt.show()\",\n \"def Traffic_Perform_Plot(performance, hurricanes):\\n fig = plt.figure(figsize = (8, 6))\\n for i in range(len(performance)):\\n temp1 = performance[i]\\n temp2 = hurricanes[i]\\n perform = sf.Normalize(temp1, Type = 'max')\\n plt.plot(np.arange(0, len(perform), 1), perform, color = temp2.c, label = temp2.name, marker = 'o')\\n plt.xlabel('Time Step')\\n plt.xticks(np.arange(0, len(perform), 1))\\n plt.ylabel('Performance')\\n plt.legend(bbox_to_anchor=(1, 1), loc='upper left', ncol=1, frameon = 0)\\n plt.grid(True)\",\n \"def _plot(self, step, rewards, losses):\\n plt.figure(figsize=(20, 5))\\n plt.subplot(131)\\n plt.title('Total Episode Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('MSE Loss')\\n plt.plot(losses)\\n plt.show()\",\n \"def cost_profile_plot(cost_values):\\n \\n ax = plt.figure(figsize = (7.5,4.5)).gca()\\n cost_values = np.array(cost_values)\\n span = np.arange(1,len(cost_values)+1)\\n ax.plot(span,cost_values, color = 'k', alpha = 0.7)\\n ax.xaxis.set_major_locator(MaxNLocator(integer=True))\\n ax.set_xlabel('Epoch')\\n ax.set_ylabel('Cost (MSE) value')\\n plt.show()\\n plt.close('all')\",\n \"def visualize_raw_dat_cost(self, dat):\\n print('Cost of Games')\\n\\n plt.hist(dat['Price'].dropna())\\n plt.xlabel('Price')\\n plt.ylabel('Count')\\n plt.title('Price Histogram')\\n plt.show()\\n\\n print('Previous graph also has a long-tail. Will narrow the scope again')\\n print('~99% of results in following graph')\\n\\n plt.hist(dat[(dat['Price'] < 15)]['Price'].dropna())\\n plt.xlabel('Price')\\n plt.ylabel('Count')\\n plt.title('Price of Apps')\\n plt.show()\\n\\n print('''84% of apps are free, skewing the results further. \\n Looking into only non-free apps for a clearer picture on what remains''')\\n\\n plt.hist(dat[(dat['Price'] < 15) & (dat['Price'] != 0)]['Price'].dropna())\\n plt.xlabel('Price')\\n plt.ylabel('Count')\\n plt.title('Price of non-free Apps')\\n plt.show()\",\n \"def graph_results(loss, acc):\\n N = len(loss)\\n x = np.linspace(0, N, N)\\n plt.subplot(1,2,1)\\n plt.plot(x, loss)\\n plt.subplot(1,2,2)\\n plt.plot(x,acc)\\n plt.show()\",\n \"def plot_learning(self):\\n plt.plot([i for i in range(len(self.fitness_list))], self.fitness_list)\\n plt.ylabel(\\\"Fitness\\\")\\n plt.xlabel(\\\"Iteration\\\")\\n plt.show()\",\n \"def draw_cost_plot(hori, verts, iic=False):\\n plot.figure().clear()\\n if not iic: title = \\\"Network cost\\\"\\n else: title = \\\"Network cost with IIC\\\"\\n plot.title(title)\\n plot.xticks(range(-1, 100, 1))\\n\\n # normally only draw inter-cost, intra-cost, door matt effect and total cost.\\n _draw_line(plot, hori, verts[0], 'g', 'IEC')\\n _draw_line(plot, hori, verts[1], 'b', 'IAC')\\n _draw_line(plot, hori, verts[2], 'r', 'DMC')\\n _draw_line(plot, hori, verts[3], 'k', 'TOTAL')\\n\\n # if want to watch inter-intra cost\\n if iic:\\n v = map(lambda iec, iac: iec + iac, verts[0], verts[1])\\n _draw_line(plot, hori, v, 'm', 'IIC')\\n \\n plot.grid(True)\\n if iic:\\n plot.savefig(\\\"./\\\" + str(datetime.datetime.now()) + \\\"iic.png\\\", format='png')\\n else:\\n plot.savefig(\\\"./\\\" + str(datetime.datetime.now()) + \\\"normal.png\\\", format='png')\\n #plot.show()\",\n \"def results_plot_fuel_reactor(self):\\n \\n import matplotlib.pyplot as plt \\n\\n # Total pressure profile\\n P = []\\n for z in self.MB_fuel.z:\\n P.append(value(self.MB_fuel.P[z]))\\n fig_P = plt.figure(1)\\n plt.plot(self.MB_fuel.z, P)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total Pressure [bar]\\\") \\n\\n # Temperature profile\\n Tg = []\\n Ts = []\\n# Tw = []\\n for z in self.MB_fuel.z:\\n Tg.append(value(self.MB_fuel.Tg[z] - 273.15))\\n Ts.append(value(self.MB_fuel.Ts[z] - 273.15))\\n# Tw.append(value(self.MB_fuel.Tw[z]))\\n fig_T = plt.figure(2)\\n plt.plot(self.MB_fuel.z, Tg, label='Tg')\\n plt.plot(self.MB_fuel.z, Ts, label='Ts')\\n# plt.plot(self.MB_fuel.z, Tw, label='Tw')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Temperature [C]\\\") \\n \\n # Superficial gas velocity and minimum fluidization velocity\\n vg = []\\n umf = []\\n for z in self.MB_fuel.z:\\n vg.append(value(self.MB_fuel.vg[z]))\\n umf.append(value(self.MB_fuel.umf[z]))\\n fig_vg = plt.figure(3)\\n plt.plot(self.MB_fuel.z, vg, label='vg')\\n plt.plot(self.MB_fuel.z, umf, label='umf')\\n plt.legend(loc=0,ncol=2)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Superficial gas velocity [m/s]\\\")\\n \\n # Gas components molar flow rate\\n for j in self.MB_fuel.GasList:\\n F = []\\n for z in self.MB_fuel.z:\\n F.append(value(self.MB_fuel.F[z,j]))\\n fig_F = plt.figure(4)\\n plt.plot(self.MB_fuel.z, F, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Gas component molar flow rate, F [mol/s]\\\") \\n \\n # Bulk gas phase total molar flow rate\\n Ftotal = []\\n for z in self.MB_fuel.z:\\n Ftotal.append(value(self.MB_fuel.Ftotal[z]))\\n fig_Ftotal = plt.figure(5)\\n plt.plot(self.MB_fuel.z, Ftotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total molar gas flow rate [mol/s]\\\") \\n\\n # Solid components mass flow rate\\n for j in self.MB_fuel.SolidList:\\n M = []\\n for z in self.MB_fuel.z:\\n M.append(value(self.MB_fuel.Solid_M[z,j]))\\n fig_M = plt.figure(6)\\n plt.plot(self.MB_fuel.z, M, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid components mass flow rate [kg/s]\\\")\\n \\n # Bulk solid phase total molar flow rate\\n Mtotal = []\\n for z in self.MB_fuel.z:\\n Mtotal.append(value(self.MB_fuel.Solid_M_total[z]))\\n fig_Mtotal = plt.figure(7)\\n plt.plot(self.MB_fuel.z, Mtotal)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Solid total mass flow rate [kg/s]\\\") \\n \\n # Gas phase concentrations\\n for j in self.MB_fuel.GasList:\\n Cg = []\\n for z in self.MB_fuel.z:\\n Cg.append(value(self.MB_fuel.Cg[z,j]))\\n fig_Cg = plt.figure(8)\\n plt.plot(self.MB_fuel.z, Cg, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Concentration [mol/m3]\\\") \\n \\n # Gas phase mole fractions\\n for j in self.MB_fuel.GasList:\\n y = []\\n for z in self.MB_fuel.z:\\n y.append(value(self.MB_fuel.y[z,j]))\\n fig_y = plt.figure(9)\\n plt.plot(self.MB_fuel.z, y, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.GasList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"y [-]\\\") \\n \\n # Solid phase mass fractions\\n for j in self.MB_fuel.SolidList:\\n x = []\\n for z in self.MB_fuel.z:\\n x.append(value(self.MB_fuel.x[z,j]))\\n fig_x = plt.figure(10)\\n plt.plot(self.MB_fuel.z, x, label=j)\\n plt.legend(loc=0,ncol=len(self.MB_fuel.SolidList))\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"x [-]\\\") \\n\\n # Total mass fraction\\n xtot = []\\n for z in self.MB_fuel.z:\\n xtot.append(value(self.MB_fuel.xtot[z]))\\n fig_xtot = plt.figure(11)\\n plt.plot(self.MB_fuel.z, xtot)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Total mass fraction [-]\\\") \\n \\n # # Gas mix density\\n # rhog = []\\n # for z in self.MB_fuel.z:\\n # rhog.append(value(self.MB_fuel.rho_vap[z]))\\n # fig_rhog = plt.figure(23)\\n # plt.plot(self.MB_fuel.z, rhog)\\n # plt.grid()\\n # plt.xlabel(\\\"Bed height [-]\\\")\\n # plt.ylabel(\\\"Gas mix density [kg/m3]\\\") \\n \\n # Fe conversion\\n X_Fe = []\\n for z in self.MB_fuel.z:\\n X_Fe.append(value(self.MB_fuel.X[z])*100)\\n fig_X_Fe = plt.figure(13)\\n plt.plot(self.MB_fuel.z, X_Fe)\\n plt.grid()\\n plt.xlabel(\\\"Bed height [-]\\\")\\n plt.ylabel(\\\"Fraction of metal oxide converted [%]\\\")\",\n \"def line_figure(self, title):\\n\\n plt.figure()\\n counter = 0\\n\\n # plot the x and y for each house and battery\\n for battery in self.grid.batteries:\\n x = []\\n y = []\\n for house in battery.connections:\\n x.append(house.x)\\n y.append(house.y)\\n plt.plot([house.x, battery.x], [house.y, battery.y],\\n color=colors[counter], linewidth=.25)\\n plt.scatter(x, y, marker='p', color=colors[counter])\\n plt.plot(battery.x, battery.y, marker='x', color=colors[counter],\\n markersize=10)\\n counter += 1\\n plt.title(f\\\"{title}. Cost: {self.cost()}\\\")\",\n \"def plot_metrics(couplings, cost_func, cost_func_name, epsilons, log = False, points=False, scale=1.0, label_font_size=18, tick_font_size=12):\\n zero_offset = epsilons[0]/2\\n all_ys = []\\n if \\\"lineageOT\\\" in couplings.keys():\\n ys = np.array([cost_func(c) for c in [couplings['lineage entropic rna ' + str(e)] for e in epsilons]])\\n plt.plot(epsilons, ys/scale, label = \\\"LineageOT, true tree\\\")\\n if points:\\n plt.scatter([zero_offset], [cost_func(couplings[\\\"lineageOT\\\"])/scale])\\n all_ys.append(ys)\\n if \\\"OT\\\" in couplings.keys():\\n ys = np.array([cost_func(c) for c in [couplings['entropic rna ' + str(e)] for e in epsilons]])\\n plt.plot(epsilons, ys/scale, label = \\\"Entropic OT\\\")\\n if points:\\n plt.scatter([zero_offset], [cost_func(couplings[\\\"OT\\\"])/scale])\\n all_ys.append(ys)\\n if \\\"lineageOT, fitted\\\" in couplings.keys():\\n ys = np.array([cost_func(c) for c in [couplings['fitted lineage rna ' + str(e)] for e in epsilons]])\\n plt.plot(epsilons, ys/scale, label = \\\"LineageOT, fitted tree\\\")\\n if points:\\n plt.scatter([zero_offset], [cost_func(couplings[\\\"lineageOT, fitted\\\"])/scale])\\n all_ys.append(ys)\\n\\n plt.ylabel(cost_func_name, fontsize=label_font_size)\\n plt.xlabel(\\\"Entropy parameter\\\", fontsize=label_font_size)\\n plt.xscale(\\\"log\\\")\\n\\n plt.xticks(fontsize=tick_font_size)\\n plt.yticks(fontsize=tick_font_size)\\n\\n if points:\\n plt.xlim([0.9*zero_offset, epsilons[-1]])\\n else:\\n plt.xlim([epsilons[0], epsilons[-1]])\\n\\n ylims = plt.ylim([0, None])\\n # upper limit should be at least 1\\n plt.ylim([0, max(ylims[1], 1)])\\n\\n plt.legend(fontsize=tick_font_size)\\n return all_ys\",\n \"def plot_results(outputs_table_totals, elec_benefits, gas_benefits):\\n summer_months = [6, 7, 8, 9]\\n shoulder_months = [3, 4, 5, 10]\\n winter_months = [11, 12, 1, 2]\\n peak_hours = [16, 17, 18, 19, 20]\\n pct_hours_in_summer = 2928 / 8760\\n pct_hours_in_shoulder = 2952 / 8760\\n pct_hours_in_winter = 2880 / 8760\\n\\n trc_costs_record = outputs_table_totals[\\\"TRC Costs ($)\\\"]\\n pac_costs_record = outputs_table_totals[\\\"PAC Costs ($)\\\"]\\n trc_record = outputs_table_totals[\\\"TRC\\\"]\\n pac_record = outputs_table_totals[\\\"PAC\\\"]\\n lifecycle_net_mwh = outputs_table_totals[\\\"Electricity Lifecycle Net Savings (MWh)\\\"]\\n lifecycle_net_therms = outputs_table_totals[\\\"Gas Lifecycle Net Savings (Therms)\\\"]\\n lifecycle_net_ghg = outputs_table_totals[\\\"Total Lifecycle GHG Savings (Tons)\\\"]\\n\\n # Getting variables for plots\\n elec_benefits_cols = (\\n [\\\"hourly_savings\\\"] + ACC_COMPONENTS_ELECTRICITY + [\\\"av_csts_levelized\\\"]\\n )\\n\\n elec_benefits_hour_month_year = (\\n elec_benefits.groupby([\\\"hour_of_day\\\", \\\"year\\\", \\\"month\\\"])\\n .agg(\\n {\\n **{component: \\\"sum\\\" for component in ACC_COMPONENTS_ELECTRICITY},\\n **{\\n \\\"hourly_savings\\\": \\\"sum\\\",\\n \\\"marginal_ghg\\\": \\\"sum\\\",\\n \\\"av_csts_levelized\\\": \\\"mean\\\",\\n },\\n }\\n )\\n .reset_index()\\n )\\n\\n total_benefits = list(\\n elec_benefits_hour_month_year.groupby([\\\"hour_of_day\\\"])[\\\"total\\\"].sum()\\n )\\n\\n summer_benefits = list(\\n elec_benefits_hour_month_year[\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(summer_months))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"total\\\"]\\n .sum()\\n )\\n summer_peak_benefits = elec_benefits_hour_month_year[\\\"total\\\"][\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(summer_months))\\n & (elec_benefits_hour_month_year[\\\"hour_of_day\\\"].isin(peak_hours))\\n ].sum()\\n shoulder_benefits = list(\\n elec_benefits_hour_month_year[\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(shoulder_months))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"total\\\"]\\n .sum()\\n )\\n winter_benefits = list(\\n elec_benefits_hour_month_year[\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(winter_months))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"total\\\"]\\n .sum()\\n )\\n total_savings = list(\\n elec_benefits_hour_month_year.groupby([\\\"hour_of_day\\\"])[\\\"hourly_savings\\\"].sum()\\n )\\n summer_savings = list(\\n elec_benefits_hour_month_year[\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(summer_months))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"hourly_savings\\\"]\\n .sum()\\n )\\n shoulder_savings = list(\\n elec_benefits_hour_month_year[\\n ((elec_benefits_hour_month_year[\\\"month\\\"].isin(shoulder_months)))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"hourly_savings\\\"]\\n .sum()\\n )\\n summer_peak_savings = elec_benefits_hour_month_year[\\\"hourly_savings\\\"][\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(summer_months))\\n & (elec_benefits_hour_month_year[\\\"hour_of_day\\\"].isin(peak_hours))\\n ].sum()\\n winter_savings = list(\\n elec_benefits_hour_month_year[\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(winter_months))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"hourly_savings\\\"]\\n .sum()\\n )\\n total_av_csts_avg = list(\\n elec_benefits_hour_month_year.groupby([\\\"hour_of_day\\\"])[\\n \\\"av_csts_levelized\\\"\\n ].mean()\\n )\\n summer_av_csts_avg = list(\\n pct_hours_in_summer\\n * elec_benefits_hour_month_year[\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(summer_months))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"av_csts_levelized\\\"]\\n .mean()\\n )\\n summer_peak_av_csts_avg = elec_benefits_hour_month_year[\\\"av_csts_levelized\\\"][\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(summer_months))\\n & (elec_benefits_hour_month_year[\\\"hour_of_day\\\"].isin(peak_hours))\\n ].mean()\\n shoulder_av_csts_avg = list(\\n pct_hours_in_shoulder\\n * elec_benefits_hour_month_year[\\n ((elec_benefits_hour_month_year[\\\"month\\\"].isin(shoulder_months)))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"av_csts_levelized\\\"]\\n .mean()\\n )\\n winter_av_csts_avg = list(\\n pct_hours_in_winter\\n * elec_benefits_hour_month_year[\\n (elec_benefits_hour_month_year[\\\"month\\\"].isin(winter_months))\\n ]\\n .groupby([\\\"hour_of_day\\\"])[\\\"av_csts_levelized\\\"]\\n .mean()\\n )\\n\\n elec_benefits_sum_by_hod = (\\n elec_benefits[elec_benefits_cols].groupby(elec_benefits[\\\"hour_of_day\\\"]).sum()\\n )\\n elec_benefits_hoy = (\\n elec_benefits[elec_benefits_cols]\\n .groupby(elec_benefits[\\\"hour_of_year\\\"])\\n .sum()\\n .cumsum()\\n .reset_index()\\n )\\n sav_avcsts_288 = (\\n elec_benefits.groupby([\\\"hour_of_day\\\", \\\"month\\\"])\\n .agg(\\n {\\n **{component: \\\"sum\\\" for component in ACC_COMPONENTS_ELECTRICITY},\\n **{\\n \\\"hourly_savings\\\": \\\"sum\\\",\\n \\\"marginal_ghg\\\": \\\"sum\\\",\\n \\\"av_csts_levelized\\\": \\\"mean\\\",\\n },\\n }\\n )\\n .reset_index()\\n )\\n sav_avcsts_288 = sav_avcsts_288[\\n [\\\"hour_of_day\\\", \\\"month\\\", \\\"hourly_savings\\\", \\\"total\\\", \\\"marginal_ghg\\\"]\\n ]\\n ghgsav = sav_avcsts_288.pivot(\\\"hour_of_day\\\", \\\"month\\\", \\\"marginal_ghg\\\")\\n sav = sav_avcsts_288.pivot(\\\"hour_of_day\\\", \\\"month\\\", \\\"hourly_savings\\\")\\n avcsts = sav_avcsts_288.pivot(\\\"hour_of_day\\\", \\\"month\\\", \\\"total\\\")\\n\\n # savings load shape plot\\n fig0, (ax1, ax2, ax3) = plt.subplots(\\n 1, 3, figsize=(18, 5), sharex=True, sharey=True\\n )\\n plt.subplots_adjust(wspace=0, hspace=0)\\n axs = [ax1, ax2, ax3]\\n hod = elec_benefits_sum_by_hod.index\\n legend_labels1 = [\\\"Summer\\\"]\\n legend_labels2 = [\\\"Shoulder\\\"]\\n legend_labels3 = [\\\"Winter\\\"]\\n\\n ax1.plot(\\n hod,\\n summer_savings,\\n c=\\\"firebrick\\\",\\n linewidth=5,\\n marker=\\\"$\\\\u25EF$\\\",\\n markersize=13,\\n linestyle=\\\"-\\\",\\n )\\n ax2.plot(\\n hod,\\n shoulder_savings,\\n c=\\\"royalblue\\\",\\n linewidth=5,\\n marker=\\\"$\\\\u2206$\\\",\\n markersize=13,\\n linestyle=\\\"-\\\",\\n )\\n ax3.plot(\\n hod,\\n winter_savings,\\n c=\\\"green\\\",\\n linewidth=5,\\n marker=\\\"$\\\\u25A1$\\\",\\n markersize=13,\\n linestyle=\\\"-\\\",\\n )\\n ax1.axhline(y=0, color=\\\"gray\\\", linewidth=1, linestyle=\\\"--\\\")\\n ax2.axhline(y=0, color=\\\"gray\\\", linewidth=1, linestyle=\\\"--\\\")\\n ax3.axhline(y=0, color=\\\"gray\\\", linewidth=1, linestyle=\\\"--\\\")\\n # Shade peak region\\n ax1.axvspan(16, 21, alpha=0.2, color=\\\"grey\\\")\\n\\n leg1 = ax1.legend(legend_labels1, fontsize=14, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg1.get_lines(), leg1.get_texts()):\\n text.set_color(line.get_color())\\n leg2 = ax2.legend(legend_labels2, fontsize=14, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg2.get_lines(), leg2.get_texts()):\\n text.set_color(line.get_color())\\n leg3 = ax3.legend(legend_labels3, fontsize=14, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg3.get_lines(), leg3.get_texts()):\\n text.set_color(line.get_color())\\n\\n ax1.set_ylabel(\\\"Savings (MWh/hr)\\\", size=16)\\n ax2.set_xlabel(\\\"Hour of Day\\\", size=16)\\n\\n if max(summer_savings + shoulder_savings + winter_savings) < 0:\\n ymax = 0\\n else:\\n ymax = max(summer_savings + shoulder_savings + winter_savings)\\n if min(summer_savings + shoulder_savings + winter_savings) > 0:\\n ymin = 0\\n else:\\n ymin = min(summer_savings + shoulder_savings + winter_savings)\\n\\n # Tick and lebel parameters\\n ax1.set_ylim(ymin * 1.08, ymax * 1.08)\\n ax1.set_yticks(\\n np.arange(\\n ymin * 1.08,\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax2.set_yticks(\\n np.arange(\\n ymin * 1.08,\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax3.set_yticks(\\n np.arange(\\n ymin * 1.08,\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax3.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax1.yaxis.set_minor_locator(AutoMinorLocator())\\n ax1.set_xticks(np.arange(0, 24, step=4))\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=7, width=2, labelsize=14\\n )\\n ax1.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax1.xaxis.set_minor_locator(AutoMinorLocator())\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=7, width=2, labelsize=14\\n )\\n ax2.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax2.xaxis.set_minor_locator(AutoMinorLocator())\\n ax3.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=7, width=2, labelsize=14\\n )\\n ax3.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax3.xaxis.set_minor_locator(AutoMinorLocator())\\n\\n # Set plot title, size, and position\\n ax1.set_title(\\\"Seasonal Savings Load Shapes\\\", size=18, loc=\\\"left\\\").set_position(\\n [0, 1.03]\\n )\\n\\n # benefits_seasonal_shape_plot\\n fig1, (ax1, ax2, ax3) = plt.subplots(\\n 1, 3, figsize=(18, 5), sharex=True, sharey=True\\n )\\n plt.subplots_adjust(wspace=0, hspace=0)\\n axs = [ax1, ax2, ax3]\\n hod = elec_benefits_sum_by_hod.index\\n legend_labels1 = [\\\"Summer\\\"]\\n legend_labels2 = [\\\"Shoulder\\\"]\\n legend_labels3 = [\\\"Winter\\\"]\\n\\n ax1.plot(\\n hod,\\n summer_benefits,\\n c=\\\"firebrick\\\",\\n linewidth=5,\\n marker=\\\"$\\\\u2B24$\\\",\\n markersize=13,\\n linestyle=\\\":\\\",\\n )\\n ax2.plot(\\n hod,\\n shoulder_benefits,\\n c=\\\"royalblue\\\",\\n linewidth=5,\\n marker=\\\"$\\\\u25B2$\\\",\\n markersize=13,\\n linestyle=\\\":\\\",\\n )\\n ax3.plot(\\n hod,\\n winter_benefits,\\n c=\\\"green\\\",\\n linewidth=5,\\n marker=\\\"$\\\\u25A0$\\\",\\n markersize=13,\\n linestyle=\\\":\\\",\\n )\\n ax1.axhline(y=0, color=\\\"gray\\\", linewidth=1, linestyle=\\\"--\\\")\\n ax2.axhline(y=0, color=\\\"gray\\\", linewidth=1, linestyle=\\\"--\\\")\\n ax3.axhline(y=0, color=\\\"gray\\\", linewidth=1, linestyle=\\\"--\\\")\\n # Shade peak region\\n ax1.axvspan(16, 21, alpha=0.2, color=\\\"grey\\\")\\n\\n leg1 = ax1.legend(legend_labels1, fontsize=15, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg1.get_lines(), leg1.get_texts()):\\n text.set_color(line.get_color())\\n leg2 = ax2.legend(legend_labels2, fontsize=15, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg2.get_lines(), leg2.get_texts()):\\n text.set_color(line.get_color())\\n leg3 = ax3.legend(legend_labels3, fontsize=15, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg3.get_lines(), leg3.get_texts()):\\n text.set_color(line.get_color())\\n\\n ax1.set_ylabel(\\\"TRC Benefits ($/hr)\\\", size=16)\\n ax2.set_xlabel(\\\"Hour of Day\\\", size=16)\\n\\n if max(summer_benefits + shoulder_benefits + winter_benefits) < 0:\\n ymax = 0\\n else:\\n ymax = max(summer_benefits + shoulder_benefits + winter_benefits)\\n if min(summer_benefits + shoulder_benefits + winter_benefits) > 0:\\n ymin = 0\\n else:\\n ymin = min(summer_benefits + shoulder_benefits + winter_benefits)\\n\\n # Tick and label parameters\\n ax1.set_ylim(ymin * 1.08, ymax * 1.08)\\n ax1.set_yticks(\\n np.arange(\\n ymin * 1.08,\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax2.set_yticks(\\n np.arange(\\n ymin * 1.08,\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax3.set_yticks(\\n np.arange(\\n ymin * 1.08,\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax3.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax1.yaxis.set_minor_locator(AutoMinorLocator())\\n ax1.set_xticks(np.arange(0, 24, step=4))\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=7, width=2, labelsize=14\\n )\\n ax1.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax1.xaxis.set_minor_locator(AutoMinorLocator())\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=7, width=2, labelsize=14\\n )\\n ax2.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax2.xaxis.set_minor_locator(AutoMinorLocator())\\n ax3.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=7, width=2, labelsize=14\\n )\\n ax3.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax3.xaxis.set_minor_locator(AutoMinorLocator())\\n\\n # Set plot title, size, and position\\n ax1.set_title(\\n \\\"Seasonal TRC Benefits by Hour ($)\\\", size=18, loc=\\\"left\\\"\\n ).set_position([0, 1.03])\\n\\n # sum_hourly_plot\\n fig2 = plt.figure(figsize=(12, 7), dpi=250)\\n ax = fig2.gca()\\n colors = [\\n \\\"royalblue\\\",\\n \\\"black\\\",\\n \\\"pink\\\",\\n \\\"firebrick\\\",\\n \\\"gray\\\",\\n \\\"darkviolet\\\",\\n \\\"darkorange\\\",\\n \\\"green\\\",\\n \\\"saddlebrown\\\",\\n ]\\n legend_labels = []\\n x = 1\\n while x <= len(ACC_COMPONENTS_ELECTRICITY[1:]):\\n if x == 1:\\n ax.bar(\\n hod,\\n elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]],\\n color=colors[x - 1],\\n )\\n legend_labels.append(\\n re.findall(\\n \\\".*Name: (.*),\\\",\\n str(elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]]),\\n )[0]\\n )\\n x += 1\\n else:\\n ax.bar(\\n hod,\\n elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]],\\n bottom=elec_benefits_sum_by_hod.iloc[:, 2 : x + 1].sum(axis=1),\\n color=colors[x - 1],\\n )\\n legend_labels.append(\\n re.findall(\\n \\\".*Name: (.*),\\\",\\n str(elec_benefits_sum_by_hod[ACC_COMPONENTS_ELECTRICITY[x]]),\\n )[0]\\n )\\n x += 1\\n\\n # Set x and y limits based on min and max values\\n ymax = elec_benefits_sum_by_hod.iloc[:, 2:x].sum(axis=1).max()\\n if elec_benefits_sum_by_hod.iloc[:, 2:x].sum(axis=1).min() > 0:\\n ymin = 0\\n else:\\n ymin = elec_benefits_sum_by_hod.iloc[:, 2:x].sum(axis=1).min()\\n\\n ax.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax.set_ylim(ymin * 1.1, ymax * 1.08)\\n\\n # Set x and y axis labels\\n ax.set_xlabel(\\\"Hour of Day\\\", size=17, labelpad=5)\\n ax.set_ylabel(\\\"$ Avoided Costs\\\", size=17)\\n\\n # Set plot title, size, and position\\n ax.set_title(\\n \\\"Sum of Electric Avoided Costs by Component and Hour of Day\\\",\\n size=17,\\n loc=\\\"left\\\",\\n )\\n\\n # Tick and lebel parameters\\n ax.tick_params(bottom=True, top=False, left=True, right=False)\\n ax.set_xticks(np.arange(0, 24, step=4))\\n ax.set_yticks(\\n np.arange(\\n int(round(ymin * 1.1, 0)),\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 2) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n\\n # Minor ticks\\n ax.xaxis.set_minor_locator(AutoMinorLocator())\\n ax.yaxis.set_minor_locator(AutoMinorLocator())\\n\\n # Legend\\n plt.legend(\\n legend_labels,\\n bbox_to_anchor=(1, 1),\\n fontsize=12,\\n loc=\\\"upper left\\\",\\n frameon=False,\\n )\\n\\n # avoided_cost_summary_plot\\n fig3, (ax1, ax2, ax3) = plt.subplots(\\n 3, 1, figsize=(6, 10), sharex=True, sharey=False\\n )\\n axs = [ax1, ax2, ax3]\\n hod = elec_benefits_sum_by_hod.index\\n legend_labels = [\\\"Total\\\", \\\"Summer\\\", \\\"Shoulder\\\", \\\"Winter\\\"]\\n\\n ax1.plot(\\n hod,\\n total_benefits,\\n c=\\\"royalblue\\\",\\n marker=\\\"$\\\\u25EF$\\\",\\n markersize=10,\\n linewidth=3,\\n linestyle=\\\"-\\\",\\n )\\n ax1.plot(hod, summer_benefits, c=\\\"darkorchid\\\", linewidth=1, linestyle=\\\"--\\\")\\n ax1.plot(hod, shoulder_benefits, c=\\\"olivedrab\\\", linewidth=1, linestyle=\\\":\\\")\\n ax1.plot(hod, winter_benefits, c=\\\"teal\\\", linewidth=1, linestyle=\\\"-\\\")\\n ax2.plot(\\n hod,\\n total_savings,\\n c=\\\"firebrick\\\",\\n marker=\\\"$\\\\u2206$\\\",\\n markersize=10,\\n linewidth=3,\\n linestyle=\\\"-\\\",\\n )\\n ax2.plot(hod, summer_savings, c=\\\"darkorchid\\\", linewidth=1, linestyle=\\\"--\\\")\\n ax2.plot(hod, shoulder_savings, c=\\\"olivedrab\\\", linewidth=1, linestyle=\\\":\\\")\\n ax2.plot(hod, winter_savings, c=\\\"teal\\\", linewidth=1, linestyle=\\\"-\\\")\\n ax3.plot(\\n hod,\\n total_av_csts_avg,\\n c=\\\"green\\\",\\n marker=\\\"$\\\\u25A0$\\\",\\n markersize=10,\\n linewidth=3,\\n linestyle=\\\"-\\\",\\n )\\n ax3.plot(hod, summer_av_csts_avg, c=\\\"darkorchid\\\", linewidth=1, linestyle=\\\"--\\\")\\n ax3.plot(hod, shoulder_av_csts_avg, c=\\\"olivedrab\\\", linewidth=1, linestyle=\\\":\\\")\\n ax3.plot(hod, winter_av_csts_avg, c=\\\"teal\\\", linewidth=1, linestyle=\\\"-\\\")\\n\\n leg1 = ax1.legend(legend_labels, fontsize=11, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg1.get_lines(), leg1.get_texts()):\\n text.set_color(line.get_color())\\n leg2 = ax2.legend(legend_labels, fontsize=11, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg2.get_lines(), leg2.get_texts()):\\n text.set_color(line.get_color())\\n leg3 = ax3.legend(legend_labels, fontsize=11, loc=\\\"upper left\\\", frameon=False)\\n for line, text in zip(leg3.get_lines(), leg3.get_texts()):\\n text.set_color(line.get_color())\\n\\n ax3.set_xticks(np.arange(0, 24, step=4))\\n ax3.set_xlabel(\\\"Hour of Day\\\", size=14, labelpad=5)\\n ax3.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=12\\n )\\n ax3.set_xlim(hod.min() - hod.max() * 0.04, hod.max() * 1.04)\\n ax3.xaxis.set_minor_locator(AutoMinorLocator())\\n\\n ax1.set_ylabel(\\\"TRC Benefits ($)\\\", size=14)\\n ax2.set_ylabel(\\\"Savings (MWh)\\\", size=14)\\n ax3.set_ylabel(\\\"Av. Cost ($/MWh)\\\", size=14)\\n\\n if max(total_benefits + summer_benefits + shoulder_benefits + winter_benefits) < 0:\\n ymax1 = 0\\n else:\\n ymax1 = max(\\n total_benefits + summer_benefits + shoulder_benefits + winter_benefits\\n )\\n if min(total_benefits + summer_benefits + shoulder_benefits + winter_benefits) > 0:\\n ymin1 = 0\\n else:\\n ymin1 = min(\\n total_benefits + summer_benefits + shoulder_benefits + winter_benefits\\n )\\n if max(total_savings + summer_savings + shoulder_savings + winter_savings) < 0:\\n ymax2 = 0\\n else:\\n ymax2 = max(total_savings + summer_savings + shoulder_savings + winter_savings)\\n if min(total_savings + summer_savings + shoulder_savings + winter_savings) > 0:\\n ymin2 = 0\\n else:\\n ymin2 = min(total_savings + summer_savings + shoulder_savings + winter_savings)\\n if (\\n max(\\n total_av_csts_avg\\n + summer_av_csts_avg\\n + shoulder_av_csts_avg\\n + winter_av_csts_avg\\n )\\n < 0\\n ):\\n ymax3 = 0\\n else:\\n ymax3 = max(\\n total_av_csts_avg\\n + summer_av_csts_avg\\n + shoulder_av_csts_avg\\n + winter_av_csts_avg\\n )\\n if (\\n min(\\n total_av_csts_avg\\n + summer_av_csts_avg\\n + shoulder_av_csts_avg\\n + winter_av_csts_avg\\n )\\n > 0\\n ):\\n ymin3 = 0\\n else:\\n ymin3 = min(\\n total_av_csts_avg\\n + summer_av_csts_avg\\n + shoulder_av_csts_avg\\n + winter_av_csts_avg\\n )\\n\\n # Tick and lebel parameters\\n ax1.set_ylim(ymin1 * 1.08, ymax1 * 1.08)\\n ax2.set_ylim(ymin2 * 1.08, ymax2 * 1.08)\\n ax3.set_ylim(ymin3 * 1.08, ymax3 * 1.08)\\n\\n ax1.set_yticks(\\n np.arange(\\n ymin1 * 1.08,\\n ymax1 * 1.08,\\n step=max(round(ymax1 - ymin1, 3) / 5, int((round(ymax1 - ymin1, 0)) / 4)),\\n )\\n )\\n ax2.set_yticks(\\n np.arange(\\n ymin2 * 1.08,\\n ymax2 * 1.08,\\n step=max(round(ymax2 - ymin2, 3) / 5, int((round(ymax2 - ymin2, 0)) / 4)),\\n )\\n )\\n ax3.set_yticks(\\n np.arange(\\n ymin3 * 1.08,\\n ymax3 * 1.08,\\n step=max(round(ymax3 - ymin3, 3) / 5, int((round(ymax3 - ymin3, 0)) / 4)),\\n )\\n )\\n\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=12\\n )\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=12\\n )\\n ax3.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=12\\n )\\n\\n # Shade peak region\\n ax1.axvspan(16, 21, alpha=0.2, color=\\\"grey\\\")\\n ax2.axvspan(16, 21, alpha=0.2, color=\\\"grey\\\")\\n ax3.axvspan(16, 21, alpha=0.2, color=\\\"grey\\\")\\n\\n # Print key information\\n plt.annotate(\\n \\\"Electric Benefits = $\\\" + str(round(elec_benefits[\\\"total\\\"].sum(), 2)),\\n xy=(350, 530),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"Gas Benefits = $\\\" + str(round(gas_benefits, 2)),\\n xy=(350, 505),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"Total Benefits = $\\\"\\n + str(round(elec_benefits[\\\"total\\\"].sum() + gas_benefits, 2)),\\n xy=(350, 480),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"TRC Costs = $\\\" + str(trc_costs_record),\\n xy=(350, 455),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"PAC Costs = $\\\" + str(pac_costs_record),\\n xy=(350, 430),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"TRC = \\\" + str(trc_record),\\n xy=(350, 405),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"PAC = \\\" + str(pac_record),\\n xy=(350, 380),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"Net Lifecycle Electric Savings = \\\" + str(lifecycle_net_mwh) + \\\" MWh\\\",\\n xy=(350, 335),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"Net Lifecycle Gas Savings = \\\" + str(lifecycle_net_therms) + \\\" Therms\\\",\\n xy=(350, 310),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"Net Lifecycle GHG Savings = \\\" + str(lifecycle_net_ghg) + \\\" Tons\\\",\\n xy=(350, 285),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n str(round(100 * ((summer_peak_savings) / sum(total_savings)), 1))\\n + \\\"% MWh savings during summer peak period\\\",\\n xy=(350, 260),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n str(round(100 * ((summer_peak_benefits) / sum(total_benefits)), 1))\\n + \\\"% Electric TRC benefits from summer peak period\\\",\\n xy=(350, 235),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"Electric Benefits per MWh = $\\\"\\n + str(round(elec_benefits[\\\"total\\\"].sum() / lifecycle_net_mwh, 2)),\\n xy=(350, 210),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n plt.annotate(\\n \\\"Typical Avoided Cost per MWh = $\\\"\\n + str(round(elec_benefits[\\\"av_csts_levelized\\\"].mean(), 2)),\\n xy=(350, 145),\\n xycoords=\\\"axes points\\\",\\n fontsize=18,\\n )\\n\\n # Set plot title, size, and position\\n ax1.set_title(\\n \\\"Savings and Avoided Cost Profiles\\\", size=16, loc=\\\"left\\\"\\n ).set_position([0, 1.03])\\n\\n # marginal_ghg_savings_plot\\n cmp = sns.diverging_palette(16, 260, l=35, n=25, as_cmap=True)\\n\\n fig4 = plt.figure(figsize=(8, 6), dpi=100)\\n ax1 = fig4.gca()\\n y_ticks = [\\n 0,\\n \\\"\\\",\\n 2,\\n \\\"\\\",\\n 4,\\n \\\"\\\",\\n 6,\\n \\\"\\\",\\n 8,\\n \\\"\\\",\\n 10,\\n \\\"\\\",\\n 12,\\n \\\"\\\",\\n 14,\\n \\\"\\\",\\n 16,\\n \\\"\\\",\\n 18,\\n \\\"\\\",\\n 20,\\n \\\"\\\",\\n 22,\\n ]\\n hmp = sns.heatmap(ghgsav, cmap=cmp, ax=ax1, yticklabels=y_ticks, center=0.00)\\n ax1.set_xlabel(\\\"Month\\\", size=15)\\n ax1.set_ylabel(\\\"Hour of Day\\\", size=15)\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=13\\n )\\n ax1.tick_params(\\n which=\\\"major\\\",\\n axis=\\\"y\\\",\\n direction=\\\"out\\\",\\n length=6,\\n width=2,\\n labelsize=13,\\n rotation=0,\\n )\\n ax1.set_title(\\\"Electric GHG Savings by Month and Hour\\\", size=15, loc=\\\"left\\\", pad=8)\\n cbar1 = hmp.collections[0].colorbar\\n cbar1.ax.tick_params(labelsize=14)\\n plt.annotate(\\\"Sum GHG\\\", xy=(370, 352), xycoords=\\\"axes points\\\", fontsize=12)\\n plt.annotate(\\\"Savings (Tons)\\\", xy=(370, 336), xycoords=\\\"axes points\\\", fontsize=12)\\n\\n # month_hour_savings_benefits_plot\\n fig5, (ax1, ax2) = plt.subplots(1, 2, figsize=(21, 10), dpi=200)\\n y_ticks = [\\n 0,\\n \\\"\\\",\\n 2,\\n \\\"\\\",\\n 4,\\n \\\"\\\",\\n 6,\\n \\\"\\\",\\n 8,\\n \\\"\\\",\\n 10,\\n \\\"\\\",\\n 12,\\n \\\"\\\",\\n 14,\\n \\\"\\\",\\n 16,\\n \\\"\\\",\\n 18,\\n \\\"\\\",\\n 20,\\n \\\"\\\",\\n 22,\\n ]\\n fleft = sns.heatmap(sav, cmap=cmp, ax=ax1, yticklabels=y_ticks, center=0.00)\\n fright = sns.heatmap(avcsts, cmap=cmp, ax=ax2, yticklabels=y_ticks, center=0.00)\\n ax1.set_xlabel(\\\"Month\\\", size=22)\\n ax1.set_ylabel(\\\"Hour of Day\\\", size=22)\\n ax2.set_xlabel(\\\"Month\\\", size=22)\\n ax2.set_ylabel(\\\"Hour of Day\\\", size=22)\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=18\\n )\\n ax1.tick_params(\\n which=\\\"major\\\",\\n axis=\\\"y\\\",\\n direction=\\\"out\\\",\\n length=6,\\n width=2,\\n labelsize=18,\\n rotation=0,\\n )\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=18\\n )\\n ax2.tick_params(\\n which=\\\"major\\\",\\n axis=\\\"y\\\",\\n direction=\\\"out\\\",\\n length=6,\\n width=2,\\n labelsize=18,\\n rotation=0,\\n )\\n ax1.set_title(\\n \\\"MWh Savings by Month and Hour\\\", size=24, loc=\\\"left\\\", pad=15\\n ).set_position([0, 1.1])\\n ax2.set_title(\\\"$ Benefits by Month and Hour\\\", size=24, loc=\\\"left\\\", pad=15)\\n fig4.tight_layout(pad=2.0)\\n cbar1 = fleft.collections[0].colorbar\\n cbar1.ax.tick_params(labelsize=18)\\n cbar2 = fright.collections[0].colorbar\\n cbar2.ax.tick_params(labelsize=18)\\n plt.annotate(\\\"Sum MWh\\\", xy=(-200, 585), xycoords=\\\"axes points\\\", fontsize=20)\\n plt.annotate(\\\"Savings\\\", xy=(-193, 560), xycoords=\\\"axes points\\\", fontsize=20)\\n plt.annotate(\\\"Sum TRC\\\", xy=(435, 585), xycoords=\\\"axes points\\\", fontsize=20)\\n plt.annotate(\\\"Benefits\\\", xy=(442, 560), xycoords=\\\"axes points\\\", fontsize=20)\\n\\n # savings_benefits_cumulative_sum_plot\\n fig6 = plt.figure(figsize=(12, 7), dpi=250)\\n ax1 = fig6.gca()\\n ax1.plot(\\n elec_benefits_hoy[\\\"hour_of_year\\\"],\\n elec_benefits_hoy[\\\"hourly_savings\\\"],\\n color=\\\"royalblue\\\",\\n linewidth=3,\\n )\\n ax2 = ax1.twinx()\\n ax2.plot(\\n elec_benefits_hoy[\\\"hour_of_year\\\"],\\n elec_benefits_hoy[\\\"total\\\"],\\n color=\\\"firebrick\\\",\\n linewidth=3,\\n linestyle=\\\"--\\\",\\n )\\n ax2.axhline(y=0, color=\\\"gray\\\", linewidth=0.7, linestyle=\\\"--\\\")\\n\\n # Set x and y limits based on min and max values\\n\\n if (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].max() >= 0\\n and elec_benefits_hoy[\\\"total\\\"].max() >= 0\\n ):\\n ymax1 = elec_benefits_hoy[\\\"hourly_savings\\\"].max()\\n ymax2 = elec_benefits_hoy[\\\"total\\\"].max()\\n elif (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].max() < 0\\n and elec_benefits_hoy[\\\"total\\\"].max() < 0\\n ):\\n ymax1 = 0\\n ymax2 = 0\\n elif (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].max() < 0\\n and elec_benefits_hoy[\\\"total\\\"].max() > 0\\n ):\\n ymax1 = (\\n -1\\n * elec_benefits_hoy[\\\"hourly_savings\\\"].min()\\n * (\\n elec_benefits_hoy[\\\"total\\\"].max()\\n / (elec_benefits_hoy[\\\"total\\\"].max() - elec_benefits_hoy[\\\"total\\\"].min())\\n )\\n / (\\n 1\\n - elec_benefits_hoy[\\\"total\\\"].max()\\n / (elec_benefits_hoy[\\\"total\\\"].max() - elec_benefits_hoy[\\\"total\\\"].min())\\n )\\n )\\n ymax2 = elec_benefits_hoy[\\\"total\\\"].max()\\n else:\\n ymax1 = 0\\n ymax2 = (\\n -1\\n * elec_benefits_hoy[\\\"total\\\"].min()\\n * (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].max()\\n / (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].max()\\n - elec_benefits_hoy[\\\"hourly_savings\\\"].min()\\n )\\n )\\n )\\n\\n if (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].min() <= 0\\n and elec_benefits_hoy[\\\"total\\\"].min() <= 0\\n ):\\n ymin1 = elec_benefits_hoy[\\\"hourly_savings\\\"].min()\\n ymin2 = elec_benefits_hoy[\\\"total\\\"].min()\\n elif (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].min() > 0\\n and elec_benefits_hoy[\\\"total\\\"].min() > 0\\n ):\\n ymin1 = 0\\n ymin2 = 0\\n elif (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].min() > 0\\n and elec_benefits_hoy[\\\"total\\\"].min() < 0\\n ):\\n ymin1 = (\\n -1\\n * elec_benefits_hoy[\\\"hourly_savings\\\"].max()\\n * (\\n elec_benefits_hoy[\\\"total\\\"].min()\\n / (elec_benefits_hoy[\\\"total\\\"].min() - elec_benefits_hoy[\\\"total\\\"].max())\\n )\\n / (\\n 1\\n - elec_benefits_hoy[\\\"total\\\"].min()\\n / (elec_benefits_hoy[\\\"total\\\"].min() - elec_benefits_hoy[\\\"total\\\"].max())\\n )\\n )\\n ymin2 = elec_benefits_hoy[\\\"total\\\"].min()\\n else:\\n ymin1 = 0\\n ymin2 = (\\n -1\\n * elec_benefits_hoy[\\\"total\\\"].min()\\n * (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].min()\\n / (\\n elec_benefits_hoy[\\\"hourly_savings\\\"].min()\\n - elec_benefits_hoy[\\\"hourly_savings\\\"].min()\\n )\\n )\\n )\\n\\n # Set x and y axis limits\\n ax1.set_xlim(-340, 9000)\\n ax1.set_ylim(ymin1 * 1.08, ymax1 * 1.08)\\n ax2.set_ylim(ymin2 * 1.08, ymax2 * 1.08)\\n\\n # Set x and y axis labels\\n ax1.set_xlabel(\\\"Hour of Year\\\", size=17, labelpad=5)\\n ax1.set_ylabel(\\\"Net Lifecycle Savings (MWh)\\\", size=17)\\n ax2.set_ylabel(\\\"$ TRC Benefits\\\", size=17, rotation=-90, labelpad=20)\\n\\n # Set plot title, size, and position\\n ax1.set_title(\\n \\\"Cumulative Savings and TRC Benefits by Hour of Year\\\",\\n size=17,\\n loc=\\\"left\\\",\\n pad=8,\\n )\\n\\n # Tick and lebel parameters\\n ax1.set_xticks(np.arange(0, 8760, step=1000))\\n ax1.set_yticks(\\n np.arange(\\n int(round(ymin1 * 1.1, 0)),\\n ymax1 * 1.08,\\n step=max(round(ymax1 - ymin1, 2) / 5, int((round(ymax1 - ymin1, 0)) / 4)),\\n )\\n )\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax1.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n\\n ax2.set_xticks(np.arange(0, 8760, step=1000))\\n ax2.set_yticks(\\n np.arange(\\n int(round(ymin2 * 1.1, 0)),\\n ymax2 * 1.08,\\n step=max(round(ymax2 - ymin2, 2) / 5, int((round(ymax2 - ymin2, 0)) / 4)),\\n )\\n )\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax2.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n\\n # Minor ticks\\n ax1.xaxis.set_minor_locator(AutoMinorLocator())\\n ax1.yaxis.set_minor_locator(AutoMinorLocator())\\n ax2.yaxis.set_minor_locator(AutoMinorLocator())\\n\\n # Legend\\n ax1.legend(\\n [\\\"Savings\\\"],\\n fontsize=12,\\n bbox_to_anchor=(0.02, 1),\\n loc=\\\"upper left\\\",\\n frameon=False,\\n )\\n ax2.legend(\\n [\\\"TRC Beneftis\\\"],\\n fontsize=12,\\n bbox_to_anchor=(0.02, 0.95),\\n loc=\\\"upper left\\\",\\n frameon=False,\\n )\\n\\n fig7 = plt.figure(figsize=(12, 7), dpi=250)\\n ax = fig7.gca()\\n colors1 = [\\n \\\"black\\\",\\n \\\"royalblue\\\",\\n \\\"black\\\",\\n \\\"pink\\\",\\n \\\"firebrick\\\",\\n \\\"gray\\\",\\n \\\"darkviolet\\\",\\n \\\"darkorange\\\",\\n \\\"green\\\",\\n \\\"saddlebrown\\\",\\n ]\\n legend_labels2 = []\\n\\n ax.plot(\\n elec_benefits_hoy[\\\"hour_of_year\\\"],\\n elec_benefits_hoy[ACC_COMPONENTS_ELECTRICITY[0]],\\n color=colors1[0],\\n linewidth=3,\\n )\\n legend_labels2.append(ACC_COMPONENTS_ELECTRICITY[0])\\n x = 1\\n while x <= len(ACC_COMPONENTS_ELECTRICITY) - 2:\\n ax.plot(\\n elec_benefits_hoy[\\\"hour_of_year\\\"],\\n elec_benefits_hoy[ACC_COMPONENTS_ELECTRICITY[x]],\\n color=colors1[x],\\n )\\n legend_labels2.append(ACC_COMPONENTS_ELECTRICITY[x])\\n x += 1\\n\\n # Set x and y limits based on min and max values\\n if max(elec_benefits_hoy.iloc[:, 2:x].max()) < 0:\\n ymax = 0\\n else:\\n ymax = max(elec_benefits_hoy.iloc[:, 2:x].max())\\n if min(elec_benefits_hoy.iloc[:, 2:x].min()) > 0:\\n ymin = 0\\n else:\\n ymin = min(elec_benefits_hoy.iloc[:, 2:x].min())\\n\\n ax.set_xlim(-340, 9000)\\n ax.set_ylim(ymin * 1.1, ymax * 1.08)\\n\\n # Set x and y axis labels\\n ax.set_xlabel(\\\"Hour of Year\\\", size=17, labelpad=5)\\n ax.set_ylabel(\\\"$ TRC Benefits\\\", size=17)\\n\\n # Set plot title, size, and position\\n ax.set_title(\\n \\\"Sum of Avoided Costs by Component and Hour of Day\\\", size=17, loc=\\\"left\\\"\\n )\\n\\n # Tick and lebel parameters\\n ax.set_xticks(np.arange(0, 8760, step=1000))\\n ax.set_yticks(\\n np.arange(\\n int(round(ymin * 1.1, 0)),\\n ymax * 1.08,\\n step=max(round(ymax - ymin, 3) / 5, int((round(ymax - ymin, 0)) / 4)),\\n )\\n )\\n ax.tick_params(\\n which=\\\"major\\\", axis=\\\"x\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n ax.tick_params(\\n which=\\\"major\\\", axis=\\\"y\\\", direction=\\\"out\\\", length=6, width=2, labelsize=14\\n )\\n\\n # Minor ticks\\n ax.xaxis.set_minor_locator(AutoMinorLocator())\\n ax.yaxis.set_minor_locator(AutoMinorLocator())\\n\\n # Legend\\n plt.legend(\\n legend_labels2,\\n bbox_to_anchor=(1, 1),\\n fontsize=12,\\n loc=\\\"upper left\\\",\\n frameon=False,\\n )\",\n \"def plot(self, n_confs):\\n \\n import pandas as pd\\n import numpy as np\\n import matplotlib as mpl\\n mpl.use('Agg')\\n import matplotlib.pyplot as plt\\n import csv\\n \\n n_iter = len(self.plot_data)\\n \\n data = np.ndarray((n_iter, n_confs+1))\\n data[:,0] = [i[0] for i in self.plot_data]\\n data[:,1:] = [i[1].detach().cpu().numpy() for i in self.plot_data]\\n\\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n df.to_csv(f\\\"{self.plot_name}.tab\\\", sep=\\\"\\\\t\\\", quoting=csv.QUOTE_NONE) \\n\\n d = data[:,1:].reshape(-1)\\n d = d[~np.isnan(d)]\\n mine = d.min() - 0.01\\n for i in range(n_confs): \\n data[:,i+1] -= mine\\n \\n df=pd.DataFrame(data)\\n names = ['iter']\\n for i in range(n_confs): names.append(f'c{i+1}')\\n df.columns = names\\n \\n colors = (0,0,0)\\n area = 10\\n \\n # Plot\\n fig = plt.figure(figsize=(15, 15))\\n ax = fig.add_subplot(1,1,1)\\n for i in range(n_confs):\\n ax.plot('iter', f'c{i+1}', data=df)\\n ax.set_yscale('log')\\n\\n plt.xlabel('iter')\\n plt.ylabel('loss')\\n plt.savefig(f'{self.plot_name}.png')\",\n \"def H_perform_plot(performance, hurricane):\\n fig = plt.figure(figsize = (15, 10))\\n for i in range(len(performance)):\\n temp1 = performance[i]\\n temp2 = hurricane[i]\\n plt.plot(np.arange(0, len(temp1), 1), temp1, color = temp2.c, label = temp2.name)\\n plt.xlabel('Time Step')\\n plt.xticks(np.arange(0, len(temp1), 30))\\n plt.ylabel('Performance')\\n plt.legend(bbox_to_anchor=(1, 1), loc='upper left', ncol=1, frameon = 0)\\n plt.grid(True)\",\n \"def plot_results(delaytype):\\n \\n if delaytype == 'Polynomial':\\n # results for ind_obs=graph.indlinks.keys()\\n tolls_collected1 = [[164.76921455176952, 690.919364787199, 1003.9715271443032], [164.76920846294715, 690.9196375266908, 1003.971503332828]]\\n so_costs1 = [[1952.813985915695, 2991.422528084584, 4716.77478205995], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs1 = [[1961.4088544768533, 3035.621746689017, 4751.282035585294], [1961.4088092322784, 3035.619283467948, 4751.282202058287]]\\n ue_costs1 = [[1993.9477013089333, 3087.4591784440836, 4889.555908205202], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected2 = [[165.05685117271955, 354.1634370314711, 1015.9141858070569], [165.0567022829941, 354.1917223859498, 1015.9119098321756]]\\n so_costs2 = [[1952.4102665477528, 2990.2968764530697, 4714.092736177128], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs2 = [[1961.0182151023969, 3019.353015234613, 4750.051821659878], [1961.4090940730164, 3020.4668352547183, 4752.675436210774]]\\n ue_costs2 = [[1993.5324364880598, 3086.401670312004, 4886.656461616093], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected3 = [[122.37203827953705, 369.5962596851687, 993.1260548913893], [124.00144138458633, 375.65796385498777, 1018.6147484597942]]\\n so_costs3 = [[1819.720988976306, 2777.3939885366685, 4677.595258102356], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs3 = [[1834.6351015726038, 2802.3016403566235, 4714.102145227426], [1965.8049083549738, 3020.126090534662, 4750.071391283308]]\\n ue_costs3 = [[1872.3492340077084, 2897.9834368843217, 4886.769726452165], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\\n tolls_collected4 = [[602.0313412901077, 596.7300601881633, 833.3678073460065], [609.094482012133, 542.8579545671112, 843.1817520139325]]\\n so_costs4 = [[13252.728980891832, 20178.927282098706, 28549.614451166774], [1952.813764068618, 2991.4225756924197, 4716.774942888717]]\\n costs4 = [[13254.342842900576, 20239.30287102026, 28549.614731411177], [1992.3969007442322, 3130.0522527298062, 4805.6728306302175]]\\n ue_costs4 = [[13259.433117552415, 20185.90937054816, 28556.779443740656], [1993.9532544651581, 3087.4592286945117, 4889.562102247506]]\\n \\n \\n if delaytype == 'Hyperbolic':\\n # results for ind_obs=graph.indlinks.keys() \\n tolls_collected1 = [[161.15742640370462, 416.80264009965265, 948.124688583883], [161.4013529462645, 417.25218843773354, 950.1674351402539]]\\n so_costs1 = [[2519.5329969919685, 3679.4257321044365, 5325.940489651684], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs1 = [[2525.7590340322095, 3679.4261220632625, 5356.8071818038225], [2551.0113714206195, 3718.3028736461647, 5412.310857035818]]\\n ue_costs1 = [[2548.8303153671195, 3736.67165067958, 5444.499035875823], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # results for ind_obs=[(36,37,1), (13,14,1), (17,8,1), (24,17,1), (28,22,1), (14,13,1), (17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected2 = [[355.56391097372205, 701.3544774585599, 806.6640717434449], [374.34816990991186, 736.3763770517197, 842.0768966826593]]\\n so_costs2 = [[2174.1387842065237, 3306.974167934956, 4969.5560792612605], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs2 = [[2201.273656230071, 3338.7536674213156, 4988.732654672769], [2564.0153714222406, 3746.115605602468, 5398.046518880896]]\\n ue_costs2 = [[2209.622435372754, 3380.7186533697286, 5104.755602389524], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # results for ind_obs=[(17,24,1), (24,40,1), (14,21,1), (16,23,1)]\\n tolls_collected3 = [[339.37838703976513, 737.9887571945254, 930.0531221139565], [353.28118085588176, 763.3708450755438, 955.644104623869]]\\n so_costs3 = [[2520.1983680076073, 3833.234908857907, 5645.320052639795], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs3 = [[2536.138622203524, 3862.614483834193, 5668.430527845267], [2562.897499637454, 3750.9322754235955, 5406.402328441233]]\\n ue_costs3 = [[2556.0266644367803, 3903.9758481975805, 5741.545038028959], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # results for ind_obs=[(10,9,1), (19,18,1), (4,5,1), (29,21,1)]\\n tolls_collected4 = [[443.85669649193784, 837.5428841560781, 1380.117295219297], [479.57423528502, 931.2309202734045, 1499.6972922042573]]\\n so_costs4 = [[2158.995768390798, 3843.4202195503713, 7595.092411648515], [2544.920874812245, 3718.292867749051, 5383.190501656683]]\\n costs4 = [[2192.900868595389, 3888.0172745668465, 7626.17585256234], [2575.5748442305207, 3755.844017718783, 5450.304046277645]]\\n ue_costs4 = [[2231.1674179937672, 3999.772800567613, 7867.415688946321], [2574.155371287541, 3775.672784740404, 5503.564654849874]]\\n \\n # effects of toll pricing\\n opacity = 0.4\\n width = 0.2\\n index = np.arange(4)\\n plt.xticks(index, ('all', '10', '4 good', '4 bad') )\\n colors = ['y', 'r', 'b']\\n demands = ['94', '118', '142']\\n for i in [0,1,2]:\\n so = so_costs1[1][i]\\n ue = ue_costs1[1][i]\\n delta = ue-so\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*(costs1[1][i]-so)/delta, \\n 100.0*(costs2[1][i]-so)/delta, \\n 100.0*(costs3[1][i]-so)/delta, \\n 100.0*(costs4[1][i]-so)/delta],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative loss (%)')\\n plt.title('Effects of toll pricing with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\\n \\n # error in predicted UE\\n for i in [0,1,2]:\\n ue = ue_costs1[1][i]\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*abs(ue_costs1[0][i]-ue)/ue,\\n 100.0*abs(ue_costs2[0][i]-ue)/ue,\\n 100.0*abs(ue_costs3[0][i]-ue)/ue,\\n 100.0*abs(ue_costs4[0][i]-ue)/ue],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative error (%)')\\n plt.title('Error in predicted UE with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\\n \\n # error in predicted SO\\n for i in [0,1,2]:\\n so = so_costs1[1][i]\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*abs(so_costs1[0][i]-so)/so,\\n 100.0*abs(so_costs2[0][i]-so)/so,\\n 100.0*abs(so_costs3[0][i]-so)/so,\\n 100.0*abs(so_costs4[0][i]-so)/so],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative error (%)')\\n plt.title('Error in predicted SO with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\\n \\n # error in predicted tolled ue\\n for i in [0,1,2]:\\n plt.bar(index-width/2+(i-1)*width,\\n [100.0*abs(costs1[0][i]-costs1[1][i])/costs1[1][i],\\n 100.0*abs(costs2[0][i]-costs2[1][i])/costs2[1][i],\\n 100.0*abs(costs3[0][i]-costs3[1][i])/costs3[1][i],\\n 100.0*abs(costs4[0][i]-costs4[1][i])/costs4[1][i]],\\n width, alpha=opacity, color=colors[i], label='demand='+demands[i])\\n plt.xlabel('Sets of observed links')\\n plt.ylabel('Relative error (%)')\\n plt.title('Error in predicted tooled UE with '+delaytype+' delay function')\\n plt.legend(loc=0)\\n plt.show()\",\n \"def plot_convergence(\\n optimizers: list = [\\\"COBYLA\\\", \\\"SLSQP\\\", \\\"L-BFGS-B\\\", \\\"NELDER-MEAD\\\"],\\n g2N: float = 0.2,\\n maxit: int = 10000,\\n varform: list = [\\\"ry\\\"],\\n depth: int = 3,\\n nrep: int = 10,\\n dataprefix: str = \\\"data/miniBMN\\\",\\n datasuffix: str = \\\"h5\\\",\\n figprefix: str = \\\"figures/miniBMN\\\",\\n ht: float = 0.0,\\n up: int = 1000,\\n):\\n # setup parameters\\n params = dict()\\n params[\\\"l\\\"] = str(g2N).replace(\\\".\\\", \\\"\\\")\\n params[\\\"d\\\"] = depth\\n params[\\\"v\\\"] = \\\"-\\\".join(varform)\\n params[\\\"m\\\"] = maxit\\n params[\\\"n\\\"] = nrep\\n params[\\\"f\\\"] = dataprefix\\n params[\\\"s\\\"] = datasuffix\\n assert type(optimizers).__name__ == \\\"list\\\"\\n # collect data\\n result = collect_data(optimizers, params)\\n # get best runs\\n gs = dict()\\n for r in optimizers:\\n gs[r] = result.loc[r].groupby(\\\"rep\\\").apply(min).energy\\n gsdf = pd.DataFrame.from_dict(gs, dtype=float)\\n print(gsdf.describe().T[[\\\"min\\\", \\\"max\\\", \\\"mean\\\", \\\"std\\\"]])\\n # Plot\\n # select the best runs for each optimizer\\n fig, ax = plt.subplots()\\n for o in optimizers:\\n result.loc[o, gsdf[o].idxmin()].plot(\\n x=\\\"counts\\\", y=\\\"energy\\\", xlim=[0, up], label=o, ax=ax\\n )\\n ax.axhline(ht, c=\\\"k\\\", ls=\\\"--\\\", lw=\\\"2\\\", label=\\\"HT\\\")\\n ax.set_xlabel(\\\"iterations\\\")\\n ax.set_ylabel(\\\"VQE energy\\\")\\n ax.legend(loc=\\\"upper right\\\")\\n filename = f\\\"{figprefix}_l{params['l']}_convergence_{params['v']}_depth{params['d']}_nr{params['n']}_max{params['m']}_xlim{up}\\\"\\n plt.savefig(f\\\"{filename}.pdf\\\")\\n plt.savefig(f\\\"{filename}.png\\\")\\n plt.savefig(f\\\"{filename}.svg\\\")\\n plt.close()\",\n \"def plot_schedulability_rates_monte_carlo():\\n modes = [\\n # name, color, linestyle, marker\\n ('pSMC (Monte Carlo)', 'cyan', 'solid', 'D'),\\n ('pSMC', 'blue', 'dashed', 's'),\\n ('pAMC-BB (Monte Carlo)', 'purple', 'solid', 'v'),\\n ('pAMC-BB', 'red', 'dashed', '^')\\n ]\\n\\n rates = {}\\n task_sets_list = pickle.load(open(task_sets_path + 'task_sets_fairgen', 'rb'))\\n fig = plt.figure(figsize=(12, 6), dpi=300)\\n fig.suptitle('Evaluation: Monte Carlo Schemes (n=%d)' % len(task_sets_list[0]))\\n ax1 = fig.add_subplot(111)\\n for name, color, linestyle, marker in modes:\\n rates[name] = pickle.load(open(eval_monte_carlo_path + name, 'rb'))\\n ax1.plot(utils, rates[name], label=name, color=color, linestyle=linestyle, marker=marker)\\n ax1.set_xlabel('LO mode utilization')\\n ax1.set_ylabel('Percentage of task sets schedulable')\\n ax1.set_xticks([k * 0.5 for k in range(5)])\\n ax1.set_yticks([k * 20 for k in range(6)])\\n ax1.xaxis.set_minor_locator(ticker.AutoMinorLocator(5))\\n ax1.yaxis.set_minor_locator(ticker.AutoMinorLocator(1))\\n ax1.minorticks_on()\\n ax1.grid(which='both', linestyle='dashed')\\n\\n plt.axvline(1.0, color='black', linewidth=0.8)\\n plt.legend(loc='center left')\\n plt.xlim(0.1, 2.1)\\n plt.ylim(-5, 105)\\n plt.savefig('./figures/schedulability_rates_monte_carlo.png')\\n # plt.show()\",\n \"def visualization(positive_weights_dict, negative_weights_dict, l2_list):\\n plt.figure()\\n cmap_positive = plt.get_cmap('Reds')\\n cmap_negative = plt.get_cmap('Blues')\\n xx = l2_list\\n plt.plot(xx, [0.]*len(xx), '--', lw=1, color='k')\\n i, j = 0, 0\\n for key, value in positive_weights_dict.items():\\n color = cmap_positive(0.8*((i+1)/(5*1.2)+0.15))\\n plt.plot(l2_list, value, '-', label=key, linewidth=4.0, color=color)\\n i += 1\\n for key, value in negative_weights_dict.items():\\n color = cmap_negative(0.8*((j+1)/(5*1.2)+0.15))\\n plt.plot(l2_list, value, '-', label=key, linewidth=4.0, color=color)\\n j += 1\\n \\n plt.legend(loc='best', ncol=3, prop={'size':16}, columnspacing=0.5)\\n plt.axis([1, 1e5, -1, 2])\\n plt.title('Coefficient path')\\n plt.xlabel('L2 penalty ($\\\\lambda$)')\\n plt.ylabel('Coefficient value')\\n plt.xscale('log')\\n plt.rcParams.update({'font.size': 18})\\n plt.tight_layout()\",\n \"def plot_graph(self) -> None:\",\n \"def plot_budget_analyais_results(df, fs=8, fs_title=14, lw=3, fontsize=20, colors=['#AA3377', '#009988', '#EE7733', '#0077BB', '#BBBBBB', '#EE3377', '#DDCC77']):\\n df_decomposed = df.loc[df['block'] == 'decomposed']\\n df_joint = df.loc[df['block'] == 'joint']\\n ticklabels = []\\n num_sweeps = df_decomposed['num_sweeps'].to_numpy()\\n sample_sizes = df_decomposed['sample_sizes'].to_numpy()\\n for i in range(len(num_sweeps)):\\n ticklabels.append('K=%d\\\\nL=%d' % (num_sweeps[i], sample_sizes[i]))\\n fig = plt.figure(figsize=(fs*2.5, fs))\\n ax1 = fig.add_subplot(1, 2, 1)\\n ax1.plot(num_sweeps, df_decomposed['density'].to_numpy(), 'o-', c=colors[0], linewidth=lw, label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax1.plot(num_sweeps, df_joint['density'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax1.set_xticks(num_sweeps)\\n ax1.set_xticklabels(ticklabels)\\n ax1.tick_params(labelsize=fontsize)\\n ax1.grid(alpha=0.4)\\n ax2 = fig.add_subplot(1, 2, 2)\\n ax2.plot(num_sweeps, df_decomposed['ess'].to_numpy(), 'o-', c=colors[0], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau\\\\}, \\\\{c\\\\}$')\\n ax2.plot(num_sweeps, df_joint['ess'].to_numpy(), 'o-', c=colors[1], linewidth=lw,label=r'$\\\\{\\\\mu, \\\\tau, c\\\\}$')\\n ax2.set_xticks(num_sweeps)\\n ax2.set_xticklabels(ticklabels)\\n ax2.tick_params(labelsize=fontsize)\\n ax2.grid(alpha=0.4)\\n ax2.legend(fontsize=fontsize)\\n ax1.legend(fontsize=fontsize)\\n ax1.set_ylabel(r'$\\\\log \\\\: p_\\\\theta(x, \\\\: z)$', fontsize=35)\\n ax2.set_ylabel('ESS / L', fontsize=35)\",\n \"def plot_price_evolution_for_nr_run(nr_log):\\n plt.figure(figsize=(10, 5))\\n\\n plt.plot(nr_log['time'], nr_log['virtual_price'], '.', label='NR')\\n\\n plt.legend()\\n\\n plt.grid()\\n\\n plt.title('Network Relaxation run - Grid price evolution')\\n\\n plt.xlabel('time [s]')\\n\\n plt.ylabel('price [$]')\\n\\n plt.show()\",\n \"def draw_costs_by_requests(costs, **kwargs):\\n\\n if 'title' in kwargs:\\n title = kwargs['title']\\n else:\\n title = 'Monthy cost by number of reqs/s'\\n data = []\\n\\n color = iter([\\n BBVAcolors['light'],\\n BBVAcolors['aqua'],\\n BBVAcolors['navy'],\\n BBVAcolors['coral']\\n ])\\n\\n for flavor in costs.keys():\\n x = list()\\n y = list()\\n for reqs, price in costs[flavor].items():\\n x.append(reqs)\\n y.append(price)\\n\\n trace = go.Scatter(\\n x=x,\\n y=y,\\n name=flavor,\\n marker=next(color)\\n )\\n data.append(trace)\\n\\n layout = go.Layout(\\n title=title,\\n legend=dict(\\n orientation=\\\"h\\\",\\n y=-.2,\\n ),\\n width=950,\\n height=500,\\n xaxis=dict(\\n title='reqs/sec',\\n type='log'\\n ),\\n yaxis=dict(\\n title='Monthly cost ($)',\\n type='log'\\n )\\n )\\n\\n return go.Figure(data=data, layout=layout)\",\n \"def bench_plotter(self):\\n\\n # plot random as histogram, upper en lower bound as a red line\\n minima = []\\n for i in range(1, 4):\\n cost_list = []\\n with open(f\\\"../output_runs/text_info_random{i}_10k.txt\\\", \\\"r\\\") as f:\\n text = f.read().split('\\\\n')\\n counter = 0\\n for number in text:\\n counter += 1\\n if number is not \\\"\\\":\\n cost_list.append(int(number))\\n if counter == 1000:\\n break\\n minim = min(cost_list)\\n minima.append(minim)\\n maxim = max(cost_list)\\n print(\\\"random:\\\", minim, maxim)\\n plt.axvline(x=53188, color='r')\\n plt.axvline(x=103030, color=\\\"r\\\")\\n plt.hist(cost_list, bins=20, alpha=0.5, label=f\\\"Random walk\\\")\\n\\n # plot histogram of priority and hillclimber\\n cost_list = []\\n with open(f\\\"../output_runs/text_info_prior_hill{i}_\\\\\\n 1k.txt\\\", \\\"r\\\") as f:\\n text = f.read().split('\\\\n')\\n for number in text:\\n if number is not \\\"\\\":\\n cost_list.append(int(number))\\n minim = min(cost_list)\\n minima.append(minim)\\n maxim = max(cost_list)\\n print(\\\"prior hill:\\\", minim, maxim)\\n plt.hist(cost_list, bins=20, alpha=0.5, label=f\\\"Priority + Hill\\\")\\n\\n # plot histogram of simulated annealing\\n cost_list = []\\n with open(f\\\"../output_runs/simulated_annealing{i}_1000.txt\\\",\\n \\\"r\\\") as f:\\n text = f.read().split('\\\\n')\\n for number in text:\\n if number is not \\\"\\\":\\n cost_list.append(int(number))\\n minim = min(cost_list)\\n minima.append(minim)\\n maxim = max(cost_list)\\n print(\\\"random+anneal:\\\", minim, maxim)\\n plt.hist(cost_list, bins=20, alpha=0.5,\\n label=f\\\"Random + sim anneal\\\")\\n\\n # plot histogram of random plus hillclimber\\n cost_list = []\\n with open(f\\\"../output_runs/random_hill{i}_1000.txt\\\", \\\"r\\\") as f:\\n text = f.read().split('\\\\n')\\n for number in text:\\n if number is not \\\"\\\":\\n cost_list.append(int(number))\\n minim = min(cost_list)\\n minima.append(minim)\\n maxim = max(cost_list)\\n print(\\\"random+hill:\\\", minim, maxim)\\n plt.hist(cost_list, bins=100, alpha=0.5,\\n label=f\\\"Random + Hillclimber\\\")\\n\\n # plot histogram of kmeans plus hillclimber\\n cost_list = []\\n with open(f\\\"../output_runs/text_k-means_hill{i}_\\\\\\n 1000.txt\\\", \\\"r\\\") as f:\\n text = f.read().split('\\\\n')\\n for number in text:\\n if number is not \\\"\\\":\\n cost_list.append(int(number))\\n plt.hist(cost_list, bins=20, alpha=0.5,\\n label=f\\\"Kmean and hill {i}\\\")\\n totalmin = min(minima)\\n plt.axvline(x=totalmin, color=\\\"g\\\")\\n plt.title(f\\\"4 algorithms Wijk {i}, lowest cost: {totalmin}\\\")\\n plt.xlabel(\\\"Cost\\\")\\n plt.ylabel(\\\"Frequency\\\")\\n plt.legend(loc='upper right')\\n plt.show()\",\n \"def plot_cost_history(alpha, cost_history):\\n \\n cost_df = pandas.DataFrame({\\n 'Cost_History': cost_history,\\n 'Iteration': range(len(cost_history))\\n })\\n \\n return ggplot(cost_df, aes('Iteration', 'Cost_History')) + geom_point() + ggtitle('Cost History for alpha = %.3f' % alpha )\",\n \"def plot_iterations(iters):\\n axes = [plt.plot(lin.X, lin.Y, color='k', alpha=.15) for lin in iters]\\n return axes\",\n \"def plot_fig(dict_cycle, number):\\n\\n for i in range(number):\\n print(i+1)\\n data = data_frame(dict_cycle, i+1)\\n plt.plot(data.Potential, data.Current, label=\\\"Cycle{}\\\".format(i+1))\\n\\n print(data.head())\\n plt.xlabel('Voltage')\\n plt.ylabel('Current')\\n plt.legend()\\n plt.savefig('cycle.png')\\n print('executed')\",\n \"def visualize(self, time, pred, true):\\n plt.plot(time, true, label='Actual')\\n plt.plot(time, pred, label='Predicted')\\n plt.xlabel('Time')\\n plt.ylabel('Price ($)')\\n plt.legend(bbox_to_anchor=(0.1, 1), loc=2, borderaxespad=0.,\\n prop={'size': 14})\\n plt.show()\",\n \"def visualize(dcf_prices, current_share_prices, regress = True):\\n # TODO: implement\\n return NotImplementedError\",\n \"def plot_results(epochs: int = 20, segments: int = 5, plot: bool = True):\\n \\\"\\\"\\\"\\n plt.figure(0)\\n plot_approximation(\\\"product\\\", modelSetProd, 1, epochs, gpus=0)\\n \\\"\\\"\\\"\\n\\n data = [\\n {\\n \\\"title\\\": \\\"Piecewise Discontinuous Function Approximation\\\",\\n \\\"layer\\\": \\\"discontinuous\\\",\\n \\\"model_set\\\": modelSetD,\\n },\\n {\\n \\\"title\\\": \\\"Piecewise Continuous Function Approximation\\\",\\n \\\"layer\\\": \\\"continuous\\\",\\n \\\"model_set\\\": modelSetC,\\n },\\n {\\n \\\"title\\\": \\\"Polynomial function approximation\\\",\\n \\\"layer\\\": \\\"polynomial\\\",\\n \\\"model_set\\\": modelSetP,\\n },\\n {\\n \\\"title\\\": \\\"Fourier function approximation\\\",\\n \\\"layer\\\": \\\"fourier\\\",\\n \\\"model_set\\\": modelSetF,\\n },\\n ]\\n\\n for index, element in enumerate(data):\\n if plot is True:\\n plt.figure(index)\\n plot_approximation(\\n element[\\\"layer\\\"],\\n element[\\\"model_set\\\"],\\n 5,\\n epochs,\\n accelerator=\\\"cpu\\\",\\n periodicity=2,\\n )\\n\\n if plot is True:\\n plt.title(\\\"Piecewise Discontinuous Function Approximation\\\")\\n\\n if plot is True:\\n plt.show()\",\n \"def plot_loss_curve(num_epochs, losses):\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss') \\n plt.title('Loss Curve') \\n plt.plot(range(num_epochs), losses)\\n plt.show()\",\n \"def updatePlot(self,cost):\\r\\n timer = time.clock() - self.start_timer\\r\\n # Add new values to plot data set \\r\\n self.lines.set_xdata(np.append(self.lines.get_xdata(), timer))\\r\\n self.lines.set_ydata(np.append(self.lines.get_ydata(), cost))\\r\\n # Re-scale\\r\\n self.axCost.relim()\\r\\n self.axCost.autoscale_view()\\r\\n # Update plot\\r\\n self.canvasPlot.draw()\\r\\n self.canvasPlot.flush_events()\",\n \"def plot(self, epochs, title=\\\"Learning Rate Schedule\\\"):\\n lrs = [self(i) for i in epochs]\\n\\n # plot the learning rate schedule\\n plt.style.use(\\\"ggplot\\\")\\n plt.figure()\\n plt.plot(epochs, lrs)\\n plt.title(title)\\n plt.xlabel(\\\"Epoch #\\\")\\n plt.ylabel(\\\"Learning Rate\\\")\\n plt.close()\",\n \"def plot_qlearning_smooth(reward_cache):\\n mean_rev = (np.array(reward_cache[0:11]).sum())/10\\n # initialize with cache mean\\n cum_rewards = [mean_rev] * 10\\n idx = 0\\n for cache in reward_cache:\\n cum_rewards[idx] = cache\\n idx += 1\\n smooth_reward = (np.array(cum_rewards).mean())\\n cum_rewards.append(smooth_reward)\\n if(idx == 10):\\n idx = 0\\n \\n plt.plot(cum_rewards)\\n plt.ylabel('Cumulative Rewards')\\n plt.xlabel('Batches of Episodes (sample size 10) ')\\n plt.title(\\\"Q-Learning Convergence of Cumulative Reward\\\")\\n plt.legend(loc='lower left', ncol=2, mode=\\\"expand\\\", borderaxespad=0.)\\n plt.show()\",\n \"def _plot(self, rewards, losses, epsilons):\\n plt.figure(figsize=(20,5))\\n plt.subplot(131)\\n plt.title('Episodic Reward')\\n plt.plot(rewards)\\n plt.subplot(132)\\n plt.title('TD Loss')\\n plt.plot(losses)\\n plt.subplot(133)\\n plt.title('Epsilon')\\n plt.plot(epsilons)\\n plt.tight_layout()\\n plt.show()\",\n \"def plot(self):\\n\\t\\tplot_chain(self.database_path, self.temp_folder)\\n\\t\\tplot_density(self.database_path, self.temp_folder, self.cal_params)\",\n \"def plot(self):\\n pass\",\n \"def plot(self, iteration):\\n plt.cla()\\n self.plot_function()\\n x = self._population[:,0]\\n y = self._population[:,1]\\n z = self._last_evaluation\\n max_x, max_y = self._global_optimal_position\\n max_z = self._global_optimal_value\\n self._axes.scatter3D(x, y, z, c=\\\"r\\\")\\n self._axes.scatter(max_x, max_y, max_z, marker=\\\"*\\\", s=500, c=\\\"b\\\")\\n\\n self._axes.set_xlabel(f\\\"x (best={max_x})\\\")\\n self._axes.set_ylabel(f\\\"y (best={max_y})\\\")\\n self._axes.set_zlabel(f\\\"z (best={max_z})\\\")\\n self._axes.text(self._lower_bound, self._lower_bound, 1.5*max_z, f\\\"#Iteration {iteration}\\\")\\n\\n plt.gcf().canvas.mpl_connect(\\\"key_press_event\\\", self.key_press_handler)\\n if self._wait_for_key:\\n while not plt.waitforbuttonpress():\\n pass\\n else:\\n plt.pause(0.5)\",\n \"def visualize(self, network, f):\\n import matplotlib\\n matplotlib.use('Agg',warn=False)\\n import matplotlib.pyplot as plt\\n # Convert to a network if it is not.\\n if not isinstance(network, NeuralNetwork):\\n network = NeuralNetwork(network)\\n \\n fig = plt.figure()\\n steps, states, actions = self._loop(network, max_steps=1000)\\n # TEMP STUFF\\n actions = np.array(actions)\\n print((actions.size, np.histogram(actions)[0]))\\n ##\\n x, dx, theta, dtheta = list(zip(*states))\\n theta = np.vstack(theta).T\\n dtheta = np.vstack(dtheta).T\\n # The top plot (cart position)\\n top = fig.add_subplot(211)\\n top.fill_between(list(range(len(x))), -self.h, self.h, facecolor='green', alpha=0.3)\\n top.plot(x, label=r'$x$') \\n top.plot(dx, label=r'$\\\\delta x$')\\n top.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\\n # The bottom plot (pole angles)\\n bottom = fig.add_subplot(212)\\n bottom.fill_between(list(range(theta.shape[1])), -self.r, self.r, facecolor='green', alpha=0.3)\\n for i, (t, dt) in enumerate(zip(theta, dtheta)):\\n bottom.plot(t, label=r'$\\\\theta_%d$'%i)\\n bottom.plot(dt, ls='--', label=r'$\\\\delta \\\\theta_%d$'%i)\\n bottom.legend(loc='lower left', ncol=4, fancybox=True, bbox_to_anchor=(0, 0, 1, 1))\\n fig.savefig(f)\",\n \"def quick_plot(solution):\\n plt.suptitle('GNLSE solution')\\n\\n plt.subplot(1, 2, 1)\\n plot_wavelength_vs_distance(solution)\\n\\n plt.subplot(1, 2, 2)\\n plot_delay_vs_distance(solution)\\n\\n plt.show()\",\n \"def plot(self) -> None:\\n if self.__fig is None:\\n self.__fig = plt.figure()\\n\\n xv = []\\n yv = []\\n for x in np.arange(self.state_min(), self.state_max(), self.state_step()):\\n xv.append(x)\\n yv.append(self.reward(x))\\n ax = self.__fig.gca()\\n ax.set_xlabel('X (State)')\\n ax.set_ylabel('Y (Reward)')\\n ax.set_title('Reward Function')\\n ax.plot(xv, yv)\\n plt.pause(self.__plot_pause)\\n plt.show(block=False)\\n return\",\n \"def plot(self):\\n\\n fig, ax = plt.subplots()\\n\\n for run in self.runs:\\n # Load datasets\\n data_measure = run.get_dataset(\\\"stats-collect_link_congestion-raw-*.csv\\\")\\n data_sp = run.get_dataset(\\\"stats-collect_link_congestion-sp-*.csv\\\")\\n\\n # Extract link congestion information\\n data_measure = data_measure['msgs']\\n data_sp = data_sp['msgs']\\n\\n # Compute ECDF and plot it\\n ecdf_measure = sm.distributions.ECDF(data_measure)\\n ecdf_sp = sm.distributions.ECDF(data_sp)\\n\\n variable_label = \\\"\\\"\\n size = run.orig.settings.get('size', None)\\n if size is not None:\\n variable_label = \\\" (n=%d)\\\" % size\\n\\n ax.plot(ecdf_measure.x, ecdf_measure.y, drawstyle='steps', linewidth=2,\\n label=\\\"U-Sphere%s\\\" % variable_label)\\n ax.plot(ecdf_sp.x, ecdf_sp.y, drawstyle='steps', linewidth=2,\\n label=u\\\"Klasični usmerjevalni protokol%s\\\" % variable_label)\\n\\n ax.set_xlabel('Obremenjenost povezave')\\n ax.set_ylabel('Kumulativna verjetnost')\\n ax.grid()\\n ax.axis((28, None, 0.99, 1.0005))\\n self.convert_axes_to_bw(ax)\\n\\n legend = ax.legend(loc='lower right')\\n if self.settings.GRAPH_TRANSPARENCY:\\n legend.get_frame().set_alpha(0.8)\\n fig.savefig(self.get_figure_filename())\",\n \"def plot_grating_coupler_sweep_efficiency(matlab_file_path, function=log):\\n d = loadmat(matlab_file_path)\\n print(d.keys())\\n\\n N = len(d[\\\"M_sweep\\\"][0])\\n parameter = np.zeros(N)\\n efficiency = np.zeros(N)\\n\\n for i in range(N):\\n parameter[i] = 1e9 * d[\\\"M_sweep\\\"][0][i]\\n # x = d[\\\"WL\\\"][0] * 1e9\\n y = function(d[\\\"M_T\\\"][i])\\n efficiency[i] = np.max(y)\\n\\n plt.figure()\\n plt.xlabel(\\\"waveguide height (nm)\\\")\\n plt.ylabel(\\\"Eficiency (dB)\\\")\\n plt.plot(parameter, efficiency, \\\".\\\")\\n plt.legend()\",\n \"def show():\\n\\tplt.show()\",\n \"def plot_progression(weights, bhs, bvs):\\n\\tweights_plot = []\\n\\tfor i in range(40):\\n\\t\\tweights_plot.append(weights[i][0][0])\\t# only plots the first value in the matrix every time\\n\\tplt.plot(weights_plot)\\n\\n\\tplt.show()\",\n \"def plot_associative_learning_progress(ax, df):\\n\\n num_objects_list = sorted(df.curr_num_objects.unique())\\n legend_list = []\\n for idx in num_objects_list:\\n ax.plot(df[df.curr_num_objects == idx].groupby('objects_iter').rewards.mean())\\n legend_list.append(f'ns={idx}')\\n ax.set_xlabel('Stimulus iteration')\\n ax.set_ylabel('P(correct)')\\n ax.set_ylim([0.4, 1])\\n ax.legend(legend_list)\",\n \"def convergence():\\n fig, axes = plt.subplots(nrows=2, figsize=figsize(aspect=1.2))\\n\\n # label names\\n label1 = str(league.lambda1)\\n label2_list = [str(lambda2) for lambda2 in league.lambda2_list]\\n\\n # point spread and point total subplots\\n subplots = [\\n (False, [-0.5, 0.5], league.spreads, 'probability spread > 0.5'),\\n (True, [200.5], league.totals, 'probability total > 200.5'),\\n ]\\n\\n for ax, (commutes, lines, values, ylabel) in zip(axes, subplots):\\n\\n # train margin-dependent Elo model\\n melo = Melo(lines=lines, commutes=commutes, k=1e-4)\\n melo.fit(league.times, league.labels1, league.labels2, values)\\n\\n line = lines[-1]\\n\\n for label2 in label2_list:\\n\\n # evaluation times and labels\\n times = np.arange(league.times.size)[::1000]\\n labels1 = times.size * [label1]\\n labels2 = times.size * [label2]\\n\\n # observed win probability\\n prob = melo.probability(times, labels1, labels2, lines=line)\\n ax.plot(times, prob)\\n\\n # true (analytic) win probability\\n if ax.is_first_row():\\n prob = skellam.sf(line, int(label1), int(label2))\\n ax.axhline(prob, color='k')\\n else:\\n prob = poisson.sf(line, int(label1) + int(label2))\\n ax.axhline(prob, color='k')\\n\\n # axes labels\\n if ax.is_last_row():\\n ax.set_xlabel('Iterations')\\n ax.set_ylabel(ylabel)\\n\\n set_tight(w_pad=.5)\",\n \"def plot_returns(self):\\n strategy = self.equity_curve['equity_curve']\\n benchmark, index = benchmark_return()\\n fig, ax = plt.subplots()\\n ax.plot(strategy.index.astype('datetime64'), strategy, label='strategy')\\n ax.plot(benchmark.index.astype('datetime64'), benchmark, label=index)\\n ax.plot(benchmark.index.astype('datetime64'), (1+strategy-benchmark),\\n label='excess earnings', linestyle='--', linewidth=0.5)\\n ax.grid(True)\\n\\n plt.xlabel('Year-Month')\\n plt.ylabel('Return (%)')\\n plt.title('Equity curve')\\n plt.legend()\",\n \"def samplecost(app, endclasses, fxnmode, samptype='std', title=\\\"\\\"):\\n associated_scens=[]\\n for phase in app.phases:\\n associated_scens = associated_scens + app.scenids.get((fxnmode, phase), [])\\n costs = np.array([endclasses[scen]['cost'] for scen in associated_scens])\\n times = np.array([time for phase, timemodes in app.sampletimes.items() if timemodes for time in timemodes if fxnmode in timemodes.get(time)] ) \\n rates = np.array(list(app.rates_timeless[fxnmode].values()))\\n \\n tPlot, axes = plt.subplots(2, 1, sharey=False, gridspec_kw={'height_ratios': [3, 1]})\\n phasetimes_start =[times[0] for phase, times in app.phases.items()]\\n phasetimes_end =[times[1] for phase, times in app.phases.items()]\\n ratetimes =[]\\n ratesvect =[]\\n phaselocs = []\\n for (ind, phasetime) in enumerate(phasetimes_start):\\n axes[0].axvline(phasetime, color=\\\"black\\\") \\n phaselocs= phaselocs +[(phasetimes_end[ind]-phasetimes_start[ind])/2 + phasetimes_start[ind]]\\n\\n axes[1].axvline(phasetime, color=\\\"black\\\") \\n ratetimes = ratetimes + [phasetimes_start[ind]] + [phasetimes_end[ind]]\\n ratesvect = ratesvect + [rates[ind]] + [rates[ind]]\\n #axes[1].text(middletime, 0.5*max(rates), list(app.phases.keys())[ind], ha='center', backgroundcolor=\\\"white\\\")\\n #rate plots\\n axes[1].set_xticks(phaselocs)\\n axes[1].set_xticklabels(list(app.phases.keys()))\\n \\n axes[1].plot(ratetimes, ratesvect)\\n axes[1].set_xlim(phasetimes_start[0], phasetimes_end[-1])\\n axes[1].set_ylim(0, np.max(ratesvect)*1.2 )\\n axes[1].set_ylabel(\\\"Rate\\\")\\n axes[1].set_xlabel(\\\"Time (\\\"+str(app.units)+\\\")\\\")\\n axes[1].grid()\\n #cost plots\\n axes[0].set_xlim(phasetimes_start[0], phasetimes_end[-1])\\n axes[0].set_ylim(0, 1.2*np.max(costs))\\n if samptype=='fullint':\\n axes[0].plot(times, costs, label=\\\"cost\\\")\\n else:\\n if samptype=='quadrature' or samptype=='pruned piecewise-linear': \\n sizes = 1000*np.array([weight if weight !=1/len(timeweights) else 0.0 for phase, timeweights in app.weights[fxnmode].items() for time, weight in timeweights.items() if time in times])\\n axes[0].scatter(times, costs,s=sizes, label=\\\"cost\\\", alpha=0.5)\\n axes[0].stem(times, costs, label=\\\"cost\\\", markerfmt=\\\",\\\", use_line_collection=True)\\n \\n axes[0].set_ylabel(\\\"Cost\\\")\\n axes[0].grid()\\n if title: axes[0].set_title(title)\\n elif type(fxnmode[0])==tuple: axes[0].set_title(\\\"Cost function of \\\"+str(fxnmode)+\\\" over time\\\")\\n else: axes[0].set_title(\\\"Cost function of \\\"+fxnmode[0]+\\\": \\\"+fxnmode[1]+\\\" over time\\\")\\n #plt.subplot_adjust()\\n plt.tight_layout()\",\n \"def plot_running_time():\\n global counter\\n counter += 1\\n running_time_targeted = []\\n running_time_fast_targeted = []\\n \\n for node_number in range(10, 1000, 10):\\n synthetic_undirected_graph = make_synthetic_undirected_graph(node_number, 5)\\n\\n start_time = time.time()\\n attack_order = targeted_order(synthetic_undirected_graph)\\n stop_time = time.time()\\n running_time_targeted.append(stop_time - start_time)\\n \\n start_time = time.time()\\n attack_order = fast_targeted_order(synthetic_undirected_graph)\\n stop_time = time.time()\\n running_time_fast_targeted.append(stop_time - start_time)\\n \\n plt.plot(range(10, 1000, 10), running_time_targeted, '-b', label = 'targeted_order')\\n plt.plot(range(10, 1000, 10), running_time_fast_targeted, '-r', label = 'fast_targeted_order')\\n \\n plt.legend(loc='upper right')\\n\\n\\n plt.title(\\\" plot of running time of desktop Python\\\")\\n plt.xlabel(\\\"the number of nodes\\\")\\n plt.ylabel(\\\"running times\\\")\\n plt.savefig(\\\"running_time_\\\"+str(counter)+\\\".png\\\", dpi = 72)\\n plt.gcf().clear() # hose-keeping\",\n \"def geneticAlgorithmPlot(population, popSize, fittestSize, mutationRate, generations):\\n pop = GA.initialPopulation(popSize, population)\\n progress = []\\n progress.append(1 / GA.rankRoutes(pop)[0][1])\\n \\n for i in range(0, generations):\\n pop = GA.nextGeneration(pop, fittestSize, mutationRate)\\n progress.append(1 / GA.rankRoutes(pop)[0][1])\\n \\n plt.plot(progress)\\n plt.ylabel('Distance')\\n plt.xlabel('Generation')\\n plt.show()\",\n \"def plot_resiliences(nodes, network_vals, er_vals, upa_vals):\\n node_vals = range(0, nodes)\\n\\n plt.plot(node_vals, network_vals, '-b', label='Network')\\n plt.plot(node_vals, er_vals, '-r', label='ER')\\n plt.plot(node_vals, upa_vals, '-g', label='UPA')\\n\\n plt.legend(loc='upper right')\\n plt.ylabel('Size of Largest Connected Component')\\n plt.xlabel('Number of Nodes Removed')\\n plt.grid(True)\\n plt.title('Comparison of Graph Resilience\\\\nMeasured by Largest Connected Component vs Nodes Removed by Target Attack\\\\n')\\n plt.show()\",\n \"def _plot(self):\\n\\n #self.best_canvas.Clear()\\n self.current_canvas.Clear()\\n\\n if len(self.results) > 0:\\n x_max = self.results[-1][2]\\n #self.best_canvas.xSpec = (0, x_max)\\n self.current_canvas.xSpec = (0, x_max)\\n\\n # best_points = [(r.time, r.best.distance) for r in self.results\\n # if r.best is not None and\\n # isinstance(r.best.distance, int)]\\n # best_line = PolyLine(best_points)\\n # best_plot = PlotGraphics([best_line],\\n # title='Best path distance over time',\\n # xLabel='Time [ns]', yLabel='Distance')\\n\\n current_points = [self.TopLevelParent.solver_view.tsp_view._points[x] for x in self.results[-1][0]] if len(self.results) > 0 else []\\n # current_points = [(r[2], r[0]) for r in self.results]\\n if len(current_points) > 0:\\n current_line = PolyLine(current_points)\\n current_plot = PlotGraphics([current_line],\\n title='Current path distance over time',\\n xLabel='Iter', yLabel='Score')\\n\\n #self.best_canvas.Draw(best_plot)\\n self.current_canvas.Draw(current_plot)\",\n \"def plotEvaluation(results,nbr_file : int,path : str, labels = [\\\"\\\"],target_name = \\\"\\\"):\\n fig,ax = plt.subplots(1,1)\\n ax.set_yscale(\\\"log\\\")\\n for res in range(len(results)):\\n data = [np.array(p[1]) for p in results[res]]\\n number_of_simulation = len(data)\\n\\n average_values = np.zeros(len(data[0]))\\n for d in data:\\n average_values =average_values + d\\n average_values = np.array(average_values) / number_of_simulation\\n \\n error_values = [0 for i in range(len(average_values))]\\n for j in range(len(error_values)):\\n if j%int(len(error_values)/50)==0 :\\n for i in range(len(data)):\\n error_values[j] += (data[i][j] - average_values[j])**2\\n error_values[j] = np.sqrt(error_values[j]/number_of_simulation)\\n opt = 0\\n tfile = ''\\n if path == 'data/B/b':\\n opt = B_opts[nbr_file-1]\\n tfile = 'b'\\n else:\\n opt = C_opts[nbr_file-1]\\n tfile = 'c'\\n \\n \\n ax.errorbar(range(len(average_values)),average_values,yerr = error_values, ecolor = \\\"black\\\", linewidth = 1, elinewidth = 1, label = labels[res])\\n \\n \\n #ax.ylim((opt-5,max(opt*2,average_values[-1]+10)))\\n plt.title(f'{target_name} : The evolution of the best evaluation (in average) \\\\nfor graph {tfile}{nbr_file}.stp for {number_of_simulation} simulations')\\n plt.xlabel(\\\"steps\\\")\\n plt.ylabel(\\\"evaluation\\\")\\n ax.legend()\\n ax.axhline(opt, color='red', label = \\\"Optimal solution\\\")\\n plt.savefig(f'best_{tfile}{nbr_file}_evaluation_{target_name}.png')\\n plt.show()\",\n \"def do_plot(self):\\n years = sorted(set(self.prediction_df_without_covid19['Year']))\\n predict_without_covid_country = self.prediction_df_without_covid19[\\n self.prediction_df_without_covid19['Country'].isin([self.country])].sort_values(['Year'],\\n ascending=[True])\\n predict_with_covid_country = self.prediction_df_with_covid19[\\n self.prediction_df_with_covid19['Country'].isin([self.country])].sort_values(['Year'],\\n ascending=[True])\\n # ------------------------------------------------------------------------------------------------------\\n pa = \\\\\\n predict_without_covid_country.loc[predict_without_covid_country['Year'] == 1990][\\n 'Total_CO2_Emissions'].values[\\n 0]\\n x = []\\n for i in range(len(years)):\\n x.append(pa * 0.6)\\n # ------------------------------------------------------------------------------------------------------\\n fig = Figure()\\n ax = fig.subplots()\\n ax.grid(True, alpha=0.3)\\n # plot_title = 'Total CO2 Emissions predicted from 2019-2030 for ' + self.country\\n plot_title = 'Total ' + '$CO_2$' + ' Emissions predicted from 2019-2030 for ' + self.country\\n label_country_without_covid = 'Total CO2 emissions without covid'\\n label_country_with_covid = 'Total CO2 emissions with Covid-19'\\n # ------------------------------------------------------------------------------------------------------\\n params = {'mathtext.default': 'regular'}\\n rcParams.update(params)\\n rcParams['font.size'] = 7\\n rcParams['lines.markersize'] = 4\\n rcParams['figure.figsize'] = [7, 4]\\n rcParams['figure.dpi'] = 150\\n rcParams['font.family'] = 'Verdana'\\n rcParams[\\\"font.weight\\\"] = \\\"normal\\\"\\n font = {'family': 'Verdana',\\n 'color': 'xkcd:darkgreen',\\n 'weight': 'normal',\\n 'size': 9,\\n }\\n colors = rcParams['axes.prop_cycle'].by_key()['color']\\n l1, = ax.plot(years, predict_without_covid_country['Total_CO2_Emissions'], color='xkcd:dark blue green',\\n marker='o',\\n label=label_country_without_covid)\\n l2, = ax.plot(years, predict_with_covid_country['Total_CO2_Emissions'], color='xkcd:neon pink', marker='.',\\n label=label_country_with_covid)\\n l3, = ax.plot(years, x, color='xkcd:orchid', marker='1')\\n print('without covid: ', predict_without_covid_country['Total_CO2_Emissions'].values)\\n print('with covid: ', predict_with_covid_country['Total_CO2_Emissions'].values)\\n ax.set_xlabel('Years', fontdict=font)\\n ax.set_ylabel('Emissions (Gg)', fontdict=font)\\n ax.set_title(plot_title, fontsize=12, fontweight='normal')\\n ax.patch.set_facecolor('xkcd:green')\\n ax.set_facecolor('xkcd:pale green')\\n fig.legend((l1, l2, l3), ('Prediction without Covid19', 'Prediction with Covid19', 'Paris Agreement'),\\n bbox_to_anchor=(0.907, 0.89))\\n fig.savefig(OUTPUT_GRAPH_PATH)\",\n \"def plot(self):\\n \\n \\n x_ibs=[] \\n x_gss=[]\\n y_ibs=[] \\n y_gss=[]\\n x_pso=[]\\n x_bgd=[]\\n y_bgd=[]\\n y_pso=[]\\n x_gd=[]\\n y_gd=[]\\n \\n i=0.0000001\\n \\n # for k in range(1,51):\\n # i= random.uniform(0.00000001, 1)\\n # t_avg_ibs=[]\\n # t_avg_gss=[]\\n # for j in range(1,51):\\n #L=random.randint(-100, 0)\\n #U=random.randint(0, 100)\\n max_iter=self.Max_iter \\n L=self.Lower_bound\\n U=self.Upper_bound\\n \\n minima=self.gss(L,U,i,1000)\\n #print(\\\"minima at X = \\\",minima[1])\\n x_ibs.append(self.I_bisection(L,U,minima[1],max_iter)[0])\\n x_gss.append(self.gss(L,U,i,max_iter)[0])\\n x_pso.append(self.particle_Swarm(self.func, L, U, 2, max_iter)[0])\\n x_gd.append(self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)[0])\\n x_bgd.append(self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)[0])\\n #print(x_pso)\\n for i in x_ibs[0]:\\n #print(self.Func(i)) \\n y_ibs.append(self.Func(i))\\n for i in x_gss[0]:\\n y_gss.append(self.Func(i)) \\n for i in x_pso[0]:\\n y_pso.append(self.Func(i)) \\n for i in x_gd[0]:\\n y_gd.append(self.Func(i)) \\n for i in x_bgd[0]:\\n y_bgd.append(self.Func(i)) \\n #print(y_gss)\\n\\n plt.plot(x_ibs[0], y_ibs, 'r.')\\n plt.plot(x_gss[0], y_gss, '.')\\n plt.plot(x_pso[0], y_pso, 'y.')\\n #plt.plot(x_gd[0], y_gd, 'y.')\\n #plt.plot(x_bgd[0], y_bgd, 'k.')\\n plt.xlabel('x')\\n plt.ylabel('y')\\n \\n plt.suptitle('Interval Bisection Search (Red) vs Golden Section Search (Blue) vs Particle swarm optimization (Green)')\\n #plt.axis([0, 100, 0.00000001, 1]) \\n plt.show()\\n plt.plot(x_gd[0], y_gd, 'r.')\\n plt.plot(x_bgd[0], y_bgd, 'k.')\\n plt.xlabel('x')\\n plt.ylabel('y') \\n plt.suptitle('Gradient Descent (Red) vs Batch Gradient Descent (Black) ')\\n \\n plt.show()\\n \\n start_time = timeit.default_timer()\\n ibs=self.I_bisection(L,U,minima[1],max_iter)\\n print(\\\" Execution time for Interval bisection Method is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n gss=self.gss(L,U,i,max_iter)\\n print(\\\" Execution time for Golden Section Search is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n pso=self.particle_Swarm(self.func, L, U, 2, max_iter)\\n print(\\\" Execution time for Particle swarm optimization is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n gd=self.gradient_descent(X=U ,eta=0.01, tol=minima[1],iter= max_iter)\\n print(\\\" Execution time for Gradient Descent is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n start_time = timeit.default_timer()\\n bgd=self.b_gradient_descent(LB=L,UB=U ,eta=0.01, tol=minima[1],iter=max_iter)\\n print(\\\" Execution time for Batch Gradient Descent is\\\", timeit.default_timer() - start_time,\\\"s\\\")\\n plt.plot(ibs[1], ibs[2], 'r.')\\n plt.text(ibs[1], ibs[2],\\\"IB\\\")\\n plt.plot(gss[1], gss[2], '.')\\n plt.text(gss[1], gss[2],\\\" GSS\\\")\\n plt.plot(pso[1], pso[2], 'y.')\\n plt.text(pso[1], pso[2],\\\" PSO\\\")\\n plt.plot(gd[1], gd[2], 'g.')\\n plt.text(gd[1], gd[2],\\\" GD \\\")\\n plt.plot(bgd[1],bgd[2], 'k.')\\n plt.text(bgd[1], bgd[2],\\\" Batch_GD\\\")\\n \\n plt.xlabel('Value of X')\\n plt.ylabel('NUmber of iteration') \\n plt.suptitle('Number of iterations vs minimum value of x')\\n \\n plt.show()\",\n \"def plot_number_steps(step_cache_qlearning, step_cache_SARSA): \\n cum_step_q = []\\n steps_mean = np.array(step_cache_qlearning).mean()\\n steps_std = np.array(step_cache_qlearning).std()\\n count = 0 # used to determine the batches\\n cur_step = 0 # accumulate reward for the batch\\n for cache in step_cache_qlearning:\\n count = count + 1\\n cur_step += cache\\n if(count == 10):\\n # normalize the sample\\n normalized_step = (cur_step - steps_mean)/steps_std\\n cum_step_q.append(normalized_step)\\n cur_step = 0\\n count = 0\\n \\n cum_step_SARSA = []\\n steps_mean = np.array(step_cache_SARSA).mean()\\n steps_std = np.array(step_cache_SARSA).std()\\n count = 0 # used to determine the batches\\n cur_step = 0 # accumulate reward for the batch\\n for cache in step_cache_SARSA:\\n count = count + 1\\n cur_step += cache\\n if(count == 10):\\n # normalize the sample\\n normalized_step = (cur_step - steps_mean)/steps_std\\n cum_step_SARSA.append(normalized_step)\\n cur_step = 0\\n count = 0 \\n # prepare the graph \\n plt.plot(cum_step_q, label = \\\"q_learning\\\")\\n plt.plot(cum_step_SARSA, label = \\\"SARSA\\\")\\n plt.ylabel('Number of iterations')\\n plt.xlabel('Batches of Episodes (sample size 10) ')\\n plt.title(\\\"Q-Learning/SARSA Iteration number untill game ends\\\")\\n plt.legend(loc='lower right', ncol=2, mode=\\\"expand\\\", borderaxespad=0.)\\n plt.show()\\n plt.savefig('number_steps.png')\",\n \"def plot_energies(self):\\n plt.plot(self.energies[0], self.energies[1])\\n plt.xlabel('Time (s)')\\n plt.ylabel('Energy (J)')\\n plt.show()\",\n \"def plot_cost_history(alpha, cost_history):\\n cost_df = pandas.DataFrame({\\n 'Cost_History': cost_history,\\n 'Iteration': range(len(cost_history))\\n })\\n return ggplot(cost_df, aes('Iteration', 'Cost_History')) + \\\\\\n geom_point() + ggtitle('Cost History for alpha = %.3f' % alpha)\",\n \"def showPlot2():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on number of robots')\\n xlabel('number of robots (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \\n MC_runs, price_tree):\\n x_values = []\\n pi_M = []\\n pi_M_RMSE = []\\n for i in range(1,MC_runs,1):\\n Mi=M*i\\n x_values.append([Mi])\\n paths = sample_paths(S0, N, u, d, q, Mi)\\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \\n barrier_type, option)\\n if option == 'Call':\\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\\n elif option == 'Put':\\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\\n payoffs = list(payoffs)\\n while len(payoffs) < Mi:\\n payoffs.append([0])\\n mean_payoff = np.mean(payoffs)[0]\\n pi_M.append(mean_payoff)\\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\\n pi_M_RMSE.append(RMSE[0])\\n \\n # plotting\\n plt.figure(figsize=(8,6))\\n plt.subplot(2, 1, 1)\\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, pi_M, 'o', label='price via MC')\\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \\n label='price via tree')\\n plt.legend()\\n plt.title('Monte Carlo price, for increasing number of paths')\\n plt.ylabel('Expected Value')\\n #The following will plot the root mean square error\\n plt.subplot(2, 1, 2)\\n plt.plot(x_values, pi_M_RMSE, '-')\\n plt.xlabel('number of paths')\\n plt.ylabel('Root Mean Square Error')\\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\\n plt.show()\",\n \"def throughputLinePlot(self):\\n\\t\\tplot(self.window_size, self.throughput, label = \\\"Throughput vs Window Size\\\")\\n\\t\\txticks(self.window_size)\\n\\t\\txlim(0, 21)\\n\\t\\txlabel('Window Size (No. of Packets)')\\n\\t\\tylabel('Throughput in Mbps')\\n\\t\\tlegend(loc=0)\\n\\t\\tsavefig('ThroughputLinePlot.png')\",\n \"def plot_residual_vs_cpu_for_each_iteration(self,\\n idx=None,\\n trajectory=None,\\n legend=True):\\n fig, ax = plt.subplots()\\n ax.set_title('Residuals of last {} steps'.format(self.p.tasks))\\n ax.set_xlabel('CPU Number')\\n ax.set_ylabel('Residual')\\n # ax.set_ylim(bottom=1e-20)\\n\\n if idx is None and trajectory is None:\\n trajectory = self.get_final_block(idx=0)\\n elif idx:\\n trajectory = self.get_final_block(idx=idx)\\n else:\\n trajectory = self.get_final_block(idx=0)\\n\\n for iteration in range(self.p.iterations):\\n try:\\n trajectory[(trajectory['iter'] == iteration + 1) & (trajectory[\\n 'level'] == self.p.levels)].plot(\\n 'rank',\\n 'residual',\\n logy=True,\\n label='iter{}'.format(iteration + 1),\\n marker='o',\\n ax=ax)\\n except:\\n pass\\n\\n if not legend:\\n ax.legend_.remove()\\n\\n return fig, ax\",\n \"def plot_runtimes(num_clusters_range):\\n scp_times = []\\n fcp_times = []\\n\\n for num in range(num_clusters_range[0], num_clusters_range[1]+1):\\n result = compute_runtimes(num)\\n scp_times.append(result[0])\\n fcp_times.append(result[1])\\n\\n print \\\"\\\\n\\\\nscp_times:\\\", scp_times\\n print \\\"fcp_times:\\\", fcp_times\\n\\n # plot n(x) vs time (y) on a standard plot\\n xvals = range(num_clusters_range[0], num_clusters_range[1]+1)\\n yvals1 = scp_times\\n yvals2 = fcp_times\\n\\n plt.plot(xvals, yvals1, '-b', label='slow_closest_pair')\\n plt.plot(xvals, yvals2, '-r', label='fast_closest_pair')\\n plt.xlabel('number of initial clusters')\\n plt.ylabel('run time (seconds)')\\n plt.legend(loc='upper right')\\n plt.show()\",\n \"def plotTotal(self, phys, forces, step): \\r\\n self.plotQuantity(step, forces.energies.potentialEnergy(phys)+TopologyUtilities.kineticEnergy(phys.myTop, phys.velvec), 'totalenergy')\",\n \"def plot(self, fname=None):\\n x = np.linspace(self.bounds[0], self.bounds[-1], 200)\\n y = [self.evaluate(xi) for xi in x]\\n plt.figure()\\n plt.plot(x, y, label='Class func')\\n plt.plot(self.bounds, self.gis, 'o', label='Algorithm')\\n plt.grid(color='0.7')\\n plt.xlabel('Dependent Variable')\\n plt.ylabel('PP Transformed Class Value')\\n if fname:\\n plt.savefig(fname)\\n else:\\n plt.show()\",\n \"def plot_loss(loss_values_dict, save_name):\\n fig, ax = plt.subplots(figsize=(10, 10))\\n # Add each method to the plot\\n for (method_name, loss_val_array) in loss_values_dict.items():\\n print(method_name, len(loss_val_array))\\n ax.plot(range(len(loss_val_array)), loss_val_array, label=method_name)\\n ax.legend(loc='upper right')\\n plt.xlabel('iteration')\\n plt.ylabel('loss')\\n plt.title('Grad Descent in Hyperbolic Space')\\n plt.savefig(save_name)\",\n \"def plot_residual_vs_iteration_for_each_cpu(self,\\n idx=0,\\n trajectory=None,\\n legend=True):\\n fig, ax = plt.subplots()\\n ax.set_title('Residuals of last {} steps'.format(self.p.tasks))\\n ax.set_xlabel('Iteration Number')\\n ax.set_ylabel('Residual')\\n # ax.set_ylim(bottom=1e-20)\\n\\n if idx is None and trajectory is None:\\n trajectory = self.get_final_block(idx=0)\\n elif idx:\\n trajectory = self.get_final_block(idx=idx)\\n else:\\n trajectory = self.get_final_block(idx=0)\\n\\n for cpu in range(self.p.tasks):\\n try:\\n trajectory[(trajectory['rank'] == cpu) & (trajectory[\\n 'level'] == self.p.levels)].plot(\\n 'iter',\\n 'residual',\\n logy=True,\\n label='cpu{}'.format(cpu),\\n marker='o',\\n ax=ax)\\n except:\\n pass\\n\\n if not legend:\\n ax.legend_.remove()\\n\\n return fig, ax\",\n \"def visualize(self):\\n import matplotlib.pyplot as plt\\n import numpy as np\\n\\n plt.figure()\\n sw_ = np.linspace(0.0, 1.0, 50)\\n plt.plot(sw_, self.krw(sw_), label=\\\"Water\\\")\\n plt.plot(sw_, self.kro(sw_), label=\\\"Oil\\\")\\n plt.xlabel(\\\"Water saturation\\\")\\n plt.ylabel(\\\"Relative permeability\\\")\\n plt.legend()\",\n \"def plot(self, iteration=None, stateVectorConv=None): \\n r = [\\\"{0}\\\".format(self.__class__.__name__)]\\n if iteration is not None:\\n r.append(\\\"i: {0}\\\".format(iteration))\\n fmt = lambda a : \\\", \\\".join([\\\"{0:.4g}\\\".format(float(v)) for v in a])\\n r.append(\\\"stateVector: {0}\\\".format(fmt(self.stateVector)))\\n if stateVectorConv is not None:\\n r.append(\\\"stateVectorConv: {0:.4g}\\\".format(stateVectorConv))\\n \\n s = \\\"; \\\".join(r)\\n \\n if iteration is not None and self.verbose > 0:\\n print(s)\\n \\n if self.verbose > 4:\\n nplot = 2 + len(self.stateVector)\\n fig = pyplot.figure()\\n fig.subplots_adjust(left=0.17, bottom=0.09, right=0.98, \\n top=0.92, wspace=0.12, hspace=0.2)\\n ax = fig.add_subplot(nplot,1,1)\\n ax.set_title(s)\\n ax.set_ylabel(\\\"$R [sr^{-1}]$\\\")\\n ax.plot(self.independentVariable, self.observation, 'k', \\n label='measurement')\\n ax.plot(self.independentVariable, self.modelCalculation, 'r', \\n label='model')\\n ax.legend(loc='lower right')\\n \\n l = fig.add_subplot(nplot,1,2)\\n l.plot(self.independentVariable, \\n (self.observation-self.modelCalculation)/self.observationError, \\n 'k', label=\\\"err\\\")\\n l.set_ylabel(\\\"$\\\\Delta R/\\\\sigma$\\\")\\n \\n color = ['k-', 'r-', 'b-', 'g-', 'k--', 'r--', 'b--', 'g--', 'k-.', \\n 'r-.', 'b-.', 'g-.', 'k:', 'r:', 'b:', 'g:']\\n for i in range(len(self.stateVector)):\\n name = self.parameterNames[i]\\n k = fig.add_subplot(nplot,1,3+i)\\n k.plot(self.independentVariable, self.Jacobian[:, i], 'k')\\n k.set_ylabel(r\\\"$\\\\partial R/\\\\partial ({0})$\\\".format(name.replace(\\\"_\\\", \\\" \\\")))\\n \\n k.set_xlabel(\\\"$\\\\lambda [nm]$\\\")\\n \\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n \\n if self.verbose > 1:\\n fig.show()\\n else:\\n fig.savefig(\\\"{0}_{1}_{2}.pdf\\\".format(r[0], \\n r[1].split()[1][:-1], \\n (\\\"{0:02d}\\\".format(iteration) \\n if iteration is not None \\n else \\\"final\\\")), transparent=True)\",\n \"def plot_curve(epochs, hist, list_of_metrics): \\n # list_of_metrics should be one of the names shown in:\\n # https://www.tensorflow.org/tutorials/structured_data/imbalanced_data#define_the_model_and_metrics \\n\\n plt.figure()\\n plt.xlabel(\\\"Epoch\\\")\\n plt.ylabel(\\\"Value\\\")\\n\\n for m in list_of_metrics:\\n x = hist[m]\\n plt.plot(epochs[1:], x[1:], label=m)\\n\\n plt.legend()\",\n \"def plot_graph(error_rates, avg_hits):\\n plt.xlabel(\\\"Error rates (σ)\\\")\\n plt.ylabel(\\\"Average pins hit\\\")\\n plt.plot(error_rates, avg_hits)\\n plt.show()\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def show_learning_curve(self):\\n\\n # Loop output classes\\n for c in range(1,self.n_output_classes):\\n # Get data\\n x_values = np.array(self.n_class_samples_list[c])\\n accuracy = np.array(self.accuracy_list[c])\\n precision = np.array(self.precision_list[c])\\n recall = np.array(self.recall_list[c])\\n F1 = np.array(self.F1_list[c])\\n\\n # Make plot\\n with sns.axes_style(\\\"ticks\\\"):\\n fig,ax = plt.subplots()\\n plt.plot([np.min(x_values),np.max(x_values)],[0.5,0.5],\\n color='#777777',linestyle='--')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.66,0.66],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.8,0.8],\\n color='#777777',linestyle=':')\\n plt.plot([np.min(x_values),np.max(x_values)],[0.9,0.9],\\n color='#777777',linestyle=':')\\n\\n plt.plot( x_values, accuracy, color='#000000',\\n linewidth=1, label='Accuracy' )\\n plt.plot( x_values, precision, color='#0000aa',\\n linewidth=1, label='Precision' )\\n plt.plot( x_values, recall, color='#00aa00',\\n linewidth=1, label='Recall' )\\n plt.plot( x_values, F1, color='#aa0000',\\n linewidth=2, label='F1' )\\n\\n plt.yticks( [0, 0.5, 0.66, 0.8, 0.9, 1.0],\\n ['0','0.5','0.66','0.8','0.9','1.0'], ha='right' )\\n plt.xlim(np.max(x_values)*-0.02,np.max(x_values)*1.02)\\n plt.ylim(-0.02,1.02)\\n plt.xlabel('Number of training samples')\\n plt.ylabel('Performance')\\n plt.title('Learning curve, class {}'.format(c))\\n sns.despine(ax=ax, offset=0, trim=True)\\n lgnd = plt.legend(loc=4, ncol=1, frameon=True, fontsize=9)\\n lgnd.get_frame().set_facecolor('#ffffff')\\n ax.spines['left'].set_bounds(0,1)\\n ax.spines['bottom'].set_bounds(np.min(x_values),np.max(x_values))\",\n \"def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option,\\n MC_runs, price_tree):\\n x_values = []\\n pi_M = []\\n pi_M_RMSE = []\\n for i in range(1, MC_runs, 1):\\n Mi = M * i\\n x_values.append([Mi])\\n paths = sample_paths(S0, N, u, d, q, Mi)\\n p_valid, p_invalid, p_counts = split_paths(paths, B, K,\\n barrier_type, option)\\n if option == 'Call':\\n payoffs = np.maximum(0, p_counts[:, -1] - K) * np.exp(-1 * r * T)\\n elif option == 'Put':\\n payoffs = np.maximum(0, K - p_counts[:, -1]) * np.exp(-1 * r * T)\\n payoffs = list(payoffs)\\n while len(payoffs) < Mi:\\n payoffs.append([0])\\n mean_payoff = np.mean(payoffs)[0]\\n pi_M.append(mean_payoff)\\n RMSE = np.sqrt(np.var(payoffs, ddof=1)) / np.sqrt(Mi)\\n pi_M_RMSE.append(RMSE[0])\\n\\n # plotting\\n plt.figure(figsize=(8, 6))\\n plt.subplot(2, 1, 1)\\n plt.plot(x_values, price_tree - 1.96 * np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, price_tree + 1.96 * np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, pi_M, 'o', label='price via MC')\\n plt.plot(x_values, [price_tree] * len(x_values), '-', lw=3,\\n label='price via tree')\\n plt.legend()\\n plt.title('Monte Carlo price, for increasing number of paths')\\n plt.ylabel('Expected Value')\\n # The following will plot the root mean square error\\n plt.subplot(2, 1, 2)\\n plt.plot(x_values, pi_M_RMSE, '-')\\n plt.xlabel('number of paths')\\n plt.ylabel('Root Mean Square Error')\\n # plt.savefig('MonteCarlo_variation.png', transparent=True)\\n plt.show()\",\n \"def visualize(self):\\r\\n self.aggregator.plot_loss()\\r\\n self.save_figure()\",\n \"def graph(self):\\n seq_obj = MultiSequence(self.symbol, self.__best_model.window_size,1)\\n test_predict = self.__best_model.model.predict(seq_obj.X)\\n\\n #our data is scaled between -1 and 1 so lets scale it back up\\n scaler = MinMaxScaler(feature_range=(self.__min_price ,self.__max_price))\\n orig_data = seq_obj.original_data.reshape(-1,1)\\n orig_prices = scaler.fit_transform(orig_data).flatten()\\n \\n # plot actual prices\\n plt.plot(orig_prices, color='k')\\n \\n # plot test set prediction after scaling back up\\n length = len(seq_obj.X) + self.__best_model.window_size \\n test_in = np.arange(self.__best_model.window_size,length,1)\\n pred_prices = scaler.fit_transform(test_predict.reshape(-1,1)).flatten()\\n plt.plot(test_in,pred_prices,color = 'b')\\n \\n # pretty up graph\\n plt.xlabel('day')\\n plt.ylabel('Closing price of stock')\\n plt.title(\\\"Price prediction for {}\\\".format(self.symbol))\\n plt.legend(['Actual','Prediction'],loc='center left', bbox_to_anchor=(1, 0.5))\\n plt.show()\",\n \"def plot(self):\\n self.plotsite()\\n self.plotbond()\\n plt.show()\",\n \"def plot_loss(self):\\n #x = [k for k in range(self.rep)]\\n loss = self.min_list[:,0]//100 #For clarity\\n #plt.plot(x,self.min_list[:,0])\\n plt.hist(loss,density=True)\\n plt.xlabel(self.list_name + '_loss//100')\\n plt.ylabel('Frequency')\\n #plt.xticks(range(8),[0,250,500,750,1000,1250,1500,1750])\\n plt.title('Distribution of '+self.list_name+'_loss ('+str(self.rep)+' iterations)')\\n plt.savefig('img/stats/'+self.list_name+'_lossFrequency_'+self.model_name+'.png')\\n plt.show()\",\n \"def plot_schedulability_rates_fairgen():\\n modes = [\\n # name, color, linestyle, marker\\n ('dSMC', 'blue', 'dashed', 'o'),\\n ('dAMC', 'red', 'dashed', 'd'),\\n ('EDF-VD', 'green', 'dashed', 's'),\\n ('pSMC', 'orange', 'dashed', '^'),\\n ('pAMC-BB', 'magenta', 'dashed', 'D'),\\n ('pAMC-BB+', 'purple', 'dashed', 'v')\\n ]\\n\\n task_sets_list = pickle.load(open(task_sets_path + 'task_sets_fairgen', 'rb'))\\n rates = {}\\n fig = plt.figure(figsize=(12, 6), dpi=300)\\n fig.suptitle('Evaluation: MC-Fairgen (n=%d)' % len(task_sets_list[0]))\\n ax1 = fig.add_subplot(111)\\n for name, color, linestyle, marker in modes:\\n rates[name] = pickle.load(open(eval_fairgen_path + name, 'rb'))\\n ax1.plot(utils, rates[name], label=name, color=color, linestyle=linestyle, marker=marker)\\n ax1.set_xlabel('LO mode utilization')\\n ax1.set_ylabel('Percentage of task sets schedulable')\\n ax1.set_xticks([k * 0.5 for k in range(5)])\\n ax1.set_yticks([k * 20 for k in range(6)])\\n ax1.xaxis.set_minor_locator(ticker.AutoMinorLocator(5))\\n ax1.yaxis.set_minor_locator(ticker.AutoMinorLocator(1))\\n ax1.minorticks_on()\\n ax1.grid(which='both', linestyle='dashed')\\n\\n # Plot average system util:\\n avg_utils = []\\n for i, _ in enumerate(utils):\\n avg_utils.append(np.average([task_set.u_avg for task_set in task_sets_list[i]]))\\n ax2 = ax1.twinx()\\n ax2.plot(utils, avg_utils, label='Avg Sys Util (right scale)', color='black', linestyle='dashed',\\n marker=None)\\n ylim = ax1.get_ylim()\\n ax2.set_ylim(ylim[0] / 100, ylim[1] / 100)\\n ax2.set_ylabel('U(Avg)')\\n\\n plt.axvline(1.0, color='black', linewidth=0.8)\\n lines1, labels1 = ax1.get_legend_handles_labels()\\n lines2, labels2 = ax2.get_legend_handles_labels()\\n plt.xlim(0.1, 2.1)\\n plt.legend(lines1 + lines2, labels1 + labels2, loc='upper right')\\n plt.savefig('./figures/schedulability_rates_fairgen.png')\\n # plt.show()\",\n \"def plot(self):\\n\\t\\tself.plotOfLoopVoltage()\",\n \"def plot_history(self, filename):\\r\\n plt.figure(figsize=(12, 9))\\r\\n plt.plot(self.Objective_value)\\r\\n plt.xlabel('Iteration')\\r\\n plt.ylabel('Value')\\r\\n plt.title('Objective Function Values')\\r\\n # plt.savefig(filename)\\r\\n plt.show()\\r\\n return\",\n \"def plot(self):\\n\\n try:\\n import matplotlib.pyplot as plt\\n except ImportError:\\n from sys import stderr\\n print(\\\"ERROR: matplotlib.pyplot not found, matplotlib must be installed to use this function\\\", file=stderr)\\n raise\\n\\n x_min = np.min(self.knot_vector)\\n x_max = np.max(self.knot_vector)\\n\\n x = np.linspace(x_min, x_max, num=1000)\\n\\n ns = np.array([self(i) for i in x]).T\\n\\n for n in ns:\\n plt.plot(x, n)\\n\\n return plt.show()\",\n \"def plot_comparison(results):\\n dfs = []\\n for res in results:\\n equity = (1 + res['equity']).cumprod()\\n equity.name = 'equity'\\n equity = equity.reset_index()\\n equity['name'] = res['name']\\n dfs.append(equity)\\n data = pd.concat(dfs, axis=0)\\n\\n fig = px.line(data, x='time_idx', y='equity', color='name')\\n fig.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7945268","0.7783235","0.767943","0.7237459","0.68332607","0.6824882","0.67958784","0.67673373","0.67216945","0.6590324","0.6507171","0.6492306","0.6478465","0.647183","0.64140046","0.6411427","0.633973","0.632849","0.63174886","0.62941676","0.6243552","0.6242639","0.62390655","0.62343913","0.6225981","0.6217687","0.62083983","0.6192615","0.61847377","0.61712354","0.6170223","0.61538607","0.61015326","0.6082549","0.60690457","0.60653937","0.60551095","0.6044064","0.60282445","0.6016301","0.5991821","0.5985089","0.59850186","0.5984225","0.5969709","0.59596896","0.5957284","0.5924792","0.59223974","0.5921372","0.59189475","0.5911327","0.5909586","0.5901603","0.5895476","0.58927816","0.58784926","0.587213","0.5870334","0.58688134","0.58680505","0.585596","0.5854485","0.58527243","0.5850089","0.58491397","0.5847577","0.584226","0.583364","0.58261263","0.5814718","0.58127475","0.5812637","0.58072084","0.5804293","0.5802979","0.5801196","0.58009565","0.5799467","0.5783847","0.5764949","0.57636654","0.5762434","0.5756869","0.57567245","0.5748326","0.5743367","0.5742366","0.5734688","0.57328486","0.5731617","0.5730416","0.57241946","0.5723972","0.5723721","0.5720299","0.57102245","0.5704184","0.5702849","0.56987584"],"string":"[\n \"0.7945268\",\n \"0.7783235\",\n \"0.767943\",\n \"0.7237459\",\n \"0.68332607\",\n \"0.6824882\",\n \"0.67958784\",\n \"0.67673373\",\n \"0.67216945\",\n \"0.6590324\",\n \"0.6507171\",\n \"0.6492306\",\n \"0.6478465\",\n \"0.647183\",\n \"0.64140046\",\n \"0.6411427\",\n \"0.633973\",\n \"0.632849\",\n \"0.63174886\",\n \"0.62941676\",\n \"0.6243552\",\n \"0.6242639\",\n \"0.62390655\",\n \"0.62343913\",\n \"0.6225981\",\n \"0.6217687\",\n \"0.62083983\",\n \"0.6192615\",\n \"0.61847377\",\n \"0.61712354\",\n \"0.6170223\",\n \"0.61538607\",\n \"0.61015326\",\n \"0.6082549\",\n \"0.60690457\",\n \"0.60653937\",\n \"0.60551095\",\n \"0.6044064\",\n \"0.60282445\",\n \"0.6016301\",\n \"0.5991821\",\n \"0.5985089\",\n \"0.59850186\",\n \"0.5984225\",\n \"0.5969709\",\n \"0.59596896\",\n \"0.5957284\",\n \"0.5924792\",\n \"0.59223974\",\n \"0.5921372\",\n \"0.59189475\",\n \"0.5911327\",\n \"0.5909586\",\n \"0.5901603\",\n \"0.5895476\",\n \"0.58927816\",\n \"0.58784926\",\n \"0.587213\",\n \"0.5870334\",\n \"0.58688134\",\n \"0.58680505\",\n \"0.585596\",\n \"0.5854485\",\n \"0.58527243\",\n \"0.5850089\",\n \"0.58491397\",\n \"0.5847577\",\n \"0.584226\",\n \"0.583364\",\n \"0.58261263\",\n \"0.5814718\",\n \"0.58127475\",\n \"0.5812637\",\n \"0.58072084\",\n \"0.5804293\",\n \"0.5802979\",\n \"0.5801196\",\n \"0.58009565\",\n \"0.5799467\",\n \"0.5783847\",\n \"0.5764949\",\n \"0.57636654\",\n \"0.5762434\",\n \"0.5756869\",\n \"0.57567245\",\n \"0.5748326\",\n \"0.5743367\",\n \"0.5742366\",\n \"0.5734688\",\n \"0.57328486\",\n \"0.5731617\",\n \"0.5730416\",\n \"0.57241946\",\n \"0.5723972\",\n \"0.5723721\",\n \"0.5720299\",\n \"0.57102245\",\n \"0.5704184\",\n \"0.5702849\",\n \"0.56987584\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69094783"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":90796,"cells":{"query":{"kind":"string","value":"Set up each webpage with a header and navigation bar."},"document":{"kind":"string","value":"def setup_page(\n self, html_page, links, label=None, title=None, approximant=None,\n background_colour=None, histogram_download=False\n ):\n html_file = webpage.open_html(\n web_dir=self.webdir, base_url=self.base_url, html_page=html_page,\n label=label\n )\n html_file.make_header(approximant=approximant)\n if html_page == \"home\" or html_page == \"home.html\":\n html_file.make_navbar(\n links=links, samples_path=self.results_path[\"home\"],\n background_color=background_colour,\n hdf5=self.hdf5, about=False\n )\n elif histogram_download:\n html_file.make_navbar(\n links=links, samples_path=self.results_path[\"other\"],\n histogram_download=os.path.join(\n \"..\", \"samples\", \"dat\", label, \"{}_{}_samples.dat\".format(\n label, html_page\n )\n ), background_color=background_colour, hdf5=self.hdf5,\n about=False\n )\n else:\n html_file.make_navbar(\n links=links, samples_path=self.results_path[\"home\"],\n background_color=background_colour, hdf5=self.hdf5,\n about=False\n )\n return html_file"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def generate_webpages(self):\n if self.add_to_existing:\n self.add_existing_data()\n self.make_home_pages()\n self.make_1d_histogram_pages()\n self.make_corner_pages()\n self.make_config_pages()\n if self.make_comparison:\n self.make_comparison_pages()\n if self.make_interactive:\n self.make_interactive_pages()\n if self.publication:\n self.make_publication_pages()\n if self.gwdata is not None:\n self.make_detector_pages()\n self.make_error_page()\n self.make_version_page()\n if self.notes is not None:\n self.make_notes_page()\n self.make_downloads_page()\n self.generate_specific_javascript()","def main():\n create_home()\n create_about()\n create_banner_list()\n\n for banner_id in appdata.banner_info:\n banner.create_banner_page(banner_id)","def controls_setup(self):\n\n self.to_homepage = element.Link(self, class_name='nav-home', alias='Return to site Link')\n self.account = element.Link(self, class_name='nav-account', alias='Account Profile Link')\n self.logout = element.Link(self, class_name='nav-logout', alias='Logout Link')","def set_up(self, web_driver):\n self.driver = web_driver\n self.wait = WebDriverWait(self.driver, 60)\n\n self.google_page = GoogleSearchPage(self.driver, locator, conf, message)\n self.flipkart_page = FlipkartPage(self.driver, locator, message)","def initialPage():\n\treturn header() + footer()","def setup(self, url, browser_config):\n\n # navigate to the front page\n browser.open_url(url)","def main():\n stylesheets = \"<link rel='stylesheet' href='/css/tablestyle.css'>\"\n webpage.htmlTop(stylesheets)\n get_data()\n webpage.htmlBottom()","def create_home():\n meta_desc = (\n 'Expected values and probability per lap of step-up'\n ' banners in Final Fantasy Brave Exvius (FFBE)')\n template_vars = {\n 'title' : sitesettings.SITE_NAME,\n 'siteurl' : sitesettings.SITE_URL,\n 'sitename' : sitesettings.SITE_NAME,\n 'meta_desc' : meta_desc,\n 'last_four_banners' : nav.get_last_four_banners('all'),\n 'last_four_single' : nav.get_last_four_banners('single'),\n 'last_four_multi' : nav.get_last_four_banners('multi'),\n 'all_banner_info' : get_all_banner_info(),\n }\n\n home_path = os.path.join(sitesettings.LOCAL_FILE_PATH)\n\n if not os.path.exists(home_path):\n os.makedirs(home_path)\n\n template_file = 'home.html'\n html_file_loc = os.path.join(home_path, 'index.html')\n generatehtml.generate_html(\n html_file_loc, template_file, template_vars, os.path.join(os.getcwd(), 'templates'))","def setup(self):\n\n setup_data = get_setup_data()\n\n self.base_url = setup_data['base_url']\n browser = setup_data['browser'].lower()\n if browser == 'chrome':\n self.driver = webdriver.Chrome()\n elif browser == 'firefox':\n self.driver = webdriver.Firefox()\n elif browser == 'phantomjs':\n self.driver = webdriver.PhantomJS()\n else:\n error = (\n '{0:s} is not a supported browser. Supported browsers: '\n 'Chrome, Firefox, PhantomJS'.format(browser)\n )\n\n self.log.error(error)\n raise ValueError(error)\n self.log.info(\n 'Setup data:\\nURL: {0}\\nBrowser: {1}'.format(\n self.base_url, browser\n )\n )\n self.log.info('Load main page')\n self.driver.get(self.base_url)","def main():\n\n return render_template(\"index.html\", title=\"Home\", heading=\"Dublin Bus\")","def index(self, **args):\n if not self.isConfigured:\n self.configure()\n s = self.override()\n if not s:\n self.pageConfig['timeStamp'] = time.strftime('%a %b %d %X %Z %Y')\n contents = self.content(**args) # Make sure contents is run first (so it\n # can change any pageConfig entries if desired\n s = startPage % self.pageConfig\n s = s + htmlDiv('header', self.header(**args),\n keepEmptyDiv=self.pageConfig['keepEmptyHeader'])\n s = s + htmlDiv('navigation', self.navigation(**args),\n keepEmptyDiv=self.pageConfig['keepEmptyNavigation'])\n s = s + htmlDiv('content', contents,\n keepEmptyDiv=self.pageConfig['keepEmptyContent'])\n s = s + htmlDiv('footer', self.footer(**args),\n keepEmptyDiv=self.pageConfig['keepEmptyFooter'])\n s = s + endPage\n return s","def main_aqa_layout():\n\n layout = html.Div(\n [\n # html.Div(\n # id=server.config['NAVBAR_CONTAINER_ID'],\n # children=[\n # navbar\n # ],\n # # id=\"header\",\n # # children=[\n # # # Header(),\n # # html.Div(\n # # id=server.config['NAVBAR_CONTAINER_ID'],\n # # children=navbar\n # # ),\n # # ]\n # ),\n dcc.Location(id=\"url\", pathname=\"/\"),\n navbar,\n dbc.Container(id=\"content\", style={\"padding\": \"20px\"}),\n ]\n )\n\n return layout","def index():\n return render_template(\n 'index.html',\n nav=nav,\n title='Home Page',\n year=datetime.now().year\n )","def make_navbar_for_homepage(self):\n links = [\n \"home\", [\"Result Pages\", self._result_page_links()], \"Version\"\n ]\n if len(self.samples) > 1:\n links[1][1] += [\"Comparison\"]\n if self.publication:\n links.insert(2, \"Publication\")\n if self.gwdata is not None:\n links.append([\"Detchar\", [i for i in self.gwdata.keys()]])\n if self.notes is not None:\n links.append(\"Notes\")\n return links","def updateFrontPages(self):\n nTmessage(\"Starting %s\" % getCallerName())\n htmlDir = os.path.join(self.results_dir, \"HTML\")\n if os.path.isdir(htmlDir):\n# nTdebug(\"Removing original html directory for NRG-CING.\")\n rmdir(htmlDir)\n # end if\n nTmessage(\"Creating HTML directory for %s.\" % self.results_base)\n mkdirs(htmlDir)\n# srcHtmlPath = os.path.join(cingRoot, cingPaths.html) \n data_dir = os.path.join (self.base_dir, \"data\" )\n base_data_dir = os.path.join (data_dir, self.results_base )\n # Most crud can come in from the traditional method.\n copyCingHtmlJsAndCssToDirectory(htmlDir)\n \n nTmessage(\"Adding frontpage-specific html.\")\n fnList = \"\"\"\n about.html \n contact.html \n credits.html \n help.html \n helpCing.html \n helpPlot.html \n helpTutorials.html\n glossary.html \n index.html\n download.html \n plot.html \n cing.png \n icon_email.gif\n icon_reference.gif\n icon_website.png\n icon_youtube.jpeg\n icon_download.gif\n NRG-CING_circle.png\n \"\"\".split()\n for fn in fnList:\n srcFile = os.path.join(base_data_dir, fn)\n dstFile = os.path.join(htmlDir, fn)\n if not fn.endswith('.html'):\n copyfile(srcFile, dstFile)\n# nTdebug(\"-1- Added extra file %s.\" % dstFile)\n continue\n # end if\n file_content = open(srcFile, 'r').read() \n old_string = r\"<!-- INSERT NEW FOOTER HERE -->\"\n file_content = string.replace(file_content, old_string, self.htmlFooter)\n old_string = r\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE) \n old_string = r\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE) \n if fn != 'index.html':\n writeTextToFile(dstFile, file_content)\n# nTdebug(\"-2- Added extra file %s.\" % dstFile)\n continue\n # end if\n # Get framework input\n file_content = self._format_html(file_content) \n htmlfile = os.path.join(htmlDir, 'index.html')\n writeTextToFile(htmlfile, file_content)\n# nTdebug(\"-3- Written HTML index file: %s\" % htmlfile) \n # end for\n nTmessage(\"Copy the overall index\")\n org_file = os.path.join(data_dir, 'redirect.html')\n new_file = os.path.join(self.results_dir, 'index.html')\n shutil.copy(org_file, new_file)\n \n nTmessage(\"Copy the python cgi server for TableTools\\n\")\n cgi_file_name = 'DataTablesServer.py'\n if not os.path.exists(self.cgi_dir):\n nTerror(\"Please first create the server directory as expected at: %s\" % self.cgi_dir)\n return True\n # end if\n org_file = os.path.join(self.base_dir, 'server', cgi_file_name)\n new_file = os.path.join(self.cgi_dir, cgi_file_name)\n if os.path.exists(new_file): # remove because if it's a hard link the copy will fail.\n os.unlink(new_file)\n # end if\n shutil.copy(org_file, new_file)","def setup_page(self):\n raise NotImplementedError","def get_homepage():\n\n list_of_students = hackbright.list_all_students()\n list_of_projects = hackbright.list_all_projects()\n\n return render_template(\"index.html\",\n list_of_students=list_of_students,\n list_of_projects=list_of_projects)","def index():\n isoko = get_sources('general')\n\n head = \"ALLOVER THE WORLD NEWS\"\n return render_template('index.html', title = head, isoko = isoko)","def homepage():\n\n general_news=get_sources('general')\n business_news=get_sources('business')\n sports_news=get_sources('sports')\n return render_template('sources.html',general=general_news, business=business_news, sports=sports_news)","def index():\r\n\r\n # initializes page title\r\n page_title = 'Home'\r\n\r\n # renders the landing page\r\n return render_template('index.html', page_title=page_title)","def main_nav():\n return render_template('home.html')","def home():\n\n\treturn render_template('index.html', title='Home Page',\n\t\t\t\t\t\t year=datetime.now().year)","def __init__(self, **args):\n self.pageConfig = { 'contentType': '', # For plain CGI need: 'Content-type: text/html\\n\\n'\n 'pageName': '',\n 'pageTitle': '',\n 'pageHeaderSnippets': '',\n 'cssName': 'default.css',\n 'css_currentLink': 'acurrentlink',\n 'header': '',\n 'navigation': '',\n 'content': '',\n 'footer': '',\n 'keepEmptyHeader': False, # Set to true to anyway generate div if empty\n 'keepEmptyNavigation': False,\n 'keepEmptyContent': False,\n 'keepEmptyFooter': False\n }\n for k in args:\n self.pageConfig[k] = args[k]\n self.globalConfig = GlobalConfiguration()\n self.isConfigured = False\n pass","def setup_page(self):\r\n raise NotImplementedError","async def setup(self):\n load_base_templates()\n uris = URI.gather()\n for uri, resource in uris.items():\n methods = resource.methods\n if \"get\" not in methods:\n methods[\"get\"] = None\n\n for method in methods.keys():\n self.app.add_routes([\n getattr(aioweb, method)(uri, resource.process)\n ])\n self.app.add_routes([aioweb.get(\"/hello\", hello)])\n\n # TMP code\n max_age = 3600 * 24 * 365 # 1 year\n setup(self.app, PonyStorage(max_age=max_age))\n self.preparing_task = asyncio.create_task(self.prepare_web())","def controls_setup(self):\n\n self.login = element.Link(self, class_name='nav-login', alias='Navbar->Login Link')\n self.register = element.Link(self, class_name='nav-register', alias='Navbar->Register Link')\n self.logout = element.Link(self, class_name='nav-logout', alias='Navbar->Logout Link')\n self.be_a_merchant = element.Link(self, class_name='nav-partner-join',\n alias='Navbar->Be A Merchant Link')\n self.wishlist = element.Link(self, class_name='nav-wishlist', alias='Navbar->Wishlist Icon Button')\n self.cart = element.Link(self, class_name='nav-cart', alias='Navbar->Cart Icon Button')\n self.account = element.Link(self, css_selector='a.nav-account', alias='Navbar->Account Link')\n self.messages = element.Link(self, class_name='nav-messages', alias='Navbar->Messages Link')\n self.dashboard = element.Link(self, class_name='nav-dashboard', alias='Navbar->Dashboard Link')\n self.messages_count = element.Element(self, dom_id='postman_unread_count',\n alias='Navbar->Unread Messages Count Label')\n\n self.search_query = element.TextBox(self, name='q', alias='Navbar->Search Box')\n self.search_button = element.Button(self, css_selector='form.search button[type=submit]',\n alias='Navbar->Search Icon Button')","def controls_setup(self):\n\n self.new_items = element.TopMenuLink(self, alias='New Items Menu',\n css_selector='#browse > li:nth-child(1) > a')\n if self.fixed:\n self.jewelry = element.TopMenuLink(self, alias='Jewelry Menu',\n css_selector='#browse > li:nth-child(2) > a')\n self.artwork = element.TopMenuLink(self, alias='Artwork Menu',\n css_selector='#browse > li:nth-child(3) > a')\n self.homeware = element.TopMenuLink(self, alias='Homeware Menu',\n css_selector='#browse > li:nth-child(4) > a')\n self.clothing = element.TopMenuLink(self, alias='Clothing Menu',\n css_selector='#browse > li:nth-child(5) > a')\n self.vintage = element.TopMenuLink(self, alias='Vintage Menu',\n css_selector='#browse > li:nth-child(6) > a')\n self.food = element.TopMenuLink(self, alias='Food Menu',\n css_selector='#browse > li:nth-child(7) > a')\n self.rings = element.SubMenuLink(self, alias='Jewelry->Rings Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(1) > a')\n self.necklaces = element.SubMenuLink(self, alias='Jewelry->Necklaces Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(2) > a')\n self.bracelets = element.SubMenuLink(self, alias='Jewelry->Bracelets Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(3) > a')\n self.earrings = element.SubMenuLink(self, alias='Jewelry->Earrings Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(4) > a')\n self.broaches = element.SubMenuLink(self, alias='Jewelry->Broaches and Pins Submenu',\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(5) > a')\n self.wall_art = element.SubMenuLink(self, alias='Artwork->Wall Art Submenu',\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(1) > a')\n self.ceramics = element.SubMenuLink(self, alias='Jewelry->Ceramics Submenu',\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(2) > a')\n self.sculpture = element.SubMenuLink(self, alias='Jewelry->Sculpture Submenu',\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(3) > a')\n self.living = element.SubMenuLink(self, alias='Homeware->Living Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(1) > a')\n self.furniture = element.SubMenuLink(self, alias='Homeware->Furniture Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(2) > a')\n self.kitchen = element.SubMenuLink(self, alias='Homeware->Kitchen Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(3) > a')\n self.lighting = element.SubMenuLink(self, alias='Homeware->Lighting Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(4) > a')\n self.outdoor = element.SubMenuLink(self, alias='Homeware->Outdoor Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(5) > a')\n self.organize = element.SubMenuLink(self, alias='Homeware->Organize Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(6) > a')\n self.party = element.SubMenuLink(self, alias='Homeware->Party Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(7) > a')\n self.sub_food = element.SubMenuLink(self, alias='Homeware->Food Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(8) > a')\n self.pets = element.SubMenuLink(self, alias='Homeware->For Pets Submenu',\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(9) > a')\n self.women = element.SubMenuLink(self, alias='Clothing->Women Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(1) > a')\n self.men = element.SubMenuLink(self, alias='Clothing->Men Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(2) > a')\n self.kids = element.SubMenuLink(self, alias='Clothing->Kids Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(3) > a')\n self.pet_lovers = element.SubMenuLink(self, alias='Clothing->Pet Lovers Submenu',\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(4) > a')\n self.antiques = element.SubMenuLink(self, alias='Vintage->Antiques Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(1) > a')\n self.accessories = element.SubMenuLink(self, alias='Vintage->Accessories Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(2) > a')\n self.sub_clothing = element.SubMenuLink(self, alias='Vintage->Clothing Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(3) > a')\n self.sub_homeware = element.SubMenuLink(self, alias='Vintage->Homeware Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(4) > a')\n self.toys = element.SubMenuLink(self, alias='Vintage->Toys Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(5) > a')\n self.books = element.SubMenuLink(self, alias='Vintage->Books Submenu',\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(6) > a')\n else:\n self.menus = []","def __init__(self,parent,pageNames=[],**kw):\n Frame.__init__(self, parent, kw)\n self.grid_location(0,0)\n self.columnconfigure(0,weight=1)\n self.rowconfigure(1,weight=1)\n self.tabBar=Frame(self)\n self.tabBar.grid(row=0,column=0,sticky=EW)\n self.activePage=StringVar(self)\n self.defaultPage=''\n self.pages={}\n for name in pageNames:\n self.AddPage(name)","def web_site_mode():\r\n css = make_style.create_css()\r\n websites = dict()\r\n argument = dict()\r\n links = '<p align=\"center\">'\r\n for args in range(1, len(sys.argv)):\r\n website, head = make_content.create_content(sys.argv[args])\r\n websites[head] = website\r\n argument[sys.argv[args]] = head\r\n filename = convert_txt_to_html(sys.argv[args])\r\n links += '<a href=' + filename + '>' + head + '</a>---'\r\n links += END_P\r\n for args in range(1, len(sys.argv)):\r\n html_body = \"\"\r\n header = create_head(css, argument[sys.argv[args]])\r\n html_head = header + links\r\n website = websites[argument[sys.argv[args]]]\r\n for website_info in website:\r\n html_body += website_create_body(website_info)\r\n filename = convert_txt_to_html(sys.argv[args])\r\n html = html_head + html_body\r\n file = open(filename, \"+w\")\r\n file.write(html)\r\n file.close()","def home():\n template_stories = [\"silly_story\", \"excited_story\"]\n\n return render_template(\"homepage.html\", story_list = template_stories)","def main():\n page = get_page_arg()\n\n items = load_data(page)\n total_pages = get_total_pages()\n context = {\"current_page\": page,\n \"total_pages\": total_pages,\n \"items\": items}\n\n return render_template('index.html', **context)","def makeHTMLIndexFile(self):\n part1 = \"\"\"<html>\n <body>\n <title>Index</title>\n <div id=\"pg_body\">\n <div id=\"testSuitesTitle\">TestSuites</div>\n <div id=\"resultsTitle\">Results</div>\n <div id=\"testSuites\">\n \"\"\"\n part2 = self.makeLinks()\n part3 = \"\"\"</div>\n <div id=\"results\">\n <iframe id=\"loadHTMLResults\" name=\"loadHTMLResults\" frameborder=\"0\" src=\"statistics.html\" style=\"height:100%;width:100%;\"></iframe>\n </div>\n <div id=\"footer\">Test Engineer(s) :\"\"\"+testEngineers+\"\"\"</div>\n </div>\n </body>\n </html>\n\t\t<style>\n\t\tbody{\n margin:0;\n }\n\t\t#pg_body{\n\t\twidth=100%;\n\t\ttext-align:center;\n\t\t}\n\t\t#testSuitesTitle{\n\t\twidth:25%;\n\t\tfloat:left;\n\t\tbackground-color:#6495ED;\n\t\tfont-weight:bold;\n\t\tcolor:white;\n\t\t}\n\t\t#resultsTitle{\n\t\twidth:75%;\n\t\tfloat:right;\n\t\tbackground-color:#6495ED;\n\t\tfont-weight:bold;\n\t\tcolor:white;\n\t\t}\n\t\t#testSuites{\n\t\twidth:25%;\n\t\tfloat:left;\n\t\tbackground-color:lightgrey;\n\t\tfont-weight:bold;\n\t\ttext-align:left;\n\t\theight:94%;\n\t\toverflow:scroll;\n\t\t}\n\t\t#results{\n\t\twidth:75%;\n\t\tbackground-color:white;\n\t\tfloat:right;\n\t\ttext-align:left;\n\t\theight:94%;\n\t\toverflow:scroll;\n\t\t}\n\t\t#footer{\n\t\twidth:100%;\n\t\ttext-align:left;\n\t\tcolor:lightgrey;\n\t\tbackground-color:#6495ED;\n\t\t}\n\t\t</style>\n \"\"\"\n \n page = (part1+part2+part3)\n f = open(self.dir+'/index.html','w')\n f.write(page)\n f.close","def setUp(self):\r\n super(CoursePagesTest, self).setUp()\r\n\r\n CourseFixture(\r\n self.course_info['org'],\r\n self.course_info['number'],\r\n self.course_info['run'],\r\n self.course_info['display_name']\r\n ).install()\r\n\r\n self.auth_page = AutoAuthPage(self.browser, staff=True)\r\n\r\n self.pages = [\r\n clz(self.browser, self.course_info['org'], self.course_info['number'], self.course_info['run'])\r\n for clz in [\r\n AssetIndexPage, ChecklistsPage, ImportPage, CourseUpdatesPage,\r\n PagesPage, ExportPage, CourseTeamPage, CourseOutlinePage, SettingsPage,\r\n AdvancedSettingsPage, GradingPage, TextbooksPage\r\n ]\r\n ]","def common_header_part2(outfile: TextIO, indexpath: str = \"\", include_map: bool = False) -> None:\n outfile.write(\" </head>\\n\")\n outfile.write(\"\\n\")\n if include_map:\n outfile.write(\" <body onload=\\\"initialize()\\\">\\n\")\n else:\n outfile.write(\" <body>\\n\")\n outfile.write(\" <div id=\\\"skip-links\\\" role=\\\"complementary\\\" aria-label=\\\"Skip links menu\\\">\")\n outfile.write(\"<a href=\\\"#Main\\\" tabindex=\\\"1\\\">Skip to content</a></div>\\n\")\n outfile.write(\" <div id=\\\"home\\\">\\n\")\n outfile.write(\" <a href=\\\"\" + indexpath + \"index.html\\\" class=\\\"home-title\\\">Fiddler Crabs</a>\\n\")\n outfile.write(\" <a href=\\\"\" + indexpath +\n \"index.html\\\" class=\\\"home-link\\\">\" + fetch_fa_glyph(\"home\") + \"Home</a>\\n\")\n # outfile.write(\" <a href=\\\"\" + indexpath +\n # \"blog\\\" class=\\\"home-link\\\">\" + fetch_fa_glyph(\"blog\") + \"Blog</a>\\n\")\n outfile.write(\" </div>\\n\")","def home_page():\n\n return render_template('index.html', stories=stories.values())","def homepage():\n return render_template('home/index.html', \n title=\"Bem vindo!\")","def create_layout() -> None:\n\n st.sidebar.title(\"Menu\")\n app_mode = st.sidebar.selectbox(\"Please select a page\", [' I. Homepage',\n \"II. Download data\" ,\n \"III. Statistic Data\",\n ' IV. AGF Indices',\n ' V. Notes',\n \" VI. Rank of patient\" ])\n \n if app_mode == ' I. Homepage':\n load_homepage() \n elif app_mode == \"III. Statistic Data\":\n leyer.leyer() \n elif app_mode == ' IV. AGF Indices':\n single.AGF_indices() \n elif app_mode == \"II. Download data\":\n download_data.download_data() \n elif app_mode == ' V. Notes':\n text_input.text_input()\n elif app_mode == \" VI. Rank of patient\":\n rank_of_patient.rank_of_patient()","def set_pages(self, selenium: fixture) -> None:\n self.API: RecurringRidesAPI = RecurringRidesAPI()\n self.details: Details = Details(selenium)\n self.rides: Rides = Rides(selenium)","def Header(page):\n style = {\n \"background-color\": \"var(--red_color)\",\n \"color\": \"black\",\n \"text-shadow\": \"0 0 10px #ffffff\"\n }\n\n button1 = html.A(id=\"btn1box\", children=[\n html.Button(\"OVERVIEW\", id=\"btn1\", className=\"btn\")\n ], href=\"/dashboard/overview\")\n\n button2 = html.A(id=\"btn2box\", children=[\n html.Button(\"BOOK\", id=\"btn2\", className=\"btn\")\n ], href=\"/dashboard/book\")\n\n button3 = html.A(id=\"btn3box\", children=[\n html.Button(\"WORD\", id=\"btn3\", className=\"btn\")\n ], href=\"/dashboard/word\")\n\n if page == \"overview\":\n button1.children[0].style = style\n if page == \"book\":\n button2.children[0].style = style\n if page == \"word\":\n button3.children[0].style = style\n\n return html.Div(id=\"header\", children=[\n get_title(),\n get_subtitle(),\n button1,\n button2,\n button3\n ])","def home():\r\n return render_template(\r\n 'index.html',\r\n title='Home Page',\r\n year=datetime.now().year,\r\n )","def controls_setup(self):\n\n self.inbox = element.NavigationTab(self, css_selector='.messaging a.nav-inbox', alias='Inbox Tab')\n self.sent = element.NavigationTab(self, css_selector='.messaging a.nav-sent', alias='Sent Tab')\n self.write = element.NavigationTab(self, css_selector='.messaging a.nav-write', alias='Write Tab')\n self.archives = element.NavigationTab(self, css_selector='.messaging a.nav-archive', alias='Archives Tab')\n self.trash = element.NavigationTab(self, css_selector='.messaging a.nav-trash', alias='Trash Tab')","def webinit():\n\troot = Root()\n\troot.player = Player()\n\troot.songs = Songs()\n\troot.albums = Albums()\n\troot.artists = Artists()\n\t\n\tapp = cherrypy.tree.mount(root, '/', 'data/cherrypy.config')\n\treturn app","def homepage():\n\treturn render_template(\"home/a_homepage.html\", title=\"Welcome\")","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n\n return render_template('index.html',\n date = d,\n mood = mood,\n header_color = color,\n day = day,\n week = week,\n month = month,\n year = year)","def load_homepage() -> None:\n st.image(\"iwakka.png\",\n use_column_width=True)\n \n st.header(\"Hello! This dashboard will help you to analize data from iWakka device\")\n st.write(\"Here are some step to process data: \")\n st.header(\" II. Download data\")\n st.write(\"Here you can download data\")\n \n st.header(\" III. Statistic Data\")\n st.write(\"You can judge patient condition accroding to provided data\") \n \n st.header(\"IV. AGF Indices\")\n st.write(\"Here you can analyse each chart\") \n \n st.header(\" V. Notes\")\n st.write(\"It can be useful for you to collect notes concerning your patient\") \n\n st.header(\" VI. Rank of patient\")\n st.write(\"You can compare results for selected patients\" )","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'AscensionESports_Baseline/index.html',\n {\n 'background': getSiteBackground(),\n 'color': getSiteColor(),\n 'title':'Home Page',\n 'year':datetime.now().year,\n }\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year\n )","def setUp(self):\n logging.info(\"## SETUP METHOD ##\")\n logging.info(\"# Initializing the webdriver.\")\n self.chprofile = self.create_chprofile()\n self.driver = webdriver.Chrome(self.chprofile)\n self.driver.maximize_window()\n self.driver.implicitly_wait(5)\n self.driver.get(\"http://the-internet.herokuapp.com/\")","def homepage():\n return render_template('home/index.html', title=\"Home\")","def _MakeFrames(self):\n for fname in self.tab_modules.keys(): \n if 'size' in self.frame_parameters[fname] :\n self.MakeFrame(fname, size=self.frame_parameters[fname]['size'], visible = False)\n else :\n self.MakeFrame(fname, visible = False)\n\n print('Executing configuration routines for each tab:')\n print('\\t')\n\n for frame in self.frame_objects.values():\n frame.MakeTabs(self)\n \n print('')\n print('The module marina is complete.\\n\\n')","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def main():\n with open(\"page_data.yaml\", 'r') as inputstr:\n config_data = yaml.safe_load(inputstr)\n ointf = OutputInterface('template.txt')\n table_data = get_song_artist_matches()\n ofilen = config_data['directory'] + os.sep + 'common_songs.html'\n title = 'Song Titles and Band Name Overlap'\n header = ['No.', 'Artist', 'Peak', 'Date', 'Song/Artist', 'Peak',\n 'Date', 'Song']\n ointf.build_page(ofilen, title, header, fmt_table(table_data))\n ointf.inject(XTRAEDIT)\n ointf.output()","def homepage():\n return render_template(\"home/index.html\", title=\"Welcome\")","def index():\n\treturn render_template(\"index.html\", title=\"Home\")","def home():\n return render_template(\n 'home.html',\n title='Home Page',\n year=datetime.now().year,\n )","def setUp(self):\r\n # Ensure that the superclass sets up\r\n super(XBlockAcidBase, self).setUp()\r\n\r\n self.setup_fixtures()\r\n\r\n AutoAuthPage(self.browser, course_id=self.course_id).visit()\r\n\r\n self.course_info_page = CourseInfoPage(self.browser, self.course_id)\r\n self.tab_nav = TabNavPage(self.browser)","def home():\n return render_template(\n 'index.html',\n title='Sairam sai baba',\n year=datetime.now().year,\n )","def index():\n title = \"Application process \"\n links = {'mentors': 'mentors',\n 'schools': 'all-school',\n 'mentors_by_country': 'mentors-by-country',\n 'contacts': 'contacts',\n 'applicants': 'applicants',\n 'applicants_and_mentors': 'applicants-and-mentors'}\n menu = ['Show mentors and schools',\n 'Show mentors and all schools',\n 'Show mentors by country',\n 'Show contacts',\n 'Show applicants',\n 'Show applicants and mentors']\n return render_template('index.html', links=links, menu=menu, title=title)","def index():\n return render_template('pages/index.html', isNav=True)","def main_page():\n return render_template(\"index.html\")","def index():\n return render_template(\n 'main/index.html',\n title='Main page'\n )","def get_homepage():\n\n projects = hackbright.get_projects()\n students = hackbright.get_students()\n\n return render_template(\"homepage.html\",\n students=students,\n projects=projects)","def main():\n\n state = _get_state()\n pages = {\n \"Home\": page_home,\n \"Dashboard\": page_dashboard,\n \"Settings\": page_settings,\n }\n\n st.sidebar.title(\":mag: Pages\")\n page = st.sidebar.radio(\"Select your page:\", tuple(pages.keys()))\n\n # Display the selected page with the session state\n pages[page](state)\n\n # Mandatory to avoid rollbacks with widgets, must be called at the end of your app\n state.sync()","def a_homepage():\n\n\treturn render_template('home/a_homepage.html', title=\"Homepage Admin\")","def main():\n download_insert_title_basics()\n download_insert_title_principals()\n download_insert_name_basics()\n download_insert_title_ratings()\n scrap_keywords()\n create_and_insert_soup()\n return","def index():\n return render_template(\"index.html\", page_title=\"Home\")","def homepage():\n\n return render_template('rosemead_homepage.html')","def app():\n # Add balloons animation when page opens\n st.balloons()\n\n # Add title\n st.title(\"Welcome to the about me page\")\n \n # Add Contact Details\n st.header('Contact Us')\n\n # Add email\n st.markdown('''### Name:\n Khushal Mehrotra''')\n\n # Add name\n st.markdown('''### Email:\n kmehrotra07@gmail.com''')\n\n # Add github\n st.markdown('''### GitHub: [Khushal Mehrotra](https://github.com/km-07)''')\n\n # Add linkedin\n st.markdown('''### Linkedin: [Khushal Mehrotra](https://www.linkedin.com/in/khushal-mehrotra-5276091a9/)''')","def home(environ):\n return render_template(template_name=\"index.html\", context={})","def index():\n response.view_title = myconf.get('app.name') + ' Home Page'\n return dict(message='')","def main():\n st.sidebar.title(\"Menu\")\n selection = st.sidebar.radio(\"Go to\", list(PAGES.keys()))\n\n page = PAGES[selection]\n\n with st.spinner(f\"Loading {selection} ...\"):\n ast.shared.components.write_page(page)","def index():\n\n # Grab the weather.\n weather = fetch_weather()\n\n # Grab the news.\n news = fetch_news(5)\n\n # Grab some photos\n photos = fetch_photos(5)\n\n return render_template('index.html', photos=photos, news=news, weather=weather)","def home():\n return render_template('home.html', title=\"Home\")","def index():\n return render_template('index.html', title='Home')","def homepage():\n \n return render_template(\"coursePage.html\",courseName = \"Welcome\", Courses = COURSES, blank = 1)","def __init__(self):\n self.html = conf.get('HTML', 'simplePage').format(title='Services',\n h1='Services', message='')","def main():\r\n st.sidebar.title(\"MỤC LỤC\")\r\n selection = st.sidebar.radio(\"Go to\", list(PAGES.keys()))\r\n\r\n page = PAGES[selection]\r\n\r\n with st.spinner(f\"Loading {selection} ...\"):\r\n ast.shared.components.write_page(page)\r\n st.sidebar.title(\"Intro\")\r\n st.sidebar.info(\r\n \"App này được làm ra nhằm mục đích phục vụ cho việc **nghiên cứu và học tập** \"\r\n \"[source code](https://github.com/BienQuangTruong/streamlit_app). \"\r\n )\r\n st.sidebar.title(\"About\")\r\n st.sidebar.info(\r\n \"\"\"\r\n App này được thực hiện bởi Biện Quang Trường - Nguyễn Văn Phước.\r\n\"\"\"\r\n )","def add_page(self,**app_names_and_pages):\n \n for app,pages in app_names_and_pages.items():\n if os.path.exists(os.path.join(self._main,app)):\n for page in pages:\n os.makedirs(os.path.join(self._main,app,page))\n self._create_init_routes(self._main,app,page)\n else:\n print(\"that app does not exist\")\n\n self._update_add_app_or_page()","def home():\n return render_template(\n 'index.html',\n title='Automation Center',\n year=datetime.now().year,\n message='Welcome to the Automation Center'\n )","def index_site() -> None:\n app = create_web_app()\n app.app_context().push()\n index.create_index()\n\n indexable: List[IndexablePage] = []\n for path in site.list_paths():\n page: Page = site.load_page(path)\n content = bleach.clean(page.markdown, strip=True, tags=[])\n indexable.append(IndexablePage(\n title=page.title,\n path=page.path,\n content=content\n ))\n index.add_documents(*indexable)","def Main(base_dir, page_set_filenames):\n runner = PageTestRunner()\n sys.exit(runner.Run(base_dir, page_set_filenames))","def add_navnodes(self):\n\n # these are related to Routes above, except that NavNodes are like a hierarchical menu structure / site map, wheras Routes are flat patterns that map to controllers\n nodes = [\n NavNode('home', {\n 'menulabel': '${sitename} home page',\n 'menulabel_short': 'home',\n 'children': [],\n 'parent': 'site',\n 'sortweight': 1.0,\n 'menuhint' : 'Return to the home page'\n }),\n NavNode('help', {\n 'parent': 'site',\n 'sortweight': 10.0,\n }),\n NavNode('contact', {\n 'parent': 'help',\n 'sortweight': 8.0,\n }),\n NavNode('about', {\n 'parent': 'help',\n 'sortweight': 9.0,\n }),\n ]\n\n # add nodes to site\n self.comp('navnodemanager').add_nodes(nodes)","def controls_setup(self):\n self.dashboard = element.Link(self, class_name='menu-dashboard', alias='Dashboard Menu')\n # catalogue and sub-menus\n self.catalogue = element.LinkButton(self, class_name='menu-catalogue', alias='Catalogue Menu')\n self.products = element.Link(self, class_name='submenu-products', alias='Catalogue->Products Menu')\n self.product_types = element.Link(self, class_name='submenu-product-types',\n alias='Catalogue->Product Types Menu')\n self.categories = element.Link(self, class_name='submenu-categories', alias='Catalogue->Categories Menu')\n self.ranges = element.Link(self, class_name='submenu-ranges', alias='Catalogue->Ranges Menu')\n self.stock_alerts = element.Link(self, class_name='submenu-low-stock-alerts',\n alias='Catalogue->Low Stock Alerts Menu')\n # fulfilment and sub-menus\n self.fulfilment = element.LinkButton(self, class_name='menu-fulfilment', alias='Fulfilment Menu')\n self.orders = element.Link(self, class_name='submenu-orders', alias='Fulfilment->Orders Menu')\n self.statistics = element.Link(self, class_name='submenu-statistics', alias='Fulfilment->Statistics Menu')\n self.partners = element.Link(self, class_name='submenu-partners', alias='Fulfilment->Partners Menu')\n # customers and sub-menus\n self.customers = element.LinkButton(self, class_name='menu-customers', alias='Customers Menu')\n self.customers_submenu = element.Link(self, class_name='submenu-customers', alias='Customers->Customers Menu')\n self.deleted_accounts = element.Link(self, class_name='submenu-deleted_accounts',\n alias='Customers->Deleted Accounts Menu')\n self.stock_alert_requests = element.Link(self, class_name='submenu-stock-alert-requests-customers',\n alias='Customers->Stock Alert Requests Menu')\n # offers and sub-menus\n self.offers = element.LinkButton(self, class_name='menu-offers', alias='Offers Menu')\n self.offers_submenu = element.Link(self, class_name='submenu-offers', alias='Offers->Offers Menu')\n self.vouchers = element.Link(self, class_name='submenu-vouchers', alias='Offers->Vouchers Menu')\n # content and sub-menus\n self.content_menu = element.LinkButton(self, class_name='menu-content', alias='Content Menu')\n self.pages = element.Link(self, class_name='menu-pages', alias='Content->Pages Menu')\n self.announcements = element.Link(self, class_name='menu-announcements', alias='Content->Announcements Menu')\n self.reviews = element.Link(self, class_name='menu-reviews', alias='Content->Reviews Menu')\n\n self.reports = element.Link(self, class_name='menu-reports', alias='Reports Menu')\n self.store_info = element.LinkButton(self, css_selector='.dropdown.store > a', alias='Store Info Menu')\n self.partner_store = []","def home():\n tc = totalclicks()\n tl1, tl2, tl3 = topthreelinks()\n bl1, bl2, bl3 = topblomoedlinks()\n return flask.render_template('home.html', tc=tc, tl1=tl1, tl2=tl2, tl3=tl3, bl1=bl1, bl2=bl2, bl3=bl3)","def __init__(self, web_dir, title, refresh=0):\n self.title = title\n self.web_dir = web_dir\n os.makedirs(self.web_dir, exist_ok=True)\n self.doc = dominate.document(title=title)\n if refresh > 0:\n with self.doc.head:\n meta(http_equiv=\"refresh\", content=str(refresh))","def init_page_elements(self):\n pass","def __call__(self):\r\n self.init_data = td.import_data(self.__module__)\r\n self.page1() # GET navigation (requests 101-153)\r\n\r\n grinder.sleep(20)\r\n self.page2() # GET case (requests 201-252)\r\n\r\n grinder.sleep(20)\r\n self.page3() # GET view (requests 301-365)\r\n\r\n grinder.sleep(20)\r\n self.page4() # POST view (requests 401-452)\r","def header_nav(self):\r\n\r\n menu_stack = PaneStack()\r\n\r\n # Ensure the default button is the first tab\r\n #default_button_name = c.site.default_listing\r\n\r\n main_buttons = [\r\n ExpandableButton('main', dest = '/promoted', sr_path = False, sub_menus =\r\n [ NamedButton('posts', dest = '/promoted', sr_path = False),\r\n NamedButton('comments', dest = '/comments', sr_path = False)]),\r\n ExpandableButton('discussion', dest = \"/r/discussion/new\", sub_reddit = \"/r/discussion/\", sub_menus =\r\n [ NamedButton('posts', dest = \"/r/discussion/new\", sr_path = False),\r\n NamedButton('comments', dest = \"/r/discussion/comments\", sr_path = False)])\r\n ]\r\n\r\n menu_stack.append(NavMenu(main_buttons, title = _('Filter by'), _id='nav', type='navlist'))\r\n\r\n\r\n if self.header_sub_nav:\r\n menu_stack.append(NavMenu(self.header_sub_nav, title = _('Filter by'), _id='filternav', type='navlist'))\r\n\r\n return menu_stack","def setUp(self):\n logging.info(\"## SETUP METHOD ##\")\n logging.info(\"# Initializing the webdriver.\")\n \n self.ffprofile = self.create_ffprofile()\n self.driver = webdriver.Firefox(self.ffprofile)\n self.driver.maximize_window()\n self.driver.implicitly_wait(5)\n self.driver.get(\"http://the-internet.herokuapp.com/\")"],"string":"[\n \"def generate_webpages(self):\\n if self.add_to_existing:\\n self.add_existing_data()\\n self.make_home_pages()\\n self.make_1d_histogram_pages()\\n self.make_corner_pages()\\n self.make_config_pages()\\n if self.make_comparison:\\n self.make_comparison_pages()\\n if self.make_interactive:\\n self.make_interactive_pages()\\n if self.publication:\\n self.make_publication_pages()\\n if self.gwdata is not None:\\n self.make_detector_pages()\\n self.make_error_page()\\n self.make_version_page()\\n if self.notes is not None:\\n self.make_notes_page()\\n self.make_downloads_page()\\n self.generate_specific_javascript()\",\n \"def main():\\n create_home()\\n create_about()\\n create_banner_list()\\n\\n for banner_id in appdata.banner_info:\\n banner.create_banner_page(banner_id)\",\n \"def controls_setup(self):\\n\\n self.to_homepage = element.Link(self, class_name='nav-home', alias='Return to site Link')\\n self.account = element.Link(self, class_name='nav-account', alias='Account Profile Link')\\n self.logout = element.Link(self, class_name='nav-logout', alias='Logout Link')\",\n \"def set_up(self, web_driver):\\n self.driver = web_driver\\n self.wait = WebDriverWait(self.driver, 60)\\n\\n self.google_page = GoogleSearchPage(self.driver, locator, conf, message)\\n self.flipkart_page = FlipkartPage(self.driver, locator, message)\",\n \"def initialPage():\\n\\treturn header() + footer()\",\n \"def setup(self, url, browser_config):\\n\\n # navigate to the front page\\n browser.open_url(url)\",\n \"def main():\\n stylesheets = \\\"<link rel='stylesheet' href='/css/tablestyle.css'>\\\"\\n webpage.htmlTop(stylesheets)\\n get_data()\\n webpage.htmlBottom()\",\n \"def create_home():\\n meta_desc = (\\n 'Expected values and probability per lap of step-up'\\n ' banners in Final Fantasy Brave Exvius (FFBE)')\\n template_vars = {\\n 'title' : sitesettings.SITE_NAME,\\n 'siteurl' : sitesettings.SITE_URL,\\n 'sitename' : sitesettings.SITE_NAME,\\n 'meta_desc' : meta_desc,\\n 'last_four_banners' : nav.get_last_four_banners('all'),\\n 'last_four_single' : nav.get_last_four_banners('single'),\\n 'last_four_multi' : nav.get_last_four_banners('multi'),\\n 'all_banner_info' : get_all_banner_info(),\\n }\\n\\n home_path = os.path.join(sitesettings.LOCAL_FILE_PATH)\\n\\n if not os.path.exists(home_path):\\n os.makedirs(home_path)\\n\\n template_file = 'home.html'\\n html_file_loc = os.path.join(home_path, 'index.html')\\n generatehtml.generate_html(\\n html_file_loc, template_file, template_vars, os.path.join(os.getcwd(), 'templates'))\",\n \"def setup(self):\\n\\n setup_data = get_setup_data()\\n\\n self.base_url = setup_data['base_url']\\n browser = setup_data['browser'].lower()\\n if browser == 'chrome':\\n self.driver = webdriver.Chrome()\\n elif browser == 'firefox':\\n self.driver = webdriver.Firefox()\\n elif browser == 'phantomjs':\\n self.driver = webdriver.PhantomJS()\\n else:\\n error = (\\n '{0:s} is not a supported browser. Supported browsers: '\\n 'Chrome, Firefox, PhantomJS'.format(browser)\\n )\\n\\n self.log.error(error)\\n raise ValueError(error)\\n self.log.info(\\n 'Setup data:\\\\nURL: {0}\\\\nBrowser: {1}'.format(\\n self.base_url, browser\\n )\\n )\\n self.log.info('Load main page')\\n self.driver.get(self.base_url)\",\n \"def main():\\n\\n return render_template(\\\"index.html\\\", title=\\\"Home\\\", heading=\\\"Dublin Bus\\\")\",\n \"def index(self, **args):\\n if not self.isConfigured:\\n self.configure()\\n s = self.override()\\n if not s:\\n self.pageConfig['timeStamp'] = time.strftime('%a %b %d %X %Z %Y')\\n contents = self.content(**args) # Make sure contents is run first (so it\\n # can change any pageConfig entries if desired\\n s = startPage % self.pageConfig\\n s = s + htmlDiv('header', self.header(**args),\\n keepEmptyDiv=self.pageConfig['keepEmptyHeader'])\\n s = s + htmlDiv('navigation', self.navigation(**args),\\n keepEmptyDiv=self.pageConfig['keepEmptyNavigation'])\\n s = s + htmlDiv('content', contents,\\n keepEmptyDiv=self.pageConfig['keepEmptyContent'])\\n s = s + htmlDiv('footer', self.footer(**args),\\n keepEmptyDiv=self.pageConfig['keepEmptyFooter'])\\n s = s + endPage\\n return s\",\n \"def main_aqa_layout():\\n\\n layout = html.Div(\\n [\\n # html.Div(\\n # id=server.config['NAVBAR_CONTAINER_ID'],\\n # children=[\\n # navbar\\n # ],\\n # # id=\\\"header\\\",\\n # # children=[\\n # # # Header(),\\n # # html.Div(\\n # # id=server.config['NAVBAR_CONTAINER_ID'],\\n # # children=navbar\\n # # ),\\n # # ]\\n # ),\\n dcc.Location(id=\\\"url\\\", pathname=\\\"/\\\"),\\n navbar,\\n dbc.Container(id=\\\"content\\\", style={\\\"padding\\\": \\\"20px\\\"}),\\n ]\\n )\\n\\n return layout\",\n \"def index():\\n return render_template(\\n 'index.html',\\n nav=nav,\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def make_navbar_for_homepage(self):\\n links = [\\n \\\"home\\\", [\\\"Result Pages\\\", self._result_page_links()], \\\"Version\\\"\\n ]\\n if len(self.samples) > 1:\\n links[1][1] += [\\\"Comparison\\\"]\\n if self.publication:\\n links.insert(2, \\\"Publication\\\")\\n if self.gwdata is not None:\\n links.append([\\\"Detchar\\\", [i for i in self.gwdata.keys()]])\\n if self.notes is not None:\\n links.append(\\\"Notes\\\")\\n return links\",\n \"def updateFrontPages(self):\\n nTmessage(\\\"Starting %s\\\" % getCallerName())\\n htmlDir = os.path.join(self.results_dir, \\\"HTML\\\")\\n if os.path.isdir(htmlDir):\\n# nTdebug(\\\"Removing original html directory for NRG-CING.\\\")\\n rmdir(htmlDir)\\n # end if\\n nTmessage(\\\"Creating HTML directory for %s.\\\" % self.results_base)\\n mkdirs(htmlDir)\\n# srcHtmlPath = os.path.join(cingRoot, cingPaths.html) \\n data_dir = os.path.join (self.base_dir, \\\"data\\\" )\\n base_data_dir = os.path.join (data_dir, self.results_base )\\n # Most crud can come in from the traditional method.\\n copyCingHtmlJsAndCssToDirectory(htmlDir)\\n \\n nTmessage(\\\"Adding frontpage-specific html.\\\")\\n fnList = \\\"\\\"\\\"\\n about.html \\n contact.html \\n credits.html \\n help.html \\n helpCing.html \\n helpPlot.html \\n helpTutorials.html\\n glossary.html \\n index.html\\n download.html \\n plot.html \\n cing.png \\n icon_email.gif\\n icon_reference.gif\\n icon_website.png\\n icon_youtube.jpeg\\n icon_download.gif\\n NRG-CING_circle.png\\n \\\"\\\"\\\".split()\\n for fn in fnList:\\n srcFile = os.path.join(base_data_dir, fn)\\n dstFile = os.path.join(htmlDir, fn)\\n if not fn.endswith('.html'):\\n copyfile(srcFile, dstFile)\\n# nTdebug(\\\"-1- Added extra file %s.\\\" % dstFile)\\n continue\\n # end if\\n file_content = open(srcFile, 'r').read() \\n old_string = r\\\"<!-- INSERT NEW FOOTER HERE -->\\\"\\n file_content = string.replace(file_content, old_string, self.htmlFooter)\\n old_string = r\\\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE) \\n old_string = r\\\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE) \\n if fn != 'index.html':\\n writeTextToFile(dstFile, file_content)\\n# nTdebug(\\\"-2- Added extra file %s.\\\" % dstFile)\\n continue\\n # end if\\n # Get framework input\\n file_content = self._format_html(file_content) \\n htmlfile = os.path.join(htmlDir, 'index.html')\\n writeTextToFile(htmlfile, file_content)\\n# nTdebug(\\\"-3- Written HTML index file: %s\\\" % htmlfile) \\n # end for\\n nTmessage(\\\"Copy the overall index\\\")\\n org_file = os.path.join(data_dir, 'redirect.html')\\n new_file = os.path.join(self.results_dir, 'index.html')\\n shutil.copy(org_file, new_file)\\n \\n nTmessage(\\\"Copy the python cgi server for TableTools\\\\n\\\")\\n cgi_file_name = 'DataTablesServer.py'\\n if not os.path.exists(self.cgi_dir):\\n nTerror(\\\"Please first create the server directory as expected at: %s\\\" % self.cgi_dir)\\n return True\\n # end if\\n org_file = os.path.join(self.base_dir, 'server', cgi_file_name)\\n new_file = os.path.join(self.cgi_dir, cgi_file_name)\\n if os.path.exists(new_file): # remove because if it's a hard link the copy will fail.\\n os.unlink(new_file)\\n # end if\\n shutil.copy(org_file, new_file)\",\n \"def setup_page(self):\\n raise NotImplementedError\",\n \"def get_homepage():\\n\\n list_of_students = hackbright.list_all_students()\\n list_of_projects = hackbright.list_all_projects()\\n\\n return render_template(\\\"index.html\\\",\\n list_of_students=list_of_students,\\n list_of_projects=list_of_projects)\",\n \"def index():\\n isoko = get_sources('general')\\n\\n head = \\\"ALLOVER THE WORLD NEWS\\\"\\n return render_template('index.html', title = head, isoko = isoko)\",\n \"def homepage():\\n\\n general_news=get_sources('general')\\n business_news=get_sources('business')\\n sports_news=get_sources('sports')\\n return render_template('sources.html',general=general_news, business=business_news, sports=sports_news)\",\n \"def index():\\r\\n\\r\\n # initializes page title\\r\\n page_title = 'Home'\\r\\n\\r\\n # renders the landing page\\r\\n return render_template('index.html', page_title=page_title)\",\n \"def main_nav():\\n return render_template('home.html')\",\n \"def home():\\n\\n\\treturn render_template('index.html', title='Home Page',\\n\\t\\t\\t\\t\\t\\t year=datetime.now().year)\",\n \"def __init__(self, **args):\\n self.pageConfig = { 'contentType': '', # For plain CGI need: 'Content-type: text/html\\\\n\\\\n'\\n 'pageName': '',\\n 'pageTitle': '',\\n 'pageHeaderSnippets': '',\\n 'cssName': 'default.css',\\n 'css_currentLink': 'acurrentlink',\\n 'header': '',\\n 'navigation': '',\\n 'content': '',\\n 'footer': '',\\n 'keepEmptyHeader': False, # Set to true to anyway generate div if empty\\n 'keepEmptyNavigation': False,\\n 'keepEmptyContent': False,\\n 'keepEmptyFooter': False\\n }\\n for k in args:\\n self.pageConfig[k] = args[k]\\n self.globalConfig = GlobalConfiguration()\\n self.isConfigured = False\\n pass\",\n \"def setup_page(self):\\r\\n raise NotImplementedError\",\n \"async def setup(self):\\n load_base_templates()\\n uris = URI.gather()\\n for uri, resource in uris.items():\\n methods = resource.methods\\n if \\\"get\\\" not in methods:\\n methods[\\\"get\\\"] = None\\n\\n for method in methods.keys():\\n self.app.add_routes([\\n getattr(aioweb, method)(uri, resource.process)\\n ])\\n self.app.add_routes([aioweb.get(\\\"/hello\\\", hello)])\\n\\n # TMP code\\n max_age = 3600 * 24 * 365 # 1 year\\n setup(self.app, PonyStorage(max_age=max_age))\\n self.preparing_task = asyncio.create_task(self.prepare_web())\",\n \"def controls_setup(self):\\n\\n self.login = element.Link(self, class_name='nav-login', alias='Navbar->Login Link')\\n self.register = element.Link(self, class_name='nav-register', alias='Navbar->Register Link')\\n self.logout = element.Link(self, class_name='nav-logout', alias='Navbar->Logout Link')\\n self.be_a_merchant = element.Link(self, class_name='nav-partner-join',\\n alias='Navbar->Be A Merchant Link')\\n self.wishlist = element.Link(self, class_name='nav-wishlist', alias='Navbar->Wishlist Icon Button')\\n self.cart = element.Link(self, class_name='nav-cart', alias='Navbar->Cart Icon Button')\\n self.account = element.Link(self, css_selector='a.nav-account', alias='Navbar->Account Link')\\n self.messages = element.Link(self, class_name='nav-messages', alias='Navbar->Messages Link')\\n self.dashboard = element.Link(self, class_name='nav-dashboard', alias='Navbar->Dashboard Link')\\n self.messages_count = element.Element(self, dom_id='postman_unread_count',\\n alias='Navbar->Unread Messages Count Label')\\n\\n self.search_query = element.TextBox(self, name='q', alias='Navbar->Search Box')\\n self.search_button = element.Button(self, css_selector='form.search button[type=submit]',\\n alias='Navbar->Search Icon Button')\",\n \"def controls_setup(self):\\n\\n self.new_items = element.TopMenuLink(self, alias='New Items Menu',\\n css_selector='#browse > li:nth-child(1) > a')\\n if self.fixed:\\n self.jewelry = element.TopMenuLink(self, alias='Jewelry Menu',\\n css_selector='#browse > li:nth-child(2) > a')\\n self.artwork = element.TopMenuLink(self, alias='Artwork Menu',\\n css_selector='#browse > li:nth-child(3) > a')\\n self.homeware = element.TopMenuLink(self, alias='Homeware Menu',\\n css_selector='#browse > li:nth-child(4) > a')\\n self.clothing = element.TopMenuLink(self, alias='Clothing Menu',\\n css_selector='#browse > li:nth-child(5) > a')\\n self.vintage = element.TopMenuLink(self, alias='Vintage Menu',\\n css_selector='#browse > li:nth-child(6) > a')\\n self.food = element.TopMenuLink(self, alias='Food Menu',\\n css_selector='#browse > li:nth-child(7) > a')\\n self.rings = element.SubMenuLink(self, alias='Jewelry->Rings Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(1) > a')\\n self.necklaces = element.SubMenuLink(self, alias='Jewelry->Necklaces Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(2) > a')\\n self.bracelets = element.SubMenuLink(self, alias='Jewelry->Bracelets Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(3) > a')\\n self.earrings = element.SubMenuLink(self, alias='Jewelry->Earrings Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(4) > a')\\n self.broaches = element.SubMenuLink(self, alias='Jewelry->Broaches and Pins Submenu',\\n css_selector='#browse > li:nth-child(2) > ul > li:nth-child(5) > a')\\n self.wall_art = element.SubMenuLink(self, alias='Artwork->Wall Art Submenu',\\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(1) > a')\\n self.ceramics = element.SubMenuLink(self, alias='Jewelry->Ceramics Submenu',\\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(2) > a')\\n self.sculpture = element.SubMenuLink(self, alias='Jewelry->Sculpture Submenu',\\n css_selector='#browse > li:nth-child(3) > ul > li:nth-child(3) > a')\\n self.living = element.SubMenuLink(self, alias='Homeware->Living Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(1) > a')\\n self.furniture = element.SubMenuLink(self, alias='Homeware->Furniture Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(2) > a')\\n self.kitchen = element.SubMenuLink(self, alias='Homeware->Kitchen Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(3) > a')\\n self.lighting = element.SubMenuLink(self, alias='Homeware->Lighting Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(4) > a')\\n self.outdoor = element.SubMenuLink(self, alias='Homeware->Outdoor Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(5) > a')\\n self.organize = element.SubMenuLink(self, alias='Homeware->Organize Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(6) > a')\\n self.party = element.SubMenuLink(self, alias='Homeware->Party Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(7) > a')\\n self.sub_food = element.SubMenuLink(self, alias='Homeware->Food Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(8) > a')\\n self.pets = element.SubMenuLink(self, alias='Homeware->For Pets Submenu',\\n css_selector='#browse > li:nth-child(4) > ul > li:nth-child(9) > a')\\n self.women = element.SubMenuLink(self, alias='Clothing->Women Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(1) > a')\\n self.men = element.SubMenuLink(self, alias='Clothing->Men Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(2) > a')\\n self.kids = element.SubMenuLink(self, alias='Clothing->Kids Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(3) > a')\\n self.pet_lovers = element.SubMenuLink(self, alias='Clothing->Pet Lovers Submenu',\\n css_selector='#browse > li:nth-child(5) > ul > li:nth-child(4) > a')\\n self.antiques = element.SubMenuLink(self, alias='Vintage->Antiques Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(1) > a')\\n self.accessories = element.SubMenuLink(self, alias='Vintage->Accessories Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(2) > a')\\n self.sub_clothing = element.SubMenuLink(self, alias='Vintage->Clothing Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(3) > a')\\n self.sub_homeware = element.SubMenuLink(self, alias='Vintage->Homeware Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(4) > a')\\n self.toys = element.SubMenuLink(self, alias='Vintage->Toys Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(5) > a')\\n self.books = element.SubMenuLink(self, alias='Vintage->Books Submenu',\\n css_selector='#browse > li:nth-child(6) > ul > li:nth-child(6) > a')\\n else:\\n self.menus = []\",\n \"def __init__(self,parent,pageNames=[],**kw):\\n Frame.__init__(self, parent, kw)\\n self.grid_location(0,0)\\n self.columnconfigure(0,weight=1)\\n self.rowconfigure(1,weight=1)\\n self.tabBar=Frame(self)\\n self.tabBar.grid(row=0,column=0,sticky=EW)\\n self.activePage=StringVar(self)\\n self.defaultPage=''\\n self.pages={}\\n for name in pageNames:\\n self.AddPage(name)\",\n \"def web_site_mode():\\r\\n css = make_style.create_css()\\r\\n websites = dict()\\r\\n argument = dict()\\r\\n links = '<p align=\\\"center\\\">'\\r\\n for args in range(1, len(sys.argv)):\\r\\n website, head = make_content.create_content(sys.argv[args])\\r\\n websites[head] = website\\r\\n argument[sys.argv[args]] = head\\r\\n filename = convert_txt_to_html(sys.argv[args])\\r\\n links += '<a href=' + filename + '>' + head + '</a>---'\\r\\n links += END_P\\r\\n for args in range(1, len(sys.argv)):\\r\\n html_body = \\\"\\\"\\r\\n header = create_head(css, argument[sys.argv[args]])\\r\\n html_head = header + links\\r\\n website = websites[argument[sys.argv[args]]]\\r\\n for website_info in website:\\r\\n html_body += website_create_body(website_info)\\r\\n filename = convert_txt_to_html(sys.argv[args])\\r\\n html = html_head + html_body\\r\\n file = open(filename, \\\"+w\\\")\\r\\n file.write(html)\\r\\n file.close()\",\n \"def home():\\n template_stories = [\\\"silly_story\\\", \\\"excited_story\\\"]\\n\\n return render_template(\\\"homepage.html\\\", story_list = template_stories)\",\n \"def main():\\n page = get_page_arg()\\n\\n items = load_data(page)\\n total_pages = get_total_pages()\\n context = {\\\"current_page\\\": page,\\n \\\"total_pages\\\": total_pages,\\n \\\"items\\\": items}\\n\\n return render_template('index.html', **context)\",\n \"def makeHTMLIndexFile(self):\\n part1 = \\\"\\\"\\\"<html>\\n <body>\\n <title>Index</title>\\n <div id=\\\"pg_body\\\">\\n <div id=\\\"testSuitesTitle\\\">TestSuites</div>\\n <div id=\\\"resultsTitle\\\">Results</div>\\n <div id=\\\"testSuites\\\">\\n \\\"\\\"\\\"\\n part2 = self.makeLinks()\\n part3 = \\\"\\\"\\\"</div>\\n <div id=\\\"results\\\">\\n <iframe id=\\\"loadHTMLResults\\\" name=\\\"loadHTMLResults\\\" frameborder=\\\"0\\\" src=\\\"statistics.html\\\" style=\\\"height:100%;width:100%;\\\"></iframe>\\n </div>\\n <div id=\\\"footer\\\">Test Engineer(s) :\\\"\\\"\\\"+testEngineers+\\\"\\\"\\\"</div>\\n </div>\\n </body>\\n </html>\\n\\t\\t<style>\\n\\t\\tbody{\\n margin:0;\\n }\\n\\t\\t#pg_body{\\n\\t\\twidth=100%;\\n\\t\\ttext-align:center;\\n\\t\\t}\\n\\t\\t#testSuitesTitle{\\n\\t\\twidth:25%;\\n\\t\\tfloat:left;\\n\\t\\tbackground-color:#6495ED;\\n\\t\\tfont-weight:bold;\\n\\t\\tcolor:white;\\n\\t\\t}\\n\\t\\t#resultsTitle{\\n\\t\\twidth:75%;\\n\\t\\tfloat:right;\\n\\t\\tbackground-color:#6495ED;\\n\\t\\tfont-weight:bold;\\n\\t\\tcolor:white;\\n\\t\\t}\\n\\t\\t#testSuites{\\n\\t\\twidth:25%;\\n\\t\\tfloat:left;\\n\\t\\tbackground-color:lightgrey;\\n\\t\\tfont-weight:bold;\\n\\t\\ttext-align:left;\\n\\t\\theight:94%;\\n\\t\\toverflow:scroll;\\n\\t\\t}\\n\\t\\t#results{\\n\\t\\twidth:75%;\\n\\t\\tbackground-color:white;\\n\\t\\tfloat:right;\\n\\t\\ttext-align:left;\\n\\t\\theight:94%;\\n\\t\\toverflow:scroll;\\n\\t\\t}\\n\\t\\t#footer{\\n\\t\\twidth:100%;\\n\\t\\ttext-align:left;\\n\\t\\tcolor:lightgrey;\\n\\t\\tbackground-color:#6495ED;\\n\\t\\t}\\n\\t\\t</style>\\n \\\"\\\"\\\"\\n \\n page = (part1+part2+part3)\\n f = open(self.dir+'/index.html','w')\\n f.write(page)\\n f.close\",\n \"def setUp(self):\\r\\n super(CoursePagesTest, self).setUp()\\r\\n\\r\\n CourseFixture(\\r\\n self.course_info['org'],\\r\\n self.course_info['number'],\\r\\n self.course_info['run'],\\r\\n self.course_info['display_name']\\r\\n ).install()\\r\\n\\r\\n self.auth_page = AutoAuthPage(self.browser, staff=True)\\r\\n\\r\\n self.pages = [\\r\\n clz(self.browser, self.course_info['org'], self.course_info['number'], self.course_info['run'])\\r\\n for clz in [\\r\\n AssetIndexPage, ChecklistsPage, ImportPage, CourseUpdatesPage,\\r\\n PagesPage, ExportPage, CourseTeamPage, CourseOutlinePage, SettingsPage,\\r\\n AdvancedSettingsPage, GradingPage, TextbooksPage\\r\\n ]\\r\\n ]\",\n \"def common_header_part2(outfile: TextIO, indexpath: str = \\\"\\\", include_map: bool = False) -> None:\\n outfile.write(\\\" </head>\\\\n\\\")\\n outfile.write(\\\"\\\\n\\\")\\n if include_map:\\n outfile.write(\\\" <body onload=\\\\\\\"initialize()\\\\\\\">\\\\n\\\")\\n else:\\n outfile.write(\\\" <body>\\\\n\\\")\\n outfile.write(\\\" <div id=\\\\\\\"skip-links\\\\\\\" role=\\\\\\\"complementary\\\\\\\" aria-label=\\\\\\\"Skip links menu\\\\\\\">\\\")\\n outfile.write(\\\"<a href=\\\\\\\"#Main\\\\\\\" tabindex=\\\\\\\"1\\\\\\\">Skip to content</a></div>\\\\n\\\")\\n outfile.write(\\\" <div id=\\\\\\\"home\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" <a href=\\\\\\\"\\\" + indexpath + \\\"index.html\\\\\\\" class=\\\\\\\"home-title\\\\\\\">Fiddler Crabs</a>\\\\n\\\")\\n outfile.write(\\\" <a href=\\\\\\\"\\\" + indexpath +\\n \\\"index.html\\\\\\\" class=\\\\\\\"home-link\\\\\\\">\\\" + fetch_fa_glyph(\\\"home\\\") + \\\"Home</a>\\\\n\\\")\\n # outfile.write(\\\" <a href=\\\\\\\"\\\" + indexpath +\\n # \\\"blog\\\\\\\" class=\\\\\\\"home-link\\\\\\\">\\\" + fetch_fa_glyph(\\\"blog\\\") + \\\"Blog</a>\\\\n\\\")\\n outfile.write(\\\" </div>\\\\n\\\")\",\n \"def home_page():\\n\\n return render_template('index.html', stories=stories.values())\",\n \"def homepage():\\n return render_template('home/index.html', \\n title=\\\"Bem vindo!\\\")\",\n \"def create_layout() -> None:\\n\\n st.sidebar.title(\\\"Menu\\\")\\n app_mode = st.sidebar.selectbox(\\\"Please select a page\\\", [' I. Homepage',\\n \\\"II. Download data\\\" ,\\n \\\"III. Statistic Data\\\",\\n ' IV. AGF Indices',\\n ' V. Notes',\\n \\\" VI. Rank of patient\\\" ])\\n \\n if app_mode == ' I. Homepage':\\n load_homepage() \\n elif app_mode == \\\"III. Statistic Data\\\":\\n leyer.leyer() \\n elif app_mode == ' IV. AGF Indices':\\n single.AGF_indices() \\n elif app_mode == \\\"II. Download data\\\":\\n download_data.download_data() \\n elif app_mode == ' V. Notes':\\n text_input.text_input()\\n elif app_mode == \\\" VI. Rank of patient\\\":\\n rank_of_patient.rank_of_patient()\",\n \"def set_pages(self, selenium: fixture) -> None:\\n self.API: RecurringRidesAPI = RecurringRidesAPI()\\n self.details: Details = Details(selenium)\\n self.rides: Rides = Rides(selenium)\",\n \"def Header(page):\\n style = {\\n \\\"background-color\\\": \\\"var(--red_color)\\\",\\n \\\"color\\\": \\\"black\\\",\\n \\\"text-shadow\\\": \\\"0 0 10px #ffffff\\\"\\n }\\n\\n button1 = html.A(id=\\\"btn1box\\\", children=[\\n html.Button(\\\"OVERVIEW\\\", id=\\\"btn1\\\", className=\\\"btn\\\")\\n ], href=\\\"/dashboard/overview\\\")\\n\\n button2 = html.A(id=\\\"btn2box\\\", children=[\\n html.Button(\\\"BOOK\\\", id=\\\"btn2\\\", className=\\\"btn\\\")\\n ], href=\\\"/dashboard/book\\\")\\n\\n button3 = html.A(id=\\\"btn3box\\\", children=[\\n html.Button(\\\"WORD\\\", id=\\\"btn3\\\", className=\\\"btn\\\")\\n ], href=\\\"/dashboard/word\\\")\\n\\n if page == \\\"overview\\\":\\n button1.children[0].style = style\\n if page == \\\"book\\\":\\n button2.children[0].style = style\\n if page == \\\"word\\\":\\n button3.children[0].style = style\\n\\n return html.Div(id=\\\"header\\\", children=[\\n get_title(),\\n get_subtitle(),\\n button1,\\n button2,\\n button3\\n ])\",\n \"def home():\\r\\n return render_template(\\r\\n 'index.html',\\r\\n title='Home Page',\\r\\n year=datetime.now().year,\\r\\n )\",\n \"def controls_setup(self):\\n\\n self.inbox = element.NavigationTab(self, css_selector='.messaging a.nav-inbox', alias='Inbox Tab')\\n self.sent = element.NavigationTab(self, css_selector='.messaging a.nav-sent', alias='Sent Tab')\\n self.write = element.NavigationTab(self, css_selector='.messaging a.nav-write', alias='Write Tab')\\n self.archives = element.NavigationTab(self, css_selector='.messaging a.nav-archive', alias='Archives Tab')\\n self.trash = element.NavigationTab(self, css_selector='.messaging a.nav-trash', alias='Trash Tab')\",\n \"def webinit():\\n\\troot = Root()\\n\\troot.player = Player()\\n\\troot.songs = Songs()\\n\\troot.albums = Albums()\\n\\troot.artists = Artists()\\n\\t\\n\\tapp = cherrypy.tree.mount(root, '/', 'data/cherrypy.config')\\n\\treturn app\",\n \"def homepage():\\n\\treturn render_template(\\\"home/a_homepage.html\\\", title=\\\"Welcome\\\")\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n\\n return render_template('index.html',\\n date = d,\\n mood = mood,\\n header_color = color,\\n day = day,\\n week = week,\\n month = month,\\n year = year)\",\n \"def load_homepage() -> None:\\n st.image(\\\"iwakka.png\\\",\\n use_column_width=True)\\n \\n st.header(\\\"Hello! This dashboard will help you to analize data from iWakka device\\\")\\n st.write(\\\"Here are some step to process data: \\\")\\n st.header(\\\" II. Download data\\\")\\n st.write(\\\"Here you can download data\\\")\\n \\n st.header(\\\" III. Statistic Data\\\")\\n st.write(\\\"You can judge patient condition accroding to provided data\\\") \\n \\n st.header(\\\"IV. AGF Indices\\\")\\n st.write(\\\"Here you can analyse each chart\\\") \\n \\n st.header(\\\" V. Notes\\\")\\n st.write(\\\"It can be useful for you to collect notes concerning your patient\\\") \\n\\n st.header(\\\" VI. Rank of patient\\\")\\n st.write(\\\"You can compare results for selected patients\\\" )\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'AscensionESports_Baseline/index.html',\\n {\\n 'background': getSiteBackground(),\\n 'color': getSiteColor(),\\n 'title':'Home Page',\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def setUp(self):\\n logging.info(\\\"## SETUP METHOD ##\\\")\\n logging.info(\\\"# Initializing the webdriver.\\\")\\n self.chprofile = self.create_chprofile()\\n self.driver = webdriver.Chrome(self.chprofile)\\n self.driver.maximize_window()\\n self.driver.implicitly_wait(5)\\n self.driver.get(\\\"http://the-internet.herokuapp.com/\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Home\\\")\",\n \"def _MakeFrames(self):\\n for fname in self.tab_modules.keys(): \\n if 'size' in self.frame_parameters[fname] :\\n self.MakeFrame(fname, size=self.frame_parameters[fname]['size'], visible = False)\\n else :\\n self.MakeFrame(fname, visible = False)\\n\\n print('Executing configuration routines for each tab:')\\n print('\\\\t')\\n\\n for frame in self.frame_objects.values():\\n frame.MakeTabs(self)\\n \\n print('')\\n print('The module marina is complete.\\\\n\\\\n')\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def main():\\n with open(\\\"page_data.yaml\\\", 'r') as inputstr:\\n config_data = yaml.safe_load(inputstr)\\n ointf = OutputInterface('template.txt')\\n table_data = get_song_artist_matches()\\n ofilen = config_data['directory'] + os.sep + 'common_songs.html'\\n title = 'Song Titles and Band Name Overlap'\\n header = ['No.', 'Artist', 'Peak', 'Date', 'Song/Artist', 'Peak',\\n 'Date', 'Song']\\n ointf.build_page(ofilen, title, header, fmt_table(table_data))\\n ointf.inject(XTRAEDIT)\\n ointf.output()\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\", title=\\\"Welcome\\\")\",\n \"def index():\\n\\treturn render_template(\\\"index.html\\\", title=\\\"Home\\\")\",\n \"def home():\\n return render_template(\\n 'home.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def setUp(self):\\r\\n # Ensure that the superclass sets up\\r\\n super(XBlockAcidBase, self).setUp()\\r\\n\\r\\n self.setup_fixtures()\\r\\n\\r\\n AutoAuthPage(self.browser, course_id=self.course_id).visit()\\r\\n\\r\\n self.course_info_page = CourseInfoPage(self.browser, self.course_id)\\r\\n self.tab_nav = TabNavPage(self.browser)\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Sairam sai baba',\\n year=datetime.now().year,\\n )\",\n \"def index():\\n title = \\\"Application process \\\"\\n links = {'mentors': 'mentors',\\n 'schools': 'all-school',\\n 'mentors_by_country': 'mentors-by-country',\\n 'contacts': 'contacts',\\n 'applicants': 'applicants',\\n 'applicants_and_mentors': 'applicants-and-mentors'}\\n menu = ['Show mentors and schools',\\n 'Show mentors and all schools',\\n 'Show mentors by country',\\n 'Show contacts',\\n 'Show applicants',\\n 'Show applicants and mentors']\\n return render_template('index.html', links=links, menu=menu, title=title)\",\n \"def index():\\n return render_template('pages/index.html', isNav=True)\",\n \"def main_page():\\n return render_template(\\\"index.html\\\")\",\n \"def index():\\n return render_template(\\n 'main/index.html',\\n title='Main page'\\n )\",\n \"def get_homepage():\\n\\n projects = hackbright.get_projects()\\n students = hackbright.get_students()\\n\\n return render_template(\\\"homepage.html\\\",\\n students=students,\\n projects=projects)\",\n \"def main():\\n\\n state = _get_state()\\n pages = {\\n \\\"Home\\\": page_home,\\n \\\"Dashboard\\\": page_dashboard,\\n \\\"Settings\\\": page_settings,\\n }\\n\\n st.sidebar.title(\\\":mag: Pages\\\")\\n page = st.sidebar.radio(\\\"Select your page:\\\", tuple(pages.keys()))\\n\\n # Display the selected page with the session state\\n pages[page](state)\\n\\n # Mandatory to avoid rollbacks with widgets, must be called at the end of your app\\n state.sync()\",\n \"def a_homepage():\\n\\n\\treturn render_template('home/a_homepage.html', title=\\\"Homepage Admin\\\")\",\n \"def main():\\n download_insert_title_basics()\\n download_insert_title_principals()\\n download_insert_name_basics()\\n download_insert_title_ratings()\\n scrap_keywords()\\n create_and_insert_soup()\\n return\",\n \"def index():\\n return render_template(\\\"index.html\\\", page_title=\\\"Home\\\")\",\n \"def homepage():\\n\\n return render_template('rosemead_homepage.html')\",\n \"def app():\\n # Add balloons animation when page opens\\n st.balloons()\\n\\n # Add title\\n st.title(\\\"Welcome to the about me page\\\")\\n \\n # Add Contact Details\\n st.header('Contact Us')\\n\\n # Add email\\n st.markdown('''### Name:\\n Khushal Mehrotra''')\\n\\n # Add name\\n st.markdown('''### Email:\\n kmehrotra07@gmail.com''')\\n\\n # Add github\\n st.markdown('''### GitHub: [Khushal Mehrotra](https://github.com/km-07)''')\\n\\n # Add linkedin\\n st.markdown('''### Linkedin: [Khushal Mehrotra](https://www.linkedin.com/in/khushal-mehrotra-5276091a9/)''')\",\n \"def home(environ):\\n return render_template(template_name=\\\"index.html\\\", context={})\",\n \"def index():\\n response.view_title = myconf.get('app.name') + ' Home Page'\\n return dict(message='')\",\n \"def main():\\n st.sidebar.title(\\\"Menu\\\")\\n selection = st.sidebar.radio(\\\"Go to\\\", list(PAGES.keys()))\\n\\n page = PAGES[selection]\\n\\n with st.spinner(f\\\"Loading {selection} ...\\\"):\\n ast.shared.components.write_page(page)\",\n \"def index():\\n\\n # Grab the weather.\\n weather = fetch_weather()\\n\\n # Grab the news.\\n news = fetch_news(5)\\n\\n # Grab some photos\\n photos = fetch_photos(5)\\n\\n return render_template('index.html', photos=photos, news=news, weather=weather)\",\n \"def home():\\n return render_template('home.html', title=\\\"Home\\\")\",\n \"def index():\\n return render_template('index.html', title='Home')\",\n \"def homepage():\\n \\n return render_template(\\\"coursePage.html\\\",courseName = \\\"Welcome\\\", Courses = COURSES, blank = 1)\",\n \"def __init__(self):\\n self.html = conf.get('HTML', 'simplePage').format(title='Services',\\n h1='Services', message='')\",\n \"def main():\\r\\n st.sidebar.title(\\\"MỤC LỤC\\\")\\r\\n selection = st.sidebar.radio(\\\"Go to\\\", list(PAGES.keys()))\\r\\n\\r\\n page = PAGES[selection]\\r\\n\\r\\n with st.spinner(f\\\"Loading {selection} ...\\\"):\\r\\n ast.shared.components.write_page(page)\\r\\n st.sidebar.title(\\\"Intro\\\")\\r\\n st.sidebar.info(\\r\\n \\\"App này được làm ra nhằm mục đích phục vụ cho việc **nghiên cứu và học tập** \\\"\\r\\n \\\"[source code](https://github.com/BienQuangTruong/streamlit_app). \\\"\\r\\n )\\r\\n st.sidebar.title(\\\"About\\\")\\r\\n st.sidebar.info(\\r\\n \\\"\\\"\\\"\\r\\n App này được thực hiện bởi Biện Quang Trường - Nguyễn Văn Phước.\\r\\n\\\"\\\"\\\"\\r\\n )\",\n \"def add_page(self,**app_names_and_pages):\\n \\n for app,pages in app_names_and_pages.items():\\n if os.path.exists(os.path.join(self._main,app)):\\n for page in pages:\\n os.makedirs(os.path.join(self._main,app,page))\\n self._create_init_routes(self._main,app,page)\\n else:\\n print(\\\"that app does not exist\\\")\\n\\n self._update_add_app_or_page()\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Automation Center',\\n year=datetime.now().year,\\n message='Welcome to the Automation Center'\\n )\",\n \"def index_site() -> None:\\n app = create_web_app()\\n app.app_context().push()\\n index.create_index()\\n\\n indexable: List[IndexablePage] = []\\n for path in site.list_paths():\\n page: Page = site.load_page(path)\\n content = bleach.clean(page.markdown, strip=True, tags=[])\\n indexable.append(IndexablePage(\\n title=page.title,\\n path=page.path,\\n content=content\\n ))\\n index.add_documents(*indexable)\",\n \"def Main(base_dir, page_set_filenames):\\n runner = PageTestRunner()\\n sys.exit(runner.Run(base_dir, page_set_filenames))\",\n \"def add_navnodes(self):\\n\\n # these are related to Routes above, except that NavNodes are like a hierarchical menu structure / site map, wheras Routes are flat patterns that map to controllers\\n nodes = [\\n NavNode('home', {\\n 'menulabel': '${sitename} home page',\\n 'menulabel_short': 'home',\\n 'children': [],\\n 'parent': 'site',\\n 'sortweight': 1.0,\\n 'menuhint' : 'Return to the home page'\\n }),\\n NavNode('help', {\\n 'parent': 'site',\\n 'sortweight': 10.0,\\n }),\\n NavNode('contact', {\\n 'parent': 'help',\\n 'sortweight': 8.0,\\n }),\\n NavNode('about', {\\n 'parent': 'help',\\n 'sortweight': 9.0,\\n }),\\n ]\\n\\n # add nodes to site\\n self.comp('navnodemanager').add_nodes(nodes)\",\n \"def controls_setup(self):\\n self.dashboard = element.Link(self, class_name='menu-dashboard', alias='Dashboard Menu')\\n # catalogue and sub-menus\\n self.catalogue = element.LinkButton(self, class_name='menu-catalogue', alias='Catalogue Menu')\\n self.products = element.Link(self, class_name='submenu-products', alias='Catalogue->Products Menu')\\n self.product_types = element.Link(self, class_name='submenu-product-types',\\n alias='Catalogue->Product Types Menu')\\n self.categories = element.Link(self, class_name='submenu-categories', alias='Catalogue->Categories Menu')\\n self.ranges = element.Link(self, class_name='submenu-ranges', alias='Catalogue->Ranges Menu')\\n self.stock_alerts = element.Link(self, class_name='submenu-low-stock-alerts',\\n alias='Catalogue->Low Stock Alerts Menu')\\n # fulfilment and sub-menus\\n self.fulfilment = element.LinkButton(self, class_name='menu-fulfilment', alias='Fulfilment Menu')\\n self.orders = element.Link(self, class_name='submenu-orders', alias='Fulfilment->Orders Menu')\\n self.statistics = element.Link(self, class_name='submenu-statistics', alias='Fulfilment->Statistics Menu')\\n self.partners = element.Link(self, class_name='submenu-partners', alias='Fulfilment->Partners Menu')\\n # customers and sub-menus\\n self.customers = element.LinkButton(self, class_name='menu-customers', alias='Customers Menu')\\n self.customers_submenu = element.Link(self, class_name='submenu-customers', alias='Customers->Customers Menu')\\n self.deleted_accounts = element.Link(self, class_name='submenu-deleted_accounts',\\n alias='Customers->Deleted Accounts Menu')\\n self.stock_alert_requests = element.Link(self, class_name='submenu-stock-alert-requests-customers',\\n alias='Customers->Stock Alert Requests Menu')\\n # offers and sub-menus\\n self.offers = element.LinkButton(self, class_name='menu-offers', alias='Offers Menu')\\n self.offers_submenu = element.Link(self, class_name='submenu-offers', alias='Offers->Offers Menu')\\n self.vouchers = element.Link(self, class_name='submenu-vouchers', alias='Offers->Vouchers Menu')\\n # content and sub-menus\\n self.content_menu = element.LinkButton(self, class_name='menu-content', alias='Content Menu')\\n self.pages = element.Link(self, class_name='menu-pages', alias='Content->Pages Menu')\\n self.announcements = element.Link(self, class_name='menu-announcements', alias='Content->Announcements Menu')\\n self.reviews = element.Link(self, class_name='menu-reviews', alias='Content->Reviews Menu')\\n\\n self.reports = element.Link(self, class_name='menu-reports', alias='Reports Menu')\\n self.store_info = element.LinkButton(self, css_selector='.dropdown.store > a', alias='Store Info Menu')\\n self.partner_store = []\",\n \"def home():\\n tc = totalclicks()\\n tl1, tl2, tl3 = topthreelinks()\\n bl1, bl2, bl3 = topblomoedlinks()\\n return flask.render_template('home.html', tc=tc, tl1=tl1, tl2=tl2, tl3=tl3, bl1=bl1, bl2=bl2, bl3=bl3)\",\n \"def __init__(self, web_dir, title, refresh=0):\\n self.title = title\\n self.web_dir = web_dir\\n os.makedirs(self.web_dir, exist_ok=True)\\n self.doc = dominate.document(title=title)\\n if refresh > 0:\\n with self.doc.head:\\n meta(http_equiv=\\\"refresh\\\", content=str(refresh))\",\n \"def init_page_elements(self):\\n pass\",\n \"def __call__(self):\\r\\n self.init_data = td.import_data(self.__module__)\\r\\n self.page1() # GET navigation (requests 101-153)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page2() # GET case (requests 201-252)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page3() # GET view (requests 301-365)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page4() # POST view (requests 401-452)\\r\",\n \"def header_nav(self):\\r\\n\\r\\n menu_stack = PaneStack()\\r\\n\\r\\n # Ensure the default button is the first tab\\r\\n #default_button_name = c.site.default_listing\\r\\n\\r\\n main_buttons = [\\r\\n ExpandableButton('main', dest = '/promoted', sr_path = False, sub_menus =\\r\\n [ NamedButton('posts', dest = '/promoted', sr_path = False),\\r\\n NamedButton('comments', dest = '/comments', sr_path = False)]),\\r\\n ExpandableButton('discussion', dest = \\\"/r/discussion/new\\\", sub_reddit = \\\"/r/discussion/\\\", sub_menus =\\r\\n [ NamedButton('posts', dest = \\\"/r/discussion/new\\\", sr_path = False),\\r\\n NamedButton('comments', dest = \\\"/r/discussion/comments\\\", sr_path = False)])\\r\\n ]\\r\\n\\r\\n menu_stack.append(NavMenu(main_buttons, title = _('Filter by'), _id='nav', type='navlist'))\\r\\n\\r\\n\\r\\n if self.header_sub_nav:\\r\\n menu_stack.append(NavMenu(self.header_sub_nav, title = _('Filter by'), _id='filternav', type='navlist'))\\r\\n\\r\\n return menu_stack\",\n \"def setUp(self):\\n logging.info(\\\"## SETUP METHOD ##\\\")\\n logging.info(\\\"# Initializing the webdriver.\\\")\\n \\n self.ffprofile = self.create_ffprofile()\\n self.driver = webdriver.Firefox(self.ffprofile)\\n self.driver.maximize_window()\\n self.driver.implicitly_wait(5)\\n self.driver.get(\\\"http://the-internet.herokuapp.com/\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6627888","0.6465586","0.62752324","0.6114537","0.6103888","0.606285","0.60445887","0.6036751","0.60337174","0.6021009","0.5930741","0.5924869","0.5913862","0.58483374","0.5833003","0.58251595","0.57794666","0.57769567","0.57743686","0.5753638","0.5752281","0.574279","0.57370317","0.57294065","0.57287544","0.5723065","0.5716562","0.5711762","0.57003355","0.5664866","0.5660989","0.5653627","0.56432766","0.56027746","0.5595816","0.5595195","0.5591435","0.5590787","0.55879","0.5578418","0.55678415","0.5557991","0.5557475","0.555065","0.555065","0.555065","0.555065","0.555065","0.555065","0.555065","0.555065","0.555065","0.555065","0.553791","0.5533484","0.55309516","0.55282766","0.5523566","0.5521277","0.55194193","0.5508152","0.5508152","0.5495358","0.5492698","0.54853684","0.54784316","0.546796","0.5466928","0.5463467","0.5460013","0.5459713","0.5458242","0.5455162","0.5447027","0.5438849","0.5432701","0.54284775","0.5415654","0.5402041","0.53997695","0.5398214","0.53910714","0.5390114","0.53876704","0.5382185","0.5371707","0.53638935","0.53628564","0.53625166","0.5362477","0.53569925","0.53515893","0.5335955","0.53330845","0.53215814","0.53169477","0.53161275","0.5311368","0.5310178","0.5299954"],"string":"[\n \"0.6627888\",\n \"0.6465586\",\n \"0.62752324\",\n \"0.6114537\",\n \"0.6103888\",\n \"0.606285\",\n \"0.60445887\",\n \"0.6036751\",\n \"0.60337174\",\n \"0.6021009\",\n \"0.5930741\",\n \"0.5924869\",\n \"0.5913862\",\n \"0.58483374\",\n \"0.5833003\",\n \"0.58251595\",\n \"0.57794666\",\n \"0.57769567\",\n \"0.57743686\",\n \"0.5753638\",\n \"0.5752281\",\n \"0.574279\",\n \"0.57370317\",\n \"0.57294065\",\n \"0.57287544\",\n \"0.5723065\",\n \"0.5716562\",\n \"0.5711762\",\n \"0.57003355\",\n \"0.5664866\",\n \"0.5660989\",\n \"0.5653627\",\n \"0.56432766\",\n \"0.56027746\",\n \"0.5595816\",\n \"0.5595195\",\n \"0.5591435\",\n \"0.5590787\",\n \"0.55879\",\n \"0.5578418\",\n \"0.55678415\",\n \"0.5557991\",\n \"0.5557475\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.555065\",\n \"0.553791\",\n \"0.5533484\",\n \"0.55309516\",\n \"0.55282766\",\n \"0.5523566\",\n \"0.5521277\",\n \"0.55194193\",\n \"0.5508152\",\n \"0.5508152\",\n \"0.5495358\",\n \"0.5492698\",\n \"0.54853684\",\n \"0.54784316\",\n \"0.546796\",\n \"0.5466928\",\n \"0.5463467\",\n \"0.5460013\",\n \"0.5459713\",\n \"0.5458242\",\n \"0.5455162\",\n \"0.5447027\",\n \"0.5438849\",\n \"0.5432701\",\n \"0.54284775\",\n \"0.5415654\",\n \"0.5402041\",\n \"0.53997695\",\n \"0.5398214\",\n \"0.53910714\",\n \"0.5390114\",\n \"0.53876704\",\n \"0.5382185\",\n \"0.5371707\",\n \"0.53638935\",\n \"0.53628564\",\n \"0.53625166\",\n \"0.5362477\",\n \"0.53569925\",\n \"0.53515893\",\n \"0.5335955\",\n \"0.53330845\",\n \"0.53215814\",\n \"0.53169477\",\n \"0.53161275\",\n \"0.5311368\",\n \"0.5310178\",\n \"0.5299954\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6815308"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":90797,"cells":{"query":{"kind":"string","value":"Make a navbar for the homepage"},"document":{"kind":"string","value":"def make_navbar_for_homepage(self):\n links = [\n \"home\", [\"Result Pages\", self._result_page_links()], \"Version\"\n ]\n if len(self.samples) > 1:\n links[1][1] += [\"Comparison\"]\n if self.publication:\n links.insert(2, \"Publication\")\n if self.gwdata is not None:\n links.append([\"Detchar\", [i for i in self.gwdata.keys()]])\n if self.notes is not None:\n links.append(\"Notes\")\n return links"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def main_nav():\n return render_template('home.html')","def homepage():\n return render_template('home/index.html', \n title=\"Bem vindo!\")","def index():\n return render_template(\n 'index.html',\n nav=nav,\n title='Home Page',\n year=datetime.now().year\n )","def home():\n\n\treturn render_template('index.html', title='Home Page',\n\t\t\t\t\t\t year=datetime.now().year)","def home():\n return render_template(\n 'index.html',\n title='Sairam sai baba',\n year=datetime.now().year,\n )","def home():\r\n return render_template(\r\n 'index.html',\r\n title='Home Page',\r\n year=datetime.now().year,\r\n )","def homepage():\n return render_template('home/index.html', title=\"Home\")","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year\n )","def home():\n return render_template(\n 'home.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template('home.html', title=\"Home\")","def navbar_user():\n return (\"machines\", render_to_string(\"deployments/navbar.html\"))","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def homepage():\n return render_template(\"home/index.html\", title=\"Welcome\")","def a_homepage():\n\n\treturn render_template('home/a_homepage.html', title=\"Homepage Admin\")","def homepage():\n\treturn render_template(\"home/a_homepage.html\", title=\"Welcome\")","def home():\n\n\treturn render_template('solai.html')","def index():\n return render_template('pages/index.html', isNav=True)","def home():\n return render_template('homepage.html')","def homepage():\n\n return render_template('rosemead_homepage.html')","def homepage():\n return render_template(\"home/index.html\")","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'AscensionESports_Baseline/index.html',\n {\n 'background': getSiteBackground(),\n 'color': getSiteColor(),\n 'title':'Home Page',\n 'year':datetime.now().year,\n }\n )","def header_nav(self):\r\n\r\n menu_stack = PaneStack()\r\n\r\n # Ensure the default button is the first tab\r\n #default_button_name = c.site.default_listing\r\n\r\n main_buttons = [\r\n ExpandableButton('main', dest = '/promoted', sr_path = False, sub_menus =\r\n [ NamedButton('posts', dest = '/promoted', sr_path = False),\r\n NamedButton('comments', dest = '/comments', sr_path = False)]),\r\n ExpandableButton('discussion', dest = \"/r/discussion/new\", sub_reddit = \"/r/discussion/\", sub_menus =\r\n [ NamedButton('posts', dest = \"/r/discussion/new\", sr_path = False),\r\n NamedButton('comments', dest = \"/r/discussion/comments\", sr_path = False)])\r\n ]\r\n\r\n menu_stack.append(NavMenu(main_buttons, title = _('Filter by'), _id='nav', type='navlist'))\r\n\r\n\r\n if self.header_sub_nav:\r\n menu_stack.append(NavMenu(self.header_sub_nav, title = _('Filter by'), _id='filternav', type='navlist'))\r\n\r\n return menu_stack","def home(request):\n\treturn render(request, \"compta/home.html\")","def home():\n\n return render_template('home_page.html')","def home():\n return render_template(\n 'index.html'\n )","def home():\n return render_template('index.html',\n title='主页',\n year=datetime.now().year,)","def home():\n\n return render_template(\"home.html\")","def index():\n return render_template('index.html', title='Home')","def home():\n\n return render_template('index.html')","def homepage(request):\n\treturn render(request, 'core/homepage.html')","def render_navbar(self):\n if self.view.do_render_navlinks:\n navlinks = self.render_navlinks()\n else:\n navlinks = \"\"\n\n with open(NAVBAR_HTML_FILENAME) as nb_file:\n navbar_html = nb_file.read()\n\n navbar_html = navbar_html.replace(\n '<div class=\"navlinks\"></div>',\n '<li>%s</li>' % navlinks)\n return navbar_html","def homepage():\n return render_template('homepage.html')","def home():\n return render_template(\n 'index.html',\n year=datetime.now().year,\n )","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def get_homepage():\n\n list_of_students = hackbright.list_all_students()\n list_of_projects = hackbright.list_all_projects()\n\n return render_template(\"index.html\",\n list_of_students=list_of_students,\n list_of_projects=list_of_projects)","def get_navbar_active(request):\n parts = request.path.split('/')\n return parts[1] or 'home'","def home():\n return render_template(\"home.html\")","def home():\n return render_template(\"home.html\")","def index():\r\n\r\n # initializes page title\r\n page_title = 'Home'\r\n\r\n # renders the landing page\r\n return render_template('index.html', page_title=page_title)","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def index():\n\treturn render_template(\"index.html\", title=\"Home\")","def home():\n template_stories = [\"silly_story\", \"excited_story\"]\n\n return render_template(\"homepage.html\", story_list = template_stories)","def index():\n return render_template(\"index.html\", page_title=\"Home\")","def add_navnodes(self):\n\n # these are related to Routes above, except that NavNodes are like a hierarchical menu structure / site map, wheras Routes are flat patterns that map to controllers\n nodes = [\n NavNode('home', {\n 'menulabel': '${sitename} home page',\n 'menulabel_short': 'home',\n 'children': [],\n 'parent': 'site',\n 'sortweight': 1.0,\n 'menuhint' : 'Return to the home page'\n }),\n NavNode('help', {\n 'parent': 'site',\n 'sortweight': 10.0,\n }),\n NavNode('contact', {\n 'parent': 'help',\n 'sortweight': 8.0,\n }),\n NavNode('about', {\n 'parent': 'help',\n 'sortweight': 9.0,\n }),\n ]\n\n # add nodes to site\n self.comp('navnodemanager').add_nodes(nodes)","def home():\n return render_template('main.html')","def index():\r\n return render_template('home.html')","def home(environ):\n return render_template(template_name=\"index.html\", context={})","def home():\n\n # sets the page to load depending on the type of user\n # if none specified the login screen will be displayed\n pageName = ''\n userType = session.get('UserType', None)\n if userType == None:\n pageName = 'anonHome.jade'\n elif userType == 'Seeker':\n pageName = 'indexJob.jade'\n elif userType == 'Manager':\n pageName = 'indexManager.jade'\n\n frogHop = url_for('static', filename='loop frog.gif')\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\n return render_template(\n pageName,\n title='Home',\n name=uName,\n getFrog=frogHop,\n year=datetime.now().year,\n )","def render_home():\r\n\treturn render_template(\"index.html\")","def home(request):\n return render_template('core/home.html')","def get_nav_bar(session):\n result = '<nav>'\n result += ' <ul>'\n result += ' <li><h1 id=\"title\">Beelance2</h1></li>'\n result += ' <li><a href=\"/\">Home</a></li>'\n if session.username:\n result += ' <li><a href=\"logout\">Logout</a></li>'\n result += ' <li><a href=\"new_project\">New</a></li>'\n result += ' <li><a href=\"change_password\">Change Password</a></li>'\n else:\n result += ' <li><a href=\"register\">Register</a></li>'\n result += ' <li><a href=\"login\">Login</a></li>'\n result += ' <li><a href=\"open_projects\">Projects</a></li>'\n result += ' </ul>'\n result += '</nav>'\n return result","def home():\n\n return render_template('index.html',\n date = d,\n mood = mood,\n header_color = color,\n day = day,\n week = week,\n month = month,\n year = year)","def home(self, *args, **kwargs):\n pass","def homepage(request):\n \n return render(request, 'homepage.html')","def home():\n return render_template('Main_Page.html')","def home():\n return render_template('index.html', year=datetime.now().year)","def home():\n return render_template(\n 'index.html',\n title='Automation Center',\n year=datetime.now().year,\n message='Welcome to the Automation Center'\n )","def index():\n\n return render_template('home.html')","def index():\n\treturn render_template('public/index.html', title='Home')","def home():\n payload = manager.get_payload()\n return render_template('index.html', payload=payload)","def get_homepage():\n\n projects = hackbright.get_projects()\n students = hackbright.get_students()\n\n return render_template(\"homepage.html\",\n students=students,\n projects=projects)","def main_aqa_layout():\n\n layout = html.Div(\n [\n # html.Div(\n # id=server.config['NAVBAR_CONTAINER_ID'],\n # children=[\n # navbar\n # ],\n # # id=\"header\",\n # # children=[\n # # # Header(),\n # # html.Div(\n # # id=server.config['NAVBAR_CONTAINER_ID'],\n # # children=navbar\n # # ),\n # # ]\n # ),\n dcc.Location(id=\"url\", pathname=\"/\"),\n navbar,\n dbc.Container(id=\"content\", style={\"padding\": \"20px\"}),\n ]\n )\n\n return layout","def home():\n makes = edmunds.get_makes()\n return render_template(\"service/index.html\",\n makes=makes)","def index():\n return render_template(\"home.html\")","def index():\n return render_template('home.html')"],"string":"[\n \"def main_nav():\\n return render_template('home.html')\",\n \"def homepage():\\n return render_template('home/index.html', \\n title=\\\"Bem vindo!\\\")\",\n \"def index():\\n return render_template(\\n 'index.html',\\n nav=nav,\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def home():\\n\\n\\treturn render_template('index.html', title='Home Page',\\n\\t\\t\\t\\t\\t\\t year=datetime.now().year)\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Sairam sai baba',\\n year=datetime.now().year,\\n )\",\n \"def home():\\r\\n return render_template(\\r\\n 'index.html',\\r\\n title='Home Page',\\r\\n year=datetime.now().year,\\r\\n )\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Home\\\")\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def home():\\n return render_template(\\n 'home.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template('home.html', title=\\\"Home\\\")\",\n \"def navbar_user():\\n return (\\\"machines\\\", render_to_string(\\\"deployments/navbar.html\\\"))\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\", title=\\\"Welcome\\\")\",\n \"def a_homepage():\\n\\n\\treturn render_template('home/a_homepage.html', title=\\\"Homepage Admin\\\")\",\n \"def homepage():\\n\\treturn render_template(\\\"home/a_homepage.html\\\", title=\\\"Welcome\\\")\",\n \"def home():\\n\\n\\treturn render_template('solai.html')\",\n \"def index():\\n return render_template('pages/index.html', isNav=True)\",\n \"def home():\\n return render_template('homepage.html')\",\n \"def homepage():\\n\\n return render_template('rosemead_homepage.html')\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\")\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'AscensionESports_Baseline/index.html',\\n {\\n 'background': getSiteBackground(),\\n 'color': getSiteColor(),\\n 'title':'Home Page',\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def header_nav(self):\\r\\n\\r\\n menu_stack = PaneStack()\\r\\n\\r\\n # Ensure the default button is the first tab\\r\\n #default_button_name = c.site.default_listing\\r\\n\\r\\n main_buttons = [\\r\\n ExpandableButton('main', dest = '/promoted', sr_path = False, sub_menus =\\r\\n [ NamedButton('posts', dest = '/promoted', sr_path = False),\\r\\n NamedButton('comments', dest = '/comments', sr_path = False)]),\\r\\n ExpandableButton('discussion', dest = \\\"/r/discussion/new\\\", sub_reddit = \\\"/r/discussion/\\\", sub_menus =\\r\\n [ NamedButton('posts', dest = \\\"/r/discussion/new\\\", sr_path = False),\\r\\n NamedButton('comments', dest = \\\"/r/discussion/comments\\\", sr_path = False)])\\r\\n ]\\r\\n\\r\\n menu_stack.append(NavMenu(main_buttons, title = _('Filter by'), _id='nav', type='navlist'))\\r\\n\\r\\n\\r\\n if self.header_sub_nav:\\r\\n menu_stack.append(NavMenu(self.header_sub_nav, title = _('Filter by'), _id='filternav', type='navlist'))\\r\\n\\r\\n return menu_stack\",\n \"def home(request):\\n\\treturn render(request, \\\"compta/home.html\\\")\",\n \"def home():\\n\\n return render_template('home_page.html')\",\n \"def home():\\n return render_template(\\n 'index.html'\\n )\",\n \"def home():\\n return render_template('index.html',\\n title='主页',\\n year=datetime.now().year,)\",\n \"def home():\\n\\n return render_template(\\\"home.html\\\")\",\n \"def index():\\n return render_template('index.html', title='Home')\",\n \"def home():\\n\\n return render_template('index.html')\",\n \"def homepage(request):\\n\\treturn render(request, 'core/homepage.html')\",\n \"def render_navbar(self):\\n if self.view.do_render_navlinks:\\n navlinks = self.render_navlinks()\\n else:\\n navlinks = \\\"\\\"\\n\\n with open(NAVBAR_HTML_FILENAME) as nb_file:\\n navbar_html = nb_file.read()\\n\\n navbar_html = navbar_html.replace(\\n '<div class=\\\"navlinks\\\"></div>',\\n '<li>%s</li>' % navlinks)\\n return navbar_html\",\n \"def homepage():\\n return render_template('homepage.html')\",\n \"def home():\\n return render_template(\\n 'index.html',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def get_homepage():\\n\\n list_of_students = hackbright.list_all_students()\\n list_of_projects = hackbright.list_all_projects()\\n\\n return render_template(\\\"index.html\\\",\\n list_of_students=list_of_students,\\n list_of_projects=list_of_projects)\",\n \"def get_navbar_active(request):\\n parts = request.path.split('/')\\n return parts[1] or 'home'\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def index():\\r\\n\\r\\n # initializes page title\\r\\n page_title = 'Home'\\r\\n\\r\\n # renders the landing page\\r\\n return render_template('index.html', page_title=page_title)\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def index():\\n\\treturn render_template(\\\"index.html\\\", title=\\\"Home\\\")\",\n \"def home():\\n template_stories = [\\\"silly_story\\\", \\\"excited_story\\\"]\\n\\n return render_template(\\\"homepage.html\\\", story_list = template_stories)\",\n \"def index():\\n return render_template(\\\"index.html\\\", page_title=\\\"Home\\\")\",\n \"def add_navnodes(self):\\n\\n # these are related to Routes above, except that NavNodes are like a hierarchical menu structure / site map, wheras Routes are flat patterns that map to controllers\\n nodes = [\\n NavNode('home', {\\n 'menulabel': '${sitename} home page',\\n 'menulabel_short': 'home',\\n 'children': [],\\n 'parent': 'site',\\n 'sortweight': 1.0,\\n 'menuhint' : 'Return to the home page'\\n }),\\n NavNode('help', {\\n 'parent': 'site',\\n 'sortweight': 10.0,\\n }),\\n NavNode('contact', {\\n 'parent': 'help',\\n 'sortweight': 8.0,\\n }),\\n NavNode('about', {\\n 'parent': 'help',\\n 'sortweight': 9.0,\\n }),\\n ]\\n\\n # add nodes to site\\n self.comp('navnodemanager').add_nodes(nodes)\",\n \"def home():\\n return render_template('main.html')\",\n \"def index():\\r\\n return render_template('home.html')\",\n \"def home(environ):\\n return render_template(template_name=\\\"index.html\\\", context={})\",\n \"def home():\\n\\n # sets the page to load depending on the type of user\\n # if none specified the login screen will be displayed\\n pageName = ''\\n userType = session.get('UserType', None)\\n if userType == None:\\n pageName = 'anonHome.jade'\\n elif userType == 'Seeker':\\n pageName = 'indexJob.jade'\\n elif userType == 'Manager':\\n pageName = 'indexManager.jade'\\n\\n frogHop = url_for('static', filename='loop frog.gif')\\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\\n return render_template(\\n pageName,\\n title='Home',\\n name=uName,\\n getFrog=frogHop,\\n year=datetime.now().year,\\n )\",\n \"def render_home():\\r\\n\\treturn render_template(\\\"index.html\\\")\",\n \"def home(request):\\n return render_template('core/home.html')\",\n \"def get_nav_bar(session):\\n result = '<nav>'\\n result += ' <ul>'\\n result += ' <li><h1 id=\\\"title\\\">Beelance2</h1></li>'\\n result += ' <li><a href=\\\"/\\\">Home</a></li>'\\n if session.username:\\n result += ' <li><a href=\\\"logout\\\">Logout</a></li>'\\n result += ' <li><a href=\\\"new_project\\\">New</a></li>'\\n result += ' <li><a href=\\\"change_password\\\">Change Password</a></li>'\\n else:\\n result += ' <li><a href=\\\"register\\\">Register</a></li>'\\n result += ' <li><a href=\\\"login\\\">Login</a></li>'\\n result += ' <li><a href=\\\"open_projects\\\">Projects</a></li>'\\n result += ' </ul>'\\n result += '</nav>'\\n return result\",\n \"def home():\\n\\n return render_template('index.html',\\n date = d,\\n mood = mood,\\n header_color = color,\\n day = day,\\n week = week,\\n month = month,\\n year = year)\",\n \"def home(self, *args, **kwargs):\\n pass\",\n \"def homepage(request):\\n \\n return render(request, 'homepage.html')\",\n \"def home():\\n return render_template('Main_Page.html')\",\n \"def home():\\n return render_template('index.html', year=datetime.now().year)\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Automation Center',\\n year=datetime.now().year,\\n message='Welcome to the Automation Center'\\n )\",\n \"def index():\\n\\n return render_template('home.html')\",\n \"def index():\\n\\treturn render_template('public/index.html', title='Home')\",\n \"def home():\\n payload = manager.get_payload()\\n return render_template('index.html', payload=payload)\",\n \"def get_homepage():\\n\\n projects = hackbright.get_projects()\\n students = hackbright.get_students()\\n\\n return render_template(\\\"homepage.html\\\",\\n students=students,\\n projects=projects)\",\n \"def main_aqa_layout():\\n\\n layout = html.Div(\\n [\\n # html.Div(\\n # id=server.config['NAVBAR_CONTAINER_ID'],\\n # children=[\\n # navbar\\n # ],\\n # # id=\\\"header\\\",\\n # # children=[\\n # # # Header(),\\n # # html.Div(\\n # # id=server.config['NAVBAR_CONTAINER_ID'],\\n # # children=navbar\\n # # ),\\n # # ]\\n # ),\\n dcc.Location(id=\\\"url\\\", pathname=\\\"/\\\"),\\n navbar,\\n dbc.Container(id=\\\"content\\\", style={\\\"padding\\\": \\\"20px\\\"}),\\n ]\\n )\\n\\n return layout\",\n \"def home():\\n makes = edmunds.get_makes()\\n return render_template(\\\"service/index.html\\\",\\n makes=makes)\",\n \"def index():\\n return render_template(\\\"home.html\\\")\",\n \"def index():\\n return render_template('home.html')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.736893","0.67783135","0.6750848","0.66524625","0.6623326","0.6588633","0.6580005","0.6562279","0.6562279","0.6562279","0.6562279","0.6562279","0.6562279","0.6562279","0.6562279","0.6562279","0.6562279","0.653496","0.6521001","0.6503073","0.64983183","0.64569396","0.64569396","0.64338464","0.64336073","0.6411863","0.6374867","0.63710874","0.63580126","0.6349584","0.63439393","0.6317438","0.62648046","0.62596923","0.62567747","0.6242426","0.6238865","0.6229193","0.6219083","0.6214306","0.61769027","0.61659557","0.6161946","0.61588824","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6156732","0.6142948","0.6141798","0.61415493","0.61415493","0.6129595","0.6127069","0.6127069","0.6127069","0.6127069","0.6127069","0.6127069","0.6114612","0.6114612","0.6114612","0.6114612","0.6114264","0.61016774","0.60905296","0.60765785","0.6072093","0.60632044","0.6061509","0.605792","0.604962","0.6046835","0.604579","0.6041466","0.6032044","0.6024083","0.6023183","0.602294","0.6019716","0.5993831","0.5977993","0.5964542","0.5959601","0.5958824","0.59529346","0.59392023","0.5931555"],"string":"[\n \"0.736893\",\n \"0.67783135\",\n \"0.6750848\",\n \"0.66524625\",\n \"0.6623326\",\n \"0.6588633\",\n \"0.6580005\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.6562279\",\n \"0.653496\",\n \"0.6521001\",\n \"0.6503073\",\n \"0.64983183\",\n \"0.64569396\",\n \"0.64569396\",\n \"0.64338464\",\n \"0.64336073\",\n \"0.6411863\",\n \"0.6374867\",\n \"0.63710874\",\n \"0.63580126\",\n \"0.6349584\",\n \"0.63439393\",\n \"0.6317438\",\n \"0.62648046\",\n \"0.62596923\",\n \"0.62567747\",\n \"0.6242426\",\n \"0.6238865\",\n \"0.6229193\",\n \"0.6219083\",\n \"0.6214306\",\n \"0.61769027\",\n \"0.61659557\",\n \"0.6161946\",\n \"0.61588824\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6156732\",\n \"0.6142948\",\n \"0.6141798\",\n \"0.61415493\",\n \"0.61415493\",\n \"0.6129595\",\n \"0.6127069\",\n \"0.6127069\",\n \"0.6127069\",\n \"0.6127069\",\n \"0.6127069\",\n \"0.6127069\",\n \"0.6114612\",\n \"0.6114612\",\n \"0.6114612\",\n \"0.6114612\",\n \"0.6114264\",\n \"0.61016774\",\n \"0.60905296\",\n \"0.60765785\",\n \"0.6072093\",\n \"0.60632044\",\n \"0.6061509\",\n \"0.605792\",\n \"0.604962\",\n \"0.6046835\",\n \"0.604579\",\n \"0.6041466\",\n \"0.6032044\",\n \"0.6024083\",\n \"0.6023183\",\n \"0.602294\",\n \"0.6019716\",\n \"0.5993831\",\n \"0.5977993\",\n \"0.5964542\",\n \"0.5959601\",\n \"0.5958824\",\n \"0.59529346\",\n \"0.59392023\",\n \"0.5931555\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71998024"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":90798,"cells":{"query":{"kind":"string","value":"Make a navbar for the result page homepage"},"document":{"kind":"string","value":"def make_navbar_for_result_page(self):\n links = {\n i: [\"1d Histograms\", [{\"Custom\": i}, {\"All\": i}]] for i in self.labels\n }\n for num, label in enumerate(self.labels):\n for j in self.categorize_parameters(self.samples[label].keys()):\n j = [j[0], [{k: label} for k in j[1]]]\n links[label].append(j)\n\n final_links = {\n i: [\n \"home\", [\"Result Pages\", self._result_page_links()],\n {\"Corner\": i}, {\"Config\": i}, links[i]\n ] for i in self.labels\n }\n if len(self.samples) > 1:\n for i in self.labels:\n final_links[i][1][1] += [\"Comparison\"]\n if self.make_interactive:\n for label in self.labels:\n final_links[label].append(\n [\"Interactive\", [{\"Interactive_Corner\": label}]]\n )\n return final_links"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def make_navbar_for_homepage(self):\n links = [\n \"home\", [\"Result Pages\", self._result_page_links()], \"Version\"\n ]\n if len(self.samples) > 1:\n links[1][1] += [\"Comparison\"]\n if self.publication:\n links.insert(2, \"Publication\")\n if self.gwdata is not None:\n links.append([\"Detchar\", [i for i in self.gwdata.keys()]])\n if self.notes is not None:\n links.append(\"Notes\")\n return links","def main_nav():\n return render_template('home.html')","def index():\n return render_template(\n 'index.html',\n nav=nav,\n title='Home Page',\n year=datetime.now().year\n )","def index():\n return render_template('pages/index.html', isNav=True)","def home():\n\n\treturn render_template('index.html', title='Home Page',\n\t\t\t\t\t\t year=datetime.now().year)","def home():\n return render_template(\n 'index.html',\n title='Sairam sai baba',\n year=datetime.now().year,\n )","def navbar_user():\n return (\"machines\", render_to_string(\"deployments/navbar.html\"))","def home():\n\n\treturn render_template('solai.html')","def homepage():\n return render_template('home/index.html', \n title=\"Bem vindo!\")","def header_nav(self):\r\n\r\n menu_stack = PaneStack()\r\n\r\n # Ensure the default button is the first tab\r\n #default_button_name = c.site.default_listing\r\n\r\n main_buttons = [\r\n ExpandableButton('main', dest = '/promoted', sr_path = False, sub_menus =\r\n [ NamedButton('posts', dest = '/promoted', sr_path = False),\r\n NamedButton('comments', dest = '/comments', sr_path = False)]),\r\n ExpandableButton('discussion', dest = \"/r/discussion/new\", sub_reddit = \"/r/discussion/\", sub_menus =\r\n [ NamedButton('posts', dest = \"/r/discussion/new\", sr_path = False),\r\n NamedButton('comments', dest = \"/r/discussion/comments\", sr_path = False)])\r\n ]\r\n\r\n menu_stack.append(NavMenu(main_buttons, title = _('Filter by'), _id='nav', type='navlist'))\r\n\r\n\r\n if self.header_sub_nav:\r\n menu_stack.append(NavMenu(self.header_sub_nav, title = _('Filter by'), _id='filternav', type='navlist'))\r\n\r\n return menu_stack","def home(request):\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'AscensionESports_Baseline/index.html',\n {\n 'background': getSiteBackground(),\n 'color': getSiteColor(),\n 'title':'Home Page',\n 'year':datetime.now().year,\n }\n )","def home():\r\n return render_template(\r\n 'index.html',\r\n title='Home Page',\r\n year=datetime.now().year,\r\n )","def home():\n return render_template('home.html', title=\"Home\")","def home():\n return render_template(\n 'home.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year,\n )","def a_homepage():\n\n\treturn render_template('home/a_homepage.html', title=\"Homepage Admin\")","def homepage():\n return render_template('home/index.html', title=\"Home\")","def home():\n return render_template(\n 'index.html',\n title='Home Page',\n year=datetime.now().year\n )","def home(request):\n\treturn render(request, \"compta/home.html\")","def home(self, *args, **kwargs):\n pass","def get_homepage():\n\n list_of_students = hackbright.list_all_students()\n list_of_projects = hackbright.list_all_projects()\n\n return render_template(\"index.html\",\n list_of_students=list_of_students,\n list_of_projects=list_of_projects)","def index():\n return render_template('index.html', title='Home')","def initialPage():\n\treturn header() + footer()","def home_page():\n return \"<h4>Welcome !</h4><br><a href='/fetch'>View Results</a>\"","def home():\n tc = totalclicks()\n tl1, tl2, tl3 = topthreelinks()\n bl1, bl2, bl3 = topblomoedlinks()\n return flask.render_template('home.html', tc=tc, tl1=tl1, tl2=tl2, tl3=tl3, bl1=bl1, bl2=bl2, bl3=bl3)","def index():\n\treturn render_template(\"index.html\", title=\"Home\")","def homepage():\n\treturn render_template(\"home/a_homepage.html\", title=\"Welcome\")","def index():\n title = \"Application process \"\n links = {'mentors': 'mentors',\n 'schools': 'all-school',\n 'mentors_by_country': 'mentors-by-country',\n 'contacts': 'contacts',\n 'applicants': 'applicants',\n 'applicants_and_mentors': 'applicants-and-mentors'}\n menu = ['Show mentors and schools',\n 'Show mentors and all schools',\n 'Show mentors by country',\n 'Show contacts',\n 'Show applicants',\n 'Show applicants and mentors']\n return render_template('index.html', links=links, menu=menu, title=title)","def index():\n return render_template(\"index.html\", page_title=\"Home\")","def home():\n return render_template('index.html',\n title='主页',\n year=datetime.now().year,)","def index(self):\n\n return render_template(\n 'home_page/index.html',\n **locals()\n )","def home():\n\n return render_template('home_page.html')","def home():\n\n return render_template('index.html',\n date = d,\n mood = mood,\n header_color = color,\n day = day,\n week = week,\n month = month,\n year = year)","def homepage():\n\n return render_template('rosemead_homepage.html')","def home():\n return render_template(\n \"home.html\",\n title = \"Capteurs\",\n liste = get_listeActions(1))","def home():\n return render_template('homepage.html')","def index():\r\n\r\n # initializes page title\r\n page_title = 'Home'\r\n\r\n # renders the landing page\r\n return render_template('index.html', page_title=page_title)","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def homepage():\n return render_template('home/index.html', title=\"Welcome\")","def home():\n payload = manager.get_payload()\n return render_template('index.html', payload=payload)","def home():\n\n return render_template(\"home.html\")","def homepage():\n return render_template(\"home/index.html\", title=\"Welcome\")","def main_aqa_layout():\n\n layout = html.Div(\n [\n # html.Div(\n # id=server.config['NAVBAR_CONTAINER_ID'],\n # children=[\n # navbar\n # ],\n # # id=\"header\",\n # # children=[\n # # # Header(),\n # # html.Div(\n # # id=server.config['NAVBAR_CONTAINER_ID'],\n # # children=navbar\n # # ),\n # # ]\n # ),\n dcc.Location(id=\"url\", pathname=\"/\"),\n navbar,\n dbc.Container(id=\"content\", style={\"padding\": \"20px\"}),\n ]\n )\n\n return layout","def homepage():\n return render_template(\"home/index.html\")","def index():\r\n return render_template('home.html')","def home():\n makes = edmunds.get_makes()\n return render_template(\"service/index.html\",\n makes=makes)","def home():\n return render_template('Main_Page.html')","def render_home():\r\n\treturn render_template(\"index.html\")","def home():\n\n return render_template('index.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n return render_template('home.html')","def home():\n template_stories = [\"silly_story\", \"excited_story\"]\n\n return render_template(\"homepage.html\", story_list = template_stories)","def home():\n return render_template(\"home.html\")","def home():\n return render_template(\"home.html\")","def home(result=None):\n print(inspect.stack()[1][3])\n\n if not session.get('logged_in') and not result:\n return render_template('login.html')\n else:\n # Based on the user_id passed, print Details, URLS and all.\n # return render_template('dashboard.html', username=result.name, user_id=result.user_type)\n return render_template('webpage/index1.html', username=result.name, user_id=result.user_type)","def home():\n\n # sets the page to load depending on the type of user\n # if none specified the login screen will be displayed\n pageName = ''\n userType = session.get('UserType', None)\n if userType == None:\n pageName = 'anonHome.jade'\n elif userType == 'Seeker':\n pageName = 'indexJob.jade'\n elif userType == 'Manager':\n pageName = 'indexManager.jade'\n\n frogHop = url_for('static', filename='loop frog.gif')\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\n return render_template(\n pageName,\n title='Home',\n name=uName,\n getFrog=frogHop,\n year=datetime.now().year,\n )","def home():\n return render_template(\n 'index.html'\n )","def home():\n return render_template(\n 'index.html',\n title='Automation Center',\n year=datetime.now().year,\n message='Welcome to the Automation Center'\n )","def dashboard_page():\n log.info('Load dashboard!')\n navigation = render_template('navigation.html', babyName=firstName)\n return render_template('index.html', babyName=firstName, nav=navigation)","def home():\n return render_template('main.html')","def home() -> Any:\n return home_page()","def navbar_list(cls):\n return cls.objects.filter(status=0).filter(is_nav=True)[:10]","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\"index.html\")","def home():\n return render_template(\n 'index.html',\n year=datetime.now().year,\n )","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home():\n return render_template('index.html')","def home_page():\n return (\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"/api/v1.0/start<br/>\"\n f\"/api/v1.0/start/end<br/>\"\n )","def index():\n\treturn render_template('public/index.html', title='Home')","def homepage(request):\n\treturn render(request, 'core/homepage.html')","def Home():\n resp = render_template('index.html')\n return resp"],"string":"[\n \"def make_navbar_for_homepage(self):\\n links = [\\n \\\"home\\\", [\\\"Result Pages\\\", self._result_page_links()], \\\"Version\\\"\\n ]\\n if len(self.samples) > 1:\\n links[1][1] += [\\\"Comparison\\\"]\\n if self.publication:\\n links.insert(2, \\\"Publication\\\")\\n if self.gwdata is not None:\\n links.append([\\\"Detchar\\\", [i for i in self.gwdata.keys()]])\\n if self.notes is not None:\\n links.append(\\\"Notes\\\")\\n return links\",\n \"def main_nav():\\n return render_template('home.html')\",\n \"def index():\\n return render_template(\\n 'index.html',\\n nav=nav,\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def index():\\n return render_template('pages/index.html', isNav=True)\",\n \"def home():\\n\\n\\treturn render_template('index.html', title='Home Page',\\n\\t\\t\\t\\t\\t\\t year=datetime.now().year)\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Sairam sai baba',\\n year=datetime.now().year,\\n )\",\n \"def navbar_user():\\n return (\\\"machines\\\", render_to_string(\\\"deployments/navbar.html\\\"))\",\n \"def home():\\n\\n\\treturn render_template('solai.html')\",\n \"def homepage():\\n return render_template('home/index.html', \\n title=\\\"Bem vindo!\\\")\",\n \"def header_nav(self):\\r\\n\\r\\n menu_stack = PaneStack()\\r\\n\\r\\n # Ensure the default button is the first tab\\r\\n #default_button_name = c.site.default_listing\\r\\n\\r\\n main_buttons = [\\r\\n ExpandableButton('main', dest = '/promoted', sr_path = False, sub_menus =\\r\\n [ NamedButton('posts', dest = '/promoted', sr_path = False),\\r\\n NamedButton('comments', dest = '/comments', sr_path = False)]),\\r\\n ExpandableButton('discussion', dest = \\\"/r/discussion/new\\\", sub_reddit = \\\"/r/discussion/\\\", sub_menus =\\r\\n [ NamedButton('posts', dest = \\\"/r/discussion/new\\\", sr_path = False),\\r\\n NamedButton('comments', dest = \\\"/r/discussion/comments\\\", sr_path = False)])\\r\\n ]\\r\\n\\r\\n menu_stack.append(NavMenu(main_buttons, title = _('Filter by'), _id='nav', type='navlist'))\\r\\n\\r\\n\\r\\n if self.header_sub_nav:\\r\\n menu_stack.append(NavMenu(self.header_sub_nav, title = _('Filter by'), _id='filternav', type='navlist'))\\r\\n\\r\\n return menu_stack\",\n \"def home(request):\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'AscensionESports_Baseline/index.html',\\n {\\n 'background': getSiteBackground(),\\n 'color': getSiteColor(),\\n 'title':'Home Page',\\n 'year':datetime.now().year,\\n }\\n )\",\n \"def home():\\r\\n return render_template(\\r\\n 'index.html',\\r\\n title='Home Page',\\r\\n year=datetime.now().year,\\r\\n )\",\n \"def home():\\n return render_template('home.html', title=\\\"Home\\\")\",\n \"def home():\\n return render_template(\\n 'home.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year,\\n )\",\n \"def a_homepage():\\n\\n\\treturn render_template('home/a_homepage.html', title=\\\"Homepage Admin\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Home\\\")\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Home Page',\\n year=datetime.now().year\\n )\",\n \"def home(request):\\n\\treturn render(request, \\\"compta/home.html\\\")\",\n \"def home(self, *args, **kwargs):\\n pass\",\n \"def get_homepage():\\n\\n list_of_students = hackbright.list_all_students()\\n list_of_projects = hackbright.list_all_projects()\\n\\n return render_template(\\\"index.html\\\",\\n list_of_students=list_of_students,\\n list_of_projects=list_of_projects)\",\n \"def index():\\n return render_template('index.html', title='Home')\",\n \"def initialPage():\\n\\treturn header() + footer()\",\n \"def home_page():\\n return \\\"<h4>Welcome !</h4><br><a href='/fetch'>View Results</a>\\\"\",\n \"def home():\\n tc = totalclicks()\\n tl1, tl2, tl3 = topthreelinks()\\n bl1, bl2, bl3 = topblomoedlinks()\\n return flask.render_template('home.html', tc=tc, tl1=tl1, tl2=tl2, tl3=tl3, bl1=bl1, bl2=bl2, bl3=bl3)\",\n \"def index():\\n\\treturn render_template(\\\"index.html\\\", title=\\\"Home\\\")\",\n \"def homepage():\\n\\treturn render_template(\\\"home/a_homepage.html\\\", title=\\\"Welcome\\\")\",\n \"def index():\\n title = \\\"Application process \\\"\\n links = {'mentors': 'mentors',\\n 'schools': 'all-school',\\n 'mentors_by_country': 'mentors-by-country',\\n 'contacts': 'contacts',\\n 'applicants': 'applicants',\\n 'applicants_and_mentors': 'applicants-and-mentors'}\\n menu = ['Show mentors and schools',\\n 'Show mentors and all schools',\\n 'Show mentors by country',\\n 'Show contacts',\\n 'Show applicants',\\n 'Show applicants and mentors']\\n return render_template('index.html', links=links, menu=menu, title=title)\",\n \"def index():\\n return render_template(\\\"index.html\\\", page_title=\\\"Home\\\")\",\n \"def home():\\n return render_template('index.html',\\n title='主页',\\n year=datetime.now().year,)\",\n \"def index(self):\\n\\n return render_template(\\n 'home_page/index.html',\\n **locals()\\n )\",\n \"def home():\\n\\n return render_template('home_page.html')\",\n \"def home():\\n\\n return render_template('index.html',\\n date = d,\\n mood = mood,\\n header_color = color,\\n day = day,\\n week = week,\\n month = month,\\n year = year)\",\n \"def homepage():\\n\\n return render_template('rosemead_homepage.html')\",\n \"def home():\\n return render_template(\\n \\\"home.html\\\",\\n title = \\\"Capteurs\\\",\\n liste = get_listeActions(1))\",\n \"def home():\\n return render_template('homepage.html')\",\n \"def index():\\r\\n\\r\\n # initializes page title\\r\\n page_title = 'Home'\\r\\n\\r\\n # renders the landing page\\r\\n return render_template('index.html', page_title=page_title)\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def homepage():\\n return render_template('home/index.html', title=\\\"Welcome\\\")\",\n \"def home():\\n payload = manager.get_payload()\\n return render_template('index.html', payload=payload)\",\n \"def home():\\n\\n return render_template(\\\"home.html\\\")\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\", title=\\\"Welcome\\\")\",\n \"def main_aqa_layout():\\n\\n layout = html.Div(\\n [\\n # html.Div(\\n # id=server.config['NAVBAR_CONTAINER_ID'],\\n # children=[\\n # navbar\\n # ],\\n # # id=\\\"header\\\",\\n # # children=[\\n # # # Header(),\\n # # html.Div(\\n # # id=server.config['NAVBAR_CONTAINER_ID'],\\n # # children=navbar\\n # # ),\\n # # ]\\n # ),\\n dcc.Location(id=\\\"url\\\", pathname=\\\"/\\\"),\\n navbar,\\n dbc.Container(id=\\\"content\\\", style={\\\"padding\\\": \\\"20px\\\"}),\\n ]\\n )\\n\\n return layout\",\n \"def homepage():\\n return render_template(\\\"home/index.html\\\")\",\n \"def index():\\r\\n return render_template('home.html')\",\n \"def home():\\n makes = edmunds.get_makes()\\n return render_template(\\\"service/index.html\\\",\\n makes=makes)\",\n \"def home():\\n return render_template('Main_Page.html')\",\n \"def render_home():\\r\\n\\treturn render_template(\\\"index.html\\\")\",\n \"def home():\\n\\n return render_template('index.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n return render_template('home.html')\",\n \"def home():\\n template_stories = [\\\"silly_story\\\", \\\"excited_story\\\"]\\n\\n return render_template(\\\"homepage.html\\\", story_list = template_stories)\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def home():\\n return render_template(\\\"home.html\\\")\",\n \"def home(result=None):\\n print(inspect.stack()[1][3])\\n\\n if not session.get('logged_in') and not result:\\n return render_template('login.html')\\n else:\\n # Based on the user_id passed, print Details, URLS and all.\\n # return render_template('dashboard.html', username=result.name, user_id=result.user_type)\\n return render_template('webpage/index1.html', username=result.name, user_id=result.user_type)\",\n \"def home():\\n\\n # sets the page to load depending on the type of user\\n # if none specified the login screen will be displayed\\n pageName = ''\\n userType = session.get('UserType', None)\\n if userType == None:\\n pageName = 'anonHome.jade'\\n elif userType == 'Seeker':\\n pageName = 'indexJob.jade'\\n elif userType == 'Manager':\\n pageName = 'indexManager.jade'\\n\\n frogHop = url_for('static', filename='loop frog.gif')\\n uName = session.get('UserName', 'Unknown') # load a default value if retrieval fails\\n return render_template(\\n pageName,\\n title='Home',\\n name=uName,\\n getFrog=frogHop,\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template(\\n 'index.html'\\n )\",\n \"def home():\\n return render_template(\\n 'index.html',\\n title='Automation Center',\\n year=datetime.now().year,\\n message='Welcome to the Automation Center'\\n )\",\n \"def dashboard_page():\\n log.info('Load dashboard!')\\n navigation = render_template('navigation.html', babyName=firstName)\\n return render_template('index.html', babyName=firstName, nav=navigation)\",\n \"def home():\\n return render_template('main.html')\",\n \"def home() -> Any:\\n return home_page()\",\n \"def navbar_list(cls):\\n return cls.objects.filter(status=0).filter(is_nav=True)[:10]\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\\"index.html\\\")\",\n \"def home():\\n return render_template(\\n 'index.html',\\n year=datetime.now().year,\\n )\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home():\\n return render_template('index.html')\",\n \"def home_page():\\n return (\\n f\\\"Available Routes:<br/>\\\"\\n f\\\"/api/v1.0/precipitation<br/>\\\"\\n f\\\"/api/v1.0/stations<br/>\\\"\\n f\\\"/api/v1.0/tobs<br/>\\\"\\n f\\\"/api/v1.0/start<br/>\\\"\\n f\\\"/api/v1.0/start/end<br/>\\\"\\n )\",\n \"def index():\\n\\treturn render_template('public/index.html', title='Home')\",\n \"def homepage(request):\\n\\treturn render(request, 'core/homepage.html')\",\n \"def Home():\\n resp = render_template('index.html')\\n return resp\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80170983","0.7169193","0.6690814","0.6587678","0.6552421","0.6529632","0.65201473","0.65188295","0.64830226","0.6469217","0.64192796","0.64133656","0.6382045","0.6367651","0.63470757","0.63470757","0.63470757","0.63470757","0.63470757","0.63470757","0.63470757","0.63470757","0.63470757","0.63470757","0.6331229","0.6330692","0.6329169","0.63190585","0.6317269","0.6284703","0.6281952","0.6277302","0.6269251","0.62622905","0.6242263","0.6236781","0.6234074","0.62266654","0.6220099","0.6214055","0.6212059","0.62118524","0.621141","0.6187659","0.61872154","0.6173767","0.6173214","0.6173214","0.6170223","0.61586696","0.61462295","0.61427575","0.61285144","0.61153495","0.61102057","0.60988516","0.6096379","0.6092031","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.608991","0.6088692","0.6088221","0.6088221","0.60677224","0.6062851","0.60574025","0.60513794","0.6051072","0.60450166","0.604101","0.6034069","0.6033515","0.6033515","0.6033515","0.6033515","0.60213673","0.6021243","0.6021243","0.6021243","0.6021243","0.6021243","0.6021243","0.6019975","0.6012704","0.6002173","0.5996983"],"string":"[\n \"0.80170983\",\n \"0.7169193\",\n \"0.6690814\",\n \"0.6587678\",\n \"0.6552421\",\n \"0.6529632\",\n \"0.65201473\",\n \"0.65188295\",\n \"0.64830226\",\n \"0.6469217\",\n \"0.64192796\",\n \"0.64133656\",\n \"0.6382045\",\n \"0.6367651\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.63470757\",\n \"0.6331229\",\n \"0.6330692\",\n \"0.6329169\",\n \"0.63190585\",\n \"0.6317269\",\n \"0.6284703\",\n \"0.6281952\",\n \"0.6277302\",\n \"0.6269251\",\n \"0.62622905\",\n \"0.6242263\",\n \"0.6236781\",\n \"0.6234074\",\n \"0.62266654\",\n \"0.6220099\",\n \"0.6214055\",\n \"0.6212059\",\n \"0.62118524\",\n \"0.621141\",\n \"0.6187659\",\n \"0.61872154\",\n \"0.6173767\",\n \"0.6173214\",\n \"0.6173214\",\n \"0.6170223\",\n \"0.61586696\",\n \"0.61462295\",\n \"0.61427575\",\n \"0.61285144\",\n \"0.61153495\",\n \"0.61102057\",\n \"0.60988516\",\n \"0.6096379\",\n \"0.6092031\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.608991\",\n \"0.6088692\",\n \"0.6088221\",\n \"0.6088221\",\n \"0.60677224\",\n \"0.6062851\",\n \"0.60574025\",\n \"0.60513794\",\n \"0.6051072\",\n \"0.60450166\",\n \"0.604101\",\n \"0.6034069\",\n \"0.6033515\",\n \"0.6033515\",\n \"0.6033515\",\n \"0.6033515\",\n \"0.60213673\",\n \"0.6021243\",\n \"0.6021243\",\n \"0.6021243\",\n \"0.6021243\",\n \"0.6021243\",\n \"0.6021243\",\n \"0.6019975\",\n \"0.6012704\",\n \"0.6002173\",\n \"0.5996983\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6568194"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":90799,"cells":{"query":{"kind":"string","value":"Generate all webpages for all result files passed"},"document":{"kind":"string","value":"def generate_webpages(self):\n if self.add_to_existing:\n self.add_existing_data()\n self.make_home_pages()\n self.make_1d_histogram_pages()\n self.make_corner_pages()\n self.make_config_pages()\n if self.make_comparison:\n self.make_comparison_pages()\n if self.make_interactive:\n self.make_interactive_pages()\n if self.publication:\n self.make_publication_pages()\n if self.gwdata is not None:\n self.make_detector_pages()\n self.make_error_page()\n self.make_version_page()\n if self.notes is not None:\n self.make_notes_page()\n self.make_downloads_page()\n self.generate_specific_javascript()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def main():\n for file_name in os.listdir(CONTENT_FOLDER):\n if file_name.endswith('.html'):\n try_generate_page(file_name)","def make_all_html_results(cmd, folder_names = [], jobs=[]):\n run = cmd.results.current['run_name']\n if not os.path.exists(pjoin(cmd.me_dir, 'HTML', run)):\n os.mkdir(pjoin(cmd.me_dir, 'HTML', run))\n \n unit = cmd.results.unit\n P_text = \"\" \n Presults = collect_result(cmd, folder_names=folder_names, jobs=jobs)\n \n for P_comb in Presults:\n P_text += P_comb.get_html(run, unit, cmd.me_dir) \n P_comb.compute_values()\n if cmd.proc_characteristics['ninitial'] == 1:\n P_comb.write_results_dat(pjoin(cmd.me_dir, 'SubProcesses', P_comb.name,\n '%s_results.dat' % run))\n \n Presults.write_results_dat(pjoin(cmd.me_dir,'SubProcesses', 'results.dat')) \n \n fsock = open(pjoin(cmd.me_dir, 'HTML', run, 'results.html'),'w')\n fsock.write(results_header)\n fsock.write('%s <dl>' % Presults.get_html(run, unit, cmd.me_dir))\n fsock.write('%s </dl></body>' % P_text)\n\n return Presults.xsec, Presults.xerru","def makeHTMLIndexFile(self):\n part1 = \"\"\"<html>\n <body>\n <title>Index</title>\n <div id=\"pg_body\">\n <div id=\"testSuitesTitle\">TestSuites</div>\n <div id=\"resultsTitle\">Results</div>\n <div id=\"testSuites\">\n \"\"\"\n part2 = self.makeLinks()\n part3 = \"\"\"</div>\n <div id=\"results\">\n <iframe id=\"loadHTMLResults\" name=\"loadHTMLResults\" frameborder=\"0\" src=\"statistics.html\" style=\"height:100%;width:100%;\"></iframe>\n </div>\n <div id=\"footer\">Test Engineer(s) :\"\"\"+testEngineers+\"\"\"</div>\n </div>\n </body>\n </html>\n\t\t<style>\n\t\tbody{\n margin:0;\n }\n\t\t#pg_body{\n\t\twidth=100%;\n\t\ttext-align:center;\n\t\t}\n\t\t#testSuitesTitle{\n\t\twidth:25%;\n\t\tfloat:left;\n\t\tbackground-color:#6495ED;\n\t\tfont-weight:bold;\n\t\tcolor:white;\n\t\t}\n\t\t#resultsTitle{\n\t\twidth:75%;\n\t\tfloat:right;\n\t\tbackground-color:#6495ED;\n\t\tfont-weight:bold;\n\t\tcolor:white;\n\t\t}\n\t\t#testSuites{\n\t\twidth:25%;\n\t\tfloat:left;\n\t\tbackground-color:lightgrey;\n\t\tfont-weight:bold;\n\t\ttext-align:left;\n\t\theight:94%;\n\t\toverflow:scroll;\n\t\t}\n\t\t#results{\n\t\twidth:75%;\n\t\tbackground-color:white;\n\t\tfloat:right;\n\t\ttext-align:left;\n\t\theight:94%;\n\t\toverflow:scroll;\n\t\t}\n\t\t#footer{\n\t\twidth:100%;\n\t\ttext-align:left;\n\t\tcolor:lightgrey;\n\t\tbackground-color:#6495ED;\n\t\t}\n\t\t</style>\n \"\"\"\n \n page = (part1+part2+part3)\n f = open(self.dir+'/index.html','w')\n f.write(page)\n f.close","def collect_html(args):\n url_list = args.url_list\n output_dir = args.output_dir\n\n print(url_list)\n\n # do some checks\n try: \n assert os.path.exists(url_list), 'url_list must exist'\n assert os.path.exists(output_dir), 'output_dir must exist'\n except AssertionError as err: \n logger.error('Failed check: {}'.format(err)) \n return \n\n urls = common.read_file(url_list)\n \n for url in urls: \n logger.debug(url) \n\n html = spy_tools.collect_html(url)\n out = url.split('/')\n output = os.path.join(output_dir, out[-1] + '.html')\n common.write_file(html, output)","def generate_pages(self, writer):\r\n write = partial(writer.write_file,\r\n relative_urls=self.settings['RELATIVE_URLS'])\r\n\r\n # to minimize the number of relative path stuff modification\r\n # in writer, articles pass first\r\n self.generate_articles(write)\r\n self.generate_period_archives(write)\r\n self.generate_direct_templates(write)\r\n\r\n # and subfolders after that\r\n self.generate_tags(write)\r\n self.generate_categories(write)\r\n self.generate_authors(write)\r\n self.generate_drafts(write)","def _gen_html(name, start_urls, session=requests.Session()):\n files = []\n for url in start_urls:\n r = _fetch_url(url, session=session)\n if r is None:\n continue\n\n content = r.text.strip()\n filename = '{0}/{1}.html'.format(FILES_DIR, name)\n\n url_suffix = url.split('/')[-1]\n if '.' in url_suffix:\n url_suffix = url_suffix.split('.')[-2]\n if url_suffix:\n filename = '{0}/{1}_{2}.html'.format(FILES_DIR, name, url_suffix)\n else:\n filename = '{0}/{1}.html'.format(FILES_DIR, name)\n\n with open(filename, 'w') as f:\n f.write(content)\n\n print('Created {0}'.format(filename))\n files.append(filename)\n\n return files","def _do_generate(*, build, out_dir, on_error):\n if out_dir == \"<test>\":\n out_dir = join(os.environ[\"TEST_TMPDIR\"], \"_builder_out\")\n if not os.path.isabs(out_dir):\n on_error(f\"--out_dir={out_dir} is not an absolute path\")\n if os.path.exists(out_dir):\n if len(os.listdir(out_dir)) > 0:\n on_error(f\"--out_dir={out_dir} is not empty\")\n else:\n if verbose():\n print(f\"+ mkdir -p {out_dir}\", flush=True)\n os.makedirs(out_dir)\n print(\"Generating HTML ...\")\n pages = _call_build(build=build, out_dir=out_dir)\n assert len(pages) > 0\n # Disallow symlinks in the output dir.\n for root, dirs, _ in os.walk(out_dir):\n for one_dir in dirs:\n for entry in os.scandir(f\"{root}/{one_dir}\"):\n assert not entry.is_symlink(), entry.path\n print(\"... done\")","def run(self):\n\n for url in self.urls:\n try:\n # Use requests to retrieve web page data\n print(url)\n response = session.get(url, ) # allow_redirects=True)\n\n if response.status_code != 200:\n print('Failed to retrieve page, URL: {0}, error: {1}\\n'.format(url, response.status_code))\n return\n\n # Get web page data from HTML response\n content = get_json_data(response.text)\n\n # Compile data into dictionary to be used for reporting\n summary_data = generate_report(content)\n\n # Generate/print report\n print_report(summary_data)\n\n except Exception as error:\n print('Scraper failed to run for URL {0}, error: {1}, {2}\\n'.format(\n url, type(error).__name__, error\n ))\n\n # time.sleep(1) # for load concerns","def getGenerator(self):\n coldatapage = pywikibot.Page(self.site, 'Data:Completely_indexed_painting_collections.tab')\n collectionjson = json.loads(coldatapage.text)\n colquery = 'SELECT ?item ?institution WHERE { VALUES ?item {'\n\n for collectioninfo in collectionjson.get('data'):\n colquery += ' wd:%s' % (collectioninfo[0],)\n colquery +=' } ?item wdt:P1612 ?institution }'\n colsq = pywikibot.data.sparql.SparqlQuery()\n colqueryresult = colsq.select(colquery)\n\n for resultitem in colqueryresult:\n institution = resultitem.get('institution').replace(' ', '_')\n query = 'file: hastemplate:Institution:%s incategory:Paintings_without_Wikidata_item -incategory:Paintings_from_completely_indexed_collections' % (institution,)\n gen = pagegenerators.SearchPageGenerator(query, total=1000, namespaces=6, site=self.site)\n for filepage in gen:\n yield filepage\n\n creatordatapage = pywikibot.Page(self.site, 'Data:Completely_indexed_painters.tab')\n creatorjson = json.loads(creatordatapage.text)\n creatorquery = 'SELECT ?item ?creator WHERE { VALUES ?item {'\n\n for creatorinfo in creatorjson.get('data'):\n creatorquery += ' wd:%s' % (creatorinfo[0],)\n creatorquery +=' } ?item wdt:P1472 ?creator }'\n creatorsq = pywikibot.data.sparql.SparqlQuery()\n creatorqueryresult = creatorsq.select(creatorquery)\n\n for resultitem in creatorqueryresult:\n creator = resultitem.get('creator').replace(' ', '_')\n query = 'file: hastemplate:Creator:%s incategory:Paintings_without_Wikidata_item -incategory:Paintings_by_completely_indexed_painters' % (creator,)\n gen = pagegenerators.SearchPageGenerator(query, total=1000, namespaces=6, site=self.site)\n for filepage in gen:\n yield filepage","def gen_static(self, output_folder):\n files = []\n for l in self.file_listers:\n files += l()\n for f in files:\n _logger.info(\"generating %s\" % f)\n content = self.get(f)\n loc = os.path.join(output_folder, f)\n d = os.path.dirname(loc)\n if not os.path.exists(d):\n os.makedirs(d)\n with open(loc, \"wb\") as file_:\n file_.write(content)","def render_all(pages):\n for page in pages:\n render_template(page['template'], page['output'], page['values'])","def run(self):\n if not os.path.exists(self.output_folder):\n os.makedirs(self.output_folder)\n for entry in glob.glob(os.path.join(self.data_folder, self.data_expression)):\n f = open(entry)\n text = json.loads(f.read())\n f.close()\n self.create_page_objects(text)","def Main(base_dir, page_set_filenames):\n runner = PageTestRunner()\n sys.exit(runner.Run(base_dir, page_set_filenames))","def create_web_output_paths() -> None:\n create_path_and_index(\"\")\n create_path_and_index(\"photos/\")\n create_path_and_index(\"video/\")\n create_path_and_index(\"references/\")\n create_path_and_index(\"names/\")\n create_path_and_index(\"art/\")\n create_path_and_index(\"morphology/\")\n create_path_and_index(\"maps/\")\n create_path_and_index(\"images/\")\n create_path_and_index(\"images/flag-icon-css/\")\n create_path_and_index(\"images/flag-icon-css/css/\")\n create_path_and_index(\"images/flag-icon-css/flags/\")\n create_path_and_index(\"images/flag-icon-css/flags/4x3/\")\n create_path_and_index(\"locations/\")\n create_path_and_index(\"locations/keys/\")\n create_path_and_index(\"js/\")\n create_path_and_index(\"sizes/\")\n create_path_and_index(\"handedness/\")","def generate(self) :\n\n\t\t# Generate\n\t\tcprint.section('Generation Start')\n\t\tstart_time = time.time()\n\n\t\tgenerator = Generator(self)\n\t\tgeneration_result = generator.generate()\n\n\t\tcost_time = round(time.time() - start_time, 2)\n\n\t\tsuccess_cnt = 0; error_cnt = 0; ignores_cnt = 0\n\t\tfor sucesses, errors, ignores, _ in generation_result :\n\t\t\terror_cnt += len(errors)\n\t\t\tsuccess_cnt += len(sucesses)\n\t\t\tignores_cnt += len(ignores)\n\t\t\n\t\tcprint.sep('=', 'Generation completed in %s seconds (%d success %d errors %d ignored)' % (cost_time, success_cnt, error_cnt, ignores_cnt), bold=True, blue=True)\n\n\n\t\tif 'nopub' not in self.options :\n\t\t\t# Publish\n\t\t\tstart_time = time.time()\n\n\t\t\tpublisher = self.settings.PUBLISHER\n\t\t\tpublisher.publish(generator=generator, generation_result=generation_result)\n\n\t\t\tcost_time = round(time.time() - start_time, 2)\n\n\t\t\tcprint.sep('=', '%d Pages are published in %s seconds' % (success_cnt, cost_time), bold=True, blue=True)\n\n\n\n\t\tfinish_scripts = self.settings.__dict__.get('FINISH_SCRIPTS', None)\n\n\t\tif finish_scripts :\n\t\t\t# Call scripts after generation completed\n\t\t\tcprint.sep('=', 'Call %d finish scripts' % len(finish_scripts), bold=True)\n\n\t\t\tfor file in finish_scripts :\n\t\t\t\tutils.load_module(file, self.settings.ROOT_PATH)","def urlGenerator(self):\n \n # VERMONT #\n baseurl = 'https://www.vermontjudiciary.org'\n path = '/opinions-decisions'\n # from date\n param1 = 'facet_from_date=01/01'\n # to date\n param2 = 'facet_to_date=01/01/'\n # division\n param3 = 'f%5B0%5D=court_division_opinions_library%3A'\n # search by text\n param4 = 'search_api_fulltext='\n # page\n param5 = 'page='\n # generate list of URL\n listURL = []\n \n # list of divisions\n vt_court_division = {\"civil\": \"1\", \"supreme court\": \"7\", \"environmental\": \"3\", \"family\": \"4\", \"criminal\": \"2\"}\n # inputs\n from_year = 2000\n to_year = 2017\n endPages = 75 #0-74\n startPages = 0\n # make change to pull data from different division by changing division name below to any of the division in vt_court_vivision dict\n division = vt_court_division[\"environmental\"]\n # url generating\n for i in range(startPages, endPages):\n build_url = baseurl + path + '?' + param1 + str(from_year) + \"&\" + param2 + str(to_year) + \"&\" + param3 + division + param4 + \"&\" + param5 + str(i) + \"\"\n # append url to listUrl\n listURL.append(build_url)\n i += 1\n \n # return full list of URLs\n return listURL","def documents():\n for domain in os.listdir(DOCUMENT_FOLDER):\n for docname in os.listdir(os.path.join(DOCUMENT_FOLDER, domain)):\n filename = os.path.join(DOCUMENT_FOLDER, domain, docname)\n if filename.endswith(\".html\"):\n fullDocname = os.path.join(domain, docname)\n yield (fullDocname, filename)","def run(self):\n\n try:\n # Get the content from this page\n if self.verbose:\n print \"Getting page content for '%s'\" % self.url.strip()\n \n content = getPageContent(self.url)\n\n # Verify that this is not binary data\n if content is not None and isHTML(content):\n\n\n # Extract basic data about this result\n content = content.lower()\n title, keywords, description = parseMetaDataFromContent(content)\n headers = parseHeaderInformationFromContent(content)\n\n # Add this result data\n self.resultDictionary['title'] = title\n self.resultDictionary['keywords'] = keywords\n self.resultDictionary['description'] = description\n self.resultDictionary['content'] = content\n self.resultDictionary['headers'] = headers\n\n # Run the extensions\n for extension in self.extensions:\n extension.run(self.resultDictionary)\n\n\n except URLError:\n\n # Skip this URL, and register it as an error on the cache\n if self.verbose:\n print(\"Error accessing '%s', %s\" % (self.url.strip(), str(sys.exc_info()[1]).strip()))","def fetch_pages(folder=pages_folder):\r\n if not (folder.endswith('/') or folder.endswith('\\\\')):\r\n folder += '/'\r\n _classes = classes\r\n if not _classes:\r\n _classes = extract_classes(getsoup())\r\n for classnum in _classes.keys():\r\n with open(folder + str(classnum) + '.html', 'x') as f:\r\n f.write(getsoup(classnum).prettify())","def _build_html():\n\n # Build twice until getnikola/nikola#1032 is fixed.\n local('nikola build && nikola build')\n\n ## Remove all the source files, we only want the output!\n local('ls | grep -v output | xargs rm -rf')\n with settings(warn_only=True):\n local('mv output/* output/.* .')","def do_GET(self):\n try:\n is_digi = False #sys.platform.startswith('digi')\n page = self.server.get_page()\n\n if self.path.endswith(page) or \\\n not is_digi and self.path == '/':\n self.send_response(200)\n self.send_header('Content-type', 'text/html')\n self.end_headers()\n self.wfile.write(web_files.html % {\"page\": page,\n \"title\":self.server.get_title()})\n elif not is_digi and self.path.endswith(\"stylesheet.css\"):\n self.send_response(200)\n self.send_header('Content-type', 'text/css')\n self.end_headers()\n self.wfile.write(stylesheet_css)\n elif not is_digi and self.path.find('?') > 0:\n self.send_response(200)\n self.send_header('Content-type', 'application/json')\n self.end_headers()\n self.wfile.write(self.server.get_table(\n self.path[self.path.find('?')+1:]))\n return\n except IOError:\n self.send_error(404,'File Not Found: %s' % self.path)","def getHTML():\n for url in urls: #Because there might be multipe URLs to scrape, iterate through the list \n r = requests.get(url)\n r.raise_for_status()\n webpage_html = str(bs4.BeautifulSoup(r.text, \"html.parser\"))\n filenumber = str(urls.index(url)) #Create a variable called filenumber using the index of the url in the list of urls\n filename = \"output_\" + filenumber + \".html\" #This and above line avoid the loop rewriting the file name of the previous file.\n with open(filename, 'w') as file_object: #open a new (or existing) file to be written (or overwritten)\n file_object.write(webpage_html) #write the scraped HTML into the file\n file_object.close #close the file","def index():\n #Getting source\n sources = get_sources()\n print(sources)\n return render_template('index.html', sources = sources)","def generate_files(self):\n\t\tapply_stemmer, xml_file, query_file, expected_file = self.read_config_file()\n\t\tself.generate_query_file(query_file, xml_file, apply_stemmer)\n\t\tself.generate_expected_file(expected_file, xml_file)\n\t\tlogging.info('FINALIZADO: MÓDULO PROCESSADOR DE CONSULTAS')","def main():\n # Step1: generate htmls\n csv_data_path= \"./frontend/html_template_data/dataset.csv\"\n html_template_path = \"./frontend/html_template_data/template.html\"\n html_save_path = \"./frontend/html_files/\"\n\n generate_htmls(csv_data_path, html_template_path, html_save_path)\n\n # Step2: push htmls to Github\n # push htmls to Github Pages, currently manual.","def execute(pagename, request):\n PackagePages(pagename, request).render()","def make_pages(src, dst, layout, **params):\n items = []\n\n for src_path in glob.glob(src):\n context = read_content(src_path)\n\n params.update(context)\n\n dst_path = render(dst, **params)\n output = render(context['content'], **params)\n\n # Add destination path to context\n context['dest_path'] = dst_path\n\n # Add item to list\n items.append(context)\n\n log('Rendering {} => {} ...', src_path, dst_path)\n fwrite(dst_path, output)\n\n return sorted(items, key=lambda x: x['date_ymd'], reverse=True)","def parsing_all_page(url):\n html_doc = get_html(url)\n# html_doc = get_html_local()\n page_count = get_html_count(html_doc)\n print 'All have find pages %d' % page_count\n\n projects = []\n\n for page in range(1, page_count + 1):\n print 'Parsing %d%%' % (page*100/page_count)\n\n url = BASE_URL + '?page=%d' % page\n projects.extend(process_page(url))\n\n return projects","def save(self):\n for page in self.pages.get_published_pages():\n site_path = page.path_to_page.replace('.md', '').replace(\n self.source_path, '').strip('/')\n save_path = self.output_path\n\n # ensure we are not creating a directory for the index file that\n # that lives at the source_path\n if page.full_path() != f'{self.source_path}{os.sep}index.md':\n site_path = slugify_path(site_path)\n save_path = os.path.join('', self.output_path, site_path)\n\n try:\n os.makedirs(save_path, exist_ok=True)\n except Exception as e:\n log((f'unable to create directories: {save_path}'\n f' because: {e}'), True)\n continue\n\n try:\n save_file = os.path.join(save_path, 'index.html')\n log(f'saving {save_file}')\n\n published = self.pages.get_published_pages()\n prev_page = self.pages.get_previous_page(page)\n next_page = self.pages.get_next_page(page)\n content = page.render(published_pages=published,\n previous_page=prev_page, next_page=next_page)\n write(save_file, content)\n except Exception as e:\n log(f'unable to save file: {save_file} -- {e}', True)\n\n unpublished = self.pages.get_unpublished_pages()\n if len(unpublished):\n log('')\n log('these pages were unpublished and not rendered:', True)\n for up in unpublished:\n log(up.path_to_page, True)\n log('')\n\n # build the _tags pages\n for tag, pages in self.tags.pages.items():\n content = self.tags.render(tag, pages)\n tag_index_dir = f'{self.tag_dir}/{slugify(tag)}'\n tag_index = f'{tag_index_dir}/index.html'\n os.makedirs(tag_index_dir, exist_ok=True)\n write(tag_index, content)\n\n log('finished builidng site')","def _generate_report(self):\n\n _LOG.info(\"Generating the HTML report.\")\n\n # Make sure the output directory exists.\n try:\n self.outdir.mkdir(parents=True, exist_ok=True)\n except OSError as err:\n raise Error(f\"failed to create directory '{self.outdir}': {err}\")\n\n raw_stats_paths, descr_paths = self._copy_raw_data()\n\n # Find the styles and templates paths.\n templdir = FSHelpers.search_for_app_data(\"wult\", Path(\"templates\"),\n pathdescr=\"HTML report Jinja2 templates\")\n csspath = FSHelpers.search_for_app_data(\"wult\", Path(\"css/style.css\"),\n pathdescr=\"HTML report CSS file\")\n\n # Copy the styles file to the output directory.\n dstpath = self.outdir.joinpath(\"style.css\")\n try:\n shutil.copyfile(csspath, dstpath)\n except OSError as err:\n raise Error(f\"failed to copy CSS file from '{csspath}' to '{dstpath}':\\n{err}\")\n\n # The summary table is only included into the main HTML page.\n sum_tbl = self._prepare_summary_table(raw_stats_paths, descr_paths)\n links_tbl = self._prepare_links_table()\n\n # Each column name gets its own HTML page.\n for colname, pinfos in self._pinfos.items():\n stats_tbl = self._prepare_stats_table(pinfos)\n\n # Render the template.\n jenv = Jinja2.build_jenv(templdir, trim_blocks=True, lstrip_blocks=True)\n jenv.globals[\"stats_tbl\"] = stats_tbl\n jenv.globals[\"pinfos\"] = pinfos\n jenv.globals[\"colname\"] = colname\n jenv.globals[\"title_descr\"] = self.title_descr\n jenv.globals[\"toolname\"] = self._refinfo[\"toolname\"]\n\n if sum_tbl:\n jenv.globals[\"sum_tbl\"] = sum_tbl\n jenv.globals[\"links_tbl\"] = links_tbl\n templfile = outfile = \"index.html\"\n sum_tbl = None\n else:\n templfile = \"metric.html\"\n outfile = links_tbl[colname][\"fname\"]\n\n Jinja2.render_template(jenv, Path(templfile), outfile=self.outdir.joinpath(outfile))","def report(self, output_dir):","def __call__(self):\r\n self.init_data = td.import_data(self.__module__)\r\n self.page1() # GET navigation (requests 101-153)\r\n\r\n grinder.sleep(20)\r\n self.page2() # GET case (requests 201-252)\r\n\r\n grinder.sleep(20)\r\n self.page3() # GET view (requests 301-365)\r\n\r\n grinder.sleep(20)\r\n self.page4() # POST view (requests 401-452)\r","def download_all(self):\r\n # Fetch website list\r\n self.fetch_website_list()\r\n\r\n for website in self.website_list:\r\n self.download(website['id'])","def fetch_web_cont(self):\n with open(self.input_file) as input_file:\n data = yaml.load(input_file, yaml.FullLoader)\n url_list = data.get(self.url_access)\n regex_list = data.get(self.regex_access)\n\n print('Fetching data:')\n\n for url in url_list:\n # This restores the same behavior as before.\n # Enabling certificate verification by default for stdlib http clients\n context = ssl._create_unverified_context()\n run_time = datetime.now().strftime(\"Date: %d-%m-%Y Time: %I:%M:%S:%f_%p\")\n start = time.perf_counter()\n web_resp = request.urlopen(url, context=context)\n respData = web_resp.read()\n resp_time = '%0.2f s' % (time.perf_counter() - start)\n\n for regex in regex_list:\n contents = re.findall(regex, str(respData))\n with open(self.output_file, 'a') as file:\n if not contents:\n print(run_time, ' | URL: ', url, '| content not found with this regex: ', regex,\n file=file)\n\n else:\n for content in contents:\n print(run_time, ' | URL: ', url, ' | Response Time: ', resp_time,\n url, ' | Contents: ', content, file=file)\n \n with open(self.output_file, 'a') as file:\n \n print('\\n#################################\\n', file=file)","def run(self):\n make_sure_path_exists(OUT_FOLDER)\n\n if self.config['type'] == 'website':\n make_sure_path_exists(self.config['out_folder'])\n\n\n for file in self.config['bodies']:\n if file['type'] == 'content':\n self.pandoc_file(file)\n if self.config['type'] == 'website':\n shutil.copyfile(file['generated'], os.path.join(self.config['out_folder'], os.path.basename(file['source'])))\n\n if self.config['type'] == 'website':\n return\n\n for file in self.config['abstract']:\n self.pandoc_file(file)\n for file in self.config['summary']:\n self.pandoc_file(file)\n\n template = LATEX_JINJA_ENV.get_template(self.config['template_file'])\n\n logging.info('Rendering template')\n out = template.render(**self.config)\n with open(self.config['name'] + self.get_file_extension(), 'w') as file:\n file.write(out)\n\n if not self.args.pandoc:\n logging.info('Rendering latex')\n self.write()\n if not self.args.fast:\n logging.info('Rendering latex, again')\n self.write() # twice for the toc\n\n logging.info('Done!')","def processing():\r\n err=test_url()\r\n of=open(default_output_path,'a+')\r\n if err!=0: \r\n metaf=scan_target_metatag()\r\n adminf=scan_admin_url()\r\n comf=scan_com_content()\r\n robotsf=scan_robots_txt()\r\n htf=scan_htaccess()\r\n moof=scan_mootools()\r\n engbf=scan_engb_ini()\r\n result=compute_result(metaf,adminf,comf,robotsf,htf,moof,engbf)\r\n if result==1:\r\n #print \"THE TARGET IS USING JOOMLA CMS\"\r\n #print \"Joomla version is \" + joomla_version\r\n of.write(\"\\nJOOMLA USED (version : \" + joomla_version + \") --> \" + provided_url + \"\\n\")\r\n else:\r\n #print \"JOOMLA NOT USED\"\r\n of.write(\"\\nJOMLA NOT USED --> \" + provided_url + \"\\n\")\r\n else:\r\n of.write(\"\\nBAD URL --> \" + provided_url + \"\\n\")\r\n of.close()\r\n return 0","def index_indexes(folder,saveAs=\"index2.html\"):\n indexes=[]\n saveAs=os.path.abspath(os.path.join(folder,saveAs))\n for subFolder in glob.glob(folder+\"/*/\"):\n if os.path.exists(subFolder+\"/SWH2P/index.html\"):\n indexes.append(os.path.abspath(subFolder+\"/SWH2P/index.html\"))\n\n html='<html><body><h1>Automatic Index</h1><ul>'\n for item in sorted(indexes):\n html+='<li><a href=\"%s\">%s</a>'%(item,\n os.path.basename(os.path.dirname(os.path.dirname(item))))\n html+='</ul></body></html>'\n with open(saveAs,'w') as f:\n f.write(html)\n print(\"saved\",saveAs)\n webbrowser.open(saveAs)","def photo2web_indexer():\n \n import numpy as np\n \n do_hh = True\n do_hbt = False\n\n if do_hh:\n num_thumbs = 3 # Number of thumbnails per folder to display\n file_out = 'index.html'\n dir_base = '/Volumes/SSD External/Hattenbach_v2'\n title = 'Hattenbach Photos'\n file_target = 'index_m.html?s=1' # Do we visit index.html, or some other file, to start the gallery?\n # For HH, we force to the mobile site, since there are zero captions anyhow.\n \n if do_hbt:\n num_thumbs = 10 # Number of thumbnails per folder to display\n file_out = 'index_all.html'\n dir_base = '/Users/throop/photos/Trips'\n file_target = 'index.html' # NB: This is oversimplified. Sometimes it should be show.html, etc.\n title = 'Henry Throop Photos' # HTML title\n \n os.chdir(dir_base)\n\n dirs = sorted(glob.glob(os.path.join(dir_base, '*')))\n \n # Create the output file\n # WARNING: DO NOT CALL THIS INDEX.HTML, since it might overwrite the existing HBT one.\n \n lun = open(file_out, \"w\")\n lun.write(f'<head><link rel=\"stylesheet\" type=\"text/css\" href=\"photos.css\"><title>{title}</title></head>\\n')\n lun.write('\\n')\n \n for dir in dirs:\n \n if os.path.isdir(dir): \n files = sorted(glob.glob(os.path.join(dir, 'thumbnails/s*jpg')))\n \n # If there are some thumbnails there, then proceed\n \n if len(files) > 0:\n basename = os.path.basename(dir)\n basename_edited = basename.replace('_', ' ')\n \n lun.write(f'<a href={basename}/{file_target}><h3>{basename_edited}</h3></a>\\n')\n lun.write('<p>\\n')\n print(dir)\n for i in range(np.amin([num_thumbs,len(files)])):\n print(f'{i}/{num_thumbs} : {files[i]}')\n lun.write(f'<a href={basename}/{file_target}><img src={basename}/thumbnails/{os.path.basename(files[i])}></a>\\n')\n lun.write('<p>\\n')\n print()\n \n lun.close()\n print(f'Wrote: {os.path.join(dir_base,file_out)}')","def getURLs():","def produce_main(self) -> list:\n self.headers_random = {'user-agent': UserAgent().random,}\n links_google, links_qwant, links_bing, \\\n links_duckduckgo, links_yahoo = self.links_search\n value_google = [[rand, self.headers_random] for rand in links_google]\n value_qwant = [[rand, self.headers_random] for rand in links_qwant]\n value_bing = [[rand, self.headers_random] for rand in links_bing]\n value_duckduckgo = [[rand, self.headers_random] for rand in links_duckduckgo]\n value_yahoo = [[rand, self.headers_random] for rand in links_yahoo]\n \n with Pool(5) as pool:\n value_html_google = pool.map(self.produce_html_text, value_google)\n value_html_qwant = pool.map(self.produce_html_text, value_qwant)\n value_html_bing = pool.map(self.produce_html_text, value_bing)\n value_html_duckduckgo = pool.map(self.produce_html_text, value_duckduckgo)\n value_html_yahoo = pool.map(self.produce_html_text, value_yahoo)\n\n value_google = [[html, link] for html, link in zip(value_html_google, links_google)]\n value_qwant = [[html, link] for html, link in zip(value_html_qwant, links_qwant)]\n value_bing = [[html, link] for html, link in zip(value_html_bing, links_bing)]\n value_duckduckgo = [[html, link] for html, link in zip(value_html_duckduckgo, links_duckduckgo)]\n value_yahoo = [[html, link] for html, link in zip(value_html_yahoo, links_yahoo)]\n \n with Pool(5) as pool:\n value_dict_google = pool.map(self.produce_parse_google, value_google)\n value_dict_qwant = pool.map(self.produce_parse_qwant, value_qwant)\n value_dict_bing = pool.map(self.produce_parse_bing, value_bing)\n value_dict_duckduckgo = pool.map(self.produce_parse_duckduckgo, value_duckduckgo)\n value_dict_yahoo = pool.map(self.produce_parse_yahoo, value_yahoo)\n \n return value_dict_google, value_dict_qwant, value_dict_bing, \\\n value_dict_duckduckgo, value_dict_yahoo","def mk_htmls(self):\n\n domain_link_list = self.scrape_domain_int_links()\n html_fail_rate = float(self.failed_retrieving_html_counter / len(domain_link_list))\n print \"mk_htmls SUCCES RATE %r\" % html_fail_rate\n if html_fail_rate < (float(0.1)):\n # driving links, to collect htmls from web and create htmls with removed img elements\n for ind in range(len(domain_link_list)):\n page_file_name = \"page_\" + str(ind + 1) + \".html\" # gen file names for html file of page on site\n active_page_link = domain_link_list[ind]\n if \";;;\" in active_page_link: # separator problems hedging\n self.links_contain_seprator.append([active_page_link, page_file_name])\n print \"LINK CONTAINS SEPARATOR, CAN NOT ADD TO PAGE LIST, WILL RUIN DATASYSTEM, WILL BE ADDED TO SEPARATE FILE\"\n else:\n BS_object = self.retrieve_html(active_page_link, self.domain_folder_name, self.html_folder_name, page_file_name)\n self.page_list.append([active_page_link, page_file_name])\n self.bs_object_dict[active_page_link] = BS_object\n # if no \";;;\" separator found in link, then write as usual\n if len(self.links_contain_seprator) > 0:\n c_m.l_of_l_write(self.links_contain_seprator, self.main_path, self.domain_folder_name, self.link_contains_separator)\n else:\n c_m.l_of_l_write(self.page_list, self.main_path, self.domain_folder_name, self.page_list_f_name)\n return self.bs_object_dict\n else:\n return False","def crawl(self) -> Dict[str, List[req.Response]]:\n loop = asyncio.get_event_loop()\n try:\n web_pages = loop.run_until_complete(\n asyncio.ensure_future(self.initialiser_crawler())\n )\n except KeyboardInterrupt:\n loop.close()\n raise KeyboardInterrupt\n return web_pages","def main():\n page = get_page_arg()\n\n items = load_data(page)\n total_pages = get_total_pages()\n context = {\"current_page\": page,\n \"total_pages\": total_pages,\n \"items\": items}\n\n return render_template('index.html', **context)","def getAllPages(base_url, node = None, page_size = 1000, from_date=None, to_date=None, delay=None):\n\n\tdocuments_csv_filepath = getScriptDirectory() + \"/result/documents.csv\"\n\n\n\t# Check if the output file exists\n\t# If it does, we can skip all of this\n\n\tif(os.path.isfile(documents_csv_filepath)):\n\t\tprint(\"Documents already exist. Moving onto sampling.\")\n\n\t\treturn\n\n\n\t# Check if result folder has been made\n\n\tresult_folder = getScriptDirectory() + \"/result\"\n\n\tif not os.path.exists(result_folder):\n\t\tos.makedirs(result_folder)\n\n\n\t# Continue fetching fresh results from the server\n\n\tnum_results = getNumResults(base_url, node, from_date=from_date, to_date=to_date);\n\tprint(\"Total results: %d\" % (num_results))\n\n\tif num_results is 0:\n\t\tprint \"No results were found. Exiting.\"\n\t\texit\n\n\tpages_required = math.ceil((num_results + 0.0) / page_size)\n\tprint(\"Total pages: %d\" % (pages_required))\n\n\n\trange_of_pages = range(1, int(pages_required) + 1)\n\n\tall_pages = getPageRange(base_url, node, range_of_pages, page_size, from_date=from_date, to_date=to_date, delay=delay)\n\tall_pages.to_csv(documents_csv_filepath, index = False, encoding = \"utf-8\")\n\n\treturn","def main(self, options):\n import sys\n import getopt\n import errno\n from os import makedirs\n from os.path import dirname\n\n try:\n opts, args = getopt.getopt(options,\n \"lt:gsp:\", [\n \"port=\",\n \"view=\",\n \"list\",\n \"static=\",\n \"generate\",\n \"server\"])\n except getopt.GetoptError, err:\n print str(err)\n sys.exit(2)\n \n generate = False\n serve = False\n listfiles = False\n statichtml = 'static'\n view = False\n port = 8080\n \n for option, arg in opts:\n if option in (\"-g\",\"--generate\"):\n generate = True\n elif option in (\"-t\",\"--static\"):\n statichtml = arg\n elif option in (\"--view\"):\n view = arg\n elif option in (\"-s\",\"--serve\"):\n serve = True\n elif option in (\"-l\",\"--list\"):\n listfiles = True\n elif option in (\"-p\",\"--port\"):\n port = int(arg)\n else:\n assert False, \"unhandle option\"\n \n if generate or listfiles:\n for path, filename in self.genlist():\n \n path = path.replace('?','')\n \n if view and view != path:\n continue\n \n if listfiles:\n print path + \" <= \" + \\\n join(path[1:],'index.html') + ' <= ' + \\\n filename\n \n if generate:\n path = join(statichtml , path[1:], 'index.html')\n try:\n makedirs(dirname(path))\n except OSError as exc:\n if exc.errno == errno.EEXIST:\n pass\n else: raise\n print \"Generating \" + path\n static_file = open(path,'w')\n static_file.write(self.generatehtml(path))\n static_file.close()\n \n if serve:\n print \"Starting wsgi web server on port \" + str(port)\n from wsgiref.simple_server import make_server\n server = make_server('', port, self.wsgiapp())\n server.serve_forever()","def run_scrapping():\n date = datetime.now().strftime(\"%Y-%m-%d\")\n size = 100\n r = list(range(size))\n random.shuffle(r)\n for i in r:\n scrap_page(url_page.format(i), date)\n print(str(i) + \" / \" + str(size))","def _yield_result_files(self, tpl, **kwargs):\n for sheet in self.shortcut_sheets:\n for ngs_library in sheet.all_ngs_libraries:\n extraction_type = ngs_library.test_sample.extra_infos[\"extractionType\"]\n if ngs_library.extra_infos[\"seqPlatform\"] in (\"ONP\", \"PacBio\"):\n suffix = \"_long\"\n else:\n suffix = \"\"\n yield from expand(\n tpl,\n mapper=self.config[\"tools\"][extraction_type.lower() + suffix],\n ngs_library=[ngs_library],\n **kwargs\n )","def create_results(self):\n\n webhost_map = {}\n # put the found paths into the webhost map\n self.process_crawled_urls(webhost_map)\n # put the found param infos into the webhost map\n self.process_param_infos(webhost_map)\n # put the found cookies into the webhost map and get as by product new domains\n new_domains = self.process_cookies(webhost_map)\n # get the newly discovered network locations\n new_netlocs = self.get_new_netlocs()\n\n # append new domains to the new network locations\n for new_domain in new_domains:\n if self.port != 80 and self.port != 443:\n new_netlocs.add(new_domains + \":\" + self.port)\n else:\n new_netlocs.add(new_domain)\n\n # process discovered redirects and put into webhost map if appropriate\n for url, redirect in self.redirects.items():\n path = urllib.parse.urlparse(url).path\n if url + \"/\" == redirect[\"to\"]:\n continue\n else:\n if not self.url_has_netloc(redirect[\"to\"]):\n redirect_to = redirect[\"to\"]\n else:\n redirect_to = urllib.parse.urlparse(redirect[\"to\"]).path\n\n code = str(redirect[\"code\"])\n if code not in webhost_map:\n webhost_map[code] = {}\n if path not in webhost_map[code]:\n webhost_map[code][path] = {}\n\n redirect_info = \"redirect to %s\" % redirect_to\n if \"misc_info\" not in webhost_map[code][path]:\n webhost_map[code][path][\"misc_info\"] = redirect_info\n elif not any(val == redirect_info for val in webhost_map[code][path].values()):\n for i in range(10):\n alt_key = \"misc_info_%d\" % i\n if alt_key not in webhost_map[code][path]:\n webhost_map[code][path][alt_key] = redirect_info\n break\n\n return webhost_map, new_netlocs, self.comments","def write_page_sets(urls):\n template = ''\n page_set_path = os.path.join(CHROMIUM_SRC, 'tools/perf/page_sets/')\n\n with open('page_set_template.py', 'rb') as f:\n template = ''.join(f.readlines())\n assert template, 'Failed to read from page set template'\n\n for i in range(len(urls)):\n test_name = 'url{0}'.format(i)\n with open('{0}{1}.py'.format(page_set_path, test_name), 'wb') as f:\n f.write(template.format(test_name, urls[i]))\n # Write modified version\n test_name = 'url{0}'.format(str(i) + '_pc')\n with open('{0}{1}.py'.format(page_set_path, test_name), 'wb') as f:\n f.write(template.format(test_name, urls[i]))","def save(self, content_dir):\n print_verbose(\n \"INFO : Writing random HTML documents to files...\",\n self.args.verbose,\n )\n for i in range(self.n):\n dir_path = content_dir + \"/\" + \"staticpage\" + str(i)\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)\n index_file = os.path.join(dir_path, \"index.html\") \n with open(index_file, \"w\") as file:\n file.write(self.doc_strings[i].decode(\"utf-8\"))","def wyniki():\n return render_template('results.html', result=request.args.get('result'))","def updateFrontPages(self):\n nTmessage(\"Starting %s\" % getCallerName())\n htmlDir = os.path.join(self.results_dir, \"HTML\")\n if os.path.isdir(htmlDir):\n# nTdebug(\"Removing original html directory for NRG-CING.\")\n rmdir(htmlDir)\n # end if\n nTmessage(\"Creating HTML directory for %s.\" % self.results_base)\n mkdirs(htmlDir)\n# srcHtmlPath = os.path.join(cingRoot, cingPaths.html) \n data_dir = os.path.join (self.base_dir, \"data\" )\n base_data_dir = os.path.join (data_dir, self.results_base )\n # Most crud can come in from the traditional method.\n copyCingHtmlJsAndCssToDirectory(htmlDir)\n \n nTmessage(\"Adding frontpage-specific html.\")\n fnList = \"\"\"\n about.html \n contact.html \n credits.html \n help.html \n helpCing.html \n helpPlot.html \n helpTutorials.html\n glossary.html \n index.html\n download.html \n plot.html \n cing.png \n icon_email.gif\n icon_reference.gif\n icon_website.png\n icon_youtube.jpeg\n icon_download.gif\n NRG-CING_circle.png\n \"\"\".split()\n for fn in fnList:\n srcFile = os.path.join(base_data_dir, fn)\n dstFile = os.path.join(htmlDir, fn)\n if not fn.endswith('.html'):\n copyfile(srcFile, dstFile)\n# nTdebug(\"-1- Added extra file %s.\" % dstFile)\n continue\n # end if\n file_content = open(srcFile, 'r').read() \n old_string = r\"<!-- INSERT NEW FOOTER HERE -->\"\n file_content = string.replace(file_content, old_string, self.htmlFooter)\n old_string = r\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE) \n old_string = r\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\"\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE) \n if fn != 'index.html':\n writeTextToFile(dstFile, file_content)\n# nTdebug(\"-2- Added extra file %s.\" % dstFile)\n continue\n # end if\n # Get framework input\n file_content = self._format_html(file_content) \n htmlfile = os.path.join(htmlDir, 'index.html')\n writeTextToFile(htmlfile, file_content)\n# nTdebug(\"-3- Written HTML index file: %s\" % htmlfile) \n # end for\n nTmessage(\"Copy the overall index\")\n org_file = os.path.join(data_dir, 'redirect.html')\n new_file = os.path.join(self.results_dir, 'index.html')\n shutil.copy(org_file, new_file)\n \n nTmessage(\"Copy the python cgi server for TableTools\\n\")\n cgi_file_name = 'DataTablesServer.py'\n if not os.path.exists(self.cgi_dir):\n nTerror(\"Please first create the server directory as expected at: %s\" % self.cgi_dir)\n return True\n # end if\n org_file = os.path.join(self.base_dir, 'server', cgi_file_name)\n new_file = os.path.join(self.cgi_dir, cgi_file_name)\n if os.path.exists(new_file): # remove because if it's a hard link the copy will fail.\n os.unlink(new_file)\n # end if\n shutil.copy(org_file, new_file)","def get(self):\n resources = []\n starting_path = self.request.get('start')\n if starting_path:\n resources = Resource.query(Resource.path >= starting_path).order(\n Resource.path).fetch(11)\n else:\n resources = Resource.query().order(Resource.path).fetch(11)\n\n self.response.headers['Content-Type'] = 'text/html'\n\n self.response.write('<!doctype><html><head>' +\n '<title>Content Lister</title></head><body>Resources:<br>')\n for i in xrange(10):\n if i < len(resources):\n # TODO: constructing the path this way makes the resource\n # path a possible vector for XSS.\n self.response.write('%s ' % (resources[i].path,) +\n '<a href=\"/content_manager%s\">' % (\n resources[i].path,) +\n 'Edit</a> <a href=\"%s\">View</a><br>' % (\n resources[i].path,))\n\n if len(resources) > 10:\n self.response.write(\n '<a href=\"/content_lister?start=%s\">Next</a>' % (\n resources[10].path,))\n \n self.response.write('</body></html>')","def generate():\n\n # Verify if directory exists\n if not os.path.isdir(config.techniques_markdown_path):\n os.mkdir(config.techniques_markdown_path)\n\n #Write the technique index.html page\n with open(os.path.join(config.techniques_markdown_path, \"overview.md\"), \"w\", encoding='utf8') as md_file:\n md_file.write(config.technique_overview_md)\n\n for domain in config.domains:\n generate_domain_markdown(domain)","def generate():\n local('cd doc && make clean && make html')","def get_result_files(self):\n name_pattern = \"{mapper}.{ngs_library.name}\"\n yield from self._yield_result_files(\n os.path.join(\"output\", name_pattern, \"out\", name_pattern + \"{ext}\"), ext=EXT_VALUES\n )\n yield from self._yield_result_files(\n os.path.join(\"output\", name_pattern, \"log\", \"{mapper}.{ngs_library.name}.{ext}\"),\n ext=(\n \"log\",\n \"conda_info.txt\",\n \"conda_list.txt\",\n \"log.md5\",\n \"conda_info.txt.md5\",\n \"conda_list.txt.md5\",\n ),\n )\n yield from self._yield_result_files(\n os.path.join(\n \"output\", name_pattern, \"report\", \"bam_qc\", name_pattern + \".bam.{report}.txt\"\n ),\n report=(\"bamstats\", \"flagstats\", \"idxstats\"),\n )\n yield from self._yield_result_files(\n os.path.join(\n \"output\", name_pattern, \"report\", \"bam_qc\", name_pattern + \".bam.{report}.txt.md5\"\n ),\n report=(\"bamstats\", \"flagstats\", \"idxstats\"),\n )\n yield from self._yield_result_files(\n os.path.join(\n \"output\", name_pattern, \"report\", \"bam_qc\", name_pattern + \".bam.bamstats.html\"\n )\n )\n yield from self._yield_result_files(\n os.path.join(\n \"output\", name_pattern, \"report\", \"bam_qc\", name_pattern + \".bam.bamstats.html.md5\"\n )\n )\n\n for sheet in self.shortcut_sheets:\n for ngs_library in sheet.all_ngs_libraries:\n if ngs_library.name in self.ngs_library_to_kit:\n extraction_type = ngs_library.test_sample.extra_infos[\"extractionType\"]\n suffix = (\n \"_long\"\n if ngs_library.extra_infos[\"seqPlatform\"] in (\"PacBio\", \"ONP\")\n else \"\"\n )\n # Per-sample target coverage report.\n yield from expand(\n os.path.join(\n \"output\", name_pattern, \"report\", \"cov_qc\", name_pattern + \".{ext}\"\n ),\n mapper=self.config[\"tools\"][extraction_type.lower() + suffix],\n ngs_library=[ngs_library],\n ext=[\"txt\", \"txt.md5\"],\n )\n yield \"output/target_cov_report/out/target_cov_report.txt\"\n yield \"output/target_cov_report/out/target_cov_report.txt.md5\"\n if (\n self.config[\"picard_hs_metrics\"][\"path_targets_interval_list\"]\n and self.config[\"picard_hs_metrics\"][\"path_baits_interval_list\"]\n ):\n yield from self._yield_result_files(\n os.path.join(\n \"output\", name_pattern, \"report\", \"picard_hs_metrics\", name_pattern + \".txt\"\n )\n )\n yield from self._yield_result_files(\n os.path.join(\n \"output\", name_pattern, \"report\", \"picard_hs_metrics\", name_pattern + \".txt.md5\"\n )\n )\n if self.config[\"compute_coverage_bed\"]:\n yield from self._yield_result_files(\n os.path.join(\"output\", name_pattern, \"report\", \"coverage\", name_pattern + \"{ext}\"),\n ext=(\".bed.gz\", \".bed.gz.tbi\"),\n )\n else:\n print(\n \"Genome-wide coverage BED generation disabled\", file=sys.stderr\n ) # pragma: no cover","def main(base_url, node, sample_size, from_date, to_date):\n\n\tgetAllPages(base_url, node, from_date=from_date, to_date=to_date) # Depends on document.csv\n\tsampleDocuments(sample_size) # Depends on sampled_documents.csv\n\tgetAndSaveDocuments(base_url)","def download_files(self):","def results_overview():\n\n if request.method == \"POST\":\n # clean out all unwanted storage\n if _pool:\n _pool.terminate()\n del _drivers[:]\n \n return redirect(url_for('upload.upload'))\n\n # GET\n \n # Captures the global drivers variable\n global _drivers\n\n processType = g.processType\n coreFactor = g.coreFactor\n\n if processType == 'parallel':\n current_app.logger.info(time.ctime() + \"\\tProcess pool with %s processes initialized for execution\" % coreFactor)\n results = _pool.map(_get_result, _drivers)\n else:\n results = [_get_result(driver) for driver in _drivers]\n\n return render_template('checks/results_overview.html', results=results)","async def initialiser_crawler(self) -> Dict[str, List[req.Response]]:\n web_pages = {}\n with ThreadPoolExecutor(max_workers=NUM_WORKERS) as exe:\n try:\n loop = asyncio.get_event_loop()\n tasks = [\n loop.run_in_executor(exe, self.collect_webpages, keyword)\n for keyword in self.keywords \n ]\n for res in await asyncio.gather(*tasks):\n web_pages.update(res)\n except KeyboardInterrupt:\n loop.close()\n raise KeyboardInterrupt\n return web_pages","def _get_allpages(self, url:str, paramsdict:Dict[str,str]):\n r1 = self._get_dict_from_url(url, paramsdict)\n r = [r1]\n #display(r)\n if 'total_pages' in r1:\n # print('more than one page')\n for next_page in range(2, r1['total_pages']+1):\n # print(f\"load page {next_page} \")\n r.append(self._get_dict_from_url(url, {**paramsdict, 'page':next_page}))\n # print(len(r))\n # print([len(rx['results']) for rx in r])\n results = [entry for rx in r for entry in rx['results'] ]\n\n return results","def _copy_results_html_file(self, destination_dir, filename):\n files_to_copy = [filename, filename + \".version\"]\n template_dir = self._path_finder.path_from_blink_tools(\n 'blinkpy', 'web_tests')\n for filename in files_to_copy:\n source_path = self._filesystem.join(template_dir, filename)\n destination_path = self._filesystem.join(destination_dir, filename)\n # Note that the results.html template file won't exist when\n # we're using a MockFileSystem during unit tests, so make sure\n # it exists before we try to copy it.\n if self._filesystem.exists(source_path):\n self._filesystem.copyfile(source_path, destination_path)","def start_requests(self):\r\n yield Request(url=MooreSpider.start_url,\r\n callback=self.parse_directory_list,\r\n method=\"GET\")","def get_output_files(self, action):\n assert action == \"run\"\n for ext in self.extensions:\n yield ext[1:].replace(\".\", \"_\"), self.base_path_out.format(mapper=self.name, ext=ext)\n for ext in (\".bamstats.html\", \".bamstats.txt\", \".flagstats.txt\", \".idxstats.txt\"):\n path = (\n \"work/{mapper}.{{library_name}}/report/bam_qc/\" \"{mapper}.{{library_name}}.bam{ext}\"\n ).format(mapper=self.name, ext=ext)\n yield \"report_\" + \".\".join(ext.split(\".\")[1:3]).replace(\".\", \"_\"), path\n for ext in (\n \".bamstats.html.md5\",\n \".bamstats.txt.md5\",\n \".flagstats.txt.md5\",\n \".idxstats.txt.md5\",\n ):\n path = (\n \"work/{mapper}.{{library_name}}/report/bam_qc/\" \"{mapper}.{{library_name}}.bam{ext}\"\n ).format(mapper=self.name, ext=ext)\n yield \"report_\" + \".\".join(ext.split(\".\")[1:3]).replace(\".\", \"_\") + \"_md5\", path","def content_creator():\n with temporary_url_for_logger(app) as logger:\n with logger:\n content = page.render_html(\n solution=solution,\n static_url=static_url,\n lesson_url=lesson_url,\n subpage_url=subpage_url,\n vars=variables\n )\n absolute_urls = [url_for(logged[0], **logged[1]) for logged in logger.logged_calls]\n\n relative_urls = [get_relative_url(request.path, x) for x in absolute_urls]\n\n return {\"content\": content, \"urls\": relative_urls}","def generate_report():\n\n # Fetch the top 3 most viewed articles and number of views and print them\n articles_query = get_articles_query()\n popular_articles = execute_query(articles_query)\n print_top_articles(popular_articles)\n\n # Fetch the most popular authors and print them\n authors_query = get_authors_query()\n popular_authors = execute_query(authors_query)\n print_authors(popular_authors)\n\n # Print the days when there were more than 1% errors in HTTP requests\n errors_query = get_errorData_query()\n error_data = execute_query(errors_query)\n print_error_data(error_data)","def get_html_pages(self, honeypotid):\n req = {\"type\": \"get_html_pages\",\n \"to\": honeypotid,\n \"from\": self.network.mc_id}\n expect_dict = {\"type\": \"send_html_pages\"}\n msg_list = self.send_receive(req, honeypotid, expect_dict)\n answer = \"\"\n i = 0;\n for msg in msg_list[0]['pages']:\n mainHTMLfilename = self.home_dir + \"/\" + msg_list[0][\"from\"] + \"_\" + str(i) + \"_\" + msg['url'].replace(\"/\",\n \"_\") + \"_login.html\"\n dashboardHTMLfilename = self.home_dir + \"/\" + msg_list[0][\"from\"] + \"_\" + str(i) + \"_\" + msg['url'].replace(\"/\",\n \"_\") + \"_dashboard.html\"\n answer = answer + \"Main HTML at: \" + mainHTMLfilename + \"\\n\"\n\n # mode w will overwrite already existent files\n with open(mainHTMLfilename, 'w') as f:\n f.write(msg[\"html\"])\n if not msg[\"dashboard\"] == \"None\":\n answer = answer + \"Dashboard HTML at: \" + dashboardHTMLfilename + \"\\n\"\n with open(dashboardHTMLfilename, 'w') as f:\n f.write(msg[\"dashboard\"])\n i = i + 1\n return answer # json.dumps(req) + \"\\n\" + msg_list[0][\"pages\"][0][\"url\"]","def __init__(self, result_files):\n self.result_files = result_files\n\n root_dir = os.getcwd()\n os.chdir('results')\n\n self._go_through_summary_reports()\n\n os.chdir(root_dir)","def generate(self, conf, env, data):\n\n path = joinurl(conf['output_dir'], self.path)\n sm = Map()\n\n pages = []\n for i in env.globals.pages:\n pages.append(i.slug)\n for i in env.globals.entrylist:\n pages.append(i.slug)\n\n if exists(path) and not self.modified and not conf.modified:\n event.skip('sitemap', path)\n raise StopIteration\n for ns, fname in self.files:\n\n if ns == 'page' or ns == 'entry' or ns == 'index':\n pass\n else:\n continue\n\n permalink = '/' + fname.replace(conf['output_dir'], '')\n permalink = rchop(permalink, 'index.html')\n url = conf['www_root'] + permalink\n\n priority, changefreq = self.scores.get(ns, (0.5, 'weekly'))\n\n _pages = env.globals.entrylist + env.globals.pages\n\n for i in _pages:\n if permalink.strip('/') in pages:\n if i.slug.strip('/') == permalink.strip('/'):\n pages.remove(permalink.strip('/'))\n video = re.search('youtube.com/(v/|watch\\?v=|embed/)([a-zA-Z0-9\\-_]*)', i.content)\n if video:\n yt = video.group().split('/')[-1]\n sm.add(url, yt, i.title, i.metadesc, getmtime(fname), changefreq, priority)\n\n sm.finish()\n yield sm, path","def offline_copy(_export_path):\n global export_path\n export_path = _export_path\n \n # First, monkey patch the original config\n main.NBCONFIG.protectect_dirs = []\n main.NBCONFIG.protected_users = {}\n main.NBCONFIG.edit_users = {}\n \n # Now monkey patch NBweb\n main.REQUIRELOGIN = False\n\n pages = []\n\n # Copy and work all source files \n for dirpath,dirnames,filenames in os.walk(NBCONFIG.source):\n for dirname in dirnames[:]: # Iterate a copy since we will delete in place\n if any(dirname.startswith(i) for i in ['.']):\n dirnames.remove(dirname) # So we do not parse it later\n continue\n if dirname == '_scratch':\n dirnames.remove(dirname) # So we do not parse it later\n continue\n \n # Names\n src_systemname = os.path.join(dirpath,dirname)\n rootname = os.path.relpath(src_systemname,NBCONFIG.source) # No leading / though\n dest_systemname = os.path.join(export_path,rootname)\n \n mkdir(rootname,isfile=False) # Will make the dir no matter what\n \n # Index\n dest = os.path.join(export_path,rootname, 'index.html')\n \n # Exclusions.\n if main.exclusion_check(utils.join('/',rootname +'/')):\n with open(dest,'w',encoding='utf8') as FF:\n FF.write('')\n continue\n \n try:\n html = main.main_route('/' + rootname + '/')\n except HTTPError:\n # Likely some additional resource in _NBweb\n try:\n os.rmdir(dest_systemname) # Should be empty\n except OSError:\n pass\n os.symlink(src_systemname,dest_systemname)\n continue\n \n \n html = process_page(html,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n \n # _all\n dest = os.path.join(export_path,'_all',rootname, 'index.html')\n mkdir(dest,isfile=True,isfull=True)\n \n html = main.allpage('/'+ rootname +'/')\n html = process_page(html,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n \n \n # Loop each file\n for filename in filenames:\n if os.path.splitext(filename)[0] == 'index':\n continue # Already made above\n \n # Names\n src_systemname = os.path.join(dirpath,filename)\n rootname = os.path.relpath(src_systemname,NBCONFIG.source) # No leading / though\n dest_systemname = os.path.join(export_path,rootname)\n \n mkdir(rootname,isfile=True) # Will make the dir no matter what\n try:\n os.symlink(src_systemname,dest_systemname) \n except OSError:\n os.remove(dest_systemname)\n os.symlink(src_systemname,dest_systemname)\n \n rootbasename,ext = os.path.splitext(rootname)\n if ext in NBCONFIG.extensions:\n dest = os.path.join(export_path,rootbasename + '.html')\n try:\n html = main.main_route(rootbasename + '.html')\n except:\n print('Issue with: {}'.format(rootname))\n \n html = process_page(html,dest)\n \n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n pages.append(rootbasename)\n\n ## Index pages\n # Home page w/o blog\n dest_systemname = os.path.join(export_path,'')\n dest = os.path.join(export_path,'index.html')\n \n html0 = main.main_route('/',map_view=True)\n \n html = process_page(html0,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n\n # Also write the sitemap\n dest = os.path.join(export_path,'_sitemap/index.html')\n mkdir('/_sitemap',isfile=False)\n html = process_page(html0,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n \n # _all\n dest = os.path.join(export_path,'_all','index.html')\n \n html = main.allpage('/')\n html = process_page(html,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n \n ## Blog Pages\n if len(NBCONFIG.blog_dirs) > 0:\n blog_num = 0\n while True:\n dest = os.path.join(export_path,'_blog',unicode(blog_num),'index.html')\n \n try:\n html = main.main_route('/',map_view=False,blog_num=blog_num)\n except HTTPError:\n break # At the last one\n \n mkdir(dest,isfile=True,isfull=True) \n \n html = process_page(html,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n blog_num += 1\n # Make the home page. \n dest = os.path.join(export_path,'index.html')\n html = main.main_route('/',map_view=False,blog_num=0)\n html = process_page(html,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n \n ## Special Pages\n make_random_forward(pages)\n \n # Tags\n dest = os.path.join(export_path,'_tags/index.html')\n mkdir(dest,isfile=True,isfull=True) \n html = main.return_tags()\n html = process_page(html,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n \n # ToDos\n dest = os.path.join(export_path,'_todo/index.html')\n mkdir(dest,isfile=True,isfull=True) \n html = main.return_todo()\n html = process_page(html,dest)\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(html)\n \n txt = main.return_todo_txt()\n dest = os.path.join(export_path,'_todo/todo.txt')\n with open(dest,'w',encoding='utf8') as FF:\n FF.write(txt)\n \n # Galleries\n cpsym( utils.join(NBCONFIG.scratch_path,'_galleries'),utils.join(export_path,'_galleries'))\n \n ## Clean up\n for F in [utils.join(export_path,'_NBweb',a) for a in ['NBCONFIG.py','NBCONFIG.pyc','template.html']]:\n try:\n os.remove(F)\n except:\n pass\n \n # Make sure there are never any directory listings\n for dirpath,dirnames,filenames in os.walk(export_path):\n if 'index.html' not in filenames:\n with open(utils.join(dirpath,'index.html'),'w',encoding='utf8') as F:\n F.write('')","def write_html_main_index(links: List[Link], out_dir: Path=OUTPUT_DIR, finished: bool=False) -> None:\n\n copy_and_overwrite(str(Path(TEMPLATES_DIR) / FAVICON_FILENAME), str(out_dir / FAVICON_FILENAME))\n copy_and_overwrite(str(Path(TEMPLATES_DIR) / ROBOTS_TXT_FILENAME), str(out_dir / ROBOTS_TXT_FILENAME))\n copy_and_overwrite(str(Path(TEMPLATES_DIR) / STATIC_DIR_NAME), str(out_dir / STATIC_DIR_NAME))\n \n rendered_html = main_index_template(links, finished=finished)\n atomic_write(str(out_dir / HTML_INDEX_FILENAME), rendered_html)","def main(self):\n\t\thtml_file = codecs.open(\"./templates/results.html\",'w','utf-8')\n\t\thtml_file.write(\"\"\"<!DOCTYPE html>\\n<html lang=\"en\"><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">\\n<meta charset=\"utf-8\">\\n<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\\n<meta name=\"description\" content=\"Results page for Yelp Road Trip app\">\\n<meta name=\"author\" content=\"Alexander Ko\">\\n\\n<title>Yelp Road Trip results</title>\\n\\n<!-- Bootstrap core CSS -->\\n<link href=\"./../static/css/bootstrap.min.css\" rel=\"stylesheet\">\\n<!-- Custom styles for this template -->\\n<link href=\"./../static/css/jumbotron-narrow.css\" rel=\"stylesheet\">\\n<link href=\"./../static/css/navbar-fixed-top.css\" rel=\"stylesheet\">\\n\\n</head>\\n\\n\\n<body class=\" hasGoogleVoiceExt\">\\n\\n<div class=\"container\">\\n\\n<nav class=\"navbar navbar-default navbar-fixed-top\" role=\"navigation\">\\n <div class=\"container-fluid\">\\n <!-- Brand and toggle get grouped for better mobile display -->\\n <div class=\"navbar-header\">\\n <button type=\"button\" class=\"navbar-toggle\" data-toggle=\"collapse\" data-target=\"#bs-example-navbar-collapse-1\">\\n <span class=\"sr-only\">Toggle navigation</span>\\n <span class=\"icon-bar\"></span>\\n <span class=\"icon-bar\"></span>\\n <span class=\"icon-bar\"></span>\\n </button>\\n <a class=\"navbar-brand\" href=\"{{ url_for(\\'show_input_form\\') }}\">Yelp Road Trip</a>\\n\\n <!--<div class=\"page-header\">\\n <h1>Yelp</h1>\\n <div class=\"tagline\">Road trip</div>\\n </div>-->\\n </div>\\n\\n <!-- Collect the nav links, forms, and other content for toggling -->\\n <div class=\"collapse navbar-collapse\" id=\"bs-example-navbar-collapse-1\">\\n <ul class=\"nav navbar-nav\">\\n <li><a href=\"{{ url_for(\\'map\\') }}\">Map</a></li>\\n <li class=\"active\"><a href=\"#\">Results</a></li>\\n </ul>\\n\\n </div><!-- /.navbar-collapse -->\\n </div><!-- /.container-fluid -->\\n</nav>\\n\\n<div class=\"row marketing\">\"\"\")\n\n\t\t# I do this twice bc there are 2 columns for the HTML file\n\t\tself.write_resturants(self.sorted_resto_keys[:4], html_file)\n\t\thtml_file.write('\\n</div>\\n')\n\t\tself.write_resturants(self.sorted_resto_keys[4:], html_file)\n\n\t\thtml_file.write(\"\"\"\\n</div> <!-- /container -->\\n\\n\\n<!-- Bootstrap core JavaScript\\n================================================== -->\\n<!-- Placed at the end of the document so the pages load faster -->\\n\\n\\n<iframe id=\"rdbIndicator\" width=\"100%\" height=\"270\" border=\"0\" src=\"./results_files/indicator.html\" style=\"display: none; border: 0; position: fixed; left: 0; top: 0; z-index: 2147483647\"></iframe></body></html>\"\"\")\n\n\t\thtml_file.close()","def build_pages(ctx, show=False):\n\n sys.path.insert(0, os.path.join(ROOT_DIR, '_docs'))\n import pages\n import webbrowser\n\n # Update all readmes first\n lines = subprocess.getoutput(['invoke', '-l']).splitlines()\n lines = [line.strip().split(' ')[0] for line in lines if line.count('.update-readme')]\n for line in lines:\n print(subprocess.getoutput(['invoke', line]))\n\n pages.build(True, False)\n if show:\n webbrowser.open(os.path.join(ROOT_DIR, '_docs', '_pages', 'index.html'))","def load_results(self):\n self.find_benchmark_directories()\n for (benchmark, producer), result in self.results.items():\n print('Reading results for ' + benchmark + ' ' + producer)\n if not result.directory:\n print('No results found for ' + benchmark + ' ' + producer)\n else:\n print('Generating report for: ' + result.directory)\n report = Report(result.directory)\n result.reports = report.generate()","def setup_output_path(self):\n self.logger.info('setting up output path')\n try:\n self.output_path.mkdir()\n except FileExistsError:\n pass\n try:\n (self.output_path / 'simple').mkdir()\n except FileExistsError:\n pass\n for filename in resource_listdir(__name__, 'static'):\n if filename == 'index.html':\n # Skip template\n continue\n with (self.output_path / filename).open('wb') as f:\n source = resource_stream(__name__, 'static/' + filename)\n f.write(source.read())\n source.close()","def gather_all_profiles(year, month):\n page = 1\n urls = []\n\n print(\"{}-{} : Begin indexing.\".format(year, month))\n\n while (page > 0):\n urlstring = \"http://scamdigger.com/{}/{}/page/{}\".format(year,month,page) \n jitter = random.choice([0,1])\n try:\n urlhandle = urlopen(urlstring)\n urls += enumerate_profiles(urlhandle, page)\n # time.sleep(1+jitter)\n page += 1\n except:\n page = 0\n\n print(\"{}-{} : {} profiles\".format(year,month,len(urls)))\n\n for url in urls:\n uid = url[30:-1]\n outfile=PROFILES+os.sep+uid+'.json'\n jitter = random.choice([0,1])\n try:\n urlhandle = urlopen(url)\n scrape_profile(urlhandle, outfile, year, month)\n # time.sleep(1+jitter)\n except Exception as e:\n print(\"Exception when handling {}\".format(url))\n print(e)\n \n print(\"{}-{} : complete.\".format(year,month))","def populate_index(db):\n\tfor url in URL:\n\t\tprint url\n\t\trequest = urllib2.Request(url)\n\t\ttry :\n\t\t\tresponse = urllib2.urlopen(request)\n\t\texcept urllib2.URLError:\n\t\t\tprint \"Network Unreachable \"\n\t\t\tsys.exit()\t\n\t\ttext = html2text(response.read())\n\t\tdb.generate_index(text,url)","def go(self):\n self.analyse_folder(BASE)\n self.analyse_folder(JS_FOLDER)","def dispatch(self, request, *args, **kwargs):\n try:\n self.copy_static_resources()\n except MissingStaticRoot:\n self.template_name = 'general_error.html'\n kwargs['error'] = _('There is no STATIC_ROOT defined in the settings file')\n return super().dispatch(request, *args, **kwargs)\n except Exception as e:\n self.template_name = 'general_error.html'\n kwargs['error'] = str(e)\n return super().dispatch(request, *args, **kwargs)\n cms_pages = Page.objects.filter(publication_date__isnull=False)\n for page in cms_pages:\n languages = page.get_languages()\n for language in languages:\n url = page.get_public_url(language)\n if url not in self.done:\n self.done.append(url)\n static_page_path = '{}{}index.html'.format(STORAGE_PATH, url)\n fetch_url = \"{}{}\".format(self.SOURCE_DOMAIN, url)\n response = requests.get(fetch_url)\n make_dir(url)\n with open(static_page_path, 'w') as file:\n file.write(response.text)\n return super().dispatch(request, *args, **kwargs)","def ui_backgrounds(request):\n out = createBaseResponseObject() \n path = os.path.join(settings.BASE_PATH , \"sketch_ui/static/ui/backgrounds\")\n files = os.listdir(path)\n for f in files:\n out['results'].append(f)\n \n return HttpResponse(json.dumps(out))","def main():\n\n app_config = load_config()\n database_connection = mysql.connector.connect(**app_config[\"database\"])\n panelists = retrieve_all_panelist_appearance_counts(database_connection)\n show_years = retrieve_all_years(database_connection)\n\n rendered_report = render_report(show_years=show_years,\n panelists=panelists,\n report_settings=app_config[\"report\"])\n\n generate_output_files(rendered_report=rendered_report,\n report_settings=app_config[\"report\"])","def parse(self, response):\n json_response = json.loads(response.text)\n fetched_results = len(json_response['results'])\n\n if not hasattr(self, 'processed_results'):\n self.processed_results = 0\n self.processed_results += fetched_results\n if fetched_results == 0:\n logging.info('No more files. Total files queried {}'.format(\n self.processed_results))\n return\n\n for result in json_response['results']:\n document = self._create_document(result['columns'])\n if document['language'] != u'ENG':\n info = 'Case {} {} not in ENG, original language {}'.format(\n document['original_id'], document['name'].encode('utf-8'),\n result['columns']['languageisocode'])\n logging.info(info)\n continue\n doc_url = self.base_document_url.format(document['original_id'])\n new_request = scrapy.Request(doc_url, callback=self.parse_document)\n new_request.meta['document'] = document\n yield new_request\n\n if self.processed_results < int(getattr(self, 'limit', DEFAULT_LIMIT)):\n next_url = self.base_main_url.format(\n start_index=self.processed_results, length=RESULT_PER_PAGE)\n yield scrapy.Request(next_url, callback=self.parse)\n else:\n logging.info('Limit reached. Total files obtained {}'.format(\n self.processed_results))","def generate(self):\n\n # Load the required datapoints into memory.\n self._load_results()\n\n # Calculate datapoints statistics, like min. and max. values.\n self._calc_stats()\n\n # Generate the plots.\n self._generate_scatter_plots()\n self._generate_histograms()\n\n # Put together the final HTML report.\n self._generate_report()","def main():\n goods = '书包'\n # 爬取深度\n depth = 3\n start_url = 'https://s.taobao.com/search?q=' + goods\n # 输出结果的列表\n infoList = []\n # 使用for循环对每一个页面进行处理\n for i in range(depth):\n try:\n # 每个页面的URL链接\n url = start_url + '' + str(44*i)\n html = getHTMLText(url)\n parsePage(infoList, html)\n except:\n continue\n printGoodsList(infoList)","def run(self):\n not_modules = []\n root = self.path\n files = []\n search_files = [\n '__openerp__.py', '__manifest__.py', 'README.rst', 'index.html']\n for sfile in search_files:\n files += subprocess.Popen(\n ['find', root, '-name', sfile],\n stdout=subprocess.PIPE).stdout.readlines()\n files.sort()\n files = [item.strip() for item in files]\n\n if os.path.isfile(os.path.join(root, '__openerp__.py')) or \\\n os.path.isfile(os.path.join(root, '__manifest__.py')):\n module_list = [os.path.basename(root)]\n root = os.path.split(root)[0]\n self.path = root\n else:\n module_list = os.walk(root).next()[1]\n if module_list.count('.git'):\n module_list.remove('.git')\n module_list.sort()\n\n for module in module_list:\n os.system('echo Generating index.html module ' + module)\n openerp_py = os.path.join(root, module, '__openerp__.py')\n readme_file = os.path.join(root, module, 'README.rst')\n index_file = os.path.join(\n root, module, 'static/description/index.html')\n\n if openerp_py not in files:\n openerp_py = os.path.join(root, module, '__manifest__.py')\n if openerp_py not in files:\n not_modules.append(module)\n continue\n\n # Get module data\n description = ''\n name, summary, description = self.get_module_data(\n openerp_py, readme_file)\n\n # Call @nhomar's script.\n html_description = rst2html.html.rst2html(description)\n\n content = self.prepare_content(html_description, name, summary)\n\n self.add_missing_dirs(index_file)\n self.add_missing_icon(module)\n\n with open(index_file, 'w') as ifile:\n ifile.write(content)\n\n if not_modules:\n for item in not_modules:\n print 'NOTE: This is not an odoo module', item\n return True","def get_pages(self, url_list):\n page_helper = self.get_page\n pool = ThreadPool(self.max_threads)\n results = pool.map(page_helper, url_list)\n pool.close()\n pool.join()\n return results","def perf_result_page():\n # Get all fields from form\n module = request.forms.getall('module')\n version = request.forms.getall('version')\n script = request.forms.getall('script')\n tag = request.forms.getall('tag')\n value_inf = request.forms.get('value_inf')\n value_sup = request.forms.get('value_sup')\n # Build html\n result = do_perf_request(module_type=module, version=version, tag=tag,\n value_inf=value_inf, value_sup=value_sup,\n script_name=script)\n\n try:\n kibana_query = 'computer_name:parrotsa* AND name:{0} AND module:{1}'.format(tag[0], module[0])\n except IndexError:\n kibana_query = '*'\n kibana_url = \"http://172.20.22.104:5601/app/kibana#/dashboard/performance?_a=(query:(query_string:(query:'{0}')))\".format(kibana_query)\n print result\n print kibana_url\n # Build template page\n with open(\"./header.html\") as header, open('./perf.tpl') as perf, open('./footer.html') as footer:\n template_html = header.read() + perf.read() + footer.read()\n\n if result:\n output = template(template_html, result=result, kibana_url=kibana_url)\n else:\n output = template(template_html, result=[], kibana_url=kibana_url)\n\n return output","def make_validation_report(\n urls=None,\n destdir=\"astropy.io.votable.validator.results\",\n multiprocess=True,\n stilts=None,\n):\n from astropy.utils.console import ProgressBar, Spinner, color_print\n\n if stilts is not None:\n if not os.path.exists(stilts):\n raise ValueError(f\"{stilts} does not exist.\")\n\n destdir = os.path.expanduser(destdir)\n destdir = os.path.abspath(destdir)\n\n if urls is None:\n with Spinner(\"Loading URLs\", \"green\") as s:\n urls = get_urls(destdir, s)\n else:\n urls = [url.encode() for url in urls if isinstance(url, str)]\n\n color_print(\"Marking URLs\", \"green\")\n for url in ProgressBar(urls):\n with result.Result(url, root=destdir) as r:\n r[\"expected\"] = type\n\n args = [(url, destdir) for url in urls]\n\n color_print(\"Downloading VO files\", \"green\")\n ProgressBar.map(download, args, multiprocess=multiprocess)\n\n color_print(\"Validating VO files\", \"green\")\n ProgressBar.map(validate_vo, args, multiprocess=multiprocess)\n\n if stilts is not None:\n color_print(\"Validating with votlint\", \"green\")\n votlint_args = [(stilts, x, destdir) for x in urls]\n ProgressBar.map(votlint_validate, votlint_args, multiprocess=multiprocess)\n\n color_print(\"Generating HTML files\", \"green\")\n ProgressBar.map(write_html_result, args, multiprocess=multiprocess)\n\n with Spinner(\"Grouping results\", \"green\") as s:\n subsets = result.get_result_subsets(urls, destdir, s)\n\n color_print(\"Generating index\", \"green\")\n html.write_index(subsets, urls, destdir)\n\n color_print(\"Generating subindices\", \"green\")\n subindex_args = [(subset, destdir, len(urls)) for subset in subsets]\n ProgressBar.map(write_subindex, subindex_args, multiprocess=multiprocess)","def index():\n\n page = \"\"\"\n <h1>Calculator</h1>\n <div>Directions. This app will calculate 2 or more numbers provided in the url string. To use:\n <ol>\n <li>Type in http://localhost:8080/</li>\n <li>Type in the arithmetic operation (add, subract, multiply, divide) followed by /</li>\n <li>Type in numbers. Between each number include a /</li>\n <li>For example, http://localhost:8080/add/5/10/</li>\n </ol></div>\n <h2>Tests:</h2><ul>\n <li><a href=\"http://localhost:8080/add/5/10/15\">Addition</a></li>\n <li><a href=\"http://localhost:8080/subtract/100/50/25\">Subraction</a></li>\n <li><a href=\"http://localhost:8080/multiply/5/10/15\">Multiplication</a></li>\n <li><a href=\"http://localhost:8080/divide/100/50\">Division</a></li>\n \"\"\"\n return page","def _go_through_summary_reports(self):\n\n for result_file in self.result_files:\n self.cur_8digit_dir = os.path.split(result_file)[0]\n try:\n with open(result_file) as f_in:\n sum_rep = json.load(f_in)\n if sum_rep.has_key('Artifacts'):\n for linked_artifact in sum_rep['Artifacts']:\n artifact_path = linked_artifact['Path']\n # For now assume only files are linked (no folders)\n rel_path_from_results = os.path.join(self.cur_8digit_dir, artifact_path)\n if os.path.exists(rel_path_from_results):\n self.files_for_export.append(os.path.join('results',\n rel_path_from_results))\n if artifact_path.endswith('.json'):\n function_tag = artifact_path.replace('.','_').replace('/','_')\n\n if hasattr(self, function_tag):\n getattr(self, function_tag)()\n except IOError:\n print '{0} does not exist on this filesystem. I cannot be check for references '\\\n 'to other files.'.format(result_file)","def get_results():\n # store info in a dictionary {name -> shortname}\n res = {}\n session = requests.Session()\n handle_url('http://www.gocomics.com/features', session, res)\n handle_url('http://www.gocomics.com/explore/editorial_list', session, res)\n handle_url('http://www.gocomics.com/explore/sherpa_list', session, res)\n save_result(res, json_file)","def test_three_paginated_list_pages():\n\n TEST_WEBSITE.wipe()\n _clean_up_test_items_md()\n _generate_test_items_md(10)\n\n Webpage.write_list_pages_from_directory(TEST_WEBSITE, TEST_WEBSITE.config.value('source_path'))\n\n # There should be an index.html and exactly 2 blog-n.html files\n assert path.isfile(TEST_WEBSITE.config.value('output_path') + 'index.html')\n assert not path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-1.html')\n assert path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-2.html')\n assert path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-3.html')\n assert not path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-4.html')\n\n with open(TEST_WEBSITE.config.value('output_path') + 'index.html', 'r') as myfile:\n blog_1_content = myfile.read()\n\n with open(TEST_WEBSITE.config.value('output_path') + 'blog-2.html', 'r') as myfile:\n blog_2_content = myfile.read()\n\n with open(TEST_WEBSITE.config.value('output_path') + 'blog-3.html', 'r') as myfile:\n blog_3_content = myfile.read()\n\n assert blog_1_content.count('<article>') == 4\n assert 'Article 10.' in blog_1_content\n assert 'Article 9.' in blog_1_content\n assert 'Article 8.' in blog_1_content\n assert 'Article 7.' in blog_1_content\n assert '<p>Listing page template</p>' in blog_1_content\n\n\n assert blog_2_content.count('<article>') == 4\n assert 'Article 6.' in blog_2_content\n assert 'Article 5.' in blog_2_content\n assert 'Article 4.' in blog_2_content\n assert 'Article 3.' in blog_2_content\n assert '<p>Listing page template</p>' in blog_2_content\n\n assert blog_3_content.count('<article>') == 2\n assert 'Article 2.' in blog_3_content\n assert 'Article 1.' in blog_3_content\n assert '<p>Listing page template</p>' in blog_3_content\n\n\n # Page title = \"Website Name - Page n\"\n assert 'Test website name - test tag & line' in blog_1_content\n assert '<title>Test website name - Page 2</title>' in blog_2_content\n assert '<title>Test website name - Page 3</title>' in blog_3_content\n\n # First page should have link to older posts but not newer\n assert '<a href=\"blog-2.html\" class=\"magnetizer-next\">Older posts</a>' in blog_1_content\n assert 'class=\"magnetizer-previous\"' not in blog_1_content\n\n # Middle page should have link to older posts (i.e. homepage) and newer\n assert '<a href=\"blog-3.html\" class=\"magnetizer-next\">Older posts</a>' in blog_2_content\n assert '<a href=\"/\" class=\"magnetizer-previous\">Newer posts</a>' in blog_2_content\n\n # Last page should have link to newer posts but not older\n assert 'class=\"magnetizer-next\"' not in blog_3_content\n assert '<a href=\"blog-2.html\" class=\"magnetizer-previous\">Newer posts</a>' in blog_3_content\n\n # Pages should have meta description from config\n assert '<meta name=\"description\" content=\"Meta \\\\\"description\\\\\" from cfg\">' in blog_1_content\n assert '<meta name=\"description\" content=\"Meta \\\\\"description\\\\\" from cfg\">' in blog_2_content\n assert '<meta name=\"description\" content=\"Meta \\\\\"description\\\\\" from cfg\">' in blog_3_content\n\n # index.html and the blog-n pages should be present in the sitemap\n assert 'https://example.com/' in TEST_WEBSITE.sitemap.pages\n assert not 'https://example.com/blog-1.html' in TEST_WEBSITE.sitemap.pages\n assert 'https://example.com/blog-2.html' in TEST_WEBSITE.sitemap.pages\n assert 'https://example.com/blog-3.html' in TEST_WEBSITE.sitemap.pages","def GenerateResults(self, want_combos, filename):\n\n all = ENTRIES_FINISH_CATEGORIES\n ord = orderByIncreasingBitCount(len(all))\n qgt = QueryGeneratorTop(self, 'entries', all)\n\n restrict = None\n if not None is want_combos:\n restrict = self._generateResults_combosToBitmasks(all, want_combos)\n print \"Restrict report to:\", restrict\n\n self.StartReport(REPORT_TITLE, filename)\n for i in ord:\n if len(restrict) > 0 and not i in restrict:\n continue\n qg = QueryGenerator(qgt, i, self.CompileReport)\n qg.GenerateResultCombinations()\n self.ReportDNFs()\n self.ReportMissings()\n self.FinishReport()","def do_html(pidx):\n response_headers = [(\"Content-type\", \"text/html\")]\n name = get_script_name(pidx)\n if not os.path.isfile(name):\n sys.stderr.write(f\"autoplot/meta 404 {name}\\n\")\n status = \"404 Not Found\"\n output = \"\"\n return output.encode(), status, response_headers\n loader = importlib.machinery.SourceFileLoader(f\"p{pidx}\", name)\n spec = importlib.util.spec_from_loader(loader.name, loader)\n mod = importlib.util.module_from_spec(spec)\n loader.exec_module(mod)\n # see how we are called, finally\n appdata = mod.get_description()\n html = generate_html(appdata)\n return html, \"200 OK\", response_headers","def index(*args, **kwargs):\n yield from _generate(*args, **kwargs)","def get_results():\n # store info in a dictionary {name -> shortname}\n res = {}\n session = requests.Session()\n handle_url('http://www.creators.com/comics/cat-seeall.html', session, res)\n save_result(res, json_file)","def main():\n # %%\n CFG.profiles_yamls_path.mkdir(parents=True, exist_ok=True)\n fpaths = list( _Config.raw_profiles_path.glob('*.html') )\n print( f'{len(fpaths)} htmls found' )\n # %%\n fpath = CFG.raw_profiles_path / 'luis-mario-urrea-murillo.html'\n # %%\n fpath = CFG.raw_profiles_path / 'cristian-david-montoya-saldarriaga-09638514a.html'\n # %%\n fpaths = [ CFG.raw_profiles_path / 'ricardo-alarcon-44079b105.html' ]\n # %%\n fpaths = [ Path('/home/teo/_data/talent/linkedin_raw_profiles/israellaguan.html')]\n # %%\n dics = {}\n # %%\n\n for i, fpath in enumerate(fpaths):\n if fpath in dics:\n continue\n\n with fpath.open('rt') as f_in:\n html = f_in.read()\n\n print( f'\\n***{i+1}/{len(fpaths)} {fpath.name}:')\n dic = extract_one( html, fpath )\n dic['linkedin_url'] = f\"https://www.linkedin.com/in/{fpath.name.split('.')[0]}\"\n dic['scraped_at'] = dt.datetime.fromtimestamp( fpath.stat().st_ctime )\n # pprint(dic['work_stats'])\n dics[fpath] = dic\n\n dics_arr = list(dics.values())\n # %%\n del dics\n # %%\n\n with (CFG.profiles_yamls_path / 'all_profiles.json').open('wt') as f_out:\n json.dump( dics_arr, f_out, cls=DateTimeEncoder, indent=4 )\n # %%\n with (CFG.profiles_yamls_path / 'all_profiles.yaml').open('wt') as f_out:\n yaml.safe_dump( dics_arr, f_out )\n # %%\n df = produce_summary_table( dics_arr )\n df.to_excel( CFG.raw_profiles_path.parent / 'mined_ruby_candidates_sample.xlsx',\n index=False)\n # %%","async def test_get_multiple_pages():\n writer = SimpleWriter()\n work_queue = asyncio.Queue()\n await work_queue.put(TestData.JOB_TEMPLATE_PAYLOAD_ALL_PAGES)\n worker = tower_api_worker.TowerApiWorker(TestData.config, writer, work_queue)\n headers = {\"Content-Type\": \"application/json\"}\n with aioresponses() as mocked:\n mocked.get(\n TestData.JOB_TEMPLATES_LIST_URL,\n status=200,\n body=json.dumps(TestData.JOB_TEMPLATES_PAGE1_RESPONSE),\n headers=headers,\n )\n mocked.get(\n TestData.JOB_TEMPLATES_LIST_URL_PAGE_2,\n status=200,\n body=json.dumps(TestData.JOB_TEMPLATES_PAGE2_RESPONSE),\n headers=headers,\n )\n res = await worker.start()\n assert writer.data[\"count\"] == 3\n assert writer.called == 2","def make_html(depends=(files['image.gif'],),\n targets=(files['index.html'],)):\n\n index_html = open(files['index.html'].rel, 'w')\n index_html.write(pyyaks.context.render(html_template))\n index_html.close()","def main():\n\n browser = initialize()\n process_directory(browser, \"data\")\n browser.close()"],"string":"[\n \"def main():\\n for file_name in os.listdir(CONTENT_FOLDER):\\n if file_name.endswith('.html'):\\n try_generate_page(file_name)\",\n \"def make_all_html_results(cmd, folder_names = [], jobs=[]):\\n run = cmd.results.current['run_name']\\n if not os.path.exists(pjoin(cmd.me_dir, 'HTML', run)):\\n os.mkdir(pjoin(cmd.me_dir, 'HTML', run))\\n \\n unit = cmd.results.unit\\n P_text = \\\"\\\" \\n Presults = collect_result(cmd, folder_names=folder_names, jobs=jobs)\\n \\n for P_comb in Presults:\\n P_text += P_comb.get_html(run, unit, cmd.me_dir) \\n P_comb.compute_values()\\n if cmd.proc_characteristics['ninitial'] == 1:\\n P_comb.write_results_dat(pjoin(cmd.me_dir, 'SubProcesses', P_comb.name,\\n '%s_results.dat' % run))\\n \\n Presults.write_results_dat(pjoin(cmd.me_dir,'SubProcesses', 'results.dat')) \\n \\n fsock = open(pjoin(cmd.me_dir, 'HTML', run, 'results.html'),'w')\\n fsock.write(results_header)\\n fsock.write('%s <dl>' % Presults.get_html(run, unit, cmd.me_dir))\\n fsock.write('%s </dl></body>' % P_text)\\n\\n return Presults.xsec, Presults.xerru\",\n \"def makeHTMLIndexFile(self):\\n part1 = \\\"\\\"\\\"<html>\\n <body>\\n <title>Index</title>\\n <div id=\\\"pg_body\\\">\\n <div id=\\\"testSuitesTitle\\\">TestSuites</div>\\n <div id=\\\"resultsTitle\\\">Results</div>\\n <div id=\\\"testSuites\\\">\\n \\\"\\\"\\\"\\n part2 = self.makeLinks()\\n part3 = \\\"\\\"\\\"</div>\\n <div id=\\\"results\\\">\\n <iframe id=\\\"loadHTMLResults\\\" name=\\\"loadHTMLResults\\\" frameborder=\\\"0\\\" src=\\\"statistics.html\\\" style=\\\"height:100%;width:100%;\\\"></iframe>\\n </div>\\n <div id=\\\"footer\\\">Test Engineer(s) :\\\"\\\"\\\"+testEngineers+\\\"\\\"\\\"</div>\\n </div>\\n </body>\\n </html>\\n\\t\\t<style>\\n\\t\\tbody{\\n margin:0;\\n }\\n\\t\\t#pg_body{\\n\\t\\twidth=100%;\\n\\t\\ttext-align:center;\\n\\t\\t}\\n\\t\\t#testSuitesTitle{\\n\\t\\twidth:25%;\\n\\t\\tfloat:left;\\n\\t\\tbackground-color:#6495ED;\\n\\t\\tfont-weight:bold;\\n\\t\\tcolor:white;\\n\\t\\t}\\n\\t\\t#resultsTitle{\\n\\t\\twidth:75%;\\n\\t\\tfloat:right;\\n\\t\\tbackground-color:#6495ED;\\n\\t\\tfont-weight:bold;\\n\\t\\tcolor:white;\\n\\t\\t}\\n\\t\\t#testSuites{\\n\\t\\twidth:25%;\\n\\t\\tfloat:left;\\n\\t\\tbackground-color:lightgrey;\\n\\t\\tfont-weight:bold;\\n\\t\\ttext-align:left;\\n\\t\\theight:94%;\\n\\t\\toverflow:scroll;\\n\\t\\t}\\n\\t\\t#results{\\n\\t\\twidth:75%;\\n\\t\\tbackground-color:white;\\n\\t\\tfloat:right;\\n\\t\\ttext-align:left;\\n\\t\\theight:94%;\\n\\t\\toverflow:scroll;\\n\\t\\t}\\n\\t\\t#footer{\\n\\t\\twidth:100%;\\n\\t\\ttext-align:left;\\n\\t\\tcolor:lightgrey;\\n\\t\\tbackground-color:#6495ED;\\n\\t\\t}\\n\\t\\t</style>\\n \\\"\\\"\\\"\\n \\n page = (part1+part2+part3)\\n f = open(self.dir+'/index.html','w')\\n f.write(page)\\n f.close\",\n \"def collect_html(args):\\n url_list = args.url_list\\n output_dir = args.output_dir\\n\\n print(url_list)\\n\\n # do some checks\\n try: \\n assert os.path.exists(url_list), 'url_list must exist'\\n assert os.path.exists(output_dir), 'output_dir must exist'\\n except AssertionError as err: \\n logger.error('Failed check: {}'.format(err)) \\n return \\n\\n urls = common.read_file(url_list)\\n \\n for url in urls: \\n logger.debug(url) \\n\\n html = spy_tools.collect_html(url)\\n out = url.split('/')\\n output = os.path.join(output_dir, out[-1] + '.html')\\n common.write_file(html, output)\",\n \"def generate_pages(self, writer):\\r\\n write = partial(writer.write_file,\\r\\n relative_urls=self.settings['RELATIVE_URLS'])\\r\\n\\r\\n # to minimize the number of relative path stuff modification\\r\\n # in writer, articles pass first\\r\\n self.generate_articles(write)\\r\\n self.generate_period_archives(write)\\r\\n self.generate_direct_templates(write)\\r\\n\\r\\n # and subfolders after that\\r\\n self.generate_tags(write)\\r\\n self.generate_categories(write)\\r\\n self.generate_authors(write)\\r\\n self.generate_drafts(write)\",\n \"def _gen_html(name, start_urls, session=requests.Session()):\\n files = []\\n for url in start_urls:\\n r = _fetch_url(url, session=session)\\n if r is None:\\n continue\\n\\n content = r.text.strip()\\n filename = '{0}/{1}.html'.format(FILES_DIR, name)\\n\\n url_suffix = url.split('/')[-1]\\n if '.' in url_suffix:\\n url_suffix = url_suffix.split('.')[-2]\\n if url_suffix:\\n filename = '{0}/{1}_{2}.html'.format(FILES_DIR, name, url_suffix)\\n else:\\n filename = '{0}/{1}.html'.format(FILES_DIR, name)\\n\\n with open(filename, 'w') as f:\\n f.write(content)\\n\\n print('Created {0}'.format(filename))\\n files.append(filename)\\n\\n return files\",\n \"def _do_generate(*, build, out_dir, on_error):\\n if out_dir == \\\"<test>\\\":\\n out_dir = join(os.environ[\\\"TEST_TMPDIR\\\"], \\\"_builder_out\\\")\\n if not os.path.isabs(out_dir):\\n on_error(f\\\"--out_dir={out_dir} is not an absolute path\\\")\\n if os.path.exists(out_dir):\\n if len(os.listdir(out_dir)) > 0:\\n on_error(f\\\"--out_dir={out_dir} is not empty\\\")\\n else:\\n if verbose():\\n print(f\\\"+ mkdir -p {out_dir}\\\", flush=True)\\n os.makedirs(out_dir)\\n print(\\\"Generating HTML ...\\\")\\n pages = _call_build(build=build, out_dir=out_dir)\\n assert len(pages) > 0\\n # Disallow symlinks in the output dir.\\n for root, dirs, _ in os.walk(out_dir):\\n for one_dir in dirs:\\n for entry in os.scandir(f\\\"{root}/{one_dir}\\\"):\\n assert not entry.is_symlink(), entry.path\\n print(\\\"... done\\\")\",\n \"def run(self):\\n\\n for url in self.urls:\\n try:\\n # Use requests to retrieve web page data\\n print(url)\\n response = session.get(url, ) # allow_redirects=True)\\n\\n if response.status_code != 200:\\n print('Failed to retrieve page, URL: {0}, error: {1}\\\\n'.format(url, response.status_code))\\n return\\n\\n # Get web page data from HTML response\\n content = get_json_data(response.text)\\n\\n # Compile data into dictionary to be used for reporting\\n summary_data = generate_report(content)\\n\\n # Generate/print report\\n print_report(summary_data)\\n\\n except Exception as error:\\n print('Scraper failed to run for URL {0}, error: {1}, {2}\\\\n'.format(\\n url, type(error).__name__, error\\n ))\\n\\n # time.sleep(1) # for load concerns\",\n \"def getGenerator(self):\\n coldatapage = pywikibot.Page(self.site, 'Data:Completely_indexed_painting_collections.tab')\\n collectionjson = json.loads(coldatapage.text)\\n colquery = 'SELECT ?item ?institution WHERE { VALUES ?item {'\\n\\n for collectioninfo in collectionjson.get('data'):\\n colquery += ' wd:%s' % (collectioninfo[0],)\\n colquery +=' } ?item wdt:P1612 ?institution }'\\n colsq = pywikibot.data.sparql.SparqlQuery()\\n colqueryresult = colsq.select(colquery)\\n\\n for resultitem in colqueryresult:\\n institution = resultitem.get('institution').replace(' ', '_')\\n query = 'file: hastemplate:Institution:%s incategory:Paintings_without_Wikidata_item -incategory:Paintings_from_completely_indexed_collections' % (institution,)\\n gen = pagegenerators.SearchPageGenerator(query, total=1000, namespaces=6, site=self.site)\\n for filepage in gen:\\n yield filepage\\n\\n creatordatapage = pywikibot.Page(self.site, 'Data:Completely_indexed_painters.tab')\\n creatorjson = json.loads(creatordatapage.text)\\n creatorquery = 'SELECT ?item ?creator WHERE { VALUES ?item {'\\n\\n for creatorinfo in creatorjson.get('data'):\\n creatorquery += ' wd:%s' % (creatorinfo[0],)\\n creatorquery +=' } ?item wdt:P1472 ?creator }'\\n creatorsq = pywikibot.data.sparql.SparqlQuery()\\n creatorqueryresult = creatorsq.select(creatorquery)\\n\\n for resultitem in creatorqueryresult:\\n creator = resultitem.get('creator').replace(' ', '_')\\n query = 'file: hastemplate:Creator:%s incategory:Paintings_without_Wikidata_item -incategory:Paintings_by_completely_indexed_painters' % (creator,)\\n gen = pagegenerators.SearchPageGenerator(query, total=1000, namespaces=6, site=self.site)\\n for filepage in gen:\\n yield filepage\",\n \"def gen_static(self, output_folder):\\n files = []\\n for l in self.file_listers:\\n files += l()\\n for f in files:\\n _logger.info(\\\"generating %s\\\" % f)\\n content = self.get(f)\\n loc = os.path.join(output_folder, f)\\n d = os.path.dirname(loc)\\n if not os.path.exists(d):\\n os.makedirs(d)\\n with open(loc, \\\"wb\\\") as file_:\\n file_.write(content)\",\n \"def render_all(pages):\\n for page in pages:\\n render_template(page['template'], page['output'], page['values'])\",\n \"def run(self):\\n if not os.path.exists(self.output_folder):\\n os.makedirs(self.output_folder)\\n for entry in glob.glob(os.path.join(self.data_folder, self.data_expression)):\\n f = open(entry)\\n text = json.loads(f.read())\\n f.close()\\n self.create_page_objects(text)\",\n \"def Main(base_dir, page_set_filenames):\\n runner = PageTestRunner()\\n sys.exit(runner.Run(base_dir, page_set_filenames))\",\n \"def create_web_output_paths() -> None:\\n create_path_and_index(\\\"\\\")\\n create_path_and_index(\\\"photos/\\\")\\n create_path_and_index(\\\"video/\\\")\\n create_path_and_index(\\\"references/\\\")\\n create_path_and_index(\\\"names/\\\")\\n create_path_and_index(\\\"art/\\\")\\n create_path_and_index(\\\"morphology/\\\")\\n create_path_and_index(\\\"maps/\\\")\\n create_path_and_index(\\\"images/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/css/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/flags/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/flags/4x3/\\\")\\n create_path_and_index(\\\"locations/\\\")\\n create_path_and_index(\\\"locations/keys/\\\")\\n create_path_and_index(\\\"js/\\\")\\n create_path_and_index(\\\"sizes/\\\")\\n create_path_and_index(\\\"handedness/\\\")\",\n \"def generate(self) :\\n\\n\\t\\t# Generate\\n\\t\\tcprint.section('Generation Start')\\n\\t\\tstart_time = time.time()\\n\\n\\t\\tgenerator = Generator(self)\\n\\t\\tgeneration_result = generator.generate()\\n\\n\\t\\tcost_time = round(time.time() - start_time, 2)\\n\\n\\t\\tsuccess_cnt = 0; error_cnt = 0; ignores_cnt = 0\\n\\t\\tfor sucesses, errors, ignores, _ in generation_result :\\n\\t\\t\\terror_cnt += len(errors)\\n\\t\\t\\tsuccess_cnt += len(sucesses)\\n\\t\\t\\tignores_cnt += len(ignores)\\n\\t\\t\\n\\t\\tcprint.sep('=', 'Generation completed in %s seconds (%d success %d errors %d ignored)' % (cost_time, success_cnt, error_cnt, ignores_cnt), bold=True, blue=True)\\n\\n\\n\\t\\tif 'nopub' not in self.options :\\n\\t\\t\\t# Publish\\n\\t\\t\\tstart_time = time.time()\\n\\n\\t\\t\\tpublisher = self.settings.PUBLISHER\\n\\t\\t\\tpublisher.publish(generator=generator, generation_result=generation_result)\\n\\n\\t\\t\\tcost_time = round(time.time() - start_time, 2)\\n\\n\\t\\t\\tcprint.sep('=', '%d Pages are published in %s seconds' % (success_cnt, cost_time), bold=True, blue=True)\\n\\n\\n\\n\\t\\tfinish_scripts = self.settings.__dict__.get('FINISH_SCRIPTS', None)\\n\\n\\t\\tif finish_scripts :\\n\\t\\t\\t# Call scripts after generation completed\\n\\t\\t\\tcprint.sep('=', 'Call %d finish scripts' % len(finish_scripts), bold=True)\\n\\n\\t\\t\\tfor file in finish_scripts :\\n\\t\\t\\t\\tutils.load_module(file, self.settings.ROOT_PATH)\",\n \"def urlGenerator(self):\\n \\n # VERMONT #\\n baseurl = 'https://www.vermontjudiciary.org'\\n path = '/opinions-decisions'\\n # from date\\n param1 = 'facet_from_date=01/01'\\n # to date\\n param2 = 'facet_to_date=01/01/'\\n # division\\n param3 = 'f%5B0%5D=court_division_opinions_library%3A'\\n # search by text\\n param4 = 'search_api_fulltext='\\n # page\\n param5 = 'page='\\n # generate list of URL\\n listURL = []\\n \\n # list of divisions\\n vt_court_division = {\\\"civil\\\": \\\"1\\\", \\\"supreme court\\\": \\\"7\\\", \\\"environmental\\\": \\\"3\\\", \\\"family\\\": \\\"4\\\", \\\"criminal\\\": \\\"2\\\"}\\n # inputs\\n from_year = 2000\\n to_year = 2017\\n endPages = 75 #0-74\\n startPages = 0\\n # make change to pull data from different division by changing division name below to any of the division in vt_court_vivision dict\\n division = vt_court_division[\\\"environmental\\\"]\\n # url generating\\n for i in range(startPages, endPages):\\n build_url = baseurl + path + '?' + param1 + str(from_year) + \\\"&\\\" + param2 + str(to_year) + \\\"&\\\" + param3 + division + param4 + \\\"&\\\" + param5 + str(i) + \\\"\\\"\\n # append url to listUrl\\n listURL.append(build_url)\\n i += 1\\n \\n # return full list of URLs\\n return listURL\",\n \"def documents():\\n for domain in os.listdir(DOCUMENT_FOLDER):\\n for docname in os.listdir(os.path.join(DOCUMENT_FOLDER, domain)):\\n filename = os.path.join(DOCUMENT_FOLDER, domain, docname)\\n if filename.endswith(\\\".html\\\"):\\n fullDocname = os.path.join(domain, docname)\\n yield (fullDocname, filename)\",\n \"def run(self):\\n\\n try:\\n # Get the content from this page\\n if self.verbose:\\n print \\\"Getting page content for '%s'\\\" % self.url.strip()\\n \\n content = getPageContent(self.url)\\n\\n # Verify that this is not binary data\\n if content is not None and isHTML(content):\\n\\n\\n # Extract basic data about this result\\n content = content.lower()\\n title, keywords, description = parseMetaDataFromContent(content)\\n headers = parseHeaderInformationFromContent(content)\\n\\n # Add this result data\\n self.resultDictionary['title'] = title\\n self.resultDictionary['keywords'] = keywords\\n self.resultDictionary['description'] = description\\n self.resultDictionary['content'] = content\\n self.resultDictionary['headers'] = headers\\n\\n # Run the extensions\\n for extension in self.extensions:\\n extension.run(self.resultDictionary)\\n\\n\\n except URLError:\\n\\n # Skip this URL, and register it as an error on the cache\\n if self.verbose:\\n print(\\\"Error accessing '%s', %s\\\" % (self.url.strip(), str(sys.exc_info()[1]).strip()))\",\n \"def fetch_pages(folder=pages_folder):\\r\\n if not (folder.endswith('/') or folder.endswith('\\\\\\\\')):\\r\\n folder += '/'\\r\\n _classes = classes\\r\\n if not _classes:\\r\\n _classes = extract_classes(getsoup())\\r\\n for classnum in _classes.keys():\\r\\n with open(folder + str(classnum) + '.html', 'x') as f:\\r\\n f.write(getsoup(classnum).prettify())\",\n \"def _build_html():\\n\\n # Build twice until getnikola/nikola#1032 is fixed.\\n local('nikola build && nikola build')\\n\\n ## Remove all the source files, we only want the output!\\n local('ls | grep -v output | xargs rm -rf')\\n with settings(warn_only=True):\\n local('mv output/* output/.* .')\",\n \"def do_GET(self):\\n try:\\n is_digi = False #sys.platform.startswith('digi')\\n page = self.server.get_page()\\n\\n if self.path.endswith(page) or \\\\\\n not is_digi and self.path == '/':\\n self.send_response(200)\\n self.send_header('Content-type', 'text/html')\\n self.end_headers()\\n self.wfile.write(web_files.html % {\\\"page\\\": page,\\n \\\"title\\\":self.server.get_title()})\\n elif not is_digi and self.path.endswith(\\\"stylesheet.css\\\"):\\n self.send_response(200)\\n self.send_header('Content-type', 'text/css')\\n self.end_headers()\\n self.wfile.write(stylesheet_css)\\n elif not is_digi and self.path.find('?') > 0:\\n self.send_response(200)\\n self.send_header('Content-type', 'application/json')\\n self.end_headers()\\n self.wfile.write(self.server.get_table(\\n self.path[self.path.find('?')+1:]))\\n return\\n except IOError:\\n self.send_error(404,'File Not Found: %s' % self.path)\",\n \"def getHTML():\\n for url in urls: #Because there might be multipe URLs to scrape, iterate through the list \\n r = requests.get(url)\\n r.raise_for_status()\\n webpage_html = str(bs4.BeautifulSoup(r.text, \\\"html.parser\\\"))\\n filenumber = str(urls.index(url)) #Create a variable called filenumber using the index of the url in the list of urls\\n filename = \\\"output_\\\" + filenumber + \\\".html\\\" #This and above line avoid the loop rewriting the file name of the previous file.\\n with open(filename, 'w') as file_object: #open a new (or existing) file to be written (or overwritten)\\n file_object.write(webpage_html) #write the scraped HTML into the file\\n file_object.close #close the file\",\n \"def index():\\n #Getting source\\n sources = get_sources()\\n print(sources)\\n return render_template('index.html', sources = sources)\",\n \"def generate_files(self):\\n\\t\\tapply_stemmer, xml_file, query_file, expected_file = self.read_config_file()\\n\\t\\tself.generate_query_file(query_file, xml_file, apply_stemmer)\\n\\t\\tself.generate_expected_file(expected_file, xml_file)\\n\\t\\tlogging.info('FINALIZADO: MÓDULO PROCESSADOR DE CONSULTAS')\",\n \"def main():\\n # Step1: generate htmls\\n csv_data_path= \\\"./frontend/html_template_data/dataset.csv\\\"\\n html_template_path = \\\"./frontend/html_template_data/template.html\\\"\\n html_save_path = \\\"./frontend/html_files/\\\"\\n\\n generate_htmls(csv_data_path, html_template_path, html_save_path)\\n\\n # Step2: push htmls to Github\\n # push htmls to Github Pages, currently manual.\",\n \"def execute(pagename, request):\\n PackagePages(pagename, request).render()\",\n \"def make_pages(src, dst, layout, **params):\\n items = []\\n\\n for src_path in glob.glob(src):\\n context = read_content(src_path)\\n\\n params.update(context)\\n\\n dst_path = render(dst, **params)\\n output = render(context['content'], **params)\\n\\n # Add destination path to context\\n context['dest_path'] = dst_path\\n\\n # Add item to list\\n items.append(context)\\n\\n log('Rendering {} => {} ...', src_path, dst_path)\\n fwrite(dst_path, output)\\n\\n return sorted(items, key=lambda x: x['date_ymd'], reverse=True)\",\n \"def parsing_all_page(url):\\n html_doc = get_html(url)\\n# html_doc = get_html_local()\\n page_count = get_html_count(html_doc)\\n print 'All have find pages %d' % page_count\\n\\n projects = []\\n\\n for page in range(1, page_count + 1):\\n print 'Parsing %d%%' % (page*100/page_count)\\n\\n url = BASE_URL + '?page=%d' % page\\n projects.extend(process_page(url))\\n\\n return projects\",\n \"def save(self):\\n for page in self.pages.get_published_pages():\\n site_path = page.path_to_page.replace('.md', '').replace(\\n self.source_path, '').strip('/')\\n save_path = self.output_path\\n\\n # ensure we are not creating a directory for the index file that\\n # that lives at the source_path\\n if page.full_path() != f'{self.source_path}{os.sep}index.md':\\n site_path = slugify_path(site_path)\\n save_path = os.path.join('', self.output_path, site_path)\\n\\n try:\\n os.makedirs(save_path, exist_ok=True)\\n except Exception as e:\\n log((f'unable to create directories: {save_path}'\\n f' because: {e}'), True)\\n continue\\n\\n try:\\n save_file = os.path.join(save_path, 'index.html')\\n log(f'saving {save_file}')\\n\\n published = self.pages.get_published_pages()\\n prev_page = self.pages.get_previous_page(page)\\n next_page = self.pages.get_next_page(page)\\n content = page.render(published_pages=published,\\n previous_page=prev_page, next_page=next_page)\\n write(save_file, content)\\n except Exception as e:\\n log(f'unable to save file: {save_file} -- {e}', True)\\n\\n unpublished = self.pages.get_unpublished_pages()\\n if len(unpublished):\\n log('')\\n log('these pages were unpublished and not rendered:', True)\\n for up in unpublished:\\n log(up.path_to_page, True)\\n log('')\\n\\n # build the _tags pages\\n for tag, pages in self.tags.pages.items():\\n content = self.tags.render(tag, pages)\\n tag_index_dir = f'{self.tag_dir}/{slugify(tag)}'\\n tag_index = f'{tag_index_dir}/index.html'\\n os.makedirs(tag_index_dir, exist_ok=True)\\n write(tag_index, content)\\n\\n log('finished builidng site')\",\n \"def _generate_report(self):\\n\\n _LOG.info(\\\"Generating the HTML report.\\\")\\n\\n # Make sure the output directory exists.\\n try:\\n self.outdir.mkdir(parents=True, exist_ok=True)\\n except OSError as err:\\n raise Error(f\\\"failed to create directory '{self.outdir}': {err}\\\")\\n\\n raw_stats_paths, descr_paths = self._copy_raw_data()\\n\\n # Find the styles and templates paths.\\n templdir = FSHelpers.search_for_app_data(\\\"wult\\\", Path(\\\"templates\\\"),\\n pathdescr=\\\"HTML report Jinja2 templates\\\")\\n csspath = FSHelpers.search_for_app_data(\\\"wult\\\", Path(\\\"css/style.css\\\"),\\n pathdescr=\\\"HTML report CSS file\\\")\\n\\n # Copy the styles file to the output directory.\\n dstpath = self.outdir.joinpath(\\\"style.css\\\")\\n try:\\n shutil.copyfile(csspath, dstpath)\\n except OSError as err:\\n raise Error(f\\\"failed to copy CSS file from '{csspath}' to '{dstpath}':\\\\n{err}\\\")\\n\\n # The summary table is only included into the main HTML page.\\n sum_tbl = self._prepare_summary_table(raw_stats_paths, descr_paths)\\n links_tbl = self._prepare_links_table()\\n\\n # Each column name gets its own HTML page.\\n for colname, pinfos in self._pinfos.items():\\n stats_tbl = self._prepare_stats_table(pinfos)\\n\\n # Render the template.\\n jenv = Jinja2.build_jenv(templdir, trim_blocks=True, lstrip_blocks=True)\\n jenv.globals[\\\"stats_tbl\\\"] = stats_tbl\\n jenv.globals[\\\"pinfos\\\"] = pinfos\\n jenv.globals[\\\"colname\\\"] = colname\\n jenv.globals[\\\"title_descr\\\"] = self.title_descr\\n jenv.globals[\\\"toolname\\\"] = self._refinfo[\\\"toolname\\\"]\\n\\n if sum_tbl:\\n jenv.globals[\\\"sum_tbl\\\"] = sum_tbl\\n jenv.globals[\\\"links_tbl\\\"] = links_tbl\\n templfile = outfile = \\\"index.html\\\"\\n sum_tbl = None\\n else:\\n templfile = \\\"metric.html\\\"\\n outfile = links_tbl[colname][\\\"fname\\\"]\\n\\n Jinja2.render_template(jenv, Path(templfile), outfile=self.outdir.joinpath(outfile))\",\n \"def report(self, output_dir):\",\n \"def __call__(self):\\r\\n self.init_data = td.import_data(self.__module__)\\r\\n self.page1() # GET navigation (requests 101-153)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page2() # GET case (requests 201-252)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page3() # GET view (requests 301-365)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page4() # POST view (requests 401-452)\\r\",\n \"def download_all(self):\\r\\n # Fetch website list\\r\\n self.fetch_website_list()\\r\\n\\r\\n for website in self.website_list:\\r\\n self.download(website['id'])\",\n \"def fetch_web_cont(self):\\n with open(self.input_file) as input_file:\\n data = yaml.load(input_file, yaml.FullLoader)\\n url_list = data.get(self.url_access)\\n regex_list = data.get(self.regex_access)\\n\\n print('Fetching data:')\\n\\n for url in url_list:\\n # This restores the same behavior as before.\\n # Enabling certificate verification by default for stdlib http clients\\n context = ssl._create_unverified_context()\\n run_time = datetime.now().strftime(\\\"Date: %d-%m-%Y Time: %I:%M:%S:%f_%p\\\")\\n start = time.perf_counter()\\n web_resp = request.urlopen(url, context=context)\\n respData = web_resp.read()\\n resp_time = '%0.2f s' % (time.perf_counter() - start)\\n\\n for regex in regex_list:\\n contents = re.findall(regex, str(respData))\\n with open(self.output_file, 'a') as file:\\n if not contents:\\n print(run_time, ' | URL: ', url, '| content not found with this regex: ', regex,\\n file=file)\\n\\n else:\\n for content in contents:\\n print(run_time, ' | URL: ', url, ' | Response Time: ', resp_time,\\n url, ' | Contents: ', content, file=file)\\n \\n with open(self.output_file, 'a') as file:\\n \\n print('\\\\n#################################\\\\n', file=file)\",\n \"def run(self):\\n make_sure_path_exists(OUT_FOLDER)\\n\\n if self.config['type'] == 'website':\\n make_sure_path_exists(self.config['out_folder'])\\n\\n\\n for file in self.config['bodies']:\\n if file['type'] == 'content':\\n self.pandoc_file(file)\\n if self.config['type'] == 'website':\\n shutil.copyfile(file['generated'], os.path.join(self.config['out_folder'], os.path.basename(file['source'])))\\n\\n if self.config['type'] == 'website':\\n return\\n\\n for file in self.config['abstract']:\\n self.pandoc_file(file)\\n for file in self.config['summary']:\\n self.pandoc_file(file)\\n\\n template = LATEX_JINJA_ENV.get_template(self.config['template_file'])\\n\\n logging.info('Rendering template')\\n out = template.render(**self.config)\\n with open(self.config['name'] + self.get_file_extension(), 'w') as file:\\n file.write(out)\\n\\n if not self.args.pandoc:\\n logging.info('Rendering latex')\\n self.write()\\n if not self.args.fast:\\n logging.info('Rendering latex, again')\\n self.write() # twice for the toc\\n\\n logging.info('Done!')\",\n \"def processing():\\r\\n err=test_url()\\r\\n of=open(default_output_path,'a+')\\r\\n if err!=0: \\r\\n metaf=scan_target_metatag()\\r\\n adminf=scan_admin_url()\\r\\n comf=scan_com_content()\\r\\n robotsf=scan_robots_txt()\\r\\n htf=scan_htaccess()\\r\\n moof=scan_mootools()\\r\\n engbf=scan_engb_ini()\\r\\n result=compute_result(metaf,adminf,comf,robotsf,htf,moof,engbf)\\r\\n if result==1:\\r\\n #print \\\"THE TARGET IS USING JOOMLA CMS\\\"\\r\\n #print \\\"Joomla version is \\\" + joomla_version\\r\\n of.write(\\\"\\\\nJOOMLA USED (version : \\\" + joomla_version + \\\") --> \\\" + provided_url + \\\"\\\\n\\\")\\r\\n else:\\r\\n #print \\\"JOOMLA NOT USED\\\"\\r\\n of.write(\\\"\\\\nJOMLA NOT USED --> \\\" + provided_url + \\\"\\\\n\\\")\\r\\n else:\\r\\n of.write(\\\"\\\\nBAD URL --> \\\" + provided_url + \\\"\\\\n\\\")\\r\\n of.close()\\r\\n return 0\",\n \"def index_indexes(folder,saveAs=\\\"index2.html\\\"):\\n indexes=[]\\n saveAs=os.path.abspath(os.path.join(folder,saveAs))\\n for subFolder in glob.glob(folder+\\\"/*/\\\"):\\n if os.path.exists(subFolder+\\\"/SWH2P/index.html\\\"):\\n indexes.append(os.path.abspath(subFolder+\\\"/SWH2P/index.html\\\"))\\n\\n html='<html><body><h1>Automatic Index</h1><ul>'\\n for item in sorted(indexes):\\n html+='<li><a href=\\\"%s\\\">%s</a>'%(item,\\n os.path.basename(os.path.dirname(os.path.dirname(item))))\\n html+='</ul></body></html>'\\n with open(saveAs,'w') as f:\\n f.write(html)\\n print(\\\"saved\\\",saveAs)\\n webbrowser.open(saveAs)\",\n \"def photo2web_indexer():\\n \\n import numpy as np\\n \\n do_hh = True\\n do_hbt = False\\n\\n if do_hh:\\n num_thumbs = 3 # Number of thumbnails per folder to display\\n file_out = 'index.html'\\n dir_base = '/Volumes/SSD External/Hattenbach_v2'\\n title = 'Hattenbach Photos'\\n file_target = 'index_m.html?s=1' # Do we visit index.html, or some other file, to start the gallery?\\n # For HH, we force to the mobile site, since there are zero captions anyhow.\\n \\n if do_hbt:\\n num_thumbs = 10 # Number of thumbnails per folder to display\\n file_out = 'index_all.html'\\n dir_base = '/Users/throop/photos/Trips'\\n file_target = 'index.html' # NB: This is oversimplified. Sometimes it should be show.html, etc.\\n title = 'Henry Throop Photos' # HTML title\\n \\n os.chdir(dir_base)\\n\\n dirs = sorted(glob.glob(os.path.join(dir_base, '*')))\\n \\n # Create the output file\\n # WARNING: DO NOT CALL THIS INDEX.HTML, since it might overwrite the existing HBT one.\\n \\n lun = open(file_out, \\\"w\\\")\\n lun.write(f'<head><link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"photos.css\\\"><title>{title}</title></head>\\\\n')\\n lun.write('\\\\n')\\n \\n for dir in dirs:\\n \\n if os.path.isdir(dir): \\n files = sorted(glob.glob(os.path.join(dir, 'thumbnails/s*jpg')))\\n \\n # If there are some thumbnails there, then proceed\\n \\n if len(files) > 0:\\n basename = os.path.basename(dir)\\n basename_edited = basename.replace('_', ' ')\\n \\n lun.write(f'<a href={basename}/{file_target}><h3>{basename_edited}</h3></a>\\\\n')\\n lun.write('<p>\\\\n')\\n print(dir)\\n for i in range(np.amin([num_thumbs,len(files)])):\\n print(f'{i}/{num_thumbs} : {files[i]}')\\n lun.write(f'<a href={basename}/{file_target}><img src={basename}/thumbnails/{os.path.basename(files[i])}></a>\\\\n')\\n lun.write('<p>\\\\n')\\n print()\\n \\n lun.close()\\n print(f'Wrote: {os.path.join(dir_base,file_out)}')\",\n \"def getURLs():\",\n \"def produce_main(self) -> list:\\n self.headers_random = {'user-agent': UserAgent().random,}\\n links_google, links_qwant, links_bing, \\\\\\n links_duckduckgo, links_yahoo = self.links_search\\n value_google = [[rand, self.headers_random] for rand in links_google]\\n value_qwant = [[rand, self.headers_random] for rand in links_qwant]\\n value_bing = [[rand, self.headers_random] for rand in links_bing]\\n value_duckduckgo = [[rand, self.headers_random] for rand in links_duckduckgo]\\n value_yahoo = [[rand, self.headers_random] for rand in links_yahoo]\\n \\n with Pool(5) as pool:\\n value_html_google = pool.map(self.produce_html_text, value_google)\\n value_html_qwant = pool.map(self.produce_html_text, value_qwant)\\n value_html_bing = pool.map(self.produce_html_text, value_bing)\\n value_html_duckduckgo = pool.map(self.produce_html_text, value_duckduckgo)\\n value_html_yahoo = pool.map(self.produce_html_text, value_yahoo)\\n\\n value_google = [[html, link] for html, link in zip(value_html_google, links_google)]\\n value_qwant = [[html, link] for html, link in zip(value_html_qwant, links_qwant)]\\n value_bing = [[html, link] for html, link in zip(value_html_bing, links_bing)]\\n value_duckduckgo = [[html, link] for html, link in zip(value_html_duckduckgo, links_duckduckgo)]\\n value_yahoo = [[html, link] for html, link in zip(value_html_yahoo, links_yahoo)]\\n \\n with Pool(5) as pool:\\n value_dict_google = pool.map(self.produce_parse_google, value_google)\\n value_dict_qwant = pool.map(self.produce_parse_qwant, value_qwant)\\n value_dict_bing = pool.map(self.produce_parse_bing, value_bing)\\n value_dict_duckduckgo = pool.map(self.produce_parse_duckduckgo, value_duckduckgo)\\n value_dict_yahoo = pool.map(self.produce_parse_yahoo, value_yahoo)\\n \\n return value_dict_google, value_dict_qwant, value_dict_bing, \\\\\\n value_dict_duckduckgo, value_dict_yahoo\",\n \"def mk_htmls(self):\\n\\n domain_link_list = self.scrape_domain_int_links()\\n html_fail_rate = float(self.failed_retrieving_html_counter / len(domain_link_list))\\n print \\\"mk_htmls SUCCES RATE %r\\\" % html_fail_rate\\n if html_fail_rate < (float(0.1)):\\n # driving links, to collect htmls from web and create htmls with removed img elements\\n for ind in range(len(domain_link_list)):\\n page_file_name = \\\"page_\\\" + str(ind + 1) + \\\".html\\\" # gen file names for html file of page on site\\n active_page_link = domain_link_list[ind]\\n if \\\";;;\\\" in active_page_link: # separator problems hedging\\n self.links_contain_seprator.append([active_page_link, page_file_name])\\n print \\\"LINK CONTAINS SEPARATOR, CAN NOT ADD TO PAGE LIST, WILL RUIN DATASYSTEM, WILL BE ADDED TO SEPARATE FILE\\\"\\n else:\\n BS_object = self.retrieve_html(active_page_link, self.domain_folder_name, self.html_folder_name, page_file_name)\\n self.page_list.append([active_page_link, page_file_name])\\n self.bs_object_dict[active_page_link] = BS_object\\n # if no \\\";;;\\\" separator found in link, then write as usual\\n if len(self.links_contain_seprator) > 0:\\n c_m.l_of_l_write(self.links_contain_seprator, self.main_path, self.domain_folder_name, self.link_contains_separator)\\n else:\\n c_m.l_of_l_write(self.page_list, self.main_path, self.domain_folder_name, self.page_list_f_name)\\n return self.bs_object_dict\\n else:\\n return False\",\n \"def crawl(self) -> Dict[str, List[req.Response]]:\\n loop = asyncio.get_event_loop()\\n try:\\n web_pages = loop.run_until_complete(\\n asyncio.ensure_future(self.initialiser_crawler())\\n )\\n except KeyboardInterrupt:\\n loop.close()\\n raise KeyboardInterrupt\\n return web_pages\",\n \"def main():\\n page = get_page_arg()\\n\\n items = load_data(page)\\n total_pages = get_total_pages()\\n context = {\\\"current_page\\\": page,\\n \\\"total_pages\\\": total_pages,\\n \\\"items\\\": items}\\n\\n return render_template('index.html', **context)\",\n \"def getAllPages(base_url, node = None, page_size = 1000, from_date=None, to_date=None, delay=None):\\n\\n\\tdocuments_csv_filepath = getScriptDirectory() + \\\"/result/documents.csv\\\"\\n\\n\\n\\t# Check if the output file exists\\n\\t# If it does, we can skip all of this\\n\\n\\tif(os.path.isfile(documents_csv_filepath)):\\n\\t\\tprint(\\\"Documents already exist. Moving onto sampling.\\\")\\n\\n\\t\\treturn\\n\\n\\n\\t# Check if result folder has been made\\n\\n\\tresult_folder = getScriptDirectory() + \\\"/result\\\"\\n\\n\\tif not os.path.exists(result_folder):\\n\\t\\tos.makedirs(result_folder)\\n\\n\\n\\t# Continue fetching fresh results from the server\\n\\n\\tnum_results = getNumResults(base_url, node, from_date=from_date, to_date=to_date);\\n\\tprint(\\\"Total results: %d\\\" % (num_results))\\n\\n\\tif num_results is 0:\\n\\t\\tprint \\\"No results were found. Exiting.\\\"\\n\\t\\texit\\n\\n\\tpages_required = math.ceil((num_results + 0.0) / page_size)\\n\\tprint(\\\"Total pages: %d\\\" % (pages_required))\\n\\n\\n\\trange_of_pages = range(1, int(pages_required) + 1)\\n\\n\\tall_pages = getPageRange(base_url, node, range_of_pages, page_size, from_date=from_date, to_date=to_date, delay=delay)\\n\\tall_pages.to_csv(documents_csv_filepath, index = False, encoding = \\\"utf-8\\\")\\n\\n\\treturn\",\n \"def main(self, options):\\n import sys\\n import getopt\\n import errno\\n from os import makedirs\\n from os.path import dirname\\n\\n try:\\n opts, args = getopt.getopt(options,\\n \\\"lt:gsp:\\\", [\\n \\\"port=\\\",\\n \\\"view=\\\",\\n \\\"list\\\",\\n \\\"static=\\\",\\n \\\"generate\\\",\\n \\\"server\\\"])\\n except getopt.GetoptError, err:\\n print str(err)\\n sys.exit(2)\\n \\n generate = False\\n serve = False\\n listfiles = False\\n statichtml = 'static'\\n view = False\\n port = 8080\\n \\n for option, arg in opts:\\n if option in (\\\"-g\\\",\\\"--generate\\\"):\\n generate = True\\n elif option in (\\\"-t\\\",\\\"--static\\\"):\\n statichtml = arg\\n elif option in (\\\"--view\\\"):\\n view = arg\\n elif option in (\\\"-s\\\",\\\"--serve\\\"):\\n serve = True\\n elif option in (\\\"-l\\\",\\\"--list\\\"):\\n listfiles = True\\n elif option in (\\\"-p\\\",\\\"--port\\\"):\\n port = int(arg)\\n else:\\n assert False, \\\"unhandle option\\\"\\n \\n if generate or listfiles:\\n for path, filename in self.genlist():\\n \\n path = path.replace('?','')\\n \\n if view and view != path:\\n continue\\n \\n if listfiles:\\n print path + \\\" <= \\\" + \\\\\\n join(path[1:],'index.html') + ' <= ' + \\\\\\n filename\\n \\n if generate:\\n path = join(statichtml , path[1:], 'index.html')\\n try:\\n makedirs(dirname(path))\\n except OSError as exc:\\n if exc.errno == errno.EEXIST:\\n pass\\n else: raise\\n print \\\"Generating \\\" + path\\n static_file = open(path,'w')\\n static_file.write(self.generatehtml(path))\\n static_file.close()\\n \\n if serve:\\n print \\\"Starting wsgi web server on port \\\" + str(port)\\n from wsgiref.simple_server import make_server\\n server = make_server('', port, self.wsgiapp())\\n server.serve_forever()\",\n \"def run_scrapping():\\n date = datetime.now().strftime(\\\"%Y-%m-%d\\\")\\n size = 100\\n r = list(range(size))\\n random.shuffle(r)\\n for i in r:\\n scrap_page(url_page.format(i), date)\\n print(str(i) + \\\" / \\\" + str(size))\",\n \"def _yield_result_files(self, tpl, **kwargs):\\n for sheet in self.shortcut_sheets:\\n for ngs_library in sheet.all_ngs_libraries:\\n extraction_type = ngs_library.test_sample.extra_infos[\\\"extractionType\\\"]\\n if ngs_library.extra_infos[\\\"seqPlatform\\\"] in (\\\"ONP\\\", \\\"PacBio\\\"):\\n suffix = \\\"_long\\\"\\n else:\\n suffix = \\\"\\\"\\n yield from expand(\\n tpl,\\n mapper=self.config[\\\"tools\\\"][extraction_type.lower() + suffix],\\n ngs_library=[ngs_library],\\n **kwargs\\n )\",\n \"def create_results(self):\\n\\n webhost_map = {}\\n # put the found paths into the webhost map\\n self.process_crawled_urls(webhost_map)\\n # put the found param infos into the webhost map\\n self.process_param_infos(webhost_map)\\n # put the found cookies into the webhost map and get as by product new domains\\n new_domains = self.process_cookies(webhost_map)\\n # get the newly discovered network locations\\n new_netlocs = self.get_new_netlocs()\\n\\n # append new domains to the new network locations\\n for new_domain in new_domains:\\n if self.port != 80 and self.port != 443:\\n new_netlocs.add(new_domains + \\\":\\\" + self.port)\\n else:\\n new_netlocs.add(new_domain)\\n\\n # process discovered redirects and put into webhost map if appropriate\\n for url, redirect in self.redirects.items():\\n path = urllib.parse.urlparse(url).path\\n if url + \\\"/\\\" == redirect[\\\"to\\\"]:\\n continue\\n else:\\n if not self.url_has_netloc(redirect[\\\"to\\\"]):\\n redirect_to = redirect[\\\"to\\\"]\\n else:\\n redirect_to = urllib.parse.urlparse(redirect[\\\"to\\\"]).path\\n\\n code = str(redirect[\\\"code\\\"])\\n if code not in webhost_map:\\n webhost_map[code] = {}\\n if path not in webhost_map[code]:\\n webhost_map[code][path] = {}\\n\\n redirect_info = \\\"redirect to %s\\\" % redirect_to\\n if \\\"misc_info\\\" not in webhost_map[code][path]:\\n webhost_map[code][path][\\\"misc_info\\\"] = redirect_info\\n elif not any(val == redirect_info for val in webhost_map[code][path].values()):\\n for i in range(10):\\n alt_key = \\\"misc_info_%d\\\" % i\\n if alt_key not in webhost_map[code][path]:\\n webhost_map[code][path][alt_key] = redirect_info\\n break\\n\\n return webhost_map, new_netlocs, self.comments\",\n \"def write_page_sets(urls):\\n template = ''\\n page_set_path = os.path.join(CHROMIUM_SRC, 'tools/perf/page_sets/')\\n\\n with open('page_set_template.py', 'rb') as f:\\n template = ''.join(f.readlines())\\n assert template, 'Failed to read from page set template'\\n\\n for i in range(len(urls)):\\n test_name = 'url{0}'.format(i)\\n with open('{0}{1}.py'.format(page_set_path, test_name), 'wb') as f:\\n f.write(template.format(test_name, urls[i]))\\n # Write modified version\\n test_name = 'url{0}'.format(str(i) + '_pc')\\n with open('{0}{1}.py'.format(page_set_path, test_name), 'wb') as f:\\n f.write(template.format(test_name, urls[i]))\",\n \"def save(self, content_dir):\\n print_verbose(\\n \\\"INFO : Writing random HTML documents to files...\\\",\\n self.args.verbose,\\n )\\n for i in range(self.n):\\n dir_path = content_dir + \\\"/\\\" + \\\"staticpage\\\" + str(i)\\n if not os.path.exists(dir_path):\\n os.makedirs(dir_path)\\n index_file = os.path.join(dir_path, \\\"index.html\\\") \\n with open(index_file, \\\"w\\\") as file:\\n file.write(self.doc_strings[i].decode(\\\"utf-8\\\"))\",\n \"def wyniki():\\n return render_template('results.html', result=request.args.get('result'))\",\n \"def updateFrontPages(self):\\n nTmessage(\\\"Starting %s\\\" % getCallerName())\\n htmlDir = os.path.join(self.results_dir, \\\"HTML\\\")\\n if os.path.isdir(htmlDir):\\n# nTdebug(\\\"Removing original html directory for NRG-CING.\\\")\\n rmdir(htmlDir)\\n # end if\\n nTmessage(\\\"Creating HTML directory for %s.\\\" % self.results_base)\\n mkdirs(htmlDir)\\n# srcHtmlPath = os.path.join(cingRoot, cingPaths.html) \\n data_dir = os.path.join (self.base_dir, \\\"data\\\" )\\n base_data_dir = os.path.join (data_dir, self.results_base )\\n # Most crud can come in from the traditional method.\\n copyCingHtmlJsAndCssToDirectory(htmlDir)\\n \\n nTmessage(\\\"Adding frontpage-specific html.\\\")\\n fnList = \\\"\\\"\\\"\\n about.html \\n contact.html \\n credits.html \\n help.html \\n helpCing.html \\n helpPlot.html \\n helpTutorials.html\\n glossary.html \\n index.html\\n download.html \\n plot.html \\n cing.png \\n icon_email.gif\\n icon_reference.gif\\n icon_website.png\\n icon_youtube.jpeg\\n icon_download.gif\\n NRG-CING_circle.png\\n \\\"\\\"\\\".split()\\n for fn in fnList:\\n srcFile = os.path.join(base_data_dir, fn)\\n dstFile = os.path.join(htmlDir, fn)\\n if not fn.endswith('.html'):\\n copyfile(srcFile, dstFile)\\n# nTdebug(\\\"-1- Added extra file %s.\\\" % dstFile)\\n continue\\n # end if\\n file_content = open(srcFile, 'r').read() \\n old_string = r\\\"<!-- INSERT NEW FOOTER HERE -->\\\"\\n file_content = string.replace(file_content, old_string, self.htmlFooter)\\n old_string = r\\\"<!-- INSERT GOOGLE ANALYTICS TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_ANALYTICS_TEMPLATE) \\n old_string = r\\\"<!-- INSERT GOOGLE PLUS ONE TEMPLATE HERE -->\\\"\\n file_content = string.replace(file_content, old_string, GOOGLE_PLUS_ONE_TEMPLATE) \\n if fn != 'index.html':\\n writeTextToFile(dstFile, file_content)\\n# nTdebug(\\\"-2- Added extra file %s.\\\" % dstFile)\\n continue\\n # end if\\n # Get framework input\\n file_content = self._format_html(file_content) \\n htmlfile = os.path.join(htmlDir, 'index.html')\\n writeTextToFile(htmlfile, file_content)\\n# nTdebug(\\\"-3- Written HTML index file: %s\\\" % htmlfile) \\n # end for\\n nTmessage(\\\"Copy the overall index\\\")\\n org_file = os.path.join(data_dir, 'redirect.html')\\n new_file = os.path.join(self.results_dir, 'index.html')\\n shutil.copy(org_file, new_file)\\n \\n nTmessage(\\\"Copy the python cgi server for TableTools\\\\n\\\")\\n cgi_file_name = 'DataTablesServer.py'\\n if not os.path.exists(self.cgi_dir):\\n nTerror(\\\"Please first create the server directory as expected at: %s\\\" % self.cgi_dir)\\n return True\\n # end if\\n org_file = os.path.join(self.base_dir, 'server', cgi_file_name)\\n new_file = os.path.join(self.cgi_dir, cgi_file_name)\\n if os.path.exists(new_file): # remove because if it's a hard link the copy will fail.\\n os.unlink(new_file)\\n # end if\\n shutil.copy(org_file, new_file)\",\n \"def get(self):\\n resources = []\\n starting_path = self.request.get('start')\\n if starting_path:\\n resources = Resource.query(Resource.path >= starting_path).order(\\n Resource.path).fetch(11)\\n else:\\n resources = Resource.query().order(Resource.path).fetch(11)\\n\\n self.response.headers['Content-Type'] = 'text/html'\\n\\n self.response.write('<!doctype><html><head>' +\\n '<title>Content Lister</title></head><body>Resources:<br>')\\n for i in xrange(10):\\n if i < len(resources):\\n # TODO: constructing the path this way makes the resource\\n # path a possible vector for XSS.\\n self.response.write('%s ' % (resources[i].path,) +\\n '<a href=\\\"/content_manager%s\\\">' % (\\n resources[i].path,) +\\n 'Edit</a> <a href=\\\"%s\\\">View</a><br>' % (\\n resources[i].path,))\\n\\n if len(resources) > 10:\\n self.response.write(\\n '<a href=\\\"/content_lister?start=%s\\\">Next</a>' % (\\n resources[10].path,))\\n \\n self.response.write('</body></html>')\",\n \"def generate():\\n\\n # Verify if directory exists\\n if not os.path.isdir(config.techniques_markdown_path):\\n os.mkdir(config.techniques_markdown_path)\\n\\n #Write the technique index.html page\\n with open(os.path.join(config.techniques_markdown_path, \\\"overview.md\\\"), \\\"w\\\", encoding='utf8') as md_file:\\n md_file.write(config.technique_overview_md)\\n\\n for domain in config.domains:\\n generate_domain_markdown(domain)\",\n \"def generate():\\n local('cd doc && make clean && make html')\",\n \"def get_result_files(self):\\n name_pattern = \\\"{mapper}.{ngs_library.name}\\\"\\n yield from self._yield_result_files(\\n os.path.join(\\\"output\\\", name_pattern, \\\"out\\\", name_pattern + \\\"{ext}\\\"), ext=EXT_VALUES\\n )\\n yield from self._yield_result_files(\\n os.path.join(\\\"output\\\", name_pattern, \\\"log\\\", \\\"{mapper}.{ngs_library.name}.{ext}\\\"),\\n ext=(\\n \\\"log\\\",\\n \\\"conda_info.txt\\\",\\n \\\"conda_list.txt\\\",\\n \\\"log.md5\\\",\\n \\\"conda_info.txt.md5\\\",\\n \\\"conda_list.txt.md5\\\",\\n ),\\n )\\n yield from self._yield_result_files(\\n os.path.join(\\n \\\"output\\\", name_pattern, \\\"report\\\", \\\"bam_qc\\\", name_pattern + \\\".bam.{report}.txt\\\"\\n ),\\n report=(\\\"bamstats\\\", \\\"flagstats\\\", \\\"idxstats\\\"),\\n )\\n yield from self._yield_result_files(\\n os.path.join(\\n \\\"output\\\", name_pattern, \\\"report\\\", \\\"bam_qc\\\", name_pattern + \\\".bam.{report}.txt.md5\\\"\\n ),\\n report=(\\\"bamstats\\\", \\\"flagstats\\\", \\\"idxstats\\\"),\\n )\\n yield from self._yield_result_files(\\n os.path.join(\\n \\\"output\\\", name_pattern, \\\"report\\\", \\\"bam_qc\\\", name_pattern + \\\".bam.bamstats.html\\\"\\n )\\n )\\n yield from self._yield_result_files(\\n os.path.join(\\n \\\"output\\\", name_pattern, \\\"report\\\", \\\"bam_qc\\\", name_pattern + \\\".bam.bamstats.html.md5\\\"\\n )\\n )\\n\\n for sheet in self.shortcut_sheets:\\n for ngs_library in sheet.all_ngs_libraries:\\n if ngs_library.name in self.ngs_library_to_kit:\\n extraction_type = ngs_library.test_sample.extra_infos[\\\"extractionType\\\"]\\n suffix = (\\n \\\"_long\\\"\\n if ngs_library.extra_infos[\\\"seqPlatform\\\"] in (\\\"PacBio\\\", \\\"ONP\\\")\\n else \\\"\\\"\\n )\\n # Per-sample target coverage report.\\n yield from expand(\\n os.path.join(\\n \\\"output\\\", name_pattern, \\\"report\\\", \\\"cov_qc\\\", name_pattern + \\\".{ext}\\\"\\n ),\\n mapper=self.config[\\\"tools\\\"][extraction_type.lower() + suffix],\\n ngs_library=[ngs_library],\\n ext=[\\\"txt\\\", \\\"txt.md5\\\"],\\n )\\n yield \\\"output/target_cov_report/out/target_cov_report.txt\\\"\\n yield \\\"output/target_cov_report/out/target_cov_report.txt.md5\\\"\\n if (\\n self.config[\\\"picard_hs_metrics\\\"][\\\"path_targets_interval_list\\\"]\\n and self.config[\\\"picard_hs_metrics\\\"][\\\"path_baits_interval_list\\\"]\\n ):\\n yield from self._yield_result_files(\\n os.path.join(\\n \\\"output\\\", name_pattern, \\\"report\\\", \\\"picard_hs_metrics\\\", name_pattern + \\\".txt\\\"\\n )\\n )\\n yield from self._yield_result_files(\\n os.path.join(\\n \\\"output\\\", name_pattern, \\\"report\\\", \\\"picard_hs_metrics\\\", name_pattern + \\\".txt.md5\\\"\\n )\\n )\\n if self.config[\\\"compute_coverage_bed\\\"]:\\n yield from self._yield_result_files(\\n os.path.join(\\\"output\\\", name_pattern, \\\"report\\\", \\\"coverage\\\", name_pattern + \\\"{ext}\\\"),\\n ext=(\\\".bed.gz\\\", \\\".bed.gz.tbi\\\"),\\n )\\n else:\\n print(\\n \\\"Genome-wide coverage BED generation disabled\\\", file=sys.stderr\\n ) # pragma: no cover\",\n \"def main(base_url, node, sample_size, from_date, to_date):\\n\\n\\tgetAllPages(base_url, node, from_date=from_date, to_date=to_date) # Depends on document.csv\\n\\tsampleDocuments(sample_size) # Depends on sampled_documents.csv\\n\\tgetAndSaveDocuments(base_url)\",\n \"def download_files(self):\",\n \"def results_overview():\\n\\n if request.method == \\\"POST\\\":\\n # clean out all unwanted storage\\n if _pool:\\n _pool.terminate()\\n del _drivers[:]\\n \\n return redirect(url_for('upload.upload'))\\n\\n # GET\\n \\n # Captures the global drivers variable\\n global _drivers\\n\\n processType = g.processType\\n coreFactor = g.coreFactor\\n\\n if processType == 'parallel':\\n current_app.logger.info(time.ctime() + \\\"\\\\tProcess pool with %s processes initialized for execution\\\" % coreFactor)\\n results = _pool.map(_get_result, _drivers)\\n else:\\n results = [_get_result(driver) for driver in _drivers]\\n\\n return render_template('checks/results_overview.html', results=results)\",\n \"async def initialiser_crawler(self) -> Dict[str, List[req.Response]]:\\n web_pages = {}\\n with ThreadPoolExecutor(max_workers=NUM_WORKERS) as exe:\\n try:\\n loop = asyncio.get_event_loop()\\n tasks = [\\n loop.run_in_executor(exe, self.collect_webpages, keyword)\\n for keyword in self.keywords \\n ]\\n for res in await asyncio.gather(*tasks):\\n web_pages.update(res)\\n except KeyboardInterrupt:\\n loop.close()\\n raise KeyboardInterrupt\\n return web_pages\",\n \"def _get_allpages(self, url:str, paramsdict:Dict[str,str]):\\n r1 = self._get_dict_from_url(url, paramsdict)\\n r = [r1]\\n #display(r)\\n if 'total_pages' in r1:\\n # print('more than one page')\\n for next_page in range(2, r1['total_pages']+1):\\n # print(f\\\"load page {next_page} \\\")\\n r.append(self._get_dict_from_url(url, {**paramsdict, 'page':next_page}))\\n # print(len(r))\\n # print([len(rx['results']) for rx in r])\\n results = [entry for rx in r for entry in rx['results'] ]\\n\\n return results\",\n \"def _copy_results_html_file(self, destination_dir, filename):\\n files_to_copy = [filename, filename + \\\".version\\\"]\\n template_dir = self._path_finder.path_from_blink_tools(\\n 'blinkpy', 'web_tests')\\n for filename in files_to_copy:\\n source_path = self._filesystem.join(template_dir, filename)\\n destination_path = self._filesystem.join(destination_dir, filename)\\n # Note that the results.html template file won't exist when\\n # we're using a MockFileSystem during unit tests, so make sure\\n # it exists before we try to copy it.\\n if self._filesystem.exists(source_path):\\n self._filesystem.copyfile(source_path, destination_path)\",\n \"def start_requests(self):\\r\\n yield Request(url=MooreSpider.start_url,\\r\\n callback=self.parse_directory_list,\\r\\n method=\\\"GET\\\")\",\n \"def get_output_files(self, action):\\n assert action == \\\"run\\\"\\n for ext in self.extensions:\\n yield ext[1:].replace(\\\".\\\", \\\"_\\\"), self.base_path_out.format(mapper=self.name, ext=ext)\\n for ext in (\\\".bamstats.html\\\", \\\".bamstats.txt\\\", \\\".flagstats.txt\\\", \\\".idxstats.txt\\\"):\\n path = (\\n \\\"work/{mapper}.{{library_name}}/report/bam_qc/\\\" \\\"{mapper}.{{library_name}}.bam{ext}\\\"\\n ).format(mapper=self.name, ext=ext)\\n yield \\\"report_\\\" + \\\".\\\".join(ext.split(\\\".\\\")[1:3]).replace(\\\".\\\", \\\"_\\\"), path\\n for ext in (\\n \\\".bamstats.html.md5\\\",\\n \\\".bamstats.txt.md5\\\",\\n \\\".flagstats.txt.md5\\\",\\n \\\".idxstats.txt.md5\\\",\\n ):\\n path = (\\n \\\"work/{mapper}.{{library_name}}/report/bam_qc/\\\" \\\"{mapper}.{{library_name}}.bam{ext}\\\"\\n ).format(mapper=self.name, ext=ext)\\n yield \\\"report_\\\" + \\\".\\\".join(ext.split(\\\".\\\")[1:3]).replace(\\\".\\\", \\\"_\\\") + \\\"_md5\\\", path\",\n \"def content_creator():\\n with temporary_url_for_logger(app) as logger:\\n with logger:\\n content = page.render_html(\\n solution=solution,\\n static_url=static_url,\\n lesson_url=lesson_url,\\n subpage_url=subpage_url,\\n vars=variables\\n )\\n absolute_urls = [url_for(logged[0], **logged[1]) for logged in logger.logged_calls]\\n\\n relative_urls = [get_relative_url(request.path, x) for x in absolute_urls]\\n\\n return {\\\"content\\\": content, \\\"urls\\\": relative_urls}\",\n \"def generate_report():\\n\\n # Fetch the top 3 most viewed articles and number of views and print them\\n articles_query = get_articles_query()\\n popular_articles = execute_query(articles_query)\\n print_top_articles(popular_articles)\\n\\n # Fetch the most popular authors and print them\\n authors_query = get_authors_query()\\n popular_authors = execute_query(authors_query)\\n print_authors(popular_authors)\\n\\n # Print the days when there were more than 1% errors in HTTP requests\\n errors_query = get_errorData_query()\\n error_data = execute_query(errors_query)\\n print_error_data(error_data)\",\n \"def get_html_pages(self, honeypotid):\\n req = {\\\"type\\\": \\\"get_html_pages\\\",\\n \\\"to\\\": honeypotid,\\n \\\"from\\\": self.network.mc_id}\\n expect_dict = {\\\"type\\\": \\\"send_html_pages\\\"}\\n msg_list = self.send_receive(req, honeypotid, expect_dict)\\n answer = \\\"\\\"\\n i = 0;\\n for msg in msg_list[0]['pages']:\\n mainHTMLfilename = self.home_dir + \\\"/\\\" + msg_list[0][\\\"from\\\"] + \\\"_\\\" + str(i) + \\\"_\\\" + msg['url'].replace(\\\"/\\\",\\n \\\"_\\\") + \\\"_login.html\\\"\\n dashboardHTMLfilename = self.home_dir + \\\"/\\\" + msg_list[0][\\\"from\\\"] + \\\"_\\\" + str(i) + \\\"_\\\" + msg['url'].replace(\\\"/\\\",\\n \\\"_\\\") + \\\"_dashboard.html\\\"\\n answer = answer + \\\"Main HTML at: \\\" + mainHTMLfilename + \\\"\\\\n\\\"\\n\\n # mode w will overwrite already existent files\\n with open(mainHTMLfilename, 'w') as f:\\n f.write(msg[\\\"html\\\"])\\n if not msg[\\\"dashboard\\\"] == \\\"None\\\":\\n answer = answer + \\\"Dashboard HTML at: \\\" + dashboardHTMLfilename + \\\"\\\\n\\\"\\n with open(dashboardHTMLfilename, 'w') as f:\\n f.write(msg[\\\"dashboard\\\"])\\n i = i + 1\\n return answer # json.dumps(req) + \\\"\\\\n\\\" + msg_list[0][\\\"pages\\\"][0][\\\"url\\\"]\",\n \"def __init__(self, result_files):\\n self.result_files = result_files\\n\\n root_dir = os.getcwd()\\n os.chdir('results')\\n\\n self._go_through_summary_reports()\\n\\n os.chdir(root_dir)\",\n \"def generate(self, conf, env, data):\\n\\n path = joinurl(conf['output_dir'], self.path)\\n sm = Map()\\n\\n pages = []\\n for i in env.globals.pages:\\n pages.append(i.slug)\\n for i in env.globals.entrylist:\\n pages.append(i.slug)\\n\\n if exists(path) and not self.modified and not conf.modified:\\n event.skip('sitemap', path)\\n raise StopIteration\\n for ns, fname in self.files:\\n\\n if ns == 'page' or ns == 'entry' or ns == 'index':\\n pass\\n else:\\n continue\\n\\n permalink = '/' + fname.replace(conf['output_dir'], '')\\n permalink = rchop(permalink, 'index.html')\\n url = conf['www_root'] + permalink\\n\\n priority, changefreq = self.scores.get(ns, (0.5, 'weekly'))\\n\\n _pages = env.globals.entrylist + env.globals.pages\\n\\n for i in _pages:\\n if permalink.strip('/') in pages:\\n if i.slug.strip('/') == permalink.strip('/'):\\n pages.remove(permalink.strip('/'))\\n video = re.search('youtube.com/(v/|watch\\\\?v=|embed/)([a-zA-Z0-9\\\\-_]*)', i.content)\\n if video:\\n yt = video.group().split('/')[-1]\\n sm.add(url, yt, i.title, i.metadesc, getmtime(fname), changefreq, priority)\\n\\n sm.finish()\\n yield sm, path\",\n \"def offline_copy(_export_path):\\n global export_path\\n export_path = _export_path\\n \\n # First, monkey patch the original config\\n main.NBCONFIG.protectect_dirs = []\\n main.NBCONFIG.protected_users = {}\\n main.NBCONFIG.edit_users = {}\\n \\n # Now monkey patch NBweb\\n main.REQUIRELOGIN = False\\n\\n pages = []\\n\\n # Copy and work all source files \\n for dirpath,dirnames,filenames in os.walk(NBCONFIG.source):\\n for dirname in dirnames[:]: # Iterate a copy since we will delete in place\\n if any(dirname.startswith(i) for i in ['.']):\\n dirnames.remove(dirname) # So we do not parse it later\\n continue\\n if dirname == '_scratch':\\n dirnames.remove(dirname) # So we do not parse it later\\n continue\\n \\n # Names\\n src_systemname = os.path.join(dirpath,dirname)\\n rootname = os.path.relpath(src_systemname,NBCONFIG.source) # No leading / though\\n dest_systemname = os.path.join(export_path,rootname)\\n \\n mkdir(rootname,isfile=False) # Will make the dir no matter what\\n \\n # Index\\n dest = os.path.join(export_path,rootname, 'index.html')\\n \\n # Exclusions.\\n if main.exclusion_check(utils.join('/',rootname +'/')):\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write('')\\n continue\\n \\n try:\\n html = main.main_route('/' + rootname + '/')\\n except HTTPError:\\n # Likely some additional resource in _NBweb\\n try:\\n os.rmdir(dest_systemname) # Should be empty\\n except OSError:\\n pass\\n os.symlink(src_systemname,dest_systemname)\\n continue\\n \\n \\n html = process_page(html,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n \\n # _all\\n dest = os.path.join(export_path,'_all',rootname, 'index.html')\\n mkdir(dest,isfile=True,isfull=True)\\n \\n html = main.allpage('/'+ rootname +'/')\\n html = process_page(html,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n \\n \\n # Loop each file\\n for filename in filenames:\\n if os.path.splitext(filename)[0] == 'index':\\n continue # Already made above\\n \\n # Names\\n src_systemname = os.path.join(dirpath,filename)\\n rootname = os.path.relpath(src_systemname,NBCONFIG.source) # No leading / though\\n dest_systemname = os.path.join(export_path,rootname)\\n \\n mkdir(rootname,isfile=True) # Will make the dir no matter what\\n try:\\n os.symlink(src_systemname,dest_systemname) \\n except OSError:\\n os.remove(dest_systemname)\\n os.symlink(src_systemname,dest_systemname)\\n \\n rootbasename,ext = os.path.splitext(rootname)\\n if ext in NBCONFIG.extensions:\\n dest = os.path.join(export_path,rootbasename + '.html')\\n try:\\n html = main.main_route(rootbasename + '.html')\\n except:\\n print('Issue with: {}'.format(rootname))\\n \\n html = process_page(html,dest)\\n \\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n pages.append(rootbasename)\\n\\n ## Index pages\\n # Home page w/o blog\\n dest_systemname = os.path.join(export_path,'')\\n dest = os.path.join(export_path,'index.html')\\n \\n html0 = main.main_route('/',map_view=True)\\n \\n html = process_page(html0,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n\\n # Also write the sitemap\\n dest = os.path.join(export_path,'_sitemap/index.html')\\n mkdir('/_sitemap',isfile=False)\\n html = process_page(html0,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n \\n # _all\\n dest = os.path.join(export_path,'_all','index.html')\\n \\n html = main.allpage('/')\\n html = process_page(html,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n \\n ## Blog Pages\\n if len(NBCONFIG.blog_dirs) > 0:\\n blog_num = 0\\n while True:\\n dest = os.path.join(export_path,'_blog',unicode(blog_num),'index.html')\\n \\n try:\\n html = main.main_route('/',map_view=False,blog_num=blog_num)\\n except HTTPError:\\n break # At the last one\\n \\n mkdir(dest,isfile=True,isfull=True) \\n \\n html = process_page(html,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n blog_num += 1\\n # Make the home page. \\n dest = os.path.join(export_path,'index.html')\\n html = main.main_route('/',map_view=False,blog_num=0)\\n html = process_page(html,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n \\n ## Special Pages\\n make_random_forward(pages)\\n \\n # Tags\\n dest = os.path.join(export_path,'_tags/index.html')\\n mkdir(dest,isfile=True,isfull=True) \\n html = main.return_tags()\\n html = process_page(html,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n \\n # ToDos\\n dest = os.path.join(export_path,'_todo/index.html')\\n mkdir(dest,isfile=True,isfull=True) \\n html = main.return_todo()\\n html = process_page(html,dest)\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(html)\\n \\n txt = main.return_todo_txt()\\n dest = os.path.join(export_path,'_todo/todo.txt')\\n with open(dest,'w',encoding='utf8') as FF:\\n FF.write(txt)\\n \\n # Galleries\\n cpsym( utils.join(NBCONFIG.scratch_path,'_galleries'),utils.join(export_path,'_galleries'))\\n \\n ## Clean up\\n for F in [utils.join(export_path,'_NBweb',a) for a in ['NBCONFIG.py','NBCONFIG.pyc','template.html']]:\\n try:\\n os.remove(F)\\n except:\\n pass\\n \\n # Make sure there are never any directory listings\\n for dirpath,dirnames,filenames in os.walk(export_path):\\n if 'index.html' not in filenames:\\n with open(utils.join(dirpath,'index.html'),'w',encoding='utf8') as F:\\n F.write('')\",\n \"def write_html_main_index(links: List[Link], out_dir: Path=OUTPUT_DIR, finished: bool=False) -> None:\\n\\n copy_and_overwrite(str(Path(TEMPLATES_DIR) / FAVICON_FILENAME), str(out_dir / FAVICON_FILENAME))\\n copy_and_overwrite(str(Path(TEMPLATES_DIR) / ROBOTS_TXT_FILENAME), str(out_dir / ROBOTS_TXT_FILENAME))\\n copy_and_overwrite(str(Path(TEMPLATES_DIR) / STATIC_DIR_NAME), str(out_dir / STATIC_DIR_NAME))\\n \\n rendered_html = main_index_template(links, finished=finished)\\n atomic_write(str(out_dir / HTML_INDEX_FILENAME), rendered_html)\",\n \"def main(self):\\n\\t\\thtml_file = codecs.open(\\\"./templates/results.html\\\",'w','utf-8')\\n\\t\\thtml_file.write(\\\"\\\"\\\"<!DOCTYPE html>\\\\n<html lang=\\\"en\\\"><head><meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html; charset=UTF-8\\\">\\\\n<meta charset=\\\"utf-8\\\">\\\\n<meta http-equiv=\\\"X-UA-Compatible\\\" content=\\\"IE=edge\\\">\\\\n<meta name=\\\"viewport\\\" content=\\\"width=device-width, initial-scale=1\\\">\\\\n<meta name=\\\"description\\\" content=\\\"Results page for Yelp Road Trip app\\\">\\\\n<meta name=\\\"author\\\" content=\\\"Alexander Ko\\\">\\\\n\\\\n<title>Yelp Road Trip results</title>\\\\n\\\\n<!-- Bootstrap core CSS -->\\\\n<link href=\\\"./../static/css/bootstrap.min.css\\\" rel=\\\"stylesheet\\\">\\\\n<!-- Custom styles for this template -->\\\\n<link href=\\\"./../static/css/jumbotron-narrow.css\\\" rel=\\\"stylesheet\\\">\\\\n<link href=\\\"./../static/css/navbar-fixed-top.css\\\" rel=\\\"stylesheet\\\">\\\\n\\\\n</head>\\\\n\\\\n\\\\n<body class=\\\" hasGoogleVoiceExt\\\">\\\\n\\\\n<div class=\\\"container\\\">\\\\n\\\\n<nav class=\\\"navbar navbar-default navbar-fixed-top\\\" role=\\\"navigation\\\">\\\\n <div class=\\\"container-fluid\\\">\\\\n <!-- Brand and toggle get grouped for better mobile display -->\\\\n <div class=\\\"navbar-header\\\">\\\\n <button type=\\\"button\\\" class=\\\"navbar-toggle\\\" data-toggle=\\\"collapse\\\" data-target=\\\"#bs-example-navbar-collapse-1\\\">\\\\n <span class=\\\"sr-only\\\">Toggle navigation</span>\\\\n <span class=\\\"icon-bar\\\"></span>\\\\n <span class=\\\"icon-bar\\\"></span>\\\\n <span class=\\\"icon-bar\\\"></span>\\\\n </button>\\\\n <a class=\\\"navbar-brand\\\" href=\\\"{{ url_for(\\\\'show_input_form\\\\') }}\\\">Yelp Road Trip</a>\\\\n\\\\n <!--<div class=\\\"page-header\\\">\\\\n <h1>Yelp</h1>\\\\n <div class=\\\"tagline\\\">Road trip</div>\\\\n </div>-->\\\\n </div>\\\\n\\\\n <!-- Collect the nav links, forms, and other content for toggling -->\\\\n <div class=\\\"collapse navbar-collapse\\\" id=\\\"bs-example-navbar-collapse-1\\\">\\\\n <ul class=\\\"nav navbar-nav\\\">\\\\n <li><a href=\\\"{{ url_for(\\\\'map\\\\') }}\\\">Map</a></li>\\\\n <li class=\\\"active\\\"><a href=\\\"#\\\">Results</a></li>\\\\n </ul>\\\\n\\\\n </div><!-- /.navbar-collapse -->\\\\n </div><!-- /.container-fluid -->\\\\n</nav>\\\\n\\\\n<div class=\\\"row marketing\\\">\\\"\\\"\\\")\\n\\n\\t\\t# I do this twice bc there are 2 columns for the HTML file\\n\\t\\tself.write_resturants(self.sorted_resto_keys[:4], html_file)\\n\\t\\thtml_file.write('\\\\n</div>\\\\n')\\n\\t\\tself.write_resturants(self.sorted_resto_keys[4:], html_file)\\n\\n\\t\\thtml_file.write(\\\"\\\"\\\"\\\\n</div> <!-- /container -->\\\\n\\\\n\\\\n<!-- Bootstrap core JavaScript\\\\n================================================== -->\\\\n<!-- Placed at the end of the document so the pages load faster -->\\\\n\\\\n\\\\n<iframe id=\\\"rdbIndicator\\\" width=\\\"100%\\\" height=\\\"270\\\" border=\\\"0\\\" src=\\\"./results_files/indicator.html\\\" style=\\\"display: none; border: 0; position: fixed; left: 0; top: 0; z-index: 2147483647\\\"></iframe></body></html>\\\"\\\"\\\")\\n\\n\\t\\thtml_file.close()\",\n \"def build_pages(ctx, show=False):\\n\\n sys.path.insert(0, os.path.join(ROOT_DIR, '_docs'))\\n import pages\\n import webbrowser\\n\\n # Update all readmes first\\n lines = subprocess.getoutput(['invoke', '-l']).splitlines()\\n lines = [line.strip().split(' ')[0] for line in lines if line.count('.update-readme')]\\n for line in lines:\\n print(subprocess.getoutput(['invoke', line]))\\n\\n pages.build(True, False)\\n if show:\\n webbrowser.open(os.path.join(ROOT_DIR, '_docs', '_pages', 'index.html'))\",\n \"def load_results(self):\\n self.find_benchmark_directories()\\n for (benchmark, producer), result in self.results.items():\\n print('Reading results for ' + benchmark + ' ' + producer)\\n if not result.directory:\\n print('No results found for ' + benchmark + ' ' + producer)\\n else:\\n print('Generating report for: ' + result.directory)\\n report = Report(result.directory)\\n result.reports = report.generate()\",\n \"def setup_output_path(self):\\n self.logger.info('setting up output path')\\n try:\\n self.output_path.mkdir()\\n except FileExistsError:\\n pass\\n try:\\n (self.output_path / 'simple').mkdir()\\n except FileExistsError:\\n pass\\n for filename in resource_listdir(__name__, 'static'):\\n if filename == 'index.html':\\n # Skip template\\n continue\\n with (self.output_path / filename).open('wb') as f:\\n source = resource_stream(__name__, 'static/' + filename)\\n f.write(source.read())\\n source.close()\",\n \"def gather_all_profiles(year, month):\\n page = 1\\n urls = []\\n\\n print(\\\"{}-{} : Begin indexing.\\\".format(year, month))\\n\\n while (page > 0):\\n urlstring = \\\"http://scamdigger.com/{}/{}/page/{}\\\".format(year,month,page) \\n jitter = random.choice([0,1])\\n try:\\n urlhandle = urlopen(urlstring)\\n urls += enumerate_profiles(urlhandle, page)\\n # time.sleep(1+jitter)\\n page += 1\\n except:\\n page = 0\\n\\n print(\\\"{}-{} : {} profiles\\\".format(year,month,len(urls)))\\n\\n for url in urls:\\n uid = url[30:-1]\\n outfile=PROFILES+os.sep+uid+'.json'\\n jitter = random.choice([0,1])\\n try:\\n urlhandle = urlopen(url)\\n scrape_profile(urlhandle, outfile, year, month)\\n # time.sleep(1+jitter)\\n except Exception as e:\\n print(\\\"Exception when handling {}\\\".format(url))\\n print(e)\\n \\n print(\\\"{}-{} : complete.\\\".format(year,month))\",\n \"def populate_index(db):\\n\\tfor url in URL:\\n\\t\\tprint url\\n\\t\\trequest = urllib2.Request(url)\\n\\t\\ttry :\\n\\t\\t\\tresponse = urllib2.urlopen(request)\\n\\t\\texcept urllib2.URLError:\\n\\t\\t\\tprint \\\"Network Unreachable \\\"\\n\\t\\t\\tsys.exit()\\t\\n\\t\\ttext = html2text(response.read())\\n\\t\\tdb.generate_index(text,url)\",\n \"def go(self):\\n self.analyse_folder(BASE)\\n self.analyse_folder(JS_FOLDER)\",\n \"def dispatch(self, request, *args, **kwargs):\\n try:\\n self.copy_static_resources()\\n except MissingStaticRoot:\\n self.template_name = 'general_error.html'\\n kwargs['error'] = _('There is no STATIC_ROOT defined in the settings file')\\n return super().dispatch(request, *args, **kwargs)\\n except Exception as e:\\n self.template_name = 'general_error.html'\\n kwargs['error'] = str(e)\\n return super().dispatch(request, *args, **kwargs)\\n cms_pages = Page.objects.filter(publication_date__isnull=False)\\n for page in cms_pages:\\n languages = page.get_languages()\\n for language in languages:\\n url = page.get_public_url(language)\\n if url not in self.done:\\n self.done.append(url)\\n static_page_path = '{}{}index.html'.format(STORAGE_PATH, url)\\n fetch_url = \\\"{}{}\\\".format(self.SOURCE_DOMAIN, url)\\n response = requests.get(fetch_url)\\n make_dir(url)\\n with open(static_page_path, 'w') as file:\\n file.write(response.text)\\n return super().dispatch(request, *args, **kwargs)\",\n \"def ui_backgrounds(request):\\n out = createBaseResponseObject() \\n path = os.path.join(settings.BASE_PATH , \\\"sketch_ui/static/ui/backgrounds\\\")\\n files = os.listdir(path)\\n for f in files:\\n out['results'].append(f)\\n \\n return HttpResponse(json.dumps(out))\",\n \"def main():\\n\\n app_config = load_config()\\n database_connection = mysql.connector.connect(**app_config[\\\"database\\\"])\\n panelists = retrieve_all_panelist_appearance_counts(database_connection)\\n show_years = retrieve_all_years(database_connection)\\n\\n rendered_report = render_report(show_years=show_years,\\n panelists=panelists,\\n report_settings=app_config[\\\"report\\\"])\\n\\n generate_output_files(rendered_report=rendered_report,\\n report_settings=app_config[\\\"report\\\"])\",\n \"def parse(self, response):\\n json_response = json.loads(response.text)\\n fetched_results = len(json_response['results'])\\n\\n if not hasattr(self, 'processed_results'):\\n self.processed_results = 0\\n self.processed_results += fetched_results\\n if fetched_results == 0:\\n logging.info('No more files. Total files queried {}'.format(\\n self.processed_results))\\n return\\n\\n for result in json_response['results']:\\n document = self._create_document(result['columns'])\\n if document['language'] != u'ENG':\\n info = 'Case {} {} not in ENG, original language {}'.format(\\n document['original_id'], document['name'].encode('utf-8'),\\n result['columns']['languageisocode'])\\n logging.info(info)\\n continue\\n doc_url = self.base_document_url.format(document['original_id'])\\n new_request = scrapy.Request(doc_url, callback=self.parse_document)\\n new_request.meta['document'] = document\\n yield new_request\\n\\n if self.processed_results < int(getattr(self, 'limit', DEFAULT_LIMIT)):\\n next_url = self.base_main_url.format(\\n start_index=self.processed_results, length=RESULT_PER_PAGE)\\n yield scrapy.Request(next_url, callback=self.parse)\\n else:\\n logging.info('Limit reached. Total files obtained {}'.format(\\n self.processed_results))\",\n \"def generate(self):\\n\\n # Load the required datapoints into memory.\\n self._load_results()\\n\\n # Calculate datapoints statistics, like min. and max. values.\\n self._calc_stats()\\n\\n # Generate the plots.\\n self._generate_scatter_plots()\\n self._generate_histograms()\\n\\n # Put together the final HTML report.\\n self._generate_report()\",\n \"def main():\\n goods = '书包'\\n # 爬取深度\\n depth = 3\\n start_url = 'https://s.taobao.com/search?q=' + goods\\n # 输出结果的列表\\n infoList = []\\n # 使用for循环对每一个页面进行处理\\n for i in range(depth):\\n try:\\n # 每个页面的URL链接\\n url = start_url + '' + str(44*i)\\n html = getHTMLText(url)\\n parsePage(infoList, html)\\n except:\\n continue\\n printGoodsList(infoList)\",\n \"def run(self):\\n not_modules = []\\n root = self.path\\n files = []\\n search_files = [\\n '__openerp__.py', '__manifest__.py', 'README.rst', 'index.html']\\n for sfile in search_files:\\n files += subprocess.Popen(\\n ['find', root, '-name', sfile],\\n stdout=subprocess.PIPE).stdout.readlines()\\n files.sort()\\n files = [item.strip() for item in files]\\n\\n if os.path.isfile(os.path.join(root, '__openerp__.py')) or \\\\\\n os.path.isfile(os.path.join(root, '__manifest__.py')):\\n module_list = [os.path.basename(root)]\\n root = os.path.split(root)[0]\\n self.path = root\\n else:\\n module_list = os.walk(root).next()[1]\\n if module_list.count('.git'):\\n module_list.remove('.git')\\n module_list.sort()\\n\\n for module in module_list:\\n os.system('echo Generating index.html module ' + module)\\n openerp_py = os.path.join(root, module, '__openerp__.py')\\n readme_file = os.path.join(root, module, 'README.rst')\\n index_file = os.path.join(\\n root, module, 'static/description/index.html')\\n\\n if openerp_py not in files:\\n openerp_py = os.path.join(root, module, '__manifest__.py')\\n if openerp_py not in files:\\n not_modules.append(module)\\n continue\\n\\n # Get module data\\n description = ''\\n name, summary, description = self.get_module_data(\\n openerp_py, readme_file)\\n\\n # Call @nhomar's script.\\n html_description = rst2html.html.rst2html(description)\\n\\n content = self.prepare_content(html_description, name, summary)\\n\\n self.add_missing_dirs(index_file)\\n self.add_missing_icon(module)\\n\\n with open(index_file, 'w') as ifile:\\n ifile.write(content)\\n\\n if not_modules:\\n for item in not_modules:\\n print 'NOTE: This is not an odoo module', item\\n return True\",\n \"def get_pages(self, url_list):\\n page_helper = self.get_page\\n pool = ThreadPool(self.max_threads)\\n results = pool.map(page_helper, url_list)\\n pool.close()\\n pool.join()\\n return results\",\n \"def perf_result_page():\\n # Get all fields from form\\n module = request.forms.getall('module')\\n version = request.forms.getall('version')\\n script = request.forms.getall('script')\\n tag = request.forms.getall('tag')\\n value_inf = request.forms.get('value_inf')\\n value_sup = request.forms.get('value_sup')\\n # Build html\\n result = do_perf_request(module_type=module, version=version, tag=tag,\\n value_inf=value_inf, value_sup=value_sup,\\n script_name=script)\\n\\n try:\\n kibana_query = 'computer_name:parrotsa* AND name:{0} AND module:{1}'.format(tag[0], module[0])\\n except IndexError:\\n kibana_query = '*'\\n kibana_url = \\\"http://172.20.22.104:5601/app/kibana#/dashboard/performance?_a=(query:(query_string:(query:'{0}')))\\\".format(kibana_query)\\n print result\\n print kibana_url\\n # Build template page\\n with open(\\\"./header.html\\\") as header, open('./perf.tpl') as perf, open('./footer.html') as footer:\\n template_html = header.read() + perf.read() + footer.read()\\n\\n if result:\\n output = template(template_html, result=result, kibana_url=kibana_url)\\n else:\\n output = template(template_html, result=[], kibana_url=kibana_url)\\n\\n return output\",\n \"def make_validation_report(\\n urls=None,\\n destdir=\\\"astropy.io.votable.validator.results\\\",\\n multiprocess=True,\\n stilts=None,\\n):\\n from astropy.utils.console import ProgressBar, Spinner, color_print\\n\\n if stilts is not None:\\n if not os.path.exists(stilts):\\n raise ValueError(f\\\"{stilts} does not exist.\\\")\\n\\n destdir = os.path.expanduser(destdir)\\n destdir = os.path.abspath(destdir)\\n\\n if urls is None:\\n with Spinner(\\\"Loading URLs\\\", \\\"green\\\") as s:\\n urls = get_urls(destdir, s)\\n else:\\n urls = [url.encode() for url in urls if isinstance(url, str)]\\n\\n color_print(\\\"Marking URLs\\\", \\\"green\\\")\\n for url in ProgressBar(urls):\\n with result.Result(url, root=destdir) as r:\\n r[\\\"expected\\\"] = type\\n\\n args = [(url, destdir) for url in urls]\\n\\n color_print(\\\"Downloading VO files\\\", \\\"green\\\")\\n ProgressBar.map(download, args, multiprocess=multiprocess)\\n\\n color_print(\\\"Validating VO files\\\", \\\"green\\\")\\n ProgressBar.map(validate_vo, args, multiprocess=multiprocess)\\n\\n if stilts is not None:\\n color_print(\\\"Validating with votlint\\\", \\\"green\\\")\\n votlint_args = [(stilts, x, destdir) for x in urls]\\n ProgressBar.map(votlint_validate, votlint_args, multiprocess=multiprocess)\\n\\n color_print(\\\"Generating HTML files\\\", \\\"green\\\")\\n ProgressBar.map(write_html_result, args, multiprocess=multiprocess)\\n\\n with Spinner(\\\"Grouping results\\\", \\\"green\\\") as s:\\n subsets = result.get_result_subsets(urls, destdir, s)\\n\\n color_print(\\\"Generating index\\\", \\\"green\\\")\\n html.write_index(subsets, urls, destdir)\\n\\n color_print(\\\"Generating subindices\\\", \\\"green\\\")\\n subindex_args = [(subset, destdir, len(urls)) for subset in subsets]\\n ProgressBar.map(write_subindex, subindex_args, multiprocess=multiprocess)\",\n \"def index():\\n\\n page = \\\"\\\"\\\"\\n <h1>Calculator</h1>\\n <div>Directions. This app will calculate 2 or more numbers provided in the url string. To use:\\n <ol>\\n <li>Type in http://localhost:8080/</li>\\n <li>Type in the arithmetic operation (add, subract, multiply, divide) followed by /</li>\\n <li>Type in numbers. Between each number include a /</li>\\n <li>For example, http://localhost:8080/add/5/10/</li>\\n </ol></div>\\n <h2>Tests:</h2><ul>\\n <li><a href=\\\"http://localhost:8080/add/5/10/15\\\">Addition</a></li>\\n <li><a href=\\\"http://localhost:8080/subtract/100/50/25\\\">Subraction</a></li>\\n <li><a href=\\\"http://localhost:8080/multiply/5/10/15\\\">Multiplication</a></li>\\n <li><a href=\\\"http://localhost:8080/divide/100/50\\\">Division</a></li>\\n \\\"\\\"\\\"\\n return page\",\n \"def _go_through_summary_reports(self):\\n\\n for result_file in self.result_files:\\n self.cur_8digit_dir = os.path.split(result_file)[0]\\n try:\\n with open(result_file) as f_in:\\n sum_rep = json.load(f_in)\\n if sum_rep.has_key('Artifacts'):\\n for linked_artifact in sum_rep['Artifacts']:\\n artifact_path = linked_artifact['Path']\\n # For now assume only files are linked (no folders)\\n rel_path_from_results = os.path.join(self.cur_8digit_dir, artifact_path)\\n if os.path.exists(rel_path_from_results):\\n self.files_for_export.append(os.path.join('results',\\n rel_path_from_results))\\n if artifact_path.endswith('.json'):\\n function_tag = artifact_path.replace('.','_').replace('/','_')\\n\\n if hasattr(self, function_tag):\\n getattr(self, function_tag)()\\n except IOError:\\n print '{0} does not exist on this filesystem. I cannot be check for references '\\\\\\n 'to other files.'.format(result_file)\",\n \"def get_results():\\n # store info in a dictionary {name -> shortname}\\n res = {}\\n session = requests.Session()\\n handle_url('http://www.gocomics.com/features', session, res)\\n handle_url('http://www.gocomics.com/explore/editorial_list', session, res)\\n handle_url('http://www.gocomics.com/explore/sherpa_list', session, res)\\n save_result(res, json_file)\",\n \"def test_three_paginated_list_pages():\\n\\n TEST_WEBSITE.wipe()\\n _clean_up_test_items_md()\\n _generate_test_items_md(10)\\n\\n Webpage.write_list_pages_from_directory(TEST_WEBSITE, TEST_WEBSITE.config.value('source_path'))\\n\\n # There should be an index.html and exactly 2 blog-n.html files\\n assert path.isfile(TEST_WEBSITE.config.value('output_path') + 'index.html')\\n assert not path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-1.html')\\n assert path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-2.html')\\n assert path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-3.html')\\n assert not path.isfile(TEST_WEBSITE.config.value('output_path') + 'blog-4.html')\\n\\n with open(TEST_WEBSITE.config.value('output_path') + 'index.html', 'r') as myfile:\\n blog_1_content = myfile.read()\\n\\n with open(TEST_WEBSITE.config.value('output_path') + 'blog-2.html', 'r') as myfile:\\n blog_2_content = myfile.read()\\n\\n with open(TEST_WEBSITE.config.value('output_path') + 'blog-3.html', 'r') as myfile:\\n blog_3_content = myfile.read()\\n\\n assert blog_1_content.count('<article>') == 4\\n assert 'Article 10.' in blog_1_content\\n assert 'Article 9.' in blog_1_content\\n assert 'Article 8.' in blog_1_content\\n assert 'Article 7.' in blog_1_content\\n assert '<p>Listing page template</p>' in blog_1_content\\n\\n\\n assert blog_2_content.count('<article>') == 4\\n assert 'Article 6.' in blog_2_content\\n assert 'Article 5.' in blog_2_content\\n assert 'Article 4.' in blog_2_content\\n assert 'Article 3.' in blog_2_content\\n assert '<p>Listing page template</p>' in blog_2_content\\n\\n assert blog_3_content.count('<article>') == 2\\n assert 'Article 2.' in blog_3_content\\n assert 'Article 1.' in blog_3_content\\n assert '<p>Listing page template</p>' in blog_3_content\\n\\n\\n # Page title = \\\"Website Name - Page n\\\"\\n assert 'Test website name - test tag & line' in blog_1_content\\n assert '<title>Test website name - Page 2</title>' in blog_2_content\\n assert '<title>Test website name - Page 3</title>' in blog_3_content\\n\\n # First page should have link to older posts but not newer\\n assert '<a href=\\\"blog-2.html\\\" class=\\\"magnetizer-next\\\">Older posts</a>' in blog_1_content\\n assert 'class=\\\"magnetizer-previous\\\"' not in blog_1_content\\n\\n # Middle page should have link to older posts (i.e. homepage) and newer\\n assert '<a href=\\\"blog-3.html\\\" class=\\\"magnetizer-next\\\">Older posts</a>' in blog_2_content\\n assert '<a href=\\\"/\\\" class=\\\"magnetizer-previous\\\">Newer posts</a>' in blog_2_content\\n\\n # Last page should have link to newer posts but not older\\n assert 'class=\\\"magnetizer-next\\\"' not in blog_3_content\\n assert '<a href=\\\"blog-2.html\\\" class=\\\"magnetizer-previous\\\">Newer posts</a>' in blog_3_content\\n\\n # Pages should have meta description from config\\n assert '<meta name=\\\"description\\\" content=\\\"Meta \\\\\\\\\\\"description\\\\\\\\\\\" from cfg\\\">' in blog_1_content\\n assert '<meta name=\\\"description\\\" content=\\\"Meta \\\\\\\\\\\"description\\\\\\\\\\\" from cfg\\\">' in blog_2_content\\n assert '<meta name=\\\"description\\\" content=\\\"Meta \\\\\\\\\\\"description\\\\\\\\\\\" from cfg\\\">' in blog_3_content\\n\\n # index.html and the blog-n pages should be present in the sitemap\\n assert 'https://example.com/' in TEST_WEBSITE.sitemap.pages\\n assert not 'https://example.com/blog-1.html' in TEST_WEBSITE.sitemap.pages\\n assert 'https://example.com/blog-2.html' in TEST_WEBSITE.sitemap.pages\\n assert 'https://example.com/blog-3.html' in TEST_WEBSITE.sitemap.pages\",\n \"def GenerateResults(self, want_combos, filename):\\n\\n all = ENTRIES_FINISH_CATEGORIES\\n ord = orderByIncreasingBitCount(len(all))\\n qgt = QueryGeneratorTop(self, 'entries', all)\\n\\n restrict = None\\n if not None is want_combos:\\n restrict = self._generateResults_combosToBitmasks(all, want_combos)\\n print \\\"Restrict report to:\\\", restrict\\n\\n self.StartReport(REPORT_TITLE, filename)\\n for i in ord:\\n if len(restrict) > 0 and not i in restrict:\\n continue\\n qg = QueryGenerator(qgt, i, self.CompileReport)\\n qg.GenerateResultCombinations()\\n self.ReportDNFs()\\n self.ReportMissings()\\n self.FinishReport()\",\n \"def do_html(pidx):\\n response_headers = [(\\\"Content-type\\\", \\\"text/html\\\")]\\n name = get_script_name(pidx)\\n if not os.path.isfile(name):\\n sys.stderr.write(f\\\"autoplot/meta 404 {name}\\\\n\\\")\\n status = \\\"404 Not Found\\\"\\n output = \\\"\\\"\\n return output.encode(), status, response_headers\\n loader = importlib.machinery.SourceFileLoader(f\\\"p{pidx}\\\", name)\\n spec = importlib.util.spec_from_loader(loader.name, loader)\\n mod = importlib.util.module_from_spec(spec)\\n loader.exec_module(mod)\\n # see how we are called, finally\\n appdata = mod.get_description()\\n html = generate_html(appdata)\\n return html, \\\"200 OK\\\", response_headers\",\n \"def index(*args, **kwargs):\\n yield from _generate(*args, **kwargs)\",\n \"def get_results():\\n # store info in a dictionary {name -> shortname}\\n res = {}\\n session = requests.Session()\\n handle_url('http://www.creators.com/comics/cat-seeall.html', session, res)\\n save_result(res, json_file)\",\n \"def main():\\n # %%\\n CFG.profiles_yamls_path.mkdir(parents=True, exist_ok=True)\\n fpaths = list( _Config.raw_profiles_path.glob('*.html') )\\n print( f'{len(fpaths)} htmls found' )\\n # %%\\n fpath = CFG.raw_profiles_path / 'luis-mario-urrea-murillo.html'\\n # %%\\n fpath = CFG.raw_profiles_path / 'cristian-david-montoya-saldarriaga-09638514a.html'\\n # %%\\n fpaths = [ CFG.raw_profiles_path / 'ricardo-alarcon-44079b105.html' ]\\n # %%\\n fpaths = [ Path('/home/teo/_data/talent/linkedin_raw_profiles/israellaguan.html')]\\n # %%\\n dics = {}\\n # %%\\n\\n for i, fpath in enumerate(fpaths):\\n if fpath in dics:\\n continue\\n\\n with fpath.open('rt') as f_in:\\n html = f_in.read()\\n\\n print( f'\\\\n***{i+1}/{len(fpaths)} {fpath.name}:')\\n dic = extract_one( html, fpath )\\n dic['linkedin_url'] = f\\\"https://www.linkedin.com/in/{fpath.name.split('.')[0]}\\\"\\n dic['scraped_at'] = dt.datetime.fromtimestamp( fpath.stat().st_ctime )\\n # pprint(dic['work_stats'])\\n dics[fpath] = dic\\n\\n dics_arr = list(dics.values())\\n # %%\\n del dics\\n # %%\\n\\n with (CFG.profiles_yamls_path / 'all_profiles.json').open('wt') as f_out:\\n json.dump( dics_arr, f_out, cls=DateTimeEncoder, indent=4 )\\n # %%\\n with (CFG.profiles_yamls_path / 'all_profiles.yaml').open('wt') as f_out:\\n yaml.safe_dump( dics_arr, f_out )\\n # %%\\n df = produce_summary_table( dics_arr )\\n df.to_excel( CFG.raw_profiles_path.parent / 'mined_ruby_candidates_sample.xlsx',\\n index=False)\\n # %%\",\n \"async def test_get_multiple_pages():\\n writer = SimpleWriter()\\n work_queue = asyncio.Queue()\\n await work_queue.put(TestData.JOB_TEMPLATE_PAYLOAD_ALL_PAGES)\\n worker = tower_api_worker.TowerApiWorker(TestData.config, writer, work_queue)\\n headers = {\\\"Content-Type\\\": \\\"application/json\\\"}\\n with aioresponses() as mocked:\\n mocked.get(\\n TestData.JOB_TEMPLATES_LIST_URL,\\n status=200,\\n body=json.dumps(TestData.JOB_TEMPLATES_PAGE1_RESPONSE),\\n headers=headers,\\n )\\n mocked.get(\\n TestData.JOB_TEMPLATES_LIST_URL_PAGE_2,\\n status=200,\\n body=json.dumps(TestData.JOB_TEMPLATES_PAGE2_RESPONSE),\\n headers=headers,\\n )\\n res = await worker.start()\\n assert writer.data[\\\"count\\\"] == 3\\n assert writer.called == 2\",\n \"def make_html(depends=(files['image.gif'],),\\n targets=(files['index.html'],)):\\n\\n index_html = open(files['index.html'].rel, 'w')\\n index_html.write(pyyaks.context.render(html_template))\\n index_html.close()\",\n \"def main():\\n\\n browser = initialize()\\n process_directory(browser, \\\"data\\\")\\n browser.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7309482","0.6664472","0.6591473","0.65694594","0.6510609","0.6404508","0.6366648","0.63231736","0.6277945","0.622136","0.6204493","0.6124423","0.6105005","0.60247594","0.6022048","0.5962354","0.5959207","0.59505546","0.59500504","0.5926389","0.5917044","0.58833563","0.58758575","0.58712196","0.5861006","0.5839438","0.58302724","0.58163726","0.5814703","0.576945","0.5751711","0.57332903","0.57329565","0.5722852","0.5715291","0.5699431","0.5694865","0.5694385","0.56841946","0.5674137","0.56706923","0.5668505","0.5664905","0.56611943","0.56534165","0.5651","0.56509495","0.56458604","0.56422746","0.564129","0.5629885","0.5623686","0.5622938","0.5617462","0.56130886","0.56117296","0.56062186","0.55991393","0.55974793","0.55943286","0.5593038","0.55919224","0.55848235","0.558441","0.5576587","0.55715346","0.5568348","0.5566925","0.55536914","0.5532098","0.55320495","0.55311894","0.55284166","0.55277365","0.5519865","0.5515222","0.55130947","0.55127555","0.55031455","0.55029786","0.5498842","0.5496672","0.5489216","0.5488596","0.54865074","0.54845935","0.54845494","0.5482051","0.5474614","0.5472611","0.54703856","0.5468356","0.54682666","0.5465927","0.5463865","0.5460804","0.5459718","0.5453266","0.5453201","0.5452915"],"string":"[\n \"0.7309482\",\n \"0.6664472\",\n \"0.6591473\",\n \"0.65694594\",\n \"0.6510609\",\n \"0.6404508\",\n \"0.6366648\",\n \"0.63231736\",\n \"0.6277945\",\n \"0.622136\",\n \"0.6204493\",\n \"0.6124423\",\n \"0.6105005\",\n \"0.60247594\",\n \"0.6022048\",\n \"0.5962354\",\n \"0.5959207\",\n \"0.59505546\",\n \"0.59500504\",\n \"0.5926389\",\n \"0.5917044\",\n \"0.58833563\",\n \"0.58758575\",\n \"0.58712196\",\n \"0.5861006\",\n \"0.5839438\",\n \"0.58302724\",\n \"0.58163726\",\n \"0.5814703\",\n \"0.576945\",\n \"0.5751711\",\n \"0.57332903\",\n \"0.57329565\",\n \"0.5722852\",\n \"0.5715291\",\n \"0.5699431\",\n \"0.5694865\",\n \"0.5694385\",\n \"0.56841946\",\n \"0.5674137\",\n \"0.56706923\",\n \"0.5668505\",\n \"0.5664905\",\n \"0.56611943\",\n \"0.56534165\",\n \"0.5651\",\n \"0.56509495\",\n \"0.56458604\",\n \"0.56422746\",\n \"0.564129\",\n \"0.5629885\",\n \"0.5623686\",\n \"0.5622938\",\n \"0.5617462\",\n \"0.56130886\",\n \"0.56117296\",\n \"0.56062186\",\n \"0.55991393\",\n \"0.55974793\",\n \"0.55943286\",\n \"0.5593038\",\n \"0.55919224\",\n \"0.55848235\",\n \"0.558441\",\n \"0.5576587\",\n \"0.55715346\",\n \"0.5568348\",\n \"0.5566925\",\n \"0.55536914\",\n \"0.5532098\",\n \"0.55320495\",\n \"0.55311894\",\n \"0.55284166\",\n \"0.55277365\",\n \"0.5519865\",\n \"0.5515222\",\n \"0.55130947\",\n \"0.55127555\",\n \"0.55031455\",\n \"0.55029786\",\n \"0.5498842\",\n \"0.5496672\",\n \"0.5489216\",\n \"0.5488596\",\n \"0.54865074\",\n \"0.54845935\",\n \"0.54845494\",\n \"0.5482051\",\n \"0.5474614\",\n \"0.5472611\",\n \"0.54703856\",\n \"0.5468356\",\n \"0.54682666\",\n \"0.5465927\",\n \"0.5463865\",\n \"0.5460804\",\n \"0.5459718\",\n \"0.5453266\",\n \"0.5453201\",\n \"0.5452915\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70953083"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":907,"numItemsPerPage":100,"numTotalItems":95772,"offset":90700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTY4NTY3NSwianRpIjoiYWY5MTA4NWEtN2VkYy00YzZmLThiMjYtYzUwMzlhZWFlYWQ0Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU2ODkyNzUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.rsVJqHx59CplebhMez29-Iv0iC6FTx6Re-4Rtv3QXKaIeeOSQmTjkbMaLkYCucQg2Ne0Wnx-jujN2iK29y_sDg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Vehicle Miles Traveled (Trips per vehicle X miles per trip) | def calculate_vht_dynamically(meta_data, interval, **kwargs):
flow_data = meta_data.get('flow')
speed_data = meta_data.get('speed')
missing_data = kwargs.get('missing_data', cfg.MISSING_VALUE)
vd = moe_helper.VIRTUAL_RNODE_DISTANCE
seconds_per_hour = 3600
vht_data = []
for flow, speed in zip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trafficJam(lanes,miles):\n\n\n feet = miles * 5280 #Feet in a mile\n total_feet = feet * lanes #Total feet in all lanes\n cars = total_feet / 15 #Average feet a car takes\n\n return cars",
"def test_get_miles(self):\n miles = location_util.vincenty(COORDINATES_PARIS,\n ... | [
"0.6453263",
"0.5916066",
"0.5779557",
"0.577009",
"0.57544905",
"0.5743861",
"0.5491067",
"0.5485611",
"0.54791665",
"0.53125626",
"0.5312528",
"0.52798194",
"0.5251859",
"0.52304333",
"0.5122987",
"0.51183033",
"0.51022637",
"0.50925875",
"0.509046",
"0.5081807",
"0.5075941... | 0.0 | -1 |
Load status code table. | def load_status_table(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data():\n try:\n loader.download()\n load_table_data()\n status = 'loaded'\n except Exception as ex:\n log.log_traceback(ex)\n status = 'failed'\n return flask.jsonify({'status': status})",
"def load_status(sec_status):\n with open(sec_status, 'r') as infil... | [
"0.6304792",
"0.6128468",
"0.6098472",
"0.5995203",
"0.55925363",
"0.55922043",
"0.55655104",
"0.55066717",
"0.54105455",
"0.53784657",
"0.5279865",
"0.52605635",
"0.51376367",
"0.5121974",
"0.5121277",
"0.51052105",
"0.5081247",
"0.50530696",
"0.5048871",
"0.5047821",
"0.504... | 0.8231332 | 0 |
Sample 'Nsamples' points from the posterior distribution. | def sample_posterior(
rng_key: random.PRNGKey,
model,
data: np.ndarray,
Nsamples: int = 1000,
alpha: float = 1,
sigma: float = 0,
T: int = 10,
gibbs_fn=None,
gibbs_sites=None):
if gibbs_fn is None or gibbs_sites is None:
return sample_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def posterior_sampler(self, nsamples, seed=0, verbose=True):\n\n import random\n\n random.seed(seed)\n sample = self.get_chain()[-self.get_tune:]\n sample = sample.reshape(-1, sample.shape[-1])\n sample = random.choices(sample, k=nsamples)\n\n return sample",
"def sample_parameters_posterior(se... | [
"0.77720845",
"0.7699922",
"0.7486653",
"0.73114294",
"0.7251321",
"0.72014636",
"0.71816784",
"0.71629894",
"0.7017441",
"0.6927576",
"0.6925858",
"0.69242823",
"0.69242823",
"0.68736494",
"0.68268055",
"0.6809603",
"0.67950916",
"0.67018616",
"0.6695109",
"0.66541606",
"0.6... | 0.0 | -1 |
Receive an answer from the daemon and return the response. | def receive_data(socket):
answer = b""
while True:
packet = socket.recv(4096)
if not packet: break
answer += packet
response = pickle.loads(answer)
socket.close()
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receive_response(self):\n return self.socket.receive()",
"def receive_response(self, private_key, responder_id, msg_tag, response):\n return self._handle_response(private_key, responder_id, msg_tag, response)",
"async def recv(self):\n return await self.receptor.response_queue.get()",
... | [
"0.60401213",
"0.59346366",
"0.57792765",
"0.56736755",
"0.5629071",
"0.5618967",
"0.5585548",
"0.55596626",
"0.55558836",
"0.55464935",
"0.5528463",
"0.55242884",
"0.5516146",
"0.5492562",
"0.54331195",
"0.5410309",
"0.54007417",
"0.5396902",
"0.5392102",
"0.53897995",
"0.53... | 0.0 | -1 |
Print a response message and exit with 1, if the response wasn't a success. | def process_response(response):
# Print it and exit with 1 if operation wasn't successful
print(response['message'])
if response['status'] != 'success':
sys.exit(1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_ok(msg):\n print('OK - %s' % (msg))\n sys.exit(0)",
"def check_response(rv):\n if rv != 'OK':\n print \"No message found\"\n return False\n return True",
"def _is_successful(response) -> bool:\n return response.status_code == 200",
"def exit_success(message: Optional[st... | [
"0.7340724",
"0.69758445",
"0.67532015",
"0.67513496",
"0.66959393",
"0.66255456",
"0.65675175",
"0.6507938",
"0.64950174",
"0.649325",
"0.6481977",
"0.6443774",
"0.6417801",
"0.64016646",
"0.6399089",
"0.63857675",
"0.6373736",
"0.6370738",
"0.634704",
"0.6334164",
"0.632734... | 0.81670505 | 0 |
Connect to a daemon's socket. | def connect_socket(root_dir):
# Get config directory where the daemon socket is located
config_dir = os.path.join(root_dir, '.config/pueue')
# Create Socket and exit with 1, if socket can't be created
try:
client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
socket_path = os.path.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect_socket(self):\n self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n self.sock.connect((self.ip, self.port))\n print(\"Connected to %s at port %d\" % (self.ip, self.port))",
"def __connect():\n # Create socket\n sock = socket.socket(socket.AF_INET, socket.SOCK_S... | [
"0.7152145",
"0.7110767",
"0.69015676",
"0.68839574",
"0.6861228",
"0.68268406",
"0.68084097",
"0.6778838",
"0.67785",
"0.67722744",
"0.67408895",
"0.6712054",
"0.66876894",
"0.6654631",
"0.6639277",
"0.66327703",
"0.6606217",
"0.6582687",
"0.65193504",
"0.64702415",
"0.64390... | 0.76585114 | 0 |
Solve x^2 Dy^2 = 1 | def solve_D(D):
sdr = math.sqrt(D)
sdi = int(sdr)
if sdi == sdr :
return None
y = 1
while True :
xr = math.sqrt(y*y*D+1)
xi = int(xr)
if xr == xi :
return xi
y += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def d2(x0,y0,x1,y1):\n return (x0-x1)*(x0-x1) + (y0-y1)*(y0-y1)",
"def DirectSolve(self, y):\n if y >= -self.R:\n a1 = self.apath[y+1]\n if y == -2:\n a2 = 0\n else:\n a2 = self.apath[y+2] \n def constraints(a)... | [
"0.68067557",
"0.6691289",
"0.65991104",
"0.63777244",
"0.6326121",
"0.63033235",
"0.6270462",
"0.6249652",
"0.62165457",
"0.61716276",
"0.61288655",
"0.6075027",
"0.6069478",
"0.60646653",
"0.6061647",
"0.60577327",
"0.60004056",
"0.5963938",
"0.5960648",
"0.59581274",
"0.59... | 0.63733596 | 4 |
Area of the shape. | def area(self) -> float:
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def area(self):\n return self._ned_shape.area",
"def area(self):\n return self.length*self.length",
"def area(self):\n area = self.__size * self.__size\n return area",
"def area(self):\n area = self.__size * self.__size\n return(area)",
"def area(self):\n ar... | [
"0.859661",
"0.8539494",
"0.8486993",
"0.84419984",
"0.8439382",
"0.8387308",
"0.83254606",
"0.8314752",
"0.8312584",
"0.8241274",
"0.8237015",
"0.8232725",
"0.821546",
"0.821546",
"0.821546",
"0.8212535",
"0.8212535",
"0.8206858",
"0.8191822",
"0.8187152",
"0.8187152",
"0.... | 0.853149 | 2 |
Check if the point is inside the shape. Support semantics like `if point in shape` | def __contains__(self, point: Point2D) -> bool:
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isInside(point_x, point_y, area_left, area_top, area_width, area_height):\n return (area_left <= point_x < area_left + area_width) and (area_top <= point_y < area_top + area_height)",
"def point_in_poly(x_point: float, y_point: float) -> bool:\n\n # Semi-F47 extended states all devices should be able t... | [
"0.7572516",
"0.75540507",
"0.7464582",
"0.7464582",
"0.74356055",
"0.74341583",
"0.73613477",
"0.73446983",
"0.732574",
"0.732574",
"0.72910684",
"0.72736067",
"0.721901",
"0.7183408",
"0.7174966",
"0.7172073",
"0.7092216",
"0.7086525",
"0.7081146",
"0.7063076",
"0.70347816"... | 0.6834352 | 40 |
Get string representation of the shape. | def __str__(self) -> str:
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape(shape):\n print shape_str(shape)",
"def shape_str(shape):\n return '\\n'.join(''.join(map({'X': 'X', None: 'O'}.get, line))\n for line in shape)",
"def shape2str(x):\n return \"[\" + \" x \".join([str(x) for x in x.shape]) + \"]\"",
"def __str__(self):\n return 'Type... | [
"0.8021077",
"0.7999233",
"0.77616286",
"0.7733696",
"0.7653659",
"0.741345",
"0.7397373",
"0.7232627",
"0.7196523",
"0.7184904",
"0.7127414",
"0.7106067",
"0.6909982",
"0.68698555",
"0.68658304",
"0.68586445",
"0.6852846",
"0.6846274",
"0.6837171",
"0.68368703",
"0.68325347"... | 0.0 | -1 |
reads the config file, which passes the full path names for the source and destination files | def readConf(confFile):
with open(confFile) as json_data_file:
configData = json.load(json_data_file)
return configData | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_config(self, config_filename):",
"def process_config(self, filename):\n \n self.log_message(\"processing config file: \"+filename)\n parser = SafeConfigParser()\n parser.optionxform = str\n parser.read(filename)\n self.source_files[filename] = parser\n \n... | [
"0.73588794",
"0.6609339",
"0.6605063",
"0.64606553",
"0.64132637",
"0.6266823",
"0.62592244",
"0.6249302",
"0.621985",
"0.61848795",
"0.6154891",
"0.61509305",
"0.60969436",
"0.6065688",
"0.60582817",
"0.60545635",
"0.60386914",
"0.6036724",
"0.6027614",
"0.6019661",
"0.6017... | 0.0 | -1 |
takes the config data and calls the moveFile function | def parseConf(confData):
groupNames = confData.keys()
for group in groupNames:
logger.info("processing {0}".format(confData[group]["group_name"]))
logger.info("source: {0}".format(confData[group]["source"]))
sourcePath = confData[group]["source"]
logger.info("destination: {0}".format(confData[group]["destinat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_file(self, ctx):\n pass",
"def move_from_temp_directory(self):",
"def on_moved(self, event):\n print(\"Moved\")\n time.sleep(5)\n self.moveFile(event.dest_path)",
"def act_move_file(self, file_source, file_target):\n try:\n if not os.path.isfile(file_sou... | [
"0.68956894",
"0.62802804",
"0.6229746",
"0.62043524",
"0.6184494",
"0.6134909",
"0.6030467",
"0.60047734",
"0.59891856",
"0.5984465",
"0.59631",
"0.59522945",
"0.59437495",
"0.59367484",
"0.5934672",
"0.5874775",
"0.5864976",
"0.58420366",
"0.5731938",
"0.57225734",
"0.57017... | 0.5333043 | 52 |
experimental function to configure logging | def logConfigure(logFileName, debugFlag=False):
logPath = '../log/'
logFile = '{0}{1}'.format(logPath, logFileName)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# create file handler which logs even debug messages
fh = logging.FileHandler(logFile)
fh.setLevel(logging.DEBUG)
# create c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _configure_logging(self):\n pass",
"def __setup_logging(self):\n\n loglevel = logging.INFO\n if self.config[\"verbose\"]:\n loglevel = logging.DEBUG\n\n FORMAT = '[%(asctime)s %(filename)s:%(lineno)s %(levelname)s] %(message)s'\n if self.config[\"log\"]:\n ... | [
"0.8682738",
"0.7844487",
"0.782434",
"0.7785766",
"0.7695341",
"0.76718855",
"0.7670273",
"0.7550738",
"0.7525644",
"0.75252914",
"0.7519401",
"0.74901396",
"0.7472518",
"0.74642056",
"0.74499345",
"0.74477077",
"0.7439869",
"0.74364644",
"0.7401072",
"0.73922217",
"0.738454... | 0.0 | -1 |
Moves a given file from one directory to another, if the target file exists in that directory then the target is coppied as .bak | def moveFile(src, dest, bak="bak"):
message = "processing: {0} -> {1}".format(src, dest)
logger.info(message)
#compare the source and destination, if the files are the same do nothing
if os.path.exists(src) and os.path.exists(dest):
message = "file {0} found, comparing to {1}".format(src, dest)
logger.info(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def act_move_file(self, file_source, file_target):\n try:\n if not os.path.isfile(file_source):\n return\n path = os.path.dirname(file_target)\n if not os.path.exists(path):\n os.makedirs(path)\n shutil.move(file_source, file_target)\... | [
"0.69844866",
"0.68424857",
"0.67688906",
"0.6750627",
"0.6640949",
"0.6619133",
"0.64734495",
"0.6451692",
"0.64118326",
"0.6409421",
"0.6336517",
"0.6331257",
"0.62477756",
"0.6222287",
"0.61894214",
"0.6184978",
"0.6182519",
"0.61495227",
"0.61475456",
"0.6146206",
"0.6137... | 0.73066294 | 0 |
checks to see if there are any pending git commits any pending commits and the script will exit | def checkGit(directory): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commit_check(ctx):\n result = ctx.run(f\"{VENV_PREFIX} cz check --rev-range master..\", warn=True)\n if result.exited == 3: # NO_COMMIT_FOUND\n exit(0)\n else:\n exit(result.exited)",
"def local_changes():\n result, output = popen('git status', False, False)\n try:\n retu... | [
"0.7016581",
"0.6914419",
"0.6737097",
"0.66644025",
"0.6564627",
"0.65292114",
"0.6516937",
"0.64886695",
"0.6482053",
"0.64482194",
"0.6266667",
"0.6266017",
"0.62159777",
"0.605793",
"0.6002832",
"0.59305567",
"0.59163755",
"0.5910263",
"0.5902178",
"0.5882748",
"0.5877310... | 0.5918445 | 16 |
uses sha512 to verify that the soruce file and the destination file are the same | def verifyFile(source, destination):
sourceHash = hashlib.sha256(open(source, 'rb').read()).digest()
destinationHash = hashlib.sha256(open(destination, 'rb').read()).digest()
if sourceHash == destinationHash:
return (True, str(sourceHash))
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sha512_file(file_name):\n\n hash_func = hashlib.sha256()\n\n with open(file_name, \"rb\") as fd:\n hash_func.update(fd.read())\n\n return hash_func.hexdigest()",
"def sha512(digest, fileName):\n\n rc = sha512sum(digest, fileName)\n logging.debug(\"SHA512 (%s) = %s\", fileName, 'ok' if r... | [
"0.67451125",
"0.6664096",
"0.657134",
"0.6448049",
"0.6399249",
"0.625933",
"0.6167828",
"0.6108488",
"0.60713184",
"0.60061806",
"0.5995028",
"0.5963704",
"0.5957321",
"0.5945975",
"0.59287506",
"0.5924034",
"0.59063375",
"0.58697104",
"0.58629924",
"0.58619326",
"0.584064"... | 0.73826236 | 0 |
Testing funciton for nose | def test_function():
logger = logConfigure("promote_test.log")
message = "starting test of promote.py"
logger.info(message)
testConfigFile = "test.json"
message = "testing existence of test config file {0}".format(testConfigFile)
logger.info(message)
testConfigExists = True
print "{0}".format(str(os.path.is... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test():\n nose.run()",
"def unitary_test():",
"def tests():",
"def test_something():",
"def test():\n pass",
"def test():",
"def test():",
"def test_func():\n pass",
"def test_dummy():",
"def test_basic_execution(self):",
"def _test(self):",
"def _test(self):",
"def _test(s... | [
"0.8469399",
"0.81757426",
"0.81619143",
"0.80219984",
"0.7960618",
"0.79495305",
"0.79495305",
"0.7836223",
"0.7823098",
"0.7812693",
"0.77668256",
"0.77668256",
"0.77668256",
"0.77668256",
"0.77668256",
"0.77300036",
"0.7686654",
"0.76723796",
"0.76494384",
"0.7616399",
"0.... | 0.0 | -1 |
Return a 2D binary array (mask) in which all pixels are either 0 or 1 | def binary_array(array, thresh, value=0):
if value == 0:
# Create an array of ones with the same shape and type as
# the input 2D array.
binary = np.ones_like(array)
else:
# Creates an array of zeros with the same shape and type as
# the input 2D array.
binary = np.zeros_like(ar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess_mask(y):\n y[y <= 255./2] = 0 # Needs to be in this order, otherwise 1 gets overwritten\n y[y > 255./2] = 1\n binary_mask = y.astype(np.uint8)\n\n return binary_mask",
"def get_binary_mask(self,index):\n mask = self.load_mask_png(index)\n (rows,cols) = np.where(mask>0)[0:... | [
"0.7493042",
"0.74517816",
"0.73958826",
"0.7184049",
"0.69006175",
"0.6856227",
"0.66759485",
"0.6636539",
"0.66169465",
"0.660961",
"0.6597759",
"0.65790963",
"0.6544609",
"0.6487091",
"0.64485276",
"0.6424487",
"0.64208025",
"0.6418105",
"0.63831675",
"0.63831675",
"0.6383... | 0.6636052 | 8 |
Implementation for Gaussian blur to reduce noise and detail in the image | def blur_gaussian(channel, ksize=3):
return cv2.GaussianBlur(channel, (ksize, ksize), 0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gaussian_blur(self,img):\n return cv2.GaussianBlur(img, (self.kernel_size, self.kernel_size), 0)",
"def __gaussian_blur(self, img, kernel_size=3):\n return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)",
"def reblur(inp_img):\n\n img = np.array(inp_img)\n kernel_deviation = 1.5\n... | [
"0.81383604",
"0.81237864",
"0.7887736",
"0.7797448",
"0.77877295",
"0.7773531",
"0.77326",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0.77160615",
"0... | 0.6984415 | 54 |
Implementation of Sobel edge detection | def mag_thresh(image, sobel_kernel=3, thresh=(0, 255)):
# Get the magnitude of the edges that are vertically aligned on the image
sobelx = np.absolute(sobel(image, orient='x', sobel_kernel=sobel_kernel))
# Get the magnitude of the edges that are horizontally aligned on the image
sobely = np.absolute(s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def edgeDetectionSobel(img: np.ndarray, thresh: float = 0.7) -> (np.ndarray, np.ndarray):\r\n img = cv2.GaussianBlur(img, (3, 3), 0)\r\n\r\n Gx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])\r\n Gy = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]])\r\n thresh = thresh * 255\r\n\r\n smooth_x = cv2.fi... | [
"0.78049487",
"0.7523176",
"0.7453298",
"0.7149273",
"0.7147045",
"0.68002224",
"0.67776054",
"0.6688813",
"0.66406983",
"0.6535428",
"0.650613",
"0.64538646",
"0.6355191",
"0.6325599",
"0.62427187",
"0.6242515",
"0.62358284",
"0.6234513",
"0.6210202",
"0.62055576",
"0.618762... | 0.5565513 | 86 |
Find edges that are aligned vertically and horizontally on the image | def sobel(img_channel, orient='x', sobel_kernel=3):
# cv2.Sobel(input image, data type, prder of the derivative x, order of the
# derivative y, small matrix used to calculate the derivative)
if orient == 'x':
# Will detect differences in pixel intensities going from
# left to right on the image (i.e.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_pixel_edges(img):\n \n transparency_cells = img.T[3].T # Ignores rbg, returns only transparency. \n # Values are either:\n # 0 (fully transparent) or \n # 1 (not at all transparent)\n right_up... | [
"0.70753133",
"0.68227047",
"0.6705829",
"0.6586866",
"0.65544",
"0.6475599",
"0.6472296",
"0.64205885",
"0.63843906",
"0.63522637",
"0.6331612",
"0.632474",
"0.63219196",
"0.625547",
"0.62513036",
"0.6231831",
"0.61775094",
"0.6137651",
"0.6128345",
"0.6114049",
"0.6106298",... | 0.0 | -1 |
Apply a threshold to the input channel | def threshold(channel, thresh=(128,255), thresh_type=cv2.THRESH_BINARY):
# If pixel intensity is greater than thresh[0], make that value
# white (255), else set it to black (0)
return cv2.threshold(channel, thresh[0], thresh[1], thresh_type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_thresholding(x):\n return x > threshold_otsu(x)",
"def global_threshold(img, threshold_method):\n pass",
"def threshold(self,thresholdValue):\n # TO DO\n pass",
"async def threshold(self, ctx, threshold: int):\n if threshold > 0:\n self.bot.db.execute(\"UPDATE ... | [
"0.694529",
"0.67643166",
"0.6673264",
"0.666129",
"0.6620091",
"0.65957475",
"0.65373987",
"0.65017444",
"0.6471623",
"0.64246637",
"0.64003336",
"0.64003336",
"0.64003336",
"0.6351905",
"0.61548465",
"0.61462206",
"0.61106056",
"0.61106056",
"0.61106056",
"0.61106056",
"0.6... | 0.6551694 | 6 |
Asks user to specify a city, month, and day to analyze. | def get_filters():
print('Hello! Let\'s explore some US bikeshare data!')
# Get user input for city (chicago, new york city, washington). HINT: Use a while loop to handle invalid inputs
while True:
city = input('Would you like to see data for Chicago, New York City or Washington?')
if city.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Raw_Data(city,month,day):\n print(\"The city you have entered is: \",city)\n print(\"The month you have entered is: \",month)\n print(\"The day you have entered is: \",day)",
"def get_filters():\n city = None\n month = None\n day = None\n while day == None:\n # TO DO: get user input f... | [
"0.6670955",
"0.65355206",
"0.64598334",
"0.6373697",
"0.63487226",
"0.6310236",
"0.6287051",
"0.6259993",
"0.62314963",
"0.62125754",
"0.62053525",
"0.61813915",
"0.6171331",
"0.6169096",
"0.61588687",
"0.6158631",
"0.6153347",
"0.6144922",
"0.6131542",
"0.6105515",
"0.61029... | 0.0 | -1 |
Loads data for the specified city and filters by month and day if applicable. | def load_data(city, month='all', day='all'):
df = pd.read_csv(CITY_DATA[city.lower()]).rename(columns={'Unnamed: 0': 'Trip Id'})
cols = df.columns
df['Start Time'] = pd.to_datetime(df['Start Time'])
df['Month'] = df['Start Time'].dt.month
df['Day of Week'] = df['Start Time'].dt.dayofweek
df['St... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(city, month, day):\n df = pd.read_csv(CITY_DATA [city])\n \n # convert the Start Time column to datetime\n df['Start Time'] = pd.to_datetime(df['Start Time'])\n \n # extract month and day of week from Start Time to create new columns\n df['month'] = df['Start Time'].dt.month\n ... | [
"0.81320685",
"0.8108889",
"0.8042514",
"0.80090284",
"0.80071104",
"0.79991937",
"0.7998333",
"0.7988789",
"0.797905",
"0.79737365",
"0.79610896",
"0.7956163",
"0.7947432",
"0.79463065",
"0.7908287",
"0.7908229",
"0.7904569",
"0.7900715",
"0.78930074",
"0.7889219",
"0.788254... | 0.8045821 | 2 |
Displays statistics on the most frequent times of travel. | def time_stats(df):
print('\nCalculating The Most Frequent Times of Travel...\n')
start_time = time.time()
# display the most common month
aux = df[['Month','Start Time']].groupby('Month').count()['Start Time']
month_max = aux.idxmax()
month_max_cnt = aux.max()
print("Most common month was... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def time_stats(df):\n\n print('\\nDisplaying the statistics on the most frequent times of '\n 'travel...\\n')\n start_time = time.time()\n\n # display the most common month\n most_common_month = df['Month'].mode()[0]\n print('For the selected filter, the month with the most travels is: ' +\... | [
"0.8023522",
"0.802221",
"0.7914353",
"0.7826378",
"0.7821697",
"0.78140223",
"0.7765606",
"0.7739828",
"0.7735833",
"0.7733764",
"0.7686237",
"0.76675326",
"0.7651101",
"0.7644171",
"0.7639292",
"0.7636152",
"0.76248395",
"0.76227194",
"0.7611663",
"0.7599656",
"0.75825727",... | 0.7194641 | 71 |
Displays statistics on the most popular stations and trip. | def station_stats(df):
print('\nCalculating The Most Popular Stations and Trip...\n')
start_time = time.time()
# display most commonly used start station
aux = df[['Start Station','Start Time']].groupby('Start Station').count()['Start Time']
station_max = aux.idxmax()
station_max_cnt = aux.max... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def station_stats(df):\n\n print('\\nCalculating The Most Popular Stations and Trip...\\n')\n start_time = time.time()\n\n # display most commonly used start station\n print(popular_start_station(df))\n\n # display most commonly used end station\n print(popular_end_station(df))\n\n # display m... | [
"0.7815998",
"0.7661799",
"0.755378",
"0.74918276",
"0.74751854",
"0.7446441",
"0.7429881",
"0.74239737",
"0.7417978",
"0.74006975",
"0.73876286",
"0.7385986",
"0.7365314",
"0.73597723",
"0.7356932",
"0.7355265",
"0.7352331",
"0.7351879",
"0.73507756",
"0.734247",
"0.734072",... | 0.0 | -1 |
Displays statistics on the total and average trip duration. | def trip_duration_stats(df):
print('\nCalculating Trip Duration...\n')
start_time = time.time()
# display total travel time
val = df['Trip Duration'].sum()/3600
print("Total trip duration was {:.2f} hours".format(val))
# display mean travel time
val = df['Trip Duration'].mean()/60
pri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trip_duration_stats(data):\n print('\\nCalculating Trip Duration...\\n')\n start_time = time.time()\n # display total travel time\n total_trip_time= data['Trip Duration'].sum()\n print('The Total Travel Time is {} Hours'. format(total_trip_time/3600))\n # display mean travel time\n avg_tri... | [
"0.8144002",
"0.8025936",
"0.80051756",
"0.7950414",
"0.7938244",
"0.7932019",
"0.7927543",
"0.79160506",
"0.7915316",
"0.79089457",
"0.79064983",
"0.7901538",
"0.7892409",
"0.7890379",
"0.7887529",
"0.78859615",
"0.78849727",
"0.7883412",
"0.78750104",
"0.7869431",
"0.786734... | 0.78604645 | 25 |
Displays statistics on bikeshare users. | def user_stats(df):
print('\nCalculating User Stats...\n')
start_time = time.time()
# Display counts of user types
aux = df[['User Type','Start Time']].groupby('User Type').count()
aux = aux.reset_index().rename(columns={'Start Time': 'Count'})
print("User Type statistics:")
print(aux.to_s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_stats(request):\r\n user_count = UserMgr.count()\r\n pending_activations = ActivationMgr.count()\r\n users_with_bookmarks = BmarkMgr.count(distinct_users=True)\r\n return _api_response(request, {\r\n 'count': user_count,\r\n 'activations': pending_activations,\r\n 'with_bo... | [
"0.73559105",
"0.73306274",
"0.7287611",
"0.72494894",
"0.72382116",
"0.71733415",
"0.7168679",
"0.7129041",
"0.7076894",
"0.7071431",
"0.70602304",
"0.7056935",
"0.70490867",
"0.7045232",
"0.703642",
"0.70238316",
"0.7022488",
"0.7022265",
"0.7012312",
"0.70086145",
"0.69945... | 0.0 | -1 |
Displays raw data (trips sample). | def raw_data(df):
print('\nDisplaying individual trip sample...\n')
start_time = time.time()
cnt = 0
rows = 5
while True:
if cnt+rows < df.shape[0]:
aux = df.iloc[cnt:cnt+rows]
print("\n" + aux.to_string(index=False))
cnt += rows
answer = inp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_data():",
"def print_raw_data(self):\n\n start_time = time.time()\n data_frame = load_data(self.selections)\n if self.raw_data_index < len(data_frame) - 1:\n if self.raw_data_index + 5 < len(data_frame) - 1:\n print(data_frame[self.raw_data_index : self.raw... | [
"0.7264192",
"0.7046372",
"0.6878045",
"0.62923914",
"0.6280577",
"0.62716645",
"0.61874425",
"0.61363494",
"0.6096002",
"0.6080934",
"0.60643417",
"0.6063628",
"0.60584444",
"0.6051726",
"0.6024864",
"0.6017971",
"0.60011894",
"0.5963676",
"0.595541",
"0.5946533",
"0.5927268... | 0.62318677 | 6 |
Creates a new nest operator. The set of keys is initially empty. If the map or entries operator is invoked before any key functions are registered, the nest operator simply returns the input array. | def __init__(self):
self._keys = []
self._sortKeys = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tree():\n return defaultdict(tree)",
"def auto_nest(func):\n def wrapper(tensors, *args, **kwargs):\n return tf.nest.map_structure(\n lambda x: func(x, *args, **kwargs), tensors)\n return wrapper",
"def _tree():\n return collections.defaultdict(_tree)",
"def __create_nested_structure(ne... | [
"0.50510037",
"0.5038567",
"0.4854392",
"0.48375788",
"0.47468472",
"0.4714622",
"0.4705582",
"0.47014457",
"0.46549824",
"0.4628407",
"0.46255538",
"0.46242553",
"0.45791712",
"0.45502764",
"0.4549578",
"0.44959244",
"0.4480521",
"0.44716427",
"0.44619203",
"0.44552702",
"0.... | 0.0 | -1 |
Registers a new key function. The key function will be invoked for each element in the input array, and must return a string identifier that is used to assign the element to its group. As most often the key function is just a simple accessor, this fuction also accepts a noncallable, which will be converted into a funct... | def key(self, fn):
if not callable(fn):
fn = itemgetter(fn)
self._keys.append(fn)
self._sortKeys.append({})
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def key(func):\n return func.__func__ if hasattr(func, \"__func__\") else func",
"def key(func):\n return func.__func__ if hasattr(func, \"__func__\") else func",
"def new_key(self, key_name=None):\r\n return self.key_class(self, key_name)",
"def __call__(self, key):\n\n def wrapper(f... | [
"0.62338203",
"0.62239367",
"0.59718996",
"0.5883624",
"0.5770307",
"0.57404315",
"0.57356715",
"0.57341254",
"0.5666792",
"0.5658345",
"0.56313723",
"0.5578466",
"0.5519251",
"0.5460523",
"0.5439024",
"0.54283136",
"0.5402386",
"0.53601855",
"0.53601855",
"0.5331967",
"0.526... | 0.6798151 | 0 |
Registers a new key function. The key function will be invoked for each element in the input array, and must return a string identifier that is used to assign the element to its group. As most often the key function is just a simple accessor, this fuction also accepts a noncallable, which will be converted into a funct... | def prop(self, fn):
if not callable(fn):
fn = attrgetter(fn)
self._keys.append(fn)
self._sortKeys.append({})
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def key(self, fn):\n if not callable(fn):\n fn = itemgetter(fn)\n self._keys.append(fn)\n self._sortKeys.append({})\n return self",
"def key(func):\n return func.__func__ if hasattr(func, \"__func__\") else func",
"def key(func):\n return func.__func__ if hasatt... | [
"0.6682632",
"0.6177009",
"0.6167243",
"0.59728664",
"0.5880275",
"0.5739148",
"0.5736727",
"0.57136136",
"0.56967425",
"0.56370705",
"0.5616288",
"0.55425495",
"0.5540175",
"0.5514391",
"0.5452194",
"0.54279727",
"0.54111975",
"0.53730154",
"0.53730154",
"0.53143835",
"0.528... | 0.0 | -1 |
Specifies the order for the mostrecently specified key. | def sortKeys(self, cmp=None, key=None, reverse=False):
self._sortKeys[-1] = dict(cmp=cmp, key=key, reverse=reverse)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _augment_order(self, stmt, key, reverse):\n sqlstmt = stmt + \" ORDER BY %s\" % key\n if reverse:\n sqlstmt += \" DESC\"\n else:\n sqlstmt += \" ASC\"\n return sqlstmt",
"def add(self, key, value):\r\n newest = Item(key, value) # make new item instan... | [
"0.5636925",
"0.5439744",
"0.54154766",
"0.53488845",
"0.53439325",
"0.53188175",
"0.5313001",
"0.5313001",
"0.52856255",
"0.52856255",
"0.5253114",
"0.52403337",
"0.52403337",
"0.52403337",
"0.5195061",
"0.5147803",
"0.5137212",
"0.51138586",
"0.5104338",
"0.50992334",
"0.50... | 0.5488794 | 1 |
Specifies the order for leaf values; applies to both maps and entries array. | def sortValues(self, cmp=None, key=None, reverse=False):
self._sortValues = dict(cmp=cmp, key=key, reverse=reverse)
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __order_dict__(self, tree_level_labels, level_entries):\n # | - __order_dict__\n order_dict = {} # <--------------------------------------\n\n level_cnt = 0\n for level in tree_level_labels:\n level_cnt += 1\n for prop in level_entries[level]:\n ... | [
"0.6510195",
"0.6324931",
"0.55555844",
"0.55430245",
"0.5464267",
"0.5439327",
"0.5316074",
"0.5254075",
"0.5250325",
"0.52135754",
"0.51128393",
"0.51121473",
"0.50785637",
"0.5063107",
"0.5053161",
"0.50316817",
"0.50295913",
"0.5025321",
"0.4987931",
"0.4981204",
"0.49711... | 0.0 | -1 |
Specifies a rollup function to be applied on each group of leaf elements. The return value of the rollup function will replace the array of leaf values in either the associative array returned by the map operator, or the values attribute of each entry returned by the entries operator. | def rollup(self, fn):
self._rollup = fn
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rollup(self, name, keys, aggregators=None, callback=None) :\n\n class Wildcard(object) :\n def __repr__(self) :\n return '*'\n w = Wildcard()\n\n # get the records for this table\n #\n rows = [d.as_dict() for d in self]\n cols = [k.get_name() ... | [
"0.5321749",
"0.5007049",
"0.4889394",
"0.4833893",
"0.47824767",
"0.47508833",
"0.47499952",
"0.4718424",
"0.4704678",
"0.4611858",
"0.45925716",
"0.45839456",
"0.4580275",
"0.45792785",
"0.4532239",
"0.45245072",
"0.45216066",
"0.44919682",
"0.44884452",
"0.44791734",
"0.44... | 0.5791968 | 0 |
Applies the nest operator to the specified array, returning an array of keyvalues entries. Each entry in the returned array corresponds to a distinct key value returned by the first key function. The entry value depends on the | def map(self, data, depth=0):
if depth >= len(self._keys):
if self._rollup: return self._rollup(data)
if self._sortValues: return sorted(data, **self._sortValues)
return data
values = defaultdict(list)
it = data.iteritems() if isinstance(data, dic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten_array(nested, prefix=''):\n result = dict()\n for index in range(len(nested)):\n prefix_key = '__'.join([prefix, str(index)]) if len(prefix) else str(index)\n\n value = nested[index]\n if isinstance(value, (list, np.ndarray)):\n result.update(flatten_array(value, p... | [
"0.55010843",
"0.50831336",
"0.49393448",
"0.4874722",
"0.48669982",
"0.4860756",
"0.48441294",
"0.48316175",
"0.47842464",
"0.47713405",
"0.47101563",
"0.46756792",
"0.46725106",
"0.46214616",
"0.4618535",
"0.4615551",
"0.46035823",
"0.4602771",
"0.45968628",
"0.4594586",
"0... | 0.0 | -1 |
Applies the nest operator to the specified array, returning an associative array. Each Entry (a named tuple with the fields 'key' and 'values') in the returned associative array corresponds to a distinct keyvalue pair returned by the first keyfunction. The entry value depends on the number | def entries(self, data, depth=0):
return self._entries(self.map(data)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def flatten_array(nested, prefix=''):\n result = dict()\n for index in range(len(nested)):\n prefix_key = '__'.join([prefix, str(index)]) if len(prefix) else str(index)\n\n value = nested[index]\n if isinstance(value, (list, np.ndarray)):\n result.update(flatten_array(value, p... | [
"0.5737612",
"0.52897036",
"0.50291884",
"0.49283966",
"0.48699978",
"0.47915348",
"0.47293574",
"0.47216898",
"0.46458194",
"0.4611427",
"0.45985267",
"0.45661286",
"0.4551411",
"0.4547691",
"0.45448223",
"0.45383206",
"0.45177352",
"0.4515706",
"0.45081964",
"0.45067057",
"... | 0.41658196 | 79 |
Create a new Team and add two new Learners with different atomic actions. These Learners are added to the Learner population, and the Team is added to both the Team and root Team populations. | def initializeTeam(self):
# Create two new Learners with different atomic actions
a1 = randint(0, Trainer.ATOMIC_ACTION_RANGE)
a2 = randint(0, Trainer.ATOMIC_ACTION_RANGE)
while a1 == a2:
a2 = randint(0, Trainer.ATOMIC_ACTION_RANGE)
l1 = Learner(action = a1)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add_team_manager_to_team(self):\n pass",
"def test_assign_managing_team(self):\n pass",
"def post(self):\n req = team_req.parse_args(strict=True)\n curr_user = api.user.get_user()\n if curr_user[\"teacher\"]:\n raise PicoException(\"Teachers may not create... | [
"0.63931805",
"0.62942845",
"0.6094177",
"0.6046148",
"0.5987049",
"0.5950534",
"0.59209555",
"0.59143233",
"0.58799905",
"0.58205515",
"0.5810097",
"0.57936954",
"0.57741076",
"0.57400084",
"0.5725225",
"0.5720262",
"0.56885177",
"0.5675747",
"0.5647381",
"0.5604889",
"0.555... | 0.7741807 | 0 |
Given a full Learner and Team population, where each Team points to two unique Learners, randomly add existing Learners to each Team until that Team reaches its full complement. | def fillTeamsInPopulation(self):
for team in self.team_pop:
while len(team.learners) < team.max_size:
learners = [l for l in self.learner_pop if l not in team.learners]
if len(learners) == 0:
break
else:
learner ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initializeTeam(self):\n\n # Create two new Learners with different atomic actions\n a1 = randint(0, Trainer.ATOMIC_ACTION_RANGE)\n a2 = randint(0, Trainer.ATOMIC_ACTION_RANGE)\n while a1 == a2:\n a2 = randint(0, Trainer.ATOMIC_ACTION_RANGE)\n\n l1 = Learner(action ... | [
"0.6198892",
"0.60099727",
"0.5909377",
"0.5602736",
"0.5578461",
"0.5570028",
"0.55162257",
"0.54663473",
"0.54535234",
"0.5446338",
"0.5419894",
"0.5384661",
"0.53839433",
"0.537948",
"0.53772473",
"0.53582704",
"0.53372985",
"0.53203225",
"0.5301221",
"0.5300238",
"0.52959... | 0.71697813 | 0 |
Create the initial complement of Teams and the Learner population. | def initialize(self):
r_keep = int(Trainer.R_SIZE * Trainer.PERCENT_KEEP)
for i in range(r_keep):
self.initializeTeam()
self.fillTeamsInPopulation()
# Double check that things are working as expected and that we now
# have PERCENT_KEEP * R_SIZE Teams and that these ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initializeTeam(self):\n\n # Create two new Learners with different atomic actions\n a1 = randint(0, Trainer.ATOMIC_ACTION_RANGE)\n a2 = randint(0, Trainer.ATOMIC_ACTION_RANGE)\n while a1 == a2:\n a2 = randint(0, Trainer.ATOMIC_ACTION_RANGE)\n\n l1 = Learner(action ... | [
"0.67016745",
"0.6666432",
"0.5825645",
"0.55707854",
"0.55236286",
"0.5364244",
"0.5268502",
"0.52265084",
"0.5218145",
"0.51675844",
"0.51194715",
"0.5089335",
"0.5085048",
"0.50581676",
"0.50530136",
"0.5036355",
"0.5020107",
"0.50176114",
"0.50176114",
"0.50087804",
"0.49... | 0.5799388 | 3 |
Refill the root Team population up to R_SIZE root Teams. This is done as the first step of every iteration of evolution to ensure that we are always evaluating R_SIZE root Teams. | def generation(self):
# Re-count and re-collect all root Teams from the main Team
# population into self.agent_pop
self.updateAgentPopulation()
# Generate new root Teams as variations of other Teams
while self.getNumRootTeams() < Trainer.R_SIZE:
# Randomly select p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize(self):\n r_keep = int(Trainer.R_SIZE * Trainer.PERCENT_KEEP)\n\n for i in range(r_keep):\n self.initializeTeam()\n self.fillTeamsInPopulation()\n\n # Double check that things are working as expected and that we now\n # have PERCENT_KEEP * R_SIZE Teams an... | [
"0.64052784",
"0.63281214",
"0.57870644",
"0.57000005",
"0.5607969",
"0.5547907",
"0.5515359",
"0.544081",
"0.54305696",
"0.53787595",
"0.53169703",
"0.53117955",
"0.5303638",
"0.52940786",
"0.5237861",
"0.5228605",
"0.5212393",
"0.5164609",
"0.5151552",
"0.5115436",
"0.51149... | 0.7226053 | 0 |
During evolution, after evaluating all agents (ie. root teams), delete the PERCENT_KEEP worstperforming Teams. | def selection(self):
# Sort root Teams from best to worst
ranked_agents = sorted(self.agent_pop, key=lambda rt : rt.team.fitness, reverse=True)
# Save trainer and top agent so far
self.save()
if self.AGENT_NAME == "":
ranked_agents[0].save(Trainer.ENV_NAME)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def agent_cleanup(self):\n\n logging.info(\"Best score: %s\" % self.best_score_ever)\n\n if self.results_file:\n self.results_file.close()",
"def _remove_experts(self):\n self.experts = [ex for ex in self.experts if np.mean(\n ex.weight) >= self.theta]",
"def trim_dat... | [
"0.56317484",
"0.5397232",
"0.5374889",
"0.5315391",
"0.5296942",
"0.5236859",
"0.52119124",
"0.5208702",
"0.51444036",
"0.5137969",
"0.5063565",
"0.5044934",
"0.4994451",
"0.49477217",
"0.49460474",
"0.4923171",
"0.49114072",
"0.4853876",
"0.4834487",
"0.48299766",
"0.481175... | 0.4908848 | 17 |
Evaluate an agent over some number of episodes in a given environment 'env' | def evaluateAgent(self, agent, env, num_episodes, num_frames):
# Skip agents that have already been evaluated, up to MAX_EVAL_SKIPS times
if agent.team.fitness is not None and Trainer.DO_FAST_TRACK:
if agent.team.num_skips < Trainer.MAX_EVAL_SKIPS:
agent.team.num_skips += 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eval_against_bot(env, q_agent, t_agent, num_episodes):\n score = 0\n for _ in range(num_episodes):\n time_step = env.reset()\n q_agent_output = q_agent.step(time_step, is_evaluation=True)\n t_agent_output = t_agent.step(time_step, is_evaluation=True)\n time_step = env.step([q_... | [
"0.73567104",
"0.73567104",
"0.72522426",
"0.72513074",
"0.72093165",
"0.7190529",
"0.718549",
"0.71360284",
"0.7111438",
"0.7026913",
"0.7013799",
"0.69604534",
"0.6952704",
"0.6939247",
"0.69145966",
"0.690422",
"0.6902681",
"0.6878677",
"0.6865183",
"0.6861071",
"0.6852929... | 0.72531104 | 2 |
Perform the TPG evolution algorithm. | def evolve(self, env, num_generations, num_episodes, num_frames):
for gen in range(num_generations):
if Trainer.VERBOSE:
print("Generation:", gen)
# Generate new root Teams
self.generation()
# Evaluate current agents
self.evaluation(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evolve(self, evolutions_to_run, evolution_count = 0):\n\n\n for i in range(evolutions_to_run):\n self.population = self.mating.mate(self.population)\n self.population = mutate.mutate(self.population)\n\n self.population = self.computeFitness.compute(self.population)\n ... | [
"0.6286169",
"0.6101547",
"0.606618",
"0.6046805",
"0.59923446",
"0.5940404",
"0.5926717",
"0.5825156",
"0.5811594",
"0.57976264",
"0.57265425",
"0.5668708",
"0.56585896",
"0.5590751",
"0.55892897",
"0.5576272",
"0.5574918",
"0.55736893",
"0.5543055",
"0.55289966",
"0.5516357... | 0.5110463 | 73 |
Perform variation operators on the Team level. | def mutateTeam(self, team):
self.removeLearners(team)
self.addLearners(team)
self.mutateLearners(team) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_team_strength(self):\n pass",
"def ImprovedScore(tgtName, yourName, teamModels, featureImprove, teamTgtPipe, teamYourPipe, Imp = 0.1):\n\n ## Put featureImprove into target model - need to reverse _op and non _op\n coef = teamModels[tgtName]\n # Get stats of Team A's win and lose mat... | [
"0.5885755",
"0.58623254",
"0.5784955",
"0.571331",
"0.5696523",
"0.55756694",
"0.55301684",
"0.5520191",
"0.54968196",
"0.545426",
"0.54406863",
"0.5344885",
"0.53093714",
"0.52367246",
"0.52123815",
"0.5171796",
"0.51657",
"0.5156609",
"0.5141747",
"0.51127",
"0.5106896",
... | 0.48860818 | 58 |
Delete all Learners that are no longer owned by any Team. | def cleanOrphanedLearners(self):
# Before deleting Learners, ensure that if any Learners that are about to be
# deleted point to a Team as their action, then that Team's count of
# referincing Learners is decremented.
for learner in self.learner_pop:
if learner.getNumReferen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_all_teachers(connection):\r\n with connection:\r\n return connection.execute(DELETE_ALL_TEACHERS)",
"def delete_teams_all(self, team_name):\n self.execute(TABELLE['teams']['delete']['all'])",
"def _delete_roles(self):\n for role in self.roles:\n role.delete()",
"... | [
"0.6313414",
"0.6120818",
"0.61091095",
"0.60356534",
"0.5935509",
"0.5842929",
"0.5828907",
"0.5745722",
"0.5733355",
"0.5720132",
"0.5718106",
"0.57144076",
"0.56988364",
"0.56943846",
"0.5681858",
"0.567302",
"0.5666653",
"0.5639008",
"0.56309897",
"0.55954045",
"0.5594834... | 0.71644795 | 0 |
Given the OpenAI Gym pendulum state [cos(theta), sin(theta), \dot{theta}], return [theta, \dot{theta}]. | def get_state(s):
return np.array([math.atan2(s[1], s[0]), s[2]]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pendulum(pos):\n\n def x_dot(x, y):\n return y\n\n def y_dot(x, y):\n return -np.sin(x)\n\n return np.array([x_dot(pos[0], pos[1]), y_dot(pos[0], pos[1])])",
"def dtheta(state, t, I, p, E, gamma):\n theta, omega = state[0], state[1]\n dtheta =omega\n domega = -(gamma / I )* om... | [
"0.7569696",
"0.69571704",
"0.68560404",
"0.6705998",
"0.6366515",
"0.6327622",
"0.6223006",
"0.62030417",
"0.6044491",
"0.60441226",
"0.59695387",
"0.5966636",
"0.5925617",
"0.5915176",
"0.58980143",
"0.58724684",
"0.5863618",
"0.583199",
"0.583199",
"0.5829571",
"0.5824251"... | 0.6069792 | 8 |
We use heapq class to implement Heaps in Python. By default Min Heap is implemented by this class. But we multiply each value by 1 so that we can use it as MaxHeap. | def addNum(self, num: int) -> None:
small, large = self.heaps
# push to small first by default
heapq.heappush(large, -heapq.heappushpop(small, -num))
# keep size even (let len(small) >= len(large))
if len(large) > len(small):
val = heapq.heappop(larg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.max_heap = [] # to contain left smaller half, or + 1\n self.min_heap = [] # to contain right bigger half",
"def __init__(self):\n # max_heap stores smaller half\n # min_heap stores larger half\n self.heaps = ([], [])",
"def min_heap(self): \n \n ... | [
"0.76983464",
"0.7662596",
"0.74752456",
"0.7363196",
"0.7337437",
"0.7319882",
"0.72922516",
"0.72666025",
"0.7229037",
"0.7225333",
"0.72153676",
"0.7207476",
"0.7174666",
"0.71282834",
"0.704995",
"0.70068634",
"0.7000654",
"0.6952775",
"0.68923765",
"0.6872462",
"0.684775... | 0.0 | -1 |
Main script to run the command doc | def run(self) -> int:
columns_sql = []
model = self._flags.model
schema = self._dbt_profile.profile.get("target_schema", "")
dbt_credentials = self._dbt_profile.profile
connector = DB_CONNECTORS.get(dbt_credentials.get("type", ""))
if not connector:
raise No... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def libdoc_cli(arguments):\n LibDoc().execute_cli(arguments)",
"def run(self):\n cmds = (self.clean_docs_cmd, self.html_docs_cmd, self.view_docs_cmd)\n self.call_in_sequence(cmds)",
"def main():\n # We know that qidoc build will set the correct cwd\n qibuild_dir = \"..\"\n qibuild_dir... | [
"0.769044",
"0.7378854",
"0.72934943",
"0.72900057",
"0.7280042",
"0.70528066",
"0.7028129",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"0.70109427",
"... | 0.0 | -1 |
Updates the model description from a schema.yaml. | def update_model_description(
self, content: Dict[str, Any], model_name: str, is_already_documented: bool = False
) -> Dict[str, Any]:
message = f"Do you want to write a description for {model_name}"
if is_already_documented:
message = f"Do you want to change the model descriptio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_model(\n self, content: Dict[str, Any], model_name: str, columns_on_db: Sequence[str]\n ) -> Dict[str, Any]:\n logger.info(f\"The model '{model_name}' already exists, updating its documentation.\")\n for model in content.get(\"models\", []):\n if model[\"name\"] == mod... | [
"0.6301844",
"0.5955802",
"0.58623356",
"0.58260643",
"0.5749849",
"0.56432885",
"0.5605579",
"0.55699617",
"0.5438667",
"0.5400471",
"0.5385811",
"0.53735393",
"0.53630406",
"0.53451717",
"0.5329007",
"0.5327524",
"0.52972335",
"0.5264293",
"0.5264293",
"0.5262192",
"0.52173... | 0.66931194 | 0 |
Move keys name and description to the beginning of the dictionary. | def move_name_and_description_to_first_position(self, model: Dict[str, Any]):
# DEPRECATION: Drop ordered dict when dropping python 3.6 support
ordered_dict = OrderedDict(model)
if ordered_dict.get("description"):
ordered_dict.move_to_end("description", last=False)
ordered_di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_prepend_key(self):\n self.prepend_key -= 1",
"def harmonize_keys(self):\n self._data.key_regex_replacements = _key_regex_replacements\n self._data.key_replacements = _key_replacements",
"def __parse_dict(self) -> OrderedDict:\r\n self.idx += 1\r\n d = OrderedDict(... | [
"0.5855813",
"0.58174276",
"0.5344455",
"0.5334281",
"0.5323044",
"0.53075933",
"0.53034145",
"0.52598774",
"0.5258003",
"0.52408934",
"0.52373326",
"0.5168691",
"0.5147976",
"0.5109821",
"0.50820005",
"0.50367594",
"0.5033817",
"0.50227356",
"0.5005109",
"0.50036335",
"0.498... | 0.67776966 | 0 |
Gets the primary key info from a dbt model's config block. | def get_primary_key_from_sql(self, sql_file_path: Path) -> Optional[str]:
sql_content = self.read_file(sql_file_path)
unique_key = re.search(r"unique_key[^\S]*=[^\S]*\'([a-z_]+)\'", sql_content)
if unique_key:
return unique_key.group(1)
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def id(self):\n return self.config['key']",
"def id(self):\n return self.config.get('key').lower()",
"def get_primary_key(cls) -> str:\n return inspect(cls).primary_key[0].name",
"def get_key_id(self):",
"def get_primary_id(self):",
"def pk(entity) -> str:\n for field in entit... | [
"0.675796",
"0.6688599",
"0.6348418",
"0.63330615",
"0.6260536",
"0.6244676",
"0.6244162",
"0.61983496",
"0.6189352",
"0.60111696",
"0.5995902",
"0.5995902",
"0.59907687",
"0.5953107",
"0.59288514",
"0.591364",
"0.58904403",
"0.587706",
"0.5850178",
"0.5824004",
"0.57448316",... | 0.0 | -1 |
Adds the primary key tests (unique, not_null) to the primary key column. | def add_primary_key_tests(
self,
schema_content: Dict[str, Any],
model_name: str,
) -> None:
model_file_path = self.get_file_path_from_sql_model(model_name=model_name)
if not model_file_path:
return
primary_key_column = self.get_primary_key_from_sql(model... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_primary_key(self):\n assert self.tbl.primary_key == 'id'",
"def test_code_add_primary_key(self):\n sql = \"\"\"\n CREATE TABLE public.address_no_primary_key\n (\n code character varying(10),\n address character varying(255),\n ... | [
"0.74589247",
"0.66175616",
"0.6569066",
"0.64053077",
"0.63456315",
"0.63337296",
"0.6306686",
"0.62847334",
"0.6270942",
"0.6083501",
"0.6062621",
"0.60461",
"0.60365766",
"0.6021916",
"0.59867954",
"0.5968053",
"0.59389657",
"0.5910877",
"0.5889046",
"0.5881331",
"0.587261... | 0.70331806 | 1 |
Method to delete the failing tests from the schema.yml. | def delete_failed_tests_from_schema(
self, path_file: Path, model_name: str, tests_to_delete: Dict[str, List[str]]
):
content = open_yaml(
path_file,
preserve_yaml_order=self._sugar_config.config.get("preserve_yaml_order", False),
)
for model in content["model... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tearDown(self):\n with app.app_context():\n db = app.db.get_db()\n cur = db.cursor()\n with app.open_resource('sql/drop_tests.sql', mode='r') as f:\n cur.execute(f.read())\n db.commit()\n cur.close()\n db.close()",
"def t... | [
"0.7157708",
"0.6840837",
"0.6840837",
"0.6744383",
"0.67398924",
"0.6644065",
"0.663067",
"0.6602651",
"0.66019326",
"0.65678084",
"0.65678084",
"0.65678084",
"0.65678084",
"0.6532619",
"0.65185887",
"0.6497793",
"0.6494446",
"0.6491216",
"0.64835113",
"0.648288",
"0.6480997... | 0.7389425 | 0 |
Method to document the columns from a model. Will ask the user which columns they want to document and collect the new definition. | def document_columns(
self, columns: Dict[str, str], question_type: str = "undocumented_columns"
) -> None:
allowed_question_types_map = {
"undocumented_columns": "undocumented columns",
"documented_columns": "documented columns",
}
assert (
questi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_model(\n self, content: Dict[str, Any], model_name: str, columns_on_db: Sequence[str]\n ) -> Dict[str, Any]:\n logger.info(f\"The model '{model_name}' already exists, updating its documentation.\")\n for model in content.get(\"models\", []):\n if model[\"name\"] == mod... | [
"0.60908073",
"0.55415165",
"0.5372188",
"0.5359274",
"0.5354231",
"0.5340466",
"0.5325151",
"0.5293703",
"0.52432853",
"0.5163885",
"0.5160039",
"0.5150177",
"0.5130315",
"0.5116568",
"0.51087177",
"0.509843",
"0.5091603",
"0.5084476",
"0.5083437",
"0.5062949",
"0.50574535",... | 0.6973812 | 0 |
Method to update the columns from a model in a schema.yaml content. | def update_model(
self, content: Dict[str, Any], model_name: str, columns_on_db: Sequence[str]
) -> Dict[str, Any]:
logger.info(f"The model '{model_name}' already exists, updating its documentation.")
for model in content.get("models", []):
if model["name"] == model_name:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def upgradeSchema(self) -> None:",
"def _patch_schema(self):\n fields = get_json()['data']['attributes'].keys()\n return make_entity_schema(\n self.SCHEMA, self.RESOURCE_NAME,\n make_data_schema(\n self.SCHEMA, id_required=True,\n only=field... | [
"0.6048077",
"0.57747126",
"0.5664433",
"0.5589418",
"0.5571424",
"0.5421451",
"0.5394761",
"0.53772175",
"0.53585315",
"0.53123355",
"0.52927804",
"0.5254707",
"0.5240652",
"0.52377737",
"0.52357596",
"0.5179389",
"0.51512194",
"0.51078886",
"0.51063067",
"0.51058704",
"0.51... | 0.74676514 | 0 |
Method to create a new model in a schema.yaml content. | def create_new_model(
self, content: Optional[Dict[str, Any]], model_name: str, columns_sql: Sequence[str]
) -> Dict[str, Any]:
logger.info(f"The model '{model_name}' has not been documented yet. Creating a new entry.")
columns = []
for column_sql in columns_sql:
descript... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_model(self, ApiId: str, Name: str, Schema: str, ContentType: str = None, Description: str = None) -> Dict:\n pass",
"def create_model(self):\n pass",
"def create_model(self):\n pass",
"def create_models( self ):",
"def test_create_model(self):\n model = ControlledSche... | [
"0.75608915",
"0.6931102",
"0.6931102",
"0.6764485",
"0.673761",
"0.6483227",
"0.64785224",
"0.6357424",
"0.6350314",
"0.63297427",
"0.6329468",
"0.6134453",
"0.61336684",
"0.6127344",
"0.6127344",
"0.60928607",
"0.60823125",
"0.60697037",
"0.6068816",
"0.6059946",
"0.6040354... | 0.6983313 | 1 |
Method to update/create a model entry in the schema.yml. | def create_or_update_model_entry(
self,
is_already_documented: bool,
content: Optional[Dict[str, Any]],
model_name: str,
columns_sql: Sequence[str],
) -> Dict[str, Any]:
if is_already_documented and content:
content = self.update_model(content, model_name,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, model: CreationType) -> CreationType:\n url = self._get_path(model.uid)\n updated = self.session.put_resource(url, model.dump())\n data = updated[self._individual_key] if self._individual_key else updated\n self._check_experimental(data)\n return self.build(data)... | [
"0.66110295",
"0.65099454",
"0.6503122",
"0.6483552",
"0.6447268",
"0.63319486",
"0.60912466",
"0.6037311",
"0.5939962",
"0.59308195",
"0.5920232",
"0.5892795",
"0.588365",
"0.58739525",
"0.58583957",
"0.5846313",
"0.58430684",
"0.58265835",
"0.5815904",
"0.5811055",
"0.58067... | 0.6266865 | 6 |
Return a list of the lengths of each component | def connected_component_lengths(self):
return [len(x) for x in nx.connected_components(self.return_undirected())] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lengths(self):\n lengths = []\n last = self._coordinates[-1]\n for c in self._coordinates:\n lengths.append(((c[0]-last[0])**2 + (c[1]-last[1])**2) ** 0.5)\n last = c\n return sorted(lengths)",
"def lengths(self):\n return tuple(self.__lengths)",
"de... | [
"0.78101194",
"0.7739306",
"0.7471985",
"0.73547244",
"0.72451776",
"0.72150517",
"0.720691",
"0.70220983",
"0.69397414",
"0.6916224",
"0.6876782",
"0.6876782",
"0.6876782",
"0.68567157",
"0.68480396",
"0.68066955",
"0.67870516",
"0.6754018",
"0.67148066",
"0.669046",
"0.6612... | 0.7256557 | 4 |
Return a dictionary with the component length and number of such sized components | def connected_component_statistics(self, printStats=False):
lengths = self.connected_component_lengths()
lengthDict = dict(collections.Counter(lengths))
if printStats:
orderedLengthDict = collections.OrderedDict(sorted(lengthDict.items()))
numberOfGroups = nx.number_conn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sizes(self) -> dict:\n raise NotImplementedError",
"def size(self):\n cols = self.max_col + 1 - self.min_col\n rows = self.max_row + 1 - self.min_row\n return {'columns':cols, 'rows':rows}",
"def component_size(self) -> int:\n return self._component_size",
"def size(sel... | [
"0.67360574",
"0.6725783",
"0.6701124",
"0.6548634",
"0.6537382",
"0.6504442",
"0.6497762",
"0.6469607",
"0.6455232",
"0.64512724",
"0.6447988",
"0.639165",
"0.63511133",
"0.6291684",
"0.6270531",
"0.6249778",
"0.6229823",
"0.62279826",
"0.62087417",
"0.6208018",
"0.61990285"... | 0.58657247 | 59 |
Return a list of connected component of a given size | def connected_components_with_size(self, size):
components = [x for x in nx.connected_component_subgraphs(self.return_undirected()) if x.number_of_nodes() == size]
for graph in components:
SynonymNetwork.convert_to_special(graph)
return components | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connected_component_nodes_with_size(self, size, showRending=False, printResults=False):\n\n graphsOfSize = self.connected_components_with_size(size)\n if showRending:\n ans = [{node:graph.rendering_of_graph_node(node) for node in super(SynonymNetwork, graph).nodes()} for graph in graph... | [
"0.7175926",
"0.6962229",
"0.68868196",
"0.6776708",
"0.6681602",
"0.6661775",
"0.664788",
"0.6627815",
"0.6584589",
"0.6561159",
"0.65440905",
"0.64664924",
"0.63913494",
"0.6352398",
"0.6340285",
"0.62921864",
"0.62775284",
"0.6261488",
"0.62403965",
"0.62268996",
"0.618964... | 0.83368003 | 0 |
Return a list of infoboxes of a node | def infoboxes_of_graph_node(self, nodeName):
return self.node[nodeName].keys() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def infoboxes_of_graph(self):\n infoboxes = []\n for nodeName in super(SynonymNetwork, self).nodes():\n infoboxes = infoboxes + self.infoboxes_of_graph_node(nodeName)\n return list(set(infoboxes))",
"def _available_boxes(self, graph):\n return sorted([node.name for node in ... | [
"0.6946358",
"0.6361805",
"0.6139065",
"0.59413755",
"0.5941131",
"0.58889467",
"0.5884175",
"0.5850629",
"0.58499706",
"0.5776936",
"0.573916",
"0.5717519",
"0.5703713",
"0.5701958",
"0.5700756",
"0.56752574",
"0.56741536",
"0.5662098",
"0.5639799",
"0.562524",
"0.5618712",
... | 0.6962848 | 0 |
Return a (nonredunant) list of a graph's infoboxes | def infoboxes_of_graph(self):
infoboxes = []
for nodeName in super(SynonymNetwork, self).nodes():
infoboxes = infoboxes + self.infoboxes_of_graph_node(nodeName)
return list(set(infoboxes)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def infoboxes_of_graph_node(self, nodeName):\n return self.node[nodeName].keys()",
"def _available_boxes(self, graph):\n return sorted([node.name for node in graph.available_nodes()\n if not isinstance(node.meta, Ibox)])",
"def infolist(self):\r\n return list(self.info... | [
"0.70919293",
"0.65511703",
"0.6170751",
"0.56518734",
"0.5469806",
"0.5438119",
"0.5431412",
"0.5327349",
"0.52892977",
"0.5260679",
"0.5251475",
"0.5249176",
"0.52470684",
"0.5231178",
"0.5216276",
"0.51862216",
"0.5169174",
"0.5155935",
"0.5152305",
"0.5131187",
"0.5118866... | 0.7810729 | 0 |
Return either 'unrend', 'rend', or 'mixed' about a node | def rendering_of_graph_node(self, nodeName):
rendingList = [item for sublist in self.node[nodeName].values() for item in sublist] # due to flattening [['unrend'],['rend','unrend']] etc.
if all(items == 'unrend' for items in rendingList): return 'unrend'
elif all(items == 'rend' for items in rend... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getNodeType(node): # {{{\n if node.nodeType == node.ELEMENT_NODE : return \"ELEMENT_NODE\"\n elif node.nodeType == node.ATTRIBUTE_NODE : return \"ATTRIBUTE_NODE\"\n elif node.nodeType == node.TEXT_NODE : return \"TEXT_NODE\"\n elif... | [
"0.59330434",
"0.57472795",
"0.55685306",
"0.55460465",
"0.5446833",
"0.52605206",
"0.5232469",
"0.5225675",
"0.5222645",
"0.5222645",
"0.5211315",
"0.5193215",
"0.5136534",
"0.5125108",
"0.50817764",
"0.5080642",
"0.5071563",
"0.5054469",
"0.5050788",
"0.5024682",
"0.5009587... | 0.7448862 | 0 |
Return a list of nodes for each connected component of a given size, optionally showing the rendering state ('rend', 'unrend', or 'mixed'), and optionally priting the results in a readable manner | def connected_component_nodes_with_size(self, size, showRending=False, printResults=False):
graphsOfSize = self.connected_components_with_size(size)
if showRending:
ans = [{node:graph.rendering_of_graph_node(node) for node in super(SynonymNetwork, graph).nodes()} for graph in graphsOfSize]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connected_components_with_size(self, size):\n components = [x for x in nx.connected_component_subgraphs(self.return_undirected()) if x.number_of_nodes() == size]\n for graph in components:\n SynonymNetwork.convert_to_special(graph)\n\n return components",
"def createNodes(self... | [
"0.7411901",
"0.5986464",
"0.5829044",
"0.57453585",
"0.56704384",
"0.5544666",
"0.5477517",
"0.54514194",
"0.5429409",
"0.5378249",
"0.5338306",
"0.5332242",
"0.5323817",
"0.5284013",
"0.52632344",
"0.5228449",
"0.52277344",
"0.5223392",
"0.51854527",
"0.5174748",
"0.5167538... | 0.838628 | 0 |
Simulate rolling the DICE exactly NUM_ROLLS > 0 times. Return the sum of the outcomes unless any of the outcomes is 1. In that case, return 1. | def roll_dice(num_rolls, dice=six_sided):
# These assert statements ensure that num_rolls is a positive integer.
assert type(num_rolls) == int, 'num_rolls must be an integer.'
assert num_rolls > 0, 'Must roll at least once.'
# BEGIN PROBLEM 1
"*** YOUR CODE HERE ***"
count, return_sum = 0, 0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def simple_roll(dice):\n return roll(dice).total",
"def roll(self):\n rolls = []\n if self.dice_array is not None:\n for dice in self.dice_array:\n rolls.append(np.random.randint(1, dice+1))\n else:\n for _ in range(0,self.number):\n rol... | [
"0.722231",
"0.721332",
"0.6934436",
"0.6907222",
"0.6787352",
"0.6770178",
"0.6726645",
"0.66901255",
"0.6653811",
"0.6575561",
"0.6574739",
"0.6486671",
"0.64543676",
"0.64318657",
"0.64160246",
"0.64070636",
"0.63740844",
"0.6315325",
"0.63017744",
"0.62919956",
"0.628643"... | 0.67655975 | 6 |
Return the points scored from rolling 0 dice (Free Bacon). | def free_bacon(score):
assert score < 100, 'The game should be over.'
# BEGIN PROBLEM 2
"*** YOUR CODE HERE ***"
return_value = 2 * (score//10) - (score%10)
if return_value > 1:
return return_value
return 1
# END PROBLEM 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_points(self):\n self.round_points = 0\n for die in self.dice:\n if die == 1:\n self.round_points += 100\n elif die == 5:\n self.round_points += 50\n return self.round_points",
"def chance_points(dice_list):\n return sum(dice_list... | [
"0.71107715",
"0.7004689",
"0.68548566",
"0.66713774",
"0.6629163",
"0.66016495",
"0.6457354",
"0.6445631",
"0.64247847",
"0.62659353",
"0.62634397",
"0.6239456",
"0.621854",
"0.6187291",
"0.61325866",
"0.609865",
"0.60897076",
"0.6088984",
"0.60556155",
"0.60112435",
"0.5987... | 0.0 | -1 |
Simulate a turn rolling NUM_ROLLS dice, which may be 0 (Free Bacon). Return the points scored for the turn by the current player. | def take_turn(num_rolls, opponent_score, dice=six_sided):
# Leave these assert statements here; they help check for errors.
assert type(num_rolls) == int, 'num_rolls must be an integer.'
assert num_rolls >= 0, 'Cannot roll a negative number of dice in take_turn.'
assert num_rolls <= 10, 'Cannot roll mor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def roll_the_dices(num_of_iterations: int) -> None:\n # initial variables\n player_wins: int = 0\n theoretical_win_chance: float = round(15/36, 4)\n\n # main loop\n for _ in range(num_of_iterations):\n croupier_roll = random.randint(1, 6)\n player_roll = random.randint(1, 6)\n i... | [
"0.7492326",
"0.7283249",
"0.72142756",
"0.7099693",
"0.70457476",
"0.7032021",
"0.70317835",
"0.70165855",
"0.7005138",
"0.6891632",
"0.6885169",
"0.68767",
"0.6866846",
"0.6863758",
"0.68346596",
"0.6831231",
"0.6797727",
"0.6764949",
"0.671695",
"0.6702425",
"0.66889226",
... | 0.6527212 | 50 |
Return whether the current player's score has the same absolute difference between its last two digits as the opponent's score. | def is_swap(player_score, opponent_score):
# BEGIN PROBLEM 4
"*** YOUR CODE HERE ***"
player_diff = abs(((player_score // 10)%10) - (player_score % 10))
opponent_diff = abs(((opponent_score // 10)%10) - (opponent_score % 10))
if player_diff == opponent_diff:
return True
return False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_for_end_of_game(self):\n return self.player_1.score + self.player_2.score >= self.number_of_cells",
"def check_score(self):\r\n # If player reaches the exit before time expires\r\n final_score = int((5 - self._maze.items_remaining())*(self._time)*(100))\r\n score = (final_sc... | [
"0.64410603",
"0.6398884",
"0.61772853",
"0.6137578",
"0.6104868",
"0.5995031",
"0.5957221",
"0.59311676",
"0.5911049",
"0.5877488",
"0.5869364",
"0.5831406",
"0.5827793",
"0.5821174",
"0.5811221",
"0.5742785",
"0.573965",
"0.5735727",
"0.5733894",
"0.57310593",
"0.5688824",
... | 0.6652104 | 0 |
Return the other player, for a player PLAYER numbered 0 or 1. >>> other(0) 1 >>> other(1) 0 | def other(player):
return 1 - player | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def otherPlayer(cls, player):\n return 0 if player == 1 else 1",
"def other_player(cls, player):\n return 0 if player == 1 else 1",
"def other_player(self, player):\n if player == self.__opponent:\n return self.__pid\n else:\n return self.__opponent",
"def __... | [
"0.81847143",
"0.81327176",
"0.79256344",
"0.7875795",
"0.7709813",
"0.7093842",
"0.68455774",
"0.6804346",
"0.66201985",
"0.66201985",
"0.6579255",
"0.6476013",
"0.64561236",
"0.64236355",
"0.6390737",
"0.63760537",
"0.6363144",
"0.6363144",
"0.6335515",
"0.62314063",
"0.619... | 0.780577 | 5 |
Announce nothing (see Phase 2). | def silence(score0, score1):
return silence | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def announceGenerate(self):",
"def acknowledged(self):\n ...",
"def nothing():\n pass",
"def announce(self):\n self.notify(self.newAgent)\n if not self.agent.is_someone_subscribed():\n self.fail(cause=\"Noone Interested\")",
"def nothing(self, **kwargs):\n pass",
... | [
"0.64833313",
"0.6462538",
"0.6427069",
"0.6208884",
"0.6080106",
"0.60444295",
"0.60401314",
"0.5978425",
"0.59485215",
"0.59143573",
"0.5901542",
"0.58910334",
"0.5884047",
"0.5867043",
"0.58350474",
"0.5829268",
"0.57348514",
"0.5711469",
"0.5711469",
"0.569965",
"0.569663... | 0.0 | -1 |
Simulate a game and return the final scores of both players, with Player 0's score first, and Player 1's score second. A strategy is a function that takes two total scores as arguments (the current player's score, and the opponent's score), and returns a number of dice that the current player will roll this turn. | def play(strategy0, strategy1, score0=0, score1=0, dice=six_sided,
goal=GOAL_SCORE, say=silence):
player = 0 # Which player is about to take a turn, 0 (first) or 1 (second)
# BEGIN PROBLEM 5
n = 0 #turn number
change_turn = 0 #0 - change turn, 1 - extra turn, 2 - just gave extra turn and canno... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play(strategy0, strategy1, score0=0, score1=0, goal=GOAL_SCORE):\n player = 0 # Which player is about to take a turn, 0 (first) or 1 (second)\n dice_swapped = False # Whether 4-sided dice have been swapped for 6-sided\n my_score = score0\n opponent_score = score1\n while(score0<goal and score1... | [
"0.8078709",
"0.77226627",
"0.7643338",
"0.7511744",
"0.72544575",
"0.72544575",
"0.72544575",
"0.69056386",
"0.6778778",
"0.67451346",
"0.6727206",
"0.6683956",
"0.6642889",
"0.65882045",
"0.6545798",
"0.6520198",
"0.64840305",
"0.64594907",
"0.6428396",
"0.64271224",
"0.642... | 0.7057277 | 7 |
A commentary function that announces the score for each player. | def say_scores(score0, score1):
print("Player 0 now has", score0, "and Player 1 now has", score1)
return say_scores | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_score():\n pass",
"def _update_score(self) -> None:\n\n # setting new score by iterating over players\n self.score_play[self.n_play_turns, ] = [\n self._score_table[(\n self.contract.level,\n self.contract.suit,\n self.tricks... | [
"0.6046844",
"0.5984142",
"0.58788544",
"0.57748145",
"0.57382643",
"0.57231647",
"0.5692457",
"0.5646813",
"0.5645962",
"0.5610773",
"0.56061566",
"0.5576601",
"0.5571611",
"0.5549147",
"0.54914784",
"0.54739916",
"0.542415",
"0.54227626",
"0.541028",
"0.53925556",
"0.539219... | 0.567084 | 7 |
Return a commentary function that announces lead changes. >>> f0 = announce_lead_changes() >>> f1 = f0(5, 0) Player 0 takes the lead by 5 >>> f2 = f1(5, 12) Player 1 takes the lead by 7 >>> f3 = f2(8, 12) >>> f4 = f3(8, 13) >>> f5 = f4(15, 13) Player 0 takes the lead by 2 | def announce_lead_changes(previous_leader=None):
def say(score0, score1):
if score0 > score1:
leader = 0
elif score1 > score0:
leader = 1
else:
leader = None
if leader != None and leader != previous_leader:
print('Player', leader, 'take... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_increment_function(delta):\n return lambda number: number + delta",
"def updates(f):\n f.updates = True\n return f",
"def announce_highest(who, previous_high=0, previous_score=0):\n assert who == 0 or who == 1, 'The who argument should indicate a player.'\n # BEGIN PROBLEM 7\n \"... | [
"0.52705693",
"0.4956819",
"0.48748475",
"0.48450497",
"0.47327447",
"0.47263965",
"0.4567901",
"0.45541704",
"0.45343226",
"0.45111257",
"0.4508821",
"0.4503597",
"0.44995",
"0.4498226",
"0.4497035",
"0.44950983",
"0.44797027",
"0.44740486",
"0.44602418",
"0.44587052",
"0.44... | 0.75322604 | 0 |
Return a commentary function that says what f says, then what g says. >>> h0 = both(say_scores, announce_lead_changes()) >>> h1 = h0(10, 0) Player 0 now has 10 and Player 1 now has 0 Player 0 takes the lead by 10 >>> h2 = h1(10, 6) Player 0 now has 10 and Player 1 now has 6 >>> h3 = h2(6, 18) Player 0 gets 8 points, th... | def both(f, g):
def say(score0, score1):
return both(f(score0, score1), g(score0, score1))
return say | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def announce_lead_changes(previous_leader=None):\n def say(score0, score1):\n if score0 > score1:\n leader = 0\n elif score1 > score0:\n leader = 1\n else:\n leader = None\n if leader != None and leader != previous_leader:\n print('Player',... | [
"0.72504",
"0.6531482",
"0.58339536",
"0.58319485",
"0.57939136",
"0.570603",
"0.5563739",
"0.5320002",
"0.53060275",
"0.53017294",
"0.5292971",
"0.5284072",
"0.52297515",
"0.5229289",
"0.51723313",
"0.51709175",
"0.51519513",
"0.5145487",
"0.51122797",
"0.5094572",
"0.508087... | 0.644719 | 2 |
Return a commentary function that announces when WHO's score increases by more than ever before in the game. >>> f0 = announce_highest(1) Only announce Player 1 score gains >>> f1 = f0(11, 0) >>> f2 = f1(11, 9) 9 point(s)! That's the biggest gain yet for Player 1 >>> f3 = f2(20, 9) >>> f4 = f3(12, 20) Player 1 gets 3 p... | def announce_highest(who, previous_high=0, previous_score=0):
assert who == 0 or who == 1, 'The who argument should indicate a player.'
# BEGIN PROBLEM 7
"*** YOUR CODE HERE ***"
def highest_commentary(score0, score1):
current_score = -1
if who == 0:
current_score = score0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def announce_highest(who, previous_high=0, previous_score=0):\n assert who == 0 or who == 1, 'The who argument should indicate a player.'\n if who ==0 :\n if previous_score> previous_high:\n previous_high=previous_score\n if previous_score>1:\n print(previous_score... | [
"0.7569457",
"0.5807958",
"0.5743568",
"0.56182736",
"0.54227114",
"0.54214245",
"0.5420976",
"0.5420976",
"0.54136336",
"0.54079795",
"0.5385615",
"0.5337723",
"0.53179383",
"0.5317137",
"0.5281766",
"0.5249433",
"0.5247084",
"0.51886827",
"0.5187498",
"0.51824766",
"0.51737... | 0.7925943 | 0 |
Return a strategy that always rolls N dice. A strategy is a function that takes two total scores as arguments (the current player's score, and the opponent's score), and returns a number of dice that the current player will roll this turn. >>> strategy = always_roll(5) >>> strategy(0, 0) 5 >>> strategy(99, 99) 5 | def always_roll(n):
def strategy(score, opponent_score):
return n
return strategy | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def always_roll(n):\r\n def strategy(score, opponent_score):\r\n return n\r\n return strategy",
"def always_roll(n):\r\n def strategy(score, opponent_score):\r\n return n\r\n return strategy",
"def roll_dice(self):\n self.roll = (random.randint(1,6), random.randint(1,6))\n ... | [
"0.7990645",
"0.7990645",
"0.6305908",
"0.6282267",
"0.6265862",
"0.6256419",
"0.62271136",
"0.6221337",
"0.62017894",
"0.60886043",
"0.6063855",
"0.6039743",
"0.6021034",
"0.6010283",
"0.60091543",
"0.5938398",
"0.59243244",
"0.59230936",
"0.59065485",
"0.59057117",
"0.59048... | 0.80193526 | 1 |
Return a function that returns the average value of FN when called. To implement this function, you will have to use args syntax, a new Python feature introduced in this project. See the project description. >>> dice = make_test_dice(4, 2, 5, 1) >>> averaged_dice = make_averaged(dice, 1000) >>> averaged_dice() 3.0 | def make_averaged(fn, num_samples=1000):
# BEGIN PROBLEM 8
"*** YOUR CODE HERE ***"
def return_average(*args):
k, total = 0, 0
while k < num_samples:
total += fn(*args)
k += 1
return total / num_samples
return return_average
# END PROBLEM 8 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_averaged(fn, num_samples=1000):\n # BEGIN PROBLEM 8\n def average(*args):\n sum = 0\n for i in range(num_samples):\n sum += fn(*args)\n return sum / num_samples\n return average\n # END PROBLEM 8",
"def make_averaged(fn, num_samples=1000):\n # BEGIN PROBLEM... | [
"0.742507",
"0.7286888",
"0.69316167",
"0.60547763",
"0.60077626",
"0.59997326",
"0.5834956",
"0.57966316",
"0.5760647",
"0.57417023",
"0.57063097",
"0.56811064",
"0.5680927",
"0.5663702",
"0.55822456",
"0.5506385",
"0.5506385",
"0.5506385",
"0.546159",
"0.54614824",
"0.54594... | 0.73083514 | 1 |
Return the number of dice (1 to 10) that gives the highest average turn score by calling roll_dice with the provided DICE over NUM_SAMPLES times. Assume that the dice always return positive outcomes. >>> dice = make_test_dice(1, 6) >>> max_scoring_num_rolls(dice) 1 | def max_scoring_num_rolls(dice=six_sided, num_samples=1000):
# BEGIN PROBLEM 9
"*** YOUR CODE HERE ***"
k, max_value, max_num = 1, 0, 0
roll = make_averaged(roll_dice, num_samples)
while k <= 10:
current_value = roll(k, dice)
#print('k: ' + str(k) + ' current_value: ' + str(current_v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_scoring_num_rolls(dice=six_sided, num_samples=1000):\n # BEGIN PROBLEM 9\n averaged_dice = make_averaged(roll_dice, num_samples)\n max_score = 0\n result = 0\n for num_rolls in range(1, 11):\n average_turn_score = averaged_dice(num_rolls, dice)\n if average_turn_score > max_sco... | [
"0.8601709",
"0.80853796",
"0.6568092",
"0.6565552",
"0.6456323",
"0.63220537",
"0.62745166",
"0.625151",
"0.6118052",
"0.60378474",
"0.59962904",
"0.5992495",
"0.59903264",
"0.5952468",
"0.59410113",
"0.5890593",
"0.5816515",
"0.5800886",
"0.5747316",
"0.5736538",
"0.5682466... | 0.8030235 | 2 |
Return 0 if strategy0 wins against strategy1, and 1 otherwise. | def winner(strategy0, strategy1):
score0, score1 = play(strategy0, strategy1)
if score0 > score1:
return 0
else:
return 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play(strategy0, strategy1):\r\n who = 0 # Which player is about to take a turn, 0 (first) or 1 (second)\r\n score0, score1 = 0, 0\r\n while who == 0:\r\n dice_num = dice_check(score0, score1, who, strategy0)\r\n score0 += take_turn(dice_num, score1, select_dice(score0, score1), name(who)... | [
"0.6689735",
"0.6615073",
"0.6372661",
"0.6286028",
"0.6247574",
"0.62431514",
"0.6144753",
"0.61409026",
"0.6093172",
"0.60292673",
"0.5996782",
"0.5976392",
"0.59516424",
"0.59036964",
"0.5876322",
"0.5876114",
"0.586334",
"0.58454233",
"0.58374006",
"0.58091956",
"0.579776... | 0.8123433 | 1 |
Return the average win rate of STRATEGY against BASELINE. Averages the winrate when starting the game as player 0 and as player 1. | def average_win_rate(strategy, baseline=always_roll(4)):
win_rate_as_player_0 = 1 - make_averaged(winner)(strategy, baseline)
win_rate_as_player_1 = make_averaged(winner)(baseline, strategy)
return (win_rate_as_player_0 + win_rate_as_player_1) / 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def win_ratio_avg(self):\n win_ratio = 0\n # Adds all the win ratios of team in this conference which will be\n # used to compute the win ratio average.\n for team_obj in self._conf_teams:\n ### INVARIANT: team_obj is a Team class object and\n ### self._con... | [
"0.6717765",
"0.64588726",
"0.63417643",
"0.62936395",
"0.6277814",
"0.610984",
"0.61046314",
"0.6065044",
"0.59797865",
"0.5971465",
"0.5899065",
"0.5877843",
"0.5819356",
"0.5789211",
"0.5763565",
"0.57442445",
"0.5724848",
"0.57111496",
"0.5692904",
"0.5664826",
"0.5659643... | 0.8115959 | 1 |
Run a series of strategy experiments and report results. | def run_experiments():
if False: # Change to False when done finding max_scoring_num_rolls
six_sided_max = max_scoring_num_rolls(six_sided)
print('Max scoring num rolls for six-sided dice:', six_sided_max)
if False: # Change to True to test always_roll(8)
print('always_roll(8) win rat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_experiments():\r\n result = eval_strategy_range(always_roll, 1, 10)\r\n print('Best always_roll strategy:', result)\r\n\r\n if True: # Change to True when ready to test make_comeback_strategy\r\n result = eval_strategy_range(make_comeback_strategy, 5, 15)\r\n print('Best comeback str... | [
"0.7600534",
"0.70792615",
"0.70204407",
"0.69126785",
"0.6863788",
"0.683368",
"0.66033673",
"0.65340483",
"0.648887",
"0.6473116",
"0.6473116",
"0.6473116",
"0.6462529",
"0.6456427",
"0.6447508",
"0.64332825",
"0.636296",
"0.6348656",
"0.62743956",
"0.6269425",
"0.6254592",... | 0.7061546 | 2 |
This strategy rolls 0 dice if that gives at least MARGIN points, and rolls NUM_ROLLS otherwise. | def bacon_strategy(score, opponent_score, margin=8, num_rolls=4):
# BEGIN PROBLEM 10
if free_bacon(opponent_score) >= margin:
return 0
return num_rolls
# END PROBLEM 10 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def roll(self):\n rolls = []\n if self.dice_array is not None:\n for dice in self.dice_array:\n rolls.append(np.random.randint(1, dice+1))\n else:\n for _ in range(0,self.number):\n rolls.append(np.random.randint(1, self.sides+1))\n #F... | [
"0.640882",
"0.6383132",
"0.6260958",
"0.62457883",
"0.623219",
"0.6221527",
"0.6191936",
"0.6188556",
"0.6102771",
"0.6068335",
"0.60042995",
"0.597458",
"0.5960024",
"0.5950923",
"0.5943093",
"0.5897673",
"0.58673483",
"0.58545053",
"0.5813064",
"0.5807225",
"0.5772373",
... | 0.0 | -1 |
This strategy rolls 0 dice when it triggers a beneficial swap. It also rolls 0 dice if it gives at least MARGIN points and does not trigger a nonbeneficial swap. Otherwise, it rolls NUM_ROLLS. | def swap_strategy(score, opponent_score, margin=8, num_rolls=4):
# BEGIN PROBLEM 11
new_score = score + free_bacon(opponent_score)
if is_swap(new_score, opponent_score) and (opponent_score > new_score):
return 0
elif free_bacon(opponent_score) >= margin and not (is_swap(new_score, opponent_score... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_comeback_strategy(margin, num_rolls=5):\r\n def from_the_depths(score, opp_score):\r\n if opp_score - score >= margin: return num_rolls + 1\r\n else: return num_rolls\r\n return from_the_depths",
"def final_strategy(score, opponent_score):\n # BEGIN PROBLEM 12\n def is_odd(n):\... | [
"0.6452284",
"0.63540983",
"0.63094753",
"0.62689674",
"0.62569886",
"0.61875606",
"0.612704",
"0.612704",
"0.6077186",
"0.60761815",
"0.60616195",
"0.60535634",
"0.60535634",
"0.60535634",
"0.6049227",
"0.60323215",
"0.60221475",
"0.5974652",
"0.5950272",
"0.5941493",
"0.592... | 0.63004863 | 3 |
Read in the commandline argument and calls corresponding functions. This function uses Python syntax/techniques not yet covered in this course. | def run(*args):
import argparse
parser = argparse.ArgumentParser(description="Play Hog")
parser.add_argument('--run_experiments', '-r', action='store_true',
help='Runs strategy experiments')
args = parser.parse_args()
if args.run_experiments:
run_experiments() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n args = parse_args()\n process_args(args)",
"def main(args):",
"def main(args):",
"def main(args=None):",
"def main(args=None):",
"def main(args=None):\n pass",
"def main():\n parser = argparse.ArgumentParser(description=\"\"\"Tester for YT Data API and different inputs\"\"\")\... | [
"0.7371581",
"0.7101281",
"0.7101281",
"0.71001196",
"0.71001196",
"0.68302774",
"0.67929476",
"0.67655843",
"0.6722067",
"0.6722067",
"0.6720285",
"0.667106",
"0.66193235",
"0.66193235",
"0.66193235",
"0.66193235",
"0.66193235",
"0.66193235",
"0.66193235",
"0.66193235",
"0.6... | 0.0 | -1 |
Ensure that it reduces to the mutual information for bivariate distributions. | def test_caekl_1(d):
assert I(d) == pytest.approx(J(d)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_fit_default_distribution(self):\n\n copula = GaussianMultivariate(GaussianUnivariate)\n copula.fit(self.data)\n\n for i, key in enumerate(self.data.columns):\n assert copula.columns[i] == key\n assert copula.univariates[i].__class__ == GaussianUnivariate\n ... | [
"0.5723322",
"0.56464213",
"0.56001174",
"0.55144453",
"0.54087925",
"0.54014647",
"0.5367786",
"0.5322792",
"0.5297757",
"0.52877957",
"0.52863365",
"0.5265465",
"0.52652",
"0.52548265",
"0.52372015",
"0.52356696",
"0.51734567",
"0.51734096",
"0.5166007",
"0.51452106",
"0.51... | 0.0 | -1 |
Ensure that it reduces to the mutual information for bivariate distributions reduced from multivariate. | def test_caekl_2(d):
rvs = [[0], [1]]
assert I(d, rvs) == pytest.approx(J(d, rvs)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multivariate_gauss_prob(observed, mean, covariance):\n\n return None",
"def _handleInput(self, paramInput):\n super()._handleInput(paramInput)\n if paramInput.parameterValues['method'] == 'pca':\n self.method = 'pca'\n elif paramInput.parameterValues['method'] == 'spline':\n self.method... | [
"0.58070433",
"0.57255405",
"0.56607497",
"0.5495321",
"0.535974",
"0.52546823",
"0.52330446",
"0.5210722",
"0.52041334",
"0.5199552",
"0.5195257",
"0.5186404",
"0.51677173",
"0.51306176",
"0.5130186",
"0.5125754",
"0.51237744",
"0.51133645",
"0.5106805",
"0.5079338",
"0.5073... | 0.0 | -1 |
Test a known value. | def test_caekl_3():
d = D(['000', '011', '101', '110'], [1 / 4] * 4)
assert J(d) == pytest.approx(0.5) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_value(self, value):",
"def _check_value(self, value):\n raise NotImplementedError",
"def check(self, value):\n raise NotImplementedError",
"def _check_value(self, value, name, check_function):\n if check_function is not None:\n is_good = check_function(value) #May ra... | [
"0.80775046",
"0.7501336",
"0.7266181",
"0.7051244",
"0.6900198",
"0.6898595",
"0.6877228",
"0.684004",
"0.6814614",
"0.6802086",
"0.6755023",
"0.6750932",
"0.66680443",
"0.66036206",
"0.6560172",
"0.65543497",
"0.6528797",
"0.6458347",
"0.64339",
"0.642714",
"0.64136505",
... | 0.0 | -1 |
Test that CAEKL is always less than or equal to the normalized total correlation. | def test_caekl_4(d):
assert J(d) <= (T(d) / 3) + 1e-6 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_absolutely_monotonic(self,r,tol):\n s=len(self)\n K=np.vstack([self.A.astype(float),self.b.astype(float)])\n K=np.hstack([K,np.zeros([s+1,1])])\n X=np.eye(s+1)+r*K\n if abs(np.linalg.det(X))<tol: return 0\n beta_r=np.linalg.solve(X,K)\n v_r_sum = np.dot(np.e... | [
"0.604998",
"0.6012431",
"0.59215325",
"0.5856045",
"0.58455676",
"0.58151805",
"0.5794475",
"0.5794475",
"0.5794475",
"0.5787765",
"0.57562685",
"0.57562685",
"0.57562685",
"0.5755928",
"0.5742629",
"0.57194674",
"0.5675751",
"0.56736386",
"0.566482",
"0.5655411",
"0.5621105... | 0.53975534 | 55 |
Applies the logistic function to x, elementwise. | def sigmoid(X):
return 1 / (1 + np.exp(-X)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logistic(self,w,Xi):\n # print(w.T)\n # print(Xi)\n a = np.dot(w.T,Xi)\n return 1/(1+np.exp(-a))",
"def logistic(self, X, w):\n g = 1 / (1 + np.exp(-X.dot(w)))\n return g",
"def forward(self, x):\n\n embeds = self.dvector(x)\n logits = self.linear(emb... | [
"0.7002704",
"0.6978957",
"0.6883872",
"0.68210745",
"0.6803985",
"0.6706345",
"0.66907454",
"0.6664395",
"0.6663363",
"0.66488755",
"0.664373",
"0.660833",
"0.6597647",
"0.6596353",
"0.6534404",
"0.64707106",
"0.64558506",
"0.64442515",
"0.64267933",
"0.6374905",
"0.6363094"... | 0.0 | -1 |
Combines given list argument in a logistic equation and returns it as a function | def logistic_hypothesis(theta):
return lambda X: sigmoid(np.dot(x_strich(X), theta)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logistic(mu):\n mu4 = 4*mu\n def f(x):\n return mu4*x*(1.-x)\n return f",
"def logistic_function(self, data, b0, b1):\n return np.array([1/(1+exp(-1*b0+(-1*b1*x))) for x in data])",
"def logistic_function(z):\n\tg = 1/(1+np.exp(-z))\n\t#g = np.exp(z)/(1+np.exp(z))\n\treturn g",
"de... | [
"0.68958294",
"0.68420416",
"0.6600226",
"0.65383476",
"0.6343635",
"0.628913",
"0.624117",
"0.62409633",
"0.61989814",
"0.6157783",
"0.61215085",
"0.6084098",
"0.60748845",
"0.6012121",
"0.5917856",
"0.5874498",
"0.58656096",
"0.5851732",
"0.58011216",
"0.57765955",
"0.57699... | 0.60247886 | 13 |
Implements crossentropy as a function costs(theta) on given traning data | def cross_entropy(X, y):
return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (
1 - y
) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy(y_observed, p):\n\n pass",
"def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)",
"def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(lik... | [
"0.73253536",
"0.6912139",
"0.6881294",
"0.6762478",
"0.6754978",
"0.6689187",
"0.6629159",
"0.660048",
"0.6590784",
"0.65587205",
"0.6547451",
"0.6451672",
"0.64506274",
"0.6429443",
"0.64189255",
"0.63606083",
"0.6355681",
"0.633888",
"0.6335124",
"0.6334",
"0.63227713",
... | 0.71423405 | 1 |
Updates learnable parameters theta The update is done by calculating the partial derivities of the cost function including the linear hypothesis. The gradients scaled by a scalar are subtracted from the given theta values. | def compute_new_theta(X, y, theta, learning_rate, lambda_reg):
thetas = np.zeros(len(theta))
thetas = theta * (1 - learning_rate * (lambda_reg / len(X))) - (
learning_rate / len(X)
) * np.sum((logistic_hypothesis(theta)(X) - y) * x_strich(X).T, axis=1)
return thetas | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_grad_updates(self):\n \n gradients = T.grad(self.cost, self.theta)\n \n for target_param, grad in zip(self.theta, gradients):\n \n if target_param.name ==\"W\" and self.num_hidden ==0\\\n and self.zero_diag:\n \n grad ... | [
"0.70289654",
"0.694744",
"0.694744",
"0.6826142",
"0.66292876",
"0.6610046",
"0.65948474",
"0.6546575",
"0.652195",
"0.65193623",
"0.65162325",
"0.65117294",
"0.65025204",
"0.64622724",
"0.64474326",
"0.641127",
"0.63753605",
"0.63573223",
"0.63517094",
"0.63488644",
"0.6333... | 0.62909085 | 27 |
Minimize theta values of a logistic model based on crossentropy cost function | def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):
thetas = [theta]
cost = np.zeros(num_iters)
J = mean_cross_entropy_costs(X, y, lambda_reg)
cost[0] = J(thetas[0])
for i in range(1, num_iters):
thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logit_cost(self, theta, X, y):\n\n cost = 0.0\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n \n for i in range(0, X.shape[0]):\n cost += (y[i]-1)*theta[i] + np.log(sig[i])\n ### END YOUR CODE\n cost = cost #+ 0.01 * self.regularizer[0](self.wei... | [
"0.75096697",
"0.7109986",
"0.7026688",
"0.69945616",
"0.6948253",
"0.68546367",
"0.6719014",
"0.6706194",
"0.66798836",
"0.6674309",
"0.6670411",
"0.6663733",
"0.6650096",
"0.6644245",
"0.6628111",
"0.6595147",
"0.6570327",
"0.6524744",
"0.6518117",
"0.6495512",
"0.6472702",... | 0.0 | -1 |
Implements mean crossentropy as a function J(theta) on given traning data | def mean_cross_entropy_costs(X, y, lambda_reg=0.0):
return lambda theta: np.mean(cross_entropy(X, y)(theta)) + L2_regularization_cost(
X, theta, lambda_reg
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy(y_observed, p):\n\n pass",
"def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)",
"def objective_function(theta, X, y):\n # m number of training instances\n m = X.shape[0]\n jtheta = sum... | [
"0.6527088",
"0.6297951",
"0.6211556",
"0.61678755",
"0.6018695",
"0.596516",
"0.59576994",
"0.5953384",
"0.59498775",
"0.59448695",
"0.59320253",
"0.5895446",
"0.58729154",
"0.58721983",
"0.5862694",
"0.5858808",
"0.5858743",
"0.5858007",
"0.583182",
"0.58312905",
"0.5809158... | 0.0 | -1 |
Plots the costs over the iterations | def plot_progress(fig, costs, learning_rate, lambda_reg):
ax = fig.add_subplot(111)
ax.plot(
np.arange(len(costs)),
costs,
alpha=0.8,
label="LR: " + str(learning_rate) + " __ Lambda: " + str(lambda_reg),
)
ax.legend(
bbox_to_anchor=(0.0, 1.02, 1.0, 0.102),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_costs(j_history):\n plt.figure(figsize=(14, 8))\n plt.plot(range(len(j_history)), j_history)\n plt.grid(True)\n plt.title('J (Cost)')\n plt.xlabel('Iteration')\n plt.ylabel('Cost function')\n plt.xlim([0, 1.05 * ITERATIONS])\n plt.ylim([4, 7])\n plt.show()\n plt.close()",
"... | [
"0.7945268",
"0.7783235",
"0.767943",
"0.7237459",
"0.68332607",
"0.6824882",
"0.67958784",
"0.67673373",
"0.67216945",
"0.6590324",
"0.6507171",
"0.6492306",
"0.6478465",
"0.647183",
"0.64140046",
"0.6411427",
"0.633973",
"0.632849",
"0.63174886",
"0.62941676",
"0.6243552",
... | 0.69094783 | 4 |
Set up each webpage with a header and navigation bar. | def setup_page(
self, html_page, links, label=None, title=None, approximant=None,
background_colour=None, histogram_download=False
):
html_file = webpage.open_html(
web_dir=self.webdir, base_url=self.base_url, html_page=html_page,
label=label
)
html_fi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_webpages(self):\n if self.add_to_existing:\n self.add_existing_data()\n self.make_home_pages()\n self.make_1d_histogram_pages()\n self.make_corner_pages()\n self.make_config_pages()\n if self.make_comparison:\n self.make_comparison_pages(... | [
"0.6627888",
"0.6465586",
"0.62752324",
"0.6114537",
"0.6103888",
"0.606285",
"0.60445887",
"0.6036751",
"0.60337174",
"0.6021009",
"0.5930741",
"0.5924869",
"0.5913862",
"0.58483374",
"0.5833003",
"0.58251595",
"0.57794666",
"0.57769567",
"0.57743686",
"0.5753638",
"0.575228... | 0.6815308 | 0 |
Make a navbar for the homepage | def make_navbar_for_homepage(self):
links = [
"home", ["Result Pages", self._result_page_links()], "Version"
]
if len(self.samples) > 1:
links[1][1] += ["Comparison"]
if self.publication:
links.insert(2, "Publication")
if self.gwdata is not Non... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main_nav():\n return render_template('home.html')",
"def homepage():\n return render_template('home/index.html', \n title=\"Bem vindo!\")",
"def index():\n return render_template(\n 'index.html',\n nav=nav,\n title='Home Page',\n year=datetime... | [
"0.736893",
"0.67783135",
"0.6750848",
"0.66524625",
"0.6623326",
"0.6588633",
"0.6580005",
"0.6562279",
"0.6562279",
"0.6562279",
"0.6562279",
"0.6562279",
"0.6562279",
"0.6562279",
"0.6562279",
"0.6562279",
"0.6562279",
"0.653496",
"0.6521001",
"0.6503073",
"0.64983183",
... | 0.71998024 | 1 |
Make a navbar for the result page homepage | def make_navbar_for_result_page(self):
links = {
i: ["1d Histograms", [{"Custom": i}, {"All": i}]] for i in self.labels
}
for num, label in enumerate(self.labels):
for j in self.categorize_parameters(self.samples[label].keys()):
j = [j[0], [{k: label} for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_navbar_for_homepage(self):\n links = [\n \"home\", [\"Result Pages\", self._result_page_links()], \"Version\"\n ]\n if len(self.samples) > 1:\n links[1][1] += [\"Comparison\"]\n if self.publication:\n links.insert(2, \"Publication\")\n if... | [
"0.80170983",
"0.7169193",
"0.6690814",
"0.6587678",
"0.6552421",
"0.6529632",
"0.65201473",
"0.65188295",
"0.64830226",
"0.6469217",
"0.64192796",
"0.64133656",
"0.6382045",
"0.6367651",
"0.63470757",
"0.63470757",
"0.63470757",
"0.63470757",
"0.63470757",
"0.63470757",
"0.6... | 0.6568194 | 4 |
Generate all webpages for all result files passed | def generate_webpages(self):
if self.add_to_existing:
self.add_existing_data()
self.make_home_pages()
self.make_1d_histogram_pages()
self.make_corner_pages()
self.make_config_pages()
if self.make_comparison:
self.make_comparison_pages()
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n for file_name in os.listdir(CONTENT_FOLDER):\n if file_name.endswith('.html'):\n try_generate_page(file_name)",
"def make_all_html_results(cmd, folder_names = [], jobs=[]):\n run = cmd.results.current['run_name']\n if not os.path.exists(pjoin(cmd.me_dir, 'HTML', run)):\n ... | [
"0.7309482",
"0.6664472",
"0.6591473",
"0.65694594",
"0.6510609",
"0.6404508",
"0.6366648",
"0.63231736",
"0.6277945",
"0.622136",
"0.6204493",
"0.6124423",
"0.6105005",
"0.60247594",
"0.6022048",
"0.5962354",
"0.5959207",
"0.59505546",
"0.59500504",
"0.5926389",
"0.5917044",... | 0.70953083 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.