Self:\n tz = timezones.maybe_get_tz(tz)\n\n if self.tz is None:\n # tz naive, use tz_localize\n raise TypeError(\n \"Cannot convert tz-naive timestamps, use tz_localize to localize\"\n )\n\n # No conversion since timestamps are all UTC to begin with\n dtype = tz_to_dtype(tz, unit=self.unit)\n return self._simple_new(self._ndarray, dtype=dtype, freq=self.freq)","def _epoch_utc_to_datetime(epoch_utc):\n return datetime.fromtimestamp(epoch_utc)","def local_timestamp():\n # type: () -> int\n now = datetime.utcnow()\n timestamp_in_seconds = calendar.timegm(now.timetuple()) + (now.microsecond / 1e6)\n timestamp_in_milliseconds = int(timestamp_in_seconds * 1000)\n return timestamp_in_milliseconds","def fromtimestamp(cls, timestamp, tz=None):\n return datetime()","def _local_time_offset():\n if time.localtime().tm_isdst and time.daylight:\n return -time.altzone\n else:\n return -time.timezone"],"string":"[\n \"def UTCtimestampTolocal(ts, local_tz):\\n t_utc = dt.datetime.fromtimestamp(ts,tz=pytz.timezone(\\\"UTC\\\"))\\n t_local = t_utc.astimezone(local_tz)\\n return t_local\",\n \"def utc_timestamp(ts):\\n import pandas\\n\\n ts = pandas.Timestamp(ts)\\n if not ts.tzinfo:\\n ts = ts.tz_localize(\\\"UTC\\\")\\n else:\\n ts = ts.tz_convert(\\\"UTC\\\")\\n\\n return ts\",\n \"def to_local_time(self, tweet_timestamp):\\n timestamp = mktime_tz(parsedate_tz(tweet_timestamp))\\n return datetime.fromtimestamp(timestamp)\",\n \"def local_to_utc(local_dt: datetime) -> datetime:\\n if local_dt is None:\\n return None\\n utc_dt = local_dt.astimezone(tz.UTC)\\n return utc_dt\",\n \"def utc_to_local_timestamp(ts, orig_tz=UTC):\\n timestamp = datetime.datetime.fromtimestamp(ts,tz=orig_tz)\\n return timestamp.astimezone(LOCAL)\",\n \"def local_to_utc(local_dt):\\n local_dt = local_dt.replace(tzinfo=tz.tzlocal())\\n return local_dt.astimezone(tz.tzlocal())\",\n \"def _local_timestamps(self) -> npt.NDArray[np.int64]:\\n if self.tz is None or timezones.is_utc(self.tz):\\n # Avoid the copy that would be made in tzconversion\\n return self.asi8\\n return tz_convert_from_utc(self.asi8, self.tz, reso=self._creso)\",\n \"def localToUTC(t, local_tz):\\n t_local = local_tz.localize(t, is_dst=None)\\n t_utc = t_local.astimezone(pytz.utc)\\n return t_utc\",\n \"def posix2local(timestamp, tz=tzlocal.get_localzone()):\\n return datetime.fromtimestamp(timestamp, tz)\",\n \"def utc_to_local_datetime(dt):\\n return dt.astimezone(LOCAL)\",\n \"def utc2local(utc_dt):\\n return datetime.fromtimestamp(timegm(utc_dt.timetuple()))\",\n \"def timestampfromlocal(local):\\n return local.timestamp()\",\n \"def utcfromtimestamp(cls, t):\\n return cls._fromtimestamp(t, True, None)\",\n \"def timestamp_to_local(timestamp):\\n naive = datetime.datetime.strptime(timestamp, '%Y-%m-%dT%H:%M:%SZ').replace(tzinfo=pytz.utc)\\n return naive.astimezone(_tz)\",\n \"def utc_timestamp(d):\\n if isinstance(d, pd.tslib.Timestamp):\\n # Pandas datetime timestamp whatever thing\\n if d.tz != pytz.utc:\\n d = d.tz_localize('UTC')\\n else:\\n # Normal datetime object\\n if d.tzinfo != pytz.utc:\\n d = pytz.utc.localize(d)\\n # Yes, you have to write it out like this, there is no convenient method.\\n # See http://stackoverflow.com/questions/8777753/converting-datetime-date-to-utc-timestamp-in-python\\n # Datetimes in python really are a mess...\\n return (d - datetime(1970, 1, 1, tzinfo=timezone('UTC'))) / timedelta(seconds=1)\",\n \"def aware_utc_from_timestamp(timestamp):\\n return datetime.utcfromtimestamp(timestamp).replace(tzinfo=pytz.utc)\",\n \"def get_datetime(ts, local_time=True):\\n tsf = float(ts) / 1000\\n timev = time.localtime(tsf) if local_time else time.gmtime(tsf)\\n dt = datetime.datetime.fromtimestamp(time.mktime(timev))\\n return dt\",\n \"def utc_to_local(utc_dt: datetime) -> datetime:\\n if utc_dt is None:\\n return None\\n local_dt = utc_dt.astimezone(tz.tzlocal())\\n return local_dt\",\n \"def utc_to_local(t):\\n # set utc tzinfo\\n t = t.replace(tzinfo=tz.tzutc())\\n # convert to local timezone\\n return t.astimezone(tz.tzlocal())\",\n \"def date_to_local(self, date):\\n if date.tzinfo is not None:\\n # date is timezone-aware\\n date = date.astimezone(self.tz_local)\\n\\n else:\\n # date is a naive date: assume expressed in UTC\\n date = date.replace(tzinfo=self.tz_utc)\\n # and converted to local time\\n date = date.astimezone(self.tz_local)\\n\\n return date\",\n \"def local_datetime(dt):\\n return dt - datetime.timedelta(seconds=utc_offset)\",\n \"def datetime_naive_to_local(dt):\\n\\n if type(dt) != datetime.datetime:\\n raise TypeError(f\\\"dt must be type datetime.datetime, not {type(dt)}\\\")\\n\\n if dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None:\\n # has timezone info\\n raise ValueError(\\n \\\"dt must be naive/timezone unaware: \\\"\\n f\\\"{dt} has tzinfo {dt.tzinfo} and offset {dt.tizinfo.utcoffset(dt)}\\\"\\n )\\n\\n return dt.replace(tzinfo=get_local_tz(dt))\",\n \"def localfromtimestamp(timestamp):\\n utctime = datetime.utcfromtimestamp(timestamp)\\n offset = datetime.fromtimestamp(timestamp) - utctime\\n return utctime + offset\",\n \"def localtime2utc(date):\\n return date + (datetime.utcnow() - datetime.now())\",\n \"def utc_to_local_timestruct(ts, orig_tz=UTC):\\n return utc_to_local_timestamp(time.mktime(ts),orig_tz)\",\n \"def date_from_utc_ts(ts):\\n return date_from_utc(dt.utcfromtimestamp(ts / 1000.0))\",\n \"def aware_local_from_timestamp(timestamp):\\n return datetime.fromtimestamp(timestamp).astimezone(get_localzone())\",\n \"def to_aware_datetime(ts: Timestamp):\\n return utc.localize(ts.ToDatetime())\",\n \"def get_local_date(self):\\n tz = pytz.timezone(self.timezone)\\n utc = pytz.utc\\n utc_now = datetime.datetime.now(utc)\\n return utc_now.astimezone(tz).date()\",\n \"def utcnow_ts():\\r\\n return calendar.timegm(utcnow().timetuple())\",\n \"def from_timestamp(timestamp: float, tz_info: tzinfo = UTC) -> datetime:\\n utc_dt = datetime.fromtimestamp(timestamp, tz=UTC)\\n return convert_timezone(utc_dt, tz_info)\",\n \"def utc():\\n return date_from_utc(dt.utcnow())\",\n \"def localize(dt):\\n if dt.tzinfo is UTC:\\n return (dt + LOCAL_UTC_OFFSET).replace(tzinfo=None)\\n # No TZ info so not going to assume anything, return as-is.\\n return dt\",\n \"def datetime_from_utc_to_local(utc_datetime):\\n now_timestamp = time.time()\\n offset = datetime.fromtimestamp(now_timestamp) - datetime.utcfromtimestamp(now_timestamp)\\n return utc_datetime + offset\",\n \"def timestamp(self) -> dt.datetime:\\n ts = self.json_data['timestamp']\\n # Extract the datetime object from the `ts` string\\n ts = dt.datetime.strptime(ts, '%Y-%m-%d %H:%M:%S')\\n # Localise to Eastern time (Formstack returns Eastern times)\\n ts = pytz.timezone('US/Eastern').localize(ts)\\n # Convert to UTC time\\n return ts.astimezone(pytz.timezone('UTC'))\",\n \"def datetime_utc_to_local(dt):\\n\\n if type(dt) != datetime.datetime:\\n raise TypeError(f\\\"dt must be type datetime.datetime, not {type(dt)}\\\")\\n\\n if dt.tzinfo is not datetime.timezone.utc:\\n raise ValueError(f\\\"{dt} must be in UTC timezone: timezone = {dt.tzinfo}\\\")\\n\\n return dt.replace(tzinfo=datetime.timezone.utc).astimezone(tz=None)\",\n \"def fromtimestamp(cls, timestamp):\\n return datetime.datetime.utcfromtimestamp(timestamp)\",\n \"def utcfromtimestamp(unix_epoch_timestamp):\\n (y, m, d, hour, min, sec) = time.gmtime(unix_epoch_timestamp)[:6]\\n return datetime.datetime(y, m, d, hour, min, sec, 0, UTC_TZ)\",\n \"def localtime(stamp):\\n return stamp - utc_offset\",\n \"def tolocal(dateobj, timezone):\\n \\n utc_date_with_tz = pytz.utc.localize(dateobj) # \\n user_tz = pytz.timezone(timezone)\\n localdate = user_tz.normalize(utc_date_with_tz) \\n \\n return localdate\",\n \"def date_to_utc(self, date):\\n if date.tzinfo is not None:\\n # date is timezone-aware\\n date = date.astimezone(self.tz_utc)\\n\\n else:\\n # date is a naive date: assume expressed in local time\\n date = date.replace(tzinfo=self.tz_local)\\n # and converted to UTC\\n date = date.astimezone(self.tz_utc)\\n return date\",\n \"def timestampfromutc(utc):\\n return (utc - datetime(1970, 1, 1)).total_seconds()\",\n \"def FromNowUTC(cls):\\n t = pytime.time()\\n utcTime = pytime.gmtime(t)\\n return cls.FromStructTime(utcTime).WithZone(zDirection=0)\",\n \"def localize_date_utc(date):\\n return pytz.utc.localize(\\n datetime.datetime.combine(\\n date, datetime.time(hour=0, minute=0, second=0)\\n )\\n )\",\n \"def localize_date_utc(date):\\n return pytz.utc.localize(\\n datetime.datetime.combine(\\n date, datetime.time(hour=0, minute=0, second=0)\\n )\\n )\",\n \"def utc2localtime(date):\\n return date - (datetime.utcnow() - datetime.now())\",\n \"def utcTime():\\r\\n return calendar.timegm(time.gmtime())\",\n \"def db_datetime_utc():\\n t = datetime.datetime.utcnow()\\n return time.mktime(t.timetuple())\",\n \"def date_from_utc(date):\\n return pytz.utc.localize(date)\",\n \"def _utc_date(self):\\n if self.date_stamp == '0':\\n return '0'\\n else:\\n if '.' in self.date_stamp:\\n t = datetime.datetime.strptime(self.date_stamp,\\n '%Y%m%d%H%M%S.%f')\\n else:\\n t = datetime.datetime.strptime(self.date_stamp,\\n '%Y%m%d%H%M%S')\\n tdelta = datetime.timedelta(hours = int(self.tzone[1:3]),\\n minutes = int(self.tzone[3:5]))\\n \\n if self.tzone[0] == '-':\\n ut = t - tdelta\\n return ut.strftime('%Y%m%d%H%M%S.%f')\\n else:\\n ut = t + tdelta\\n return ut.strftime('%Y%m%d%H%M%S.%f')\",\n \"def convert_timezone(time):\\n if time is None:\\n return None\\n from_zone = tz.tzutc()\\n to_zone = tz.tzlocal()\\n try:\\n utc = datetime.strptime(time, \\\"%Y-%m-%dT%H:%M:%S.%fZ\\\")\\n except:\\n utc = datetime.strptime(time, \\\"%Y-%m-%d\\\")\\n utc = utc.replace(tzinfo=from_zone)\\n local_date = utc.astimezone(to_zone).date()\\n return local_date\",\n \"def ensure_utc_time(ts: datetime) -> datetime:\\n if ts.tzinfo is None:\\n return datetime(*ts.timetuple()[:6], tzinfo=UTC_TZ)\\n elif str(ts.tzinfo) != str(UTC_TZ):\\n return ts.astimezone(UTC_TZ)\\n return ts\",\n \"def normalize_time(timestamp):\\r\\n offset = timestamp.utcoffset()\\r\\n if offset is None:\\r\\n return timestamp\\r\\n return timestamp.replace(tzinfo=None) - offset\",\n \"def timestamp(date, time, timezone):\\n if date and time and timezone:\\n # return datetime.datetime.strptime(date + time[:6], '%Y%m%d%H%M%S')\\n return timezone.localize(datetime.datetime.strptime(date + time[:6], '%Y%m%d%H%M%S'), timezone)\\n return None\",\n \"def localize_time_utc(non_utc_time):\\n return pytz.utc.localize(non_utc_time)\",\n \"def localize_time_utc(non_utc_time):\\n return pytz.utc.localize(non_utc_time)\",\n \"def convert_timezone(time):\\r\\n if time is None:\\r\\n return None\\r\\n from_zone = tz.tzutc()\\r\\n to_zone = tz.tzlocal()\\r\\n try:\\r\\n utc = datetime.strptime(time, \\\"%Y-%m-%dT%H:%M:%S.%fZ\\\")\\r\\n except ValueError:\\r\\n try:\\r\\n utc = datetime.strptime(time, \\\"%Y-%m-%d\\\")\\r\\n except ValueError:\\r\\n return None\\r\\n\\r\\n if utc.year < 1900 or utc.year > 9999:\\r\\n return None\\r\\n\\r\\n utc = utc.replace(tzinfo=from_zone)\\r\\n local_date = utc.astimezone(to_zone).date()\\r\\n return local_date\",\n \"def localize_datetime_utc(date_time):\\n return pytz.utc.localize(date_time)\",\n \"def localize_datetime_utc(date_time):\\n return pytz.utc.localize(date_time)\",\n \"def localize_datetime_utc(date_time):\\n return pytz.utc.localize(date_time)\",\n \"def normalize_time(timestamp):\\n offset = timestamp.utcoffset()\\n if offset is None:\\n return timestamp\\n return timestamp.replace(tzinfo=None) - offset\",\n \"def utc_to_local(utc_dt: datetime):\\n utc_dt = utc_dt.replace(tzinfo=tz.gettz(\\\"UTC\\\"))\\n return utc_dt.astimezone(tz.tzlocal())\",\n \"def timestamp_aware(dt):\\n if dt.tzinfo is None:\\n dt = dt.replace(tzinfo=tz.tzlocal()) # new object\\n return dt\",\n \"def to_utc(dt):\\n time_tuple = time.gmtime(time.mktime(dt.timetuple()))\\n return datetime.datetime(*time_tuple[0:6])\",\n \"def datetime_to_utc(timestamp):\\n\\n epoch = datetime.utcfromtimestamp(0)\\n delta = timestamp-epoch\\n\\n return long(delta.total_seconds() * 1000)\",\n \"def set_utc(df, locale):\\n return df.tz_localize('utc').tz_convert(None)\",\n \"def normalize_to_utc(date, timezone):\\n local_tz = pytz.timezone(timezone)\\n new_date = date.replace(tzinfo = local_tz)\\n utc_tz = pytz.timezone('UTC')\\n new_date = new_date.astimezone(utc_tz)\\n return new_date\",\n \"def localdate_from_utc_string(timestring):\\n utc_datetime = arrow.get(timestring)\\n local_datetime = utc_datetime.to('local')\\n return local_datetime.format(\\\"YYYY-MM-DD HH:mm:ss\\\")\",\n \"def nowUTC():\\n return datetime.datetime.now(pytz.utc)\",\n \"def timestamp_to_datetime(from_timestamp, time_multiplicator=DEFAULT_MULTIPLICATOR):\\n utc_tz = pytz.timezone(\\\"UTC\\\")\\n utc_dt = utc_tz.localize(datetime.datetime.utcfromtimestamp(int(from_timestamp) / time_multiplicator))\\n return utc_dt\",\n \"def GetLocalTime(dt, tz):\\n return dt.replace(tzinfo=pytz.utc).astimezone(tz)\",\n \"def localTimeOffset(t=None):\\n\\tif t is None:\\n\\t\\tt = time.time()\\n\\t\\n\\tif time.localtime(t).tm_isdst and time.daylight:\\n\\t\\treturn -time.altzone\\n\\telse:\\n\\t\\treturn -time.timezone\",\n \"def convert_to_localtime(dt):\\n tz = pytz.timezone('Europe/Stockholm')\\n dt = dt.replace(tzinfo=pytz.utc)\\n dt = dt.astimezone(tz)\\n return dt\",\n \"def test_time_to_commute_retrieved_from_google_api_in_posix_is_converted_to_utc(self):\\n result = calculate_time_of_commute(\\n origin_name='Gatwick Airport',\\n destination_name='Kings Cross St Pancras',\\n )\\n assert type(result) == datetime\\n assert result.tzinfo is None # Assert it is a naive datetime\",\n \"def may_the_timezone_be_with_it(self):\\n self.timestamp = pytz.utc.localize(self.timestamp)\",\n \"def np_utc_to_timestamp(utc_series, unit=\\\"ns\\\", origin=\\\"unix\\\", tz='UTC'):\\n \\n #if len(utc_series):\\n # first = utc_series.iloc[0]\\n # assert_unixtime(first, unit=unit)\\n\\n return pd.Index(pd.to_datetime(utc_series, unit=unit, origin=origin)).tz_localize('utc').tz_convert(tz)\",\n \"def stamp_time(utc):\\n return utc.replace(hour=15, minute=30, second=0, microsecond=0)\",\n \"def datetime_naive_to_utc(dt):\\n\\n if type(dt) != datetime.datetime:\\n raise TypeError(f\\\"dt must be type datetime.datetime, not {type(dt)}\\\")\\n\\n if dt.tzinfo is not None and dt.tzinfo.utcoffset(dt) is not None:\\n # has timezone info\\n raise ValueError(\\n \\\"dt must be naive/timezone unaware: \\\"\\n f\\\"{dt} has tzinfo {dt.tzinfo} and offset {dt.tzinfo.utcoffset(dt)}\\\"\\n )\\n\\n return dt.replace(tzinfo=datetime.timezone.utc)\",\n \"def datetime_utc_epoch_start() -> datetime:\\n return timestamp_to_datetime(0)\",\n \"def convertToUsersTimeZone(self, timestamp):\\n user = self.zport.dmd.ZenUsers.getUserSettings()\\n if user.timezone:\\n utc_dt = pytz.utc.localize(datetime.utcfromtimestamp(int(timestamp)))\\n tz = pytz.timezone(user.timezone)\\n tval = tz.normalize(utc_dt.astimezone(tz))\\n return tval.strftime(convertJsTimeFormatToPy(user.dateFormat+\\\" \\\"+user.timeFormat))\\n return isoDateTime(timestamp)\",\n \"def dt_from_s(timestamp_s, tz='UTC'):\\n\\n try:\\n timestamp_dt = datetime.datetime.utcfromtimestamp(float(timestamp_s))\\n except TypeError:\\n raise Exception('timestamp_s argument must be string or number, got {}'.format(type(timestamp_s)))\\n\\n pytz_tz = timezonize(tz)\\n timestamp_dt = timestamp_dt.replace(tzinfo=pytz.utc).astimezone(pytz_tz)\\n \\n return timestamp_dt\",\n \"def utcnow(cls):\\n t = _time.time()\\n return cls.utcfromtimestamp(t)\",\n \"def datetime_from_timestamp(timestamp, tzinfo=pytz.utc):\\n if isinstance(timestamp, six.string_types):\\n timestamp = float(timestamp)\\n\\n dt = datetime.datetime.utcfromtimestamp(timestamp)\\n\\n if tzinfo:\\n return dt.replace(tzinfo=pytz.utc).astimezone(tzinfo)\\n else:\\n return dt\",\n \"def fromutc(self, dt):\\n if dt.tzinfo is None:\\n return dt.replace(tzinfo=self)\\n return super(UTC, self).fromutc(dt)\",\n \"def dt(*args, **kwargs):\\n \\n if 'tz' in kwargs:\\n tzinfo = kwargs.pop('tz')\\n else:\\n tzinfo = kwargs.pop('tzinfo', None)\\n \\n offset_s = kwargs.pop('offset_s', None) \\n trustme = kwargs.pop('trustme', False)\\n \\n if kwargs:\\n raise Exception('Unhandled arg: \\\"{}\\\".'.format(kwargs))\\n \\n if (tzinfo is None):\\n # Force UTC if None\\n timezone = timezonize('UTC')\\n \\n else:\\n timezone = timezonize(tzinfo)\\n \\n if offset_s:\\n # Special case for the offset\\n from dateutil.tz import tzoffset\\n if not tzoffset:\\n raise Exception('For ISO date with offset please install dateutil')\\n time_dt = datetime.datetime(*args, tzinfo=tzoffset(None, offset_s))\\n else:\\n # Standard timezone\\n time_dt = timezone.localize(datetime.datetime(*args))\\n\\n # Check consistency \\n if not trustme and timezone != pytz.UTC:\\n if not check_dt_consistency(time_dt):\\n raise ValueError('Sorry, time {} does not exists on timezone {}'.format(time_dt, timezone))\\n\\n return time_dt\",\n \"def local_datetime(rdd_tuple):\\n timezone = rdd_tuple[0].split(\\\" ; \\\")[2]\\n utc_time = rdd_tuple[2]\\n city_key = rdd_tuple[0][:-(len(timezone) + 3)]\\n temperature = rdd_tuple[1]\\n local_dt = utils.locutils.convert_timezone(utc_time, timezone)\\n return city_key, temperature, local_dt\",\n \"def add_local_timezone(dt):\\n assert dt.tzinfo is None\\n localtz = tzlocal.get_localzone()\\n logging.warning(\\\"Assuming timezone for {} is {}\\\".format(dt, localtz))\\n return localtz.localize(dt)\",\n \"def utc_now():\\n realtime = datetime.utcnow()\\n realtime = pytz.utc.localize(realtime)\\n return realtime\",\n \"def now_utc() -> datetime:\\n return datetime.now(timezone.utc)\",\n \"def to_utc(dt):\\n if dt.tzinfo is None:\\n return dt.replace(tzinfo=pytz.utc)\\n else:\\n return dt.astimezone(pytz.utc)\",\n \"def now_dt(tz='UTC'):\\n if tz != 'UTC':\\n raise NotImplementedError()\\n return datetime.datetime.utcnow().replace(tzinfo = pytz.utc)\",\n \"def utcnow() -> datetime.datetime:\\n return datetime.datetime.utcnow().replace(tzinfo=pytz.UTC)\",\n \"def make_naive_utc(date_time: datetime.datetime) -> datetime.datetime:\\n utc_timezone = datetime.timezone(datetime.timedelta(seconds=0))\\n return date_time.astimezone(utc_timezone).replace(tzinfo=None)\",\n \"def datetime_to_local_timezone(dt, timezone=\\\"America/New_York\\\", from_timezone=\\\"UTC\\\"):\\n from_zone = tz.gettz(from_timezone)\\n to_zone = tz.gettz(timezone)\\n dt = dt.replace(tzinfo=from_zone)\\n return dt.astimezone(to_zone)\",\n \"def local_to_utc(local: pd.Series, tz: Iterable, **kwargs: Any) -> pd.Series:\\n return local.groupby(tz).transform(\\n lambda x: x.dt.tz_localize(\\n datetime.timezone(datetime.timedelta(hours=x.name))\\n if isinstance(x.name, (int, float))\\n else x.name,\\n **kwargs,\\n ).dt.tz_convert(None)\\n )\",\n \"def tz_convert(self, tz) -> Self:\\n tz = timezones.maybe_get_tz(tz)\\n\\n if self.tz is None:\\n # tz naive, use tz_localize\\n raise TypeError(\\n \\\"Cannot convert tz-naive timestamps, use tz_localize to localize\\\"\\n )\\n\\n # No conversion since timestamps are all UTC to begin with\\n dtype = tz_to_dtype(tz, unit=self.unit)\\n return self._simple_new(self._ndarray, dtype=dtype, freq=self.freq)\",\n \"def _epoch_utc_to_datetime(epoch_utc):\\n return datetime.fromtimestamp(epoch_utc)\",\n \"def local_timestamp():\\n # type: () -> int\\n now = datetime.utcnow()\\n timestamp_in_seconds = calendar.timegm(now.timetuple()) + (now.microsecond / 1e6)\\n timestamp_in_milliseconds = int(timestamp_in_seconds * 1000)\\n return timestamp_in_milliseconds\",\n \"def fromtimestamp(cls, timestamp, tz=None):\\n return datetime()\",\n \"def _local_time_offset():\\n if time.localtime().tm_isdst and time.daylight:\\n return -time.altzone\\n else:\\n return -time.timezone\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72205764","0.6983059","0.6770738","0.677013","0.6730794","0.67281","0.6722522","0.67161834","0.6703183","0.66836935","0.65544444","0.6550889","0.6534934","0.6487955","0.6462393","0.64471936","0.64004195","0.63812923","0.6343139","0.6335491","0.63339645","0.63313836","0.631342","0.62961525","0.6292903","0.6268688","0.62573326","0.6255673","0.6255315","0.62297773","0.6216344","0.6212436","0.6200388","0.6133536","0.61170805","0.6069875","0.60689217","0.6062277","0.605273","0.6047055","0.604449","0.6028303","0.60171586","0.60061586","0.60061586","0.5979852","0.59733975","0.5944659","0.5925409","0.5897049","0.5893144","0.5883807","0.5864181","0.58617634","0.5860437","0.5860437","0.58378637","0.5836699","0.5836699","0.5836699","0.5827541","0.5825515","0.5776266","0.57754517","0.5764169","0.57564396","0.5745526","0.5739991","0.5717863","0.57109","0.57101935","0.57050997","0.5693612","0.5688355","0.5685256","0.568454","0.568238","0.567474","0.5651036","0.56414944","0.564035","0.56377345","0.56340086","0.56302744","0.5627965","0.55794466","0.5565695","0.5537866","0.55269295","0.5525175","0.5514989","0.55136937","0.55132085","0.5505344","0.5498472","0.54957896","0.5489122","0.5487486","0.5486503","0.5482921"],"string":"[\n \"0.72205764\",\n \"0.6983059\",\n \"0.6770738\",\n \"0.677013\",\n \"0.6730794\",\n \"0.67281\",\n \"0.6722522\",\n \"0.67161834\",\n \"0.6703183\",\n \"0.66836935\",\n \"0.65544444\",\n \"0.6550889\",\n \"0.6534934\",\n \"0.6487955\",\n \"0.6462393\",\n \"0.64471936\",\n \"0.64004195\",\n \"0.63812923\",\n \"0.6343139\",\n \"0.6335491\",\n \"0.63339645\",\n \"0.63313836\",\n \"0.631342\",\n \"0.62961525\",\n \"0.6292903\",\n \"0.6268688\",\n \"0.62573326\",\n \"0.6255673\",\n \"0.6255315\",\n \"0.62297773\",\n \"0.6216344\",\n \"0.6212436\",\n \"0.6200388\",\n \"0.6133536\",\n \"0.61170805\",\n \"0.6069875\",\n \"0.60689217\",\n \"0.6062277\",\n \"0.605273\",\n \"0.6047055\",\n \"0.604449\",\n \"0.6028303\",\n \"0.60171586\",\n \"0.60061586\",\n \"0.60061586\",\n \"0.5979852\",\n \"0.59733975\",\n \"0.5944659\",\n \"0.5925409\",\n \"0.5897049\",\n \"0.5893144\",\n \"0.5883807\",\n \"0.5864181\",\n \"0.58617634\",\n \"0.5860437\",\n \"0.5860437\",\n \"0.58378637\",\n \"0.5836699\",\n \"0.5836699\",\n \"0.5836699\",\n \"0.5827541\",\n \"0.5825515\",\n \"0.5776266\",\n \"0.57754517\",\n \"0.5764169\",\n \"0.57564396\",\n \"0.5745526\",\n \"0.5739991\",\n \"0.5717863\",\n \"0.57109\",\n \"0.57101935\",\n \"0.57050997\",\n \"0.5693612\",\n \"0.5688355\",\n \"0.5685256\",\n \"0.568454\",\n \"0.568238\",\n \"0.567474\",\n \"0.5651036\",\n \"0.56414944\",\n \"0.564035\",\n \"0.56377345\",\n \"0.56340086\",\n \"0.56302744\",\n \"0.5627965\",\n \"0.55794466\",\n \"0.5565695\",\n \"0.5537866\",\n \"0.55269295\",\n \"0.5525175\",\n \"0.5514989\",\n \"0.55136937\",\n \"0.55132085\",\n \"0.5505344\",\n \"0.5498472\",\n \"0.54957896\",\n \"0.5489122\",\n \"0.5487486\",\n \"0.5486503\",\n \"0.5482921\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76103634"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6494,"cells":{"query":{"kind":"string","value":"Calculate the gravitational delay The implementation is described in IERS Conventions [1]_, section 11.1, in particular equation (11.9)."},"document":{"kind":"string","value":"def vlbi_grav_delay(dset):\n eph = apriori.get(\"ephemerides\", time=dset.time)\n grav_delay = np.zeros(dset.num_obs)\n\n # List of celestial bodies. Major moons are also recommended, like Titan, Ganymedes, ...\n bodies = [\n \"mercury barycenter\",\n \"venus barycenter\",\n \"earth\",\n \"moon\",\n \"mars barycenter\",\n \"jupiter barycenter\",\n \"saturn barycenter\",\n \"uranus barycenter\",\n \"neptune barycenter\",\n \"pluto barycenter\",\n \"sun\",\n ]\n\n bcrs_vel_earth = eph.vel_bcrs(\"earth\")\n\n baseline_gcrs = dset.site_pos_2.gcrs.pos - dset.site_pos_1.gcrs.pos\n src_dot_baseline = (dset.src_dir.unit_vector[:, None, :] @ baseline_gcrs.mat)[:, 0, 0]\n\n # Equation 11.6\n bcrs_site1 = eph.pos_bcrs(\"earth\") + dset.site_pos_1.gcrs.pos.val\n bcrs_site2 = eph.pos_bcrs(\"earth\") + dset.site_pos_2.gcrs.pos.val\n\n for body in bodies:\n try:\n GM_name = \"GM\" if body == \"earth\" else f\"GM_{body.split()[0]}\"\n GM_body = constant.get(GM_name, source=eph.ephemerides)\n except KeyError:\n log.warn(\n f\"The GM value of {body.split()[0].title()} is not defined for {eph.ephemerides}. \"\n f\"Correction set to zero.\"\n )\n continue\n bcrs_body_t1 = eph.pos_bcrs(body)\n\n # Equation 11.3\n delta_t = TimeDelta(\n np.maximum(0, dset.src_dir.unit_vector[:, None, :] @ (bcrs_body_t1 - bcrs_site1)[:, :, None])[:, 0, 0]\n * Unit.second2day\n / constant.c,\n fmt=\"jd\",\n scale=\"tdb\",\n )\n time_1J = dset.time.tdb - delta_t\n\n # Equation 11.4\n bcrs_body_t1J = eph.pos_bcrs(body, time=time_1J)\n vector_body_site1 = bcrs_site1 - bcrs_body_t1J\n\n # Equation 11.5\n vector_body_site2 = bcrs_site2 - bcrs_body_t1J - bcrs_vel_earth / constant.c * src_dot_baseline[:, None]\n\n # Needed for equation 11.1\n norm_body_site1 = np.linalg.norm(vector_body_site1, axis=1)\n src_dot_vector_body_site1 = (dset.src_dir.unit_vector[:, None, :] @ vector_body_site1[:, :, None])[:, 0, 0]\n nomJ = norm_body_site1 + src_dot_vector_body_site1\n denomJ = (\n np.linalg.norm(vector_body_site2, axis=1)\n + (dset.src_dir.unit_vector[:, None, :] @ vector_body_site2[:, :, None])[:, 0, 0]\n )\n\n # Main correction (equation 11.1)\n grav_delay += 2 * GM_body / constant.c ** 2 * np.log(nomJ / denomJ)\n\n # Higher order correction (equation 11.14)\n baseline_dot_vector_body_site1 = (baseline_gcrs.val[:, None, :] @ vector_body_site1[:, :, None])[:, 0, 0]\n grav_delay += (\n 4\n * GM_body ** 2\n / constant.c ** 4\n * (baseline_dot_vector_body_site1 / norm_body_site1 + src_dot_baseline)\n / (norm_body_site1 + src_dot_vector_body_site1) ** 2\n )\n\n # Denominator (equation 11.9)\n denominator = (\n 1\n + (\n (bcrs_vel_earth + dset.site_pos_2.gcrs.vel.val)[:, None, :]\n @ dset.src_dir.unit_vector[:, :, None]\n / constant.c\n )[:, 0, 0]\n )\n\n return grav_delay / denominator"},"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 test_gravitation(self):\n with PhysicsEngineHarness('tests/massive-objects.json') as physics_engine:\n # In this case, the first entity is very massive and the second\n # entity should gravitate towards the first entity.\n t0 = 1\n t1 = 2\n initial = physics_engine.get_state(t0)\n moved = physics_engine.get_state(t1)\n # https://www.wolframalpha.com/input/?i=1e30+kg+*+G+%2F+(1e8+m)%5E2\n # According to the above, this should be somewhere between 6500 and\n # 7000 m/s after one second.\n self.assertTrue(moved[1].vx > 5000,\n msg=f'vx is actually {moved[1].vx}')\n\n # Test the internal math that the internal derive function is doing\n # the right calculations. Break out your SPH4U physics equations!!\n y0 = initial\n # Note that dy.X is actually the velocity at 0,\n # and dy.VX is acceleration.\n dy = PhysicsState(\n ode_solver.simulation_differential_function(\n 0, y0.y0(), y0._proto_state, physics_engine.M, physics_engine._artificials),\n y0._proto_state)\n self.assertEqual(len(dy.X), 2)\n self.assertAlmostEqual(dy.X[0], y0.VX[0])\n self.assertAlmostEqual(dy.Y[0], y0.VY[0])\n self.assertEqual(round(abs(dy.VX[0])),\n round(common.G * initial[1].mass\n / (y0.X[0] - y0.X[1]) ** 2))\n self.assertAlmostEqual(dy.VY[0], 0)\n\n self.assertAlmostEqual(dy.X[1], y0.VX[1])\n self.assertAlmostEqual(dy.Y[1], y0.VY[1])\n self.assertEqual(round(abs(dy.VX[1])),\n round(common.G * initial[0].mass\n / (y0.X[1] - y0.X[0]) ** 2))\n self.assertAlmostEqual(dy.VY[1], 0)","def compute_gravity(self):\r\n # compute the gravity from the Gauss form.\r\n # if it fails, marks divergence\r\n try:\r\n self.gravsolver.solve()\r\n except:\r\n print(\"GRAVITY DIVERGED\")\r\n\r\n # write to log\r\n self.logfile.write(\"%s: STOPPED DUE TO DIVERGENCE IN GRAVITY \\n\" %\r\n (self.convert_time(time.time() -\r\n self.start_time)))\r\n self.diverged = True # set diverged to True, break the run\r\n return\r\n\r\n # split and update the gravity function with the answers\r\n # note the gravscale\r\n gravg, gravs = self.gravgs.split()\r\n\r\n # assign the result to the gravity function\r\n self.gravity.assign(project(gravg/self.gravscale, self.V))","def get_gravitational_attraction(self, rocket_mass, altitude):\n return self.gravitational_constant * self.earth_mass * rocket_mass / (\n self.earth_radius + altitude + self.base_altitude) ** 2","def calc_grav(self):\n if self.change_y == 0:\n self.change_y = 1\n else:\n self.change_y += .35\n \n # See if we are on the ground.\n if self.rect.y >= SCREEN_HEIGHT:\n self.level.game_over()","def calculate_delay(self, velocity):\n if velocity > 0:\n rps = velocity / 1.444\n delay = (1 / (200 * float(rps))) / 2\n return delay\n else:\n return 0","def gravity():\n\tg = _scene.gravity()\n\treturn Vector3(g[0], g[1], g[2])","def _get_delta_time(r0):\n\n s1 = random() # To pick time\n epsilon = 0.001 # To avoid division by zero\n lam = (1 / (r0 + epsilon))\n return lam * pow(e, -lam * s1)","def _compute_gravity_torque(self, curr_date):\n if self._to_add[0]:\n # return gravity gradient torque in satellite frame\n body2inertial = self.earth.getBodyFrame().getTransformTo(self.in_frame, curr_date)\n body2sat = self.inertial2Sat.applyTo(body2inertial.getRotation())\n body2satRot = PyRotation(body2sat.q0,\n body2sat.q1,\n body2sat.q2,\n body2sat.q3)\n sat2bodyRot = body2satRot.revert()\n body2sat = body2satRot.getMatrix()\n sat2body = sat2bodyRot.getMatrix()\n\n satM = self.spacecraft_state.getMass()\n mCub = self.inCub['dm'] * satM\n # add booms\n if \"dm_boom\" in self.inCub:\n mCub = np.concatenate((mCub, self.inCub['dm_boom']), axis=0) # boom store with mass\n CoM = self.inCub['CoM_np']\n\n dmPos_s = CoM + self.satPos_s\n\n gNewton = (-self.muGM / np.linalg.norm(dmPos_s,\n axis=1,\n keepdims=True)**3) * dmPos_s\n\n # rotate vectors:\n dmPos_b = np.einsum('ij,kj->ki', sat2body, dmPos_s)\n\n gDist = np.empty(dmPos_b.shape)\n for i in xrange(0, dmPos_b.shape[0]):\n gDist[i, :] = np.asarray(\n self.GravityModel.gradient(curr_date,\n Vector3D(float(dmPos_b[i, 0]),\n float(dmPos_b[i, 1]),\n float(dmPos_b[i, 2])),\n self.muGM))\n\n gDist_s = np.einsum('ij,kj->ki', body2sat, gDist)\n\n gT = np.sum(np.cross(CoM, mCub*(gNewton + gDist_s)), axis=0)\n\n self._gTorque = Vector3D(float(gT[0]), float(gT[1]), float(gT[2]))\n\n else:\n self._gTorque = Vector3D.ZERO","def _calc_grav(self):\n if self.change_y == 0:\n self.change_y = 1\n else:\n self.change_y += 1.35\n\n # See if we are on the ground.\n # if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0:\n # self.change_y = 0\n # self.rect.y = SCREEN_HEIGHT - self.rect.height","def calcGravity(self, seconds):\n if self.change_y == 0:\n self.change_y = 1\n else:\n self.change_y += .35\n \n # See if we are on the ground.\n if self.rect.y >= SCR_HEIGHT - self.rect.height and self.change_y >= 0:\n self.change_y = 0\n self.rect.y = SCR_HEIGHT - self.rect.height","def delayR(self): # Is this needed?\n\n rDelay = self.a1()/c.c*(self.sOmg*(self.cosEcc_A-self.er) \\\n +(1-self.eTheta()**2)**0.5*self.cOmg*self.sinEcc_A)\n return rDelay.decompose()","def delayE(self):\n sinE = np.sin(self.E())\n return self.GAMMA","def calc_grav(self):\n if self.change_y == 0:\n self.change_y = 1\n\n else:\n self.change_y += .35\n\n # See if we are on the ground.\n\n if (self.rect.y >= constants.SCREEN_HEIGHT - self.rect.height and self.change_y >= 0):\n self.change_y = 0\n self.rect.y = constants.SCREEN_HEIGHT - self.rect.height","def calc_grav(self):\n if self.change_y == 0:\n self.change_y = 1\n\n else:\n self.change_y += .35\n\n # See if we are on the ground.\n\n if (self.rect.y >= constants.SCREEN_HEIGHT - self.rect.height and self.change_y >= 0):\n self.change_y = 0\n self.rect.y = constants.SCREEN_HEIGHT - self.rect.height","def standard_gravity():\n mu = 3.986004418E14\n return mu","def delay(self):\r\n return self.relative_phases / (2 * np.pi * self.frequencies)","def delay(self):\r\n return self.relative_phases / (2 * np.pi * self.frequencies)","def calc_gpm(pulse_count):\n # PATRICK --- WE NEED TO FIGURE THIS OUT FOR THE ACTUAL FLOW RATE (LPM and GPM)\n # FROM THE NUMBER OF PULSES AND THE TOTAL TIME IN SECONDS THAT HAVE ELAPSED\n\n # From the sensor specification data sheet:\n # Calculate Liters per minute using sensor specification\n # F = Constant * units of flow (liter per min) * time (seconds)\n # ~ 330 pulse/liter\n\n # To calculate Liters per minute\n constant = 10 # PATRICK NEED TO FIGURE THE CONSTANT VALUE OUT\n time_seconds = 60 # since this function is called every minute\n lpm = round((constant * (pulse_count / 330.0) / (time_seconds / 60)), 2)\n\n # Convert lpm to gpm\n gpm = round(lpm * 0.26417205236)\n return gpm","def calc_gravitational_energy(self):\n\n star = self.star\n\n K, N = star.mesh_size\n mu = star.mu_coords\n r = star.r_coords\n\n def S1(j):\n return np.sum((mu[2::2] - mu[:-2:2]) * (star.rho[:-2:2, j] * star.Phi[:-2:2, j] +\n 4 * star.rho[1:-1:2, j] * star.Phi[1:-1:2, j] +\n star.rho[2::2, j] * star.Phi[2::2, j])) / 6\n\n W = 0\n\n for j in range(0, N - 2, 2):\n W += (r[j + 2] - r[j]) * (r[j]**2 * S1(j) +\n 4 * r[j + 1]**2 * S1(j + 1) +\n r[j + 2]**2 * S1(j + 2))\n\n return -1 / 3 * np.pi * W","def calc_gravitational_energy(self):\n\n star = self.star\n\n M, K, N = star.mesh_size\n ph = star.phi_coords\n mu = star.mu_coords\n r = star.r_coords\n\n def S1(j, k):\n sum = 0\n\n for i in range(0, M - 2, 2):\n sum += (1 / 6) * (ph[i + 2] - ph[i]) * (star.rho[i, j, k] * star.Phi[i, j, k] + 4 *\n star.rho[i + 1, j, k] * star.Phi[i + 1, j, k] +\n star.rho[i + 2, j, k] * star.Phi[i + 2, j, k])\n return 2 * sum\n\n def S2(k):\n sum = 0\n\n for j in range(0, K - 2, 2):\n sum += (1 / 6) * (mu[j + 2] - mu[j]) * \\\n (S1(j, k) + 4 * S1(j + 1, k) + S1(j + 2, k))\n\n return 2 * sum\n\n W = 0\n\n for k in range(0, N - 2, 2):\n W -= 0.5 * (1 / 6) * (r[k + 2] - r[k]) * (r[k]**2 * S2(k) +\n 4 * r[k + 1]**2 * S2(k + 1) +\n r[k + 2]**2 * S2(k + 2))\n\n return W","def calc_grav(self):\n if self.change_y == 0:\n self.change_y = 1\n else:\n self.change_y += .35\n \n # See if the sprite is on the ground.\n if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0:\n self.change_y = 0\n self.rect.y = SCREEN_HEIGHT - self.rect.height","def _g(self, x):\n e_x = math.exp(-self._alpha * x)\n return (1.0 / (1 + e_x))","def gravity_gradients(self, p):\n Le = self._Le(p)\n wf = self._wf(p)\n EeLe = np.einsum(\"i...,i\", self.Ee, Le)\n FfWf = np.einsum(\"i...,i\", self.Ff, wf)\n return G * self.d * (EeLe - FfWf)","def __gravity__(self, dt):\n t = dt - self.airtime\n self.velocity += self.gravity * t","def gmean_diff(self) -> float:\n sim_log = np.log1p(self.predicted)\n obs_log = np.log1p(self.true)\n return float(np.exp(gmean(sim_log) - gmean(obs_log)))","def time(self) -> float:\n return self.state.game_loop / 22.4 # / (1/1.4) * (1/16)","def compute_gains(self, t, add_noise=True):\n #get the basis funtion at a time step\n basis, Dbasis = self.get_basis(t)\n\n if t < self._time_steps-1:\n basis_t_dt, _ = self.get_basis(t+1)\n else:\n basis_t_dt = np.zeros_like(basis)\n\n\n #part 1 equation 46\n B_pseudo = np.linalg.pinv(self._B)\n\n #equation 12 for t\n Sigma_t = np.dot(np.dot(basis, self._sigma_W), basis.T)\n\n #equation 12 for t+dt\n Sigma_t_dt = np.dot(np.dot(basis_t_dt, self._sigma_W), basis_t_dt.T)\n\n #Cross correlation between t, t+dt, Equation 49\n Ct = np.dot(np.dot(basis, self._sigma_W), basis_t_dt.T)\n\n #System noise Equation 51\n Sigma_s = (1./self._dt)* ( Sigma_t_dt - np.dot( np.dot( Ct.T, np.linalg.inv(Sigma_t) ), Ct) )\n\n #control noise Equation 52\n Sigma_u = np.dot(np.dot(B_pseudo, Sigma_s), B_pseudo.T)\n\n #part 2 equation 46\n tmp1 = np.dot(np.dot(Dbasis, self._sigma_W), basis.T)\n\n #part 3 equation 46\n tmp2 = np.dot(self._A, Sigma_t) + 0.5*Sigma_s\n\n #compute feedback gain; complete equation 46\n K = np.dot( np.dot(B_pseudo, (tmp1-tmp2) ), np.linalg.inv(Sigma_t))\n\n #part 1 equation 48\n tmp3 = np.dot(Dbasis, self._mean_W)\n\n #part 2 equation 48\n tmp4 = np.dot( (self._A + np.dot(self._B, K)), np.dot(basis, self._mean_W) )\n\n #compute feedforward gain; complete equation 48\n k = np.dot(B_pseudo, (tmp3-tmp4))\n\n return K, k, Sigma_u","def accelerationCalcX(x,y):\r\n global G # the gravitational constant is initialised like this so that it can be used in this function\r\n global massEarth #the same goes for the mass of the Earth\r\n return (-G*massEarth*x)/((x**2+y**2)**(3/2)) # here from Newton's law of gravitation we return the acceleration on a projectile in the x direction\r","def _compute_gravity_torque(self):\n pass","def gVI(g,rBC,lBC,time,npts):\n #Important coeffcients\n global gamma\n gamma = g\n global alpha\n alpha = (gamma+1)/(gamma-1)\n global beta\n beta = (2*gamma)/(gamma-1)\n global epsilon\n epsilon = (2*gamma)/(gamma+1)\n #Boundary conditions\n global lbc\n lbc = lBC\n global rbc\n rbc = rBC\n #Time\n global t\n t = time\n #points\n global numPts\n numPts = npts\n #Speed of sound for states 1 and 5\n global cL\n cL = np.sqrt(gamma*lbc[0]/lbc[1])\n global cR\n cR = np.sqrt(gamma*rbc[0]/rbc[1])","def g(r):\n return np.cos(r) / (np.exp(0.4 * (r - 8)) + 1)","def run_grav(self):\n\n # Solucao direta\n self.prod_w = []\n self.prod_o = []\n t0 = time.time()\n # self.set_volumes_in_primal()\n self.set_sat_in()\n self.set_lamb_2()\n self.set_global_problem_vf_3_gr1_bif()\n self.Pf = self.solve_linear_problem(self.trans_fine, self.b, len(self.all_fine_vols_ic))\n self.organize_Pf()\n del self.Pf\n self.mb.tag_set_data(self.pf_tag, self.all_fine_vols, np.asarray(self.Pf_all))\n del self.Pf_all\n self.test_conservation_fine()\n # self.store_flux_pf_gr_bif = self.create_flux_vector_pf_gr_bif_1()\n\n \"\"\"\n ################################################################\n # Solucao Multiescala\n self.calculate_restriction_op_2()\n self.calculate_prolongation_op_het()\n self.organize_op()\n self.Tc = self.modificar_matriz(self.pymultimat(self.pymultimat(self.trilOR, self.trans_fine, self.nf_ic), self.trilOP, self.nf_ic), self.nc, self.nc)\n self.Qc = self.modificar_vetor(self.multimat_vector(self.trilOR, self.nf_ic, self.b), self.nc)\n self.Pc = self.solve_linear_problem(self.Tc, self.Qc, self.nc)\n self.set_Pc()\n self.Pms = self.multimat_vector(self.trilOP, self.nf_ic, self.Pc)\n\n del self.trilOP\n del self.trilOR\n del self.Tc\n del self.Qc\n del self.Pc\n\n self.organize_Pms()\n del self.Pms\n self.mb.tag_set_data(self.pms_tag, self.all_fine_vols, np.asarray(self.Pms_all))\n del self.Pms_all\n self.erro()\n\n self.test_conservation_coarse_gr()\n # self.Neuman_problem_6_gr()\n # self.store_flux_pms_gr = self.create_flux_vector_pms_gr()\n ####################################################################\n \"\"\"\n\n\n\n\n\n\n\n print('acaboooou')\n self.mb.write_file('new_out_bif_gr.vtk')\n\n\n shutil.copytree(self.caminho1, self.pasta)","def weber_velocity(weber_number, reynolds_number, d=2e-3):\n sigma = 0.07\n rho_g = 1.225\n u_l = velocity_calculator(reynolds_number)\n u_g = np.sqrt((weber_number*sigma)/(d*rho_g))+u_l\n return u_g","def method_compute_timestep(self):\n\n myg = self.cc_data.grid\n\n cfl = self.rp.get_param(\"driver.cfl\")\n\n u = self.cc_data.get_var(\"x-velocity\")\n v = self.cc_data.get_var(\"y-velocity\")\n\n # the timestep is min(dx/|u|, dy|v|)\n xtmp = ytmp = 1.e33\n if not abs(u).max() == 0:\n xtmp = myg.dx/abs(u.v()).max()\n if not abs(v).max() == 0:\n ytmp = myg.dy/abs(v.v()).max()\n\n dt = cfl*min(xtmp, ytmp)\n\n # We need an alternate timestep that accounts for buoyancy, to\n # handle the case where the velocity is initially zero.\n rho = self.cc_data.get_var(\"density\")\n rho0 = self.base[\"rho0\"]\n rhoprime = self.make_prime(rho, rho0)\n\n g = self.rp.get_param(\"lm-atmosphere.grav\")\n\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\n\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\n\n self.dt = min(dt, dt_buoy)\n if self.verbose > 0:\n print(f\"timestep is {dt}\")","def geometric_brownian_motion_log_returns(param):\n assert isinstance(param, ModelParameters)\n gbmprocess = np.array(brownian_motion_log_returns(param))\n sigma_pow_mu_delta = (param.drift - 0.5 * math.pow(param.vol, 2.0)) * param.time_rate\n return gbmprocess + sigma_pow_mu_delta","def backward_G(self):\n mask = self.mask*0.5 + 0.5\n\n self.loss_G_SH = self.criterionS(self.pr_SH*mask, self.gt_SH*mask) * self.opt.lambda_S\n self.loss_G = self.loss_G_SH\n\n if not self.opt.no_brightness:\n self.loss_G_BA = self.criterionBA(self.pr_BA*mask, self.gt_BA*mask) * self.opt.lambda_BA\n self.loss_G_BC = 0\n for i in range(25):\n gt_BC = self.gt_BC[i][:, :2]\n bc_num = int(self.gt_BC[i][0, 3].item())\n pr_BC = self.pr_BC[i]\n loss_G_BC = util.min_loss_BC_NoBatch(pr_BC, gt_BC, bc_num, self.criterionBC)\n loss_G_BC = loss_G_BC * self.opt.lambda_BC / 25.0\n self.loss_G_BC += loss_G_BC\n\n loss_B = self.loss_G_BA + self.loss_G_BC\n self.loss_G += loss_B\n\n # Third, LTM Regularization\n if self.opt.reg_LTM:\n ltm_mean = torch.mean(self.ltm, dim=0, keepdim=True) # [1, 75, 256, 256]\n ltm_mean = ltm_mean.expand(self.ltm.size(0), ltm_mean.size(1), ltm_mean.size(2), ltm_mean.size(3)) # [25, 75, 256, 256]\n self.loss_LTMReg = self.criterionReg(self.ltm, ltm_mean) * self.opt.lambda_regLTM\n self.loss_G += self.loss_LTMReg\n\n\n self.loss_G.backward()","def _compute_gravity_torque(self, curr_date):\n if self._to_add[0]:\n body2inertial = self.earth.getBodyFrame().getTransformTo(self.in_frame, curr_date)\n body2sat = self.inertial2Sat.applyTo(body2inertial.getRotation())\n sat2body = body2sat.revert()\n\n satM = self.state_observer.spacecraftState.getMass()\n mCub = self.inCub['mass_frac'] * satM\n\n self._gTorque = Vector3D.ZERO\n\n for CoM in self.inCub['CoM']:\n\n S_dmPos = self.satPos_s.add(CoM)\n\n r2 = S_dmPos.getNormSq()\n gNewton = Vector3D(-self.muGM / (sqrt(r2) * r2), S_dmPos)\n\n B_dmPos = sat2body.applyTo(S_dmPos)\n\n gDist = Vector3D(self.GravityModel.gradient(curr_date,\n B_dmPos,\n self.muGM))\n\n g_Dist_s = body2sat.applyTo(gDist)\n\n dmForce = Vector3D(mCub, gNewton.add(g_Dist_s))\n self._gTorque = self._gTorque.add(self.V3_cross(CoM, dmForce))\n\n else:\n self._gTorque = Vector3D.ZERO","def spin_gap(B, g_ex):\n\n return mu_bohr * g_ex * B / k_b","def ObserverGravity(latitude, height):\n s2 = math.sin(math.radians(latitude)) ** 2\n g0 = 9.7803253359 * (1.0 + 0.00193185265241*s2) / math.sqrt(1.0 - 0.00669437999013*s2)\n return g0 * (1.0 - (3.15704e-07 - 2.10269e-09*s2)*height + 7.37452e-14*height*height)","def reward_function(self):\r\n def R(state, decision, nodes):\r\n return -1.0/1000*nodes['G'].get_preds_value(state)*(decision['G:R_1']+decision['G:L'])\r\n \r\n return R","def _calc_g(self, lambdify=True):\n g = None\n g_func = None\n # check to see if we have our gravity term saved in file\n g, g_func = self._load_from_file('g', lambdify)\n\n if g is None and g_func is None:\n # if no saved file was loaded, generate function\n print('Generating gravity compensation function')\n\n # get the Jacobians for each link's COM\n J_links = [self._calc_J('link%s' % ii, x=self.x_zeros,\n lambdify=False)\n for ii in range(self.N_LINKS)]\n J_joints = [self._calc_J('joint%s' % ii, x=self.x_zeros,\n lambdify=False)\n for ii in range(self.N_JOINTS)]\n\n # sum together the effects of each arm segment's inertia\n g = sp.zeros(self.N_JOINTS, 1)\n for ii in range(self.N_LINKS):\n # transform each inertia matrix into joint space\n g += (J_links[ii].T * self._M_LINKS[ii] * self.gravity)\n # sum together the effects of each joint's inertia on each motor\n for ii in range(self.N_JOINTS):\n # transform each inertia matrix into joint space\n g += (J_joints[ii].T * self._M_JOINTS[ii] * self.gravity)\n g = sp.Matrix(g)\n\n # save to file\n abr_control.utils.os_utils.makedirs(\n '%s/g' % self.config_folder)\n cloudpickle.dump(g, open(\n '%s/g/g' % self.config_folder, 'wb'))\n\n if lambdify is False:\n # if should return expression not function\n return g\n\n if g_func is None:\n g_func = self._generate_and_save_function(\n filename='g', expression=g,\n parameters=self.q)\n return g_func","def generalisedDecayConstant(ep, epp, g, G, Q_decay):\n # Calculate the total branching from the excited state to all ground states\n sum_decay_channels_epg = 0\n sum_decay_channels_eppg = 0\n for gp in G:\n for q in Q_decay:\n sum_decay_channels_epg += abs(coupling(ep, gp, q)*coupling(ep, gp, q))\n sum_decay_channels_eppg += abs(coupling(epp, gp, q)*coupling(epp, gp, q))\n\n # Calculate the decay constants separately\n gamma_epg = 0\n gamma_eppg = 0\n for q in Q_decay:\n gamma_epg += abs(coupling(ep, g, q)*coupling(ep, g, q))\n gamma_eppg += abs(coupling(epp, g, q)*coupling(epp, g, q))\n\n gamma_epg = gamma_epg/(sum_decay_channels_epg)\n gamma_eppg = gamma_eppg/(sum_decay_channels_eppg)\n\n # Calculate the generalised decay constant\n gamma_epeppg = np.power(gamma_epg*gamma_eppg, 0.5)\n # Calculate the sign: only one polarisation will result in non-zero coupling so can sum over all\n for q in Q_decay:\n if(coupling(ep, g, q)*coupling(epp, g, q) < 0): \n gamma_epeppg = -1*gamma_epeppg\n return gamma_epeppg","def Gtilde(x):\n gt1 = 1.808 * cbrt(x) / np.sqrt(1 + 3.4 * cbrt(x) ** 2.)\n gt2 = 1 + 2.210 * cbrt(x) ** 2. + 0.347 * cbrt(x) ** 4.\n gt3 = 1 + 1.353 * cbrt(x) ** 2. + 0.217 * cbrt(x) ** 4.\n return gt1 * (gt2 / gt3) * np.exp(-x)","def GJframe():\n beta0 = pomega.Vect() * (1 / pomega[3])\n pomega.Boost(-beta0)\n pbeam.Boost(-beta0)\n ptarg.Boost(-beta0)\n precoil.Boost(-beta0)\n theta0 = pbeam.Theta()\n phi0 = pbeam.Phi()\n pbeam.RotateZ(-phi0)\n ptarg.RotateZ(-phi0)\n precoil.RotateZ(-phi0)\n pbeam.RotateY(-theta0)\n precoil.RotateY(-theta0)\n psi0 = precoil.Phi()\n ptarg.RotateZ(-psi0)\n precoil.RotateZ(-psi0)\n for g in range(0, 3):\n pgamma[g].Boost(-beta0)\n pgamma[g].RotateZ(-phi0)\n pgamma[g].RotateY(-theta0)\n pgamma[g].RotateZ(-psi0)","def gravity(self, second_object):\n # Fg = F12 = F21 = G(m1)(m2)/r^2\n m1, m2 = self.mass, second_object.mass\n r = self.radial_distance(second_object)\n return (self.G*m1*m2)/pow(r, 2)","def calc_D(state):\n\t\tif t < thresh:\n\t\t\tstate.D_g[t] = 0.5\n\t\t\tstate.D_n[t] = 0.5\n\t\telse:\n\t\t\tif mod == \"constant\":\n\t\t\t\tstate.D_g[t] = D\n\t\t\t\tstate.D_n[t] = 1-D\n\t\t\tif mod == \"value\":\n\t\t\t\t# NOTE: if rmag and lmag is 1/0, can just use V\n\t\t\t\t# average of two actions\n\t\t\t\tV = np.mean(1/2*(state.QG[t,:] - state.QN[t,:])) # state average(?) \n\t\t\t\tV = 1/(1 + np.exp(-V*k)) # translate between 0 and 1\n\t\t\t\tstate.D_g[t] = V \n\t\t\t\tstate.D_n[t] = 1 - V\n\t\treturn state","def leapfrog(params, momentum, log_prob_func, steps=10, step_size=0.1, jitter=0.01, normalizing_const=1., softabs_const=1e6, explicit_binding_const=100, fixed_point_threshold=1e-20, fixed_point_max_iterations=6, jitter_max_tries=10, inv_mass=None, ham_func=None, sampler=Sampler.HMC, integrator=Integrator.IMPLICIT, metric=Metric.HESSIAN, store_on_GPU = True, debug=False, pass_grad = None):\n\n params = params.clone(); momentum = momentum.clone()\n # TodO detach graph when storing ret_params for memory saving\n if sampler == Sampler.HMC and integrator != Integrator.SPLITTING and integrator != Integrator.SPLITTING_RAND and integrator != Integrator.SPLITTING_KMID:\n def params_grad(p):\n p = p.detach().requires_grad_()\n log_prob = log_prob_func(p)\n # log_prob.backward()\n p = collect_gradients(log_prob, p, pass_grad)\n # print(p.grad.std())\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n return p.grad\n ret_params = []\n ret_momenta = []\n momentum += 0.5 * step_size * params_grad(params)\n for n in range(steps):\n if inv_mass is None:\n params = params + step_size * momentum #/normalizing_const\n else:\n #Assum G is diag here so 1/Mass = G inverse\n if type(inv_mass) is list:\n i = 0\n for block in inv_mass:\n it = block[0].shape[0]\n params[i:it+i] = params[i:it+i] + step_size * torch.matmul(block,momentum[i:it+i].view(-1,1)).view(-1) #/normalizing_const\n i += it\n elif len(inv_mass.shape) == 2:\n params = params + step_size * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params = params + step_size * inv_mass * momentum #/normalizing_const\n p_grad = params_grad(params)\n momentum += step_size * p_grad\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n # only need last for Hamiltoninian check (see p.14) https://arxiv.org/pdf/1206.1901.pdf\n ret_momenta[-1] = ret_momenta[-1] - 0.5 * step_size * p_grad.clone()\n # import pdb; pdb.set_trace()\n return ret_params, ret_momenta\n elif sampler == Sampler.RMHMC and (integrator == Integrator.IMPLICIT or integrator == Integrator.S3):\n if integrator is not Integrator.S3:\n ham_func = None\n # Else we are doing semi sep and need auxiliary for Riemann version.\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\n\n def fixed_point_momentum(params, momentum):\n momentum_old = momentum.clone()\n # print('s')\n for i in range(fixed_point_max_iterations):\n momentum_prev = momentum.clone()\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n # import pdb; pdb.set_trace()\n raise util.LogProbError()\n # import pdb; pdb.set_trace()\n # break\n\n momentum = momentum_old - 0.5 * step_size * params.grad\n momenta_diff = torch.max((momentum_prev-momentum)**2)\n if momenta_diff < fixed_point_threshold:\n break\n if debug == 1:\n print('Converged (momentum), iterations: {}, momenta_diff: {}'.format(i, momenta_diff))\n return momentum\n\n def fixed_point_params(params, momentum):\n params_old = params.clone()\n momentum = momentum.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n momentum = collect_gradients(ham,momentum)\n momentum_grad_old = momentum.grad.clone()\n for i in range(fixed_point_max_iterations):\n params_prev = params.clone()\n momentum = momentum.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n momentum = collect_gradients(ham,momentum)#collect_gradients(ham, params)\n params = params_old + 0.5 * step_size * momentum.grad + 0.5 * step_size * momentum_grad_old\n params_diff = torch.max((params_prev-params)**2)\n if params_diff < fixed_point_threshold:\n break\n if debug == 1:\n print('Converged (params), iterations: {}, params_diff: {}'.format(i, params_diff))\n return params\n ret_params = []\n ret_momenta = []\n for n in range(steps):\n # import pdb; pdb.set_trace()\n momentum = fixed_point_momentum(params, momentum)\n params = fixed_point_params(params, momentum)\n\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n raise util.LogProbError()\n # break\n momentum -= 0.5 * step_size * params.grad\n\n ret_params.append(params)\n ret_momenta.append(momentum)\n return ret_params, ret_momenta\n\n elif sampler == Sampler.RMHMC and integrator == Integrator.EXPLICIT:\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\n\n #During leapfrog define integrator as implict when passing into riemannian_hamiltonian\n leapfrog_hamiltonian_flag = Integrator.IMPLICIT\n def hamAB_grad_params(params,momentum):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n # import pdb; pdb.set_trace()\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n raise util.LogProbError()\n # import pdb; pdb.set_trace()\n # break\n\n return params.grad\n def hamAB_grad_momentum(params,momentum):\n momentum = momentum.detach().requires_grad_()\n params = params.detach().requires_grad_()\n # Can't detach p as we still need grad to do derivatives\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n # import pdb; pdb.set_trace()\n momentum = collect_gradients(ham,momentum)\n return momentum.grad\n ret_params = []\n ret_momenta = []\n params_copy = params.clone()\n momentum_copy = momentum.clone()\n for n in range(steps):\n # \\phi_{H_A}\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\n # \\phi_{H_B}\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\n # \\phi_{H_C}\n c = torch.cos(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\n s = torch.sin(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\n # params_add = params + params_copy\n # params_sub = params - params_copy\n # momentum_add = momentum + momentum_copy\n # momentum_sub = momentum - momentum_copy\n # ### CHECK IF THE VALUES ON THE RIGHT NEED TO BE THE OLD OR UPDATED ones\n # ### INSTINCT IS THAT USING UPDATED ONES IS BETTER\n # params = 0.5 * ((params_add) + c*(params_sub) + s*(momentum_sub))\n # momentum = 0.5 * ((momentum_add) - s*(params_sub) + c*(momentum_sub))\n # params_copy = 0.5 * ((params_add) - c*(params_sub) - s*(momentum_sub))\n # momentum_copy = 0.5 * ((momentum_add) + s*(params_sub) - c*(momentum_sub))\n params = 0.5 * ((params+params_copy) + c*(params-params_copy) + s*(momentum-momentum_copy))\n momentum = 0.5 * ((momentum+momentum_copy) - s*(params-params_copy) + c*(momentum-momentum_copy))\n params_copy = 0.5 * ((params+params_copy) - c*(params-params_copy) - s*(momentum-momentum_copy))\n momentum_copy = 0.5 * ((momentum+momentum_copy) + s*(params-params_copy) - c*(momentum-momentum_copy))\n\n\n # \\phi_{H_B}\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\n # \\phi_{H_A}\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n return [ret_params,params_copy], [ret_momenta, momentum_copy]\n\n # PAGE 35 MCMC Using Hamiltonian dynamics (Neal 2011)\n elif sampler == Sampler.HMC and (integrator == Integrator.SPLITTING or integrator == Integrator.SPLITTING_RAND or Integrator.SPLITTING_KMID):\n if type(log_prob_func) is not list:\n raise RuntimeError('For splitting log_prob_func must be list of functions')\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for splitting')\n\n def params_grad(p,log_prob_func):\n # OLD:\n # p = p.detach().requires_grad_()\n # log_prob = log_prob_func(p)\n # # log_prob.backward()\n # p = collect_gradients(log_prob, p)\n # grad = p.grad\n # # For removing GPU memory for large data sets.\n # del p, log_prob\n # torch.cuda.empty_cache()\n\n p = p.detach().requires_grad_()\n log_prob = log_prob_func(p)\n # Need to check memory issues in collect_gradients\n grad = torch.autograd.grad(log_prob,p)[0]\n # For removing GPU memory for large data sets.\n del p, log_prob, log_prob_func\n torch.cuda.empty_cache()\n return grad\n\n params = params.detach() # Detach as we do not need to remember graph until we pass into log_prob\n ret_params = []\n ret_momenta = []\n if integrator == Integrator.SPLITTING:\n M = len(log_prob_func)\n K_div = (M - 1) * 2\n if M == 1:\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\n for n in range(steps):\n # Symmetric loop to ensure reversible\n for m in range(M):\n # print('p ',n)\n grad = params_grad(params,log_prob_func[m])\n with torch.no_grad():\n momentum += 0.5 * step_size * grad\n del grad\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n if m < M-1:\n # print('q ',n)\n if inv_mass is None:\n params += (step_size/K_div) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\n for m in reversed(range(M)):\n # print('p ', n )\n grad = params_grad(params,log_prob_func[m])\n with torch.no_grad():\n momentum += 0.5 * step_size * grad\n del grad\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n if m > 0:\n # print('q ', n-1)\n if inv_mass is None:\n params += (step_size/K_div) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\n\n if store_on_GPU:\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n else:\n ret_params.append(params.clone().cpu())\n ret_momenta.append(momentum.clone().cpu())\n elif integrator == Integrator.SPLITTING_RAND:\n M = len(log_prob_func)\n idx = torch.randperm(M)\n for n in range(steps):\n # \"Labelling of subsets is randomised for each iteration\"\n # idx = torch.randperm(M)\n for m in range(M):\n # print('p ',n)\n momentum += 0.5 * step_size * params_grad(params, log_prob_func[idx[m]])\n # print('q ',n)\n if inv_mass is None:\n params += (step_size/M) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/M) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/M) * inv_mass * momentum #/normalizing_const\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[idx[m]])\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n # import pdb; pdb.set_trace()\n\n\n elif integrator == Integrator.SPLITTING_KMID:\n M = len(log_prob_func)\n if M == 1:\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\n for n in range(steps):\n # Symmetric loop to ensure reversible\n for m in range(M):\n # print('p ',n)\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\n\n if inv_mass is None:\n params = params + (step_size) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params = params + (step_size) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params = params + (step_size) * inv_mass * momentum #/normalizing_const\n\n for m in reversed(range(M)):\n # print('p ', n )\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n\n return ret_params, ret_momenta\n\n else:\n raise NotImplementedError()","def get_rm(g):\n return 1 / g","def gdm(x0,gradient,learning_rate=0.01,momentum_weight=0.9,iterations=100,\n initial_momentum=0,**kwargs):\n momentum = initial_momentum\n for i in range(iterations):\n momentum = momentum_weight*momentum+(1-momentum_weight)*gradient(x0)\n x0 -= learning_rate*momentum\n return x0, momentum","def accelerationCalcY(x,y):\r\n global G #glabel variables are initialised\r\n global massEarth\r\n return (-G*massEarth*y)/((x**2+y**2)**(3/2))# here from Newton's law of gravitation we return the acceleration on a projectile in the y direction\r","def gravitation_force(self, other):\n force = ((CONSTANTS.G * self.mass * other.mass) /\n (self.distance(other) ** 2))\n return force","def mv_delay(self):\n return self._TERRAINS[self.terrain]['delay']","def DDdelay(self):\n return self.delayInverse()+self.delayS()+self.delayA()","def g(self, x):\n return x * (1 - x)","def derivative(r, t, G=6.67e-11, AU=1.496e+11,\n m1=5.972e+24, m2=6.417e+23, m3=1.989e+30,\n a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n if G < 0:\n print(f\"The gravitational constant is negative\")\n\n if AU < 0:\n print(f\"The Astronomical unit is negative\")\n\n if m1 < 0:\n print(f\"The mass of the first body is negative\")\n\n if m2 < 0:\n print(f\"The mass of the second body is negative\")\n\n if m3 < 0:\n print(f\"The mass of the third body is negative\")\n\n if a1 < 0:\n print(f\"The distance of body 1 from the body center is negative\")\n\n if a2 < 0:\n print(f\"The distance of body 2 from the body center is negative\")\n\n x1 = r[0]\n y1 = r[1]\n v_x1 = r[2]\n v_y1 = r[3]\n\n x2 = r[4]\n y2 = r[5]\n v_x2 = r[6]\n v_y2 = r[7]\n\n x3 = r[8]\n y3 = r[9]\n v_x3 = r[10]\n v_y3 = r[11]\n\n z1 = r[12]\n z2 = r[13]\n z3 = r[14]\n\n v_z1 = r[15]\n v_z2 = r[16]\n v_z3 = r[17]\n\n r1 = np.array([x1, y1, z1])\n r2 = np.array([x2, y2, z2])\n r3 = np.array([x3, y3, z3])\n\n dr1 = v_x1\n dr2 = v_y1\n\n dr3 = (G*m2/distance(r1, r2)**3)*(x2-x1) + (G*m3/distance(r1, r3)**3)*(x3-x1)\n dr4 = (G*m2/distance(r1, r2)**3)*(y2-y1) + (G*m3/distance(r1, r3)**3)*(y3-y1)\n\n dr5 = v_x2\n dr6 = v_y2\n\n dr7 = (G*m1/distance(r1, r2)**3)*(x1-x2) + (G*m3/distance(r2, r3)**3)*(x3-x2)\n dr8 = (G*m1/distance(r1, r2)**3)*(y1-y2) + (G*m3/distance(r2, r3)**3)*(y3-y2)\n\n dr9 = v_x3\n dr10 = v_y3\n\n dr11 = (G*m1/distance(r1, r3)**3)*(x1-x3) + (G*m2/distance(r2, r3)**3)*(x2-x3)\n dr12 = (G*m1/distance(r1, r3)**3)*(y1-y3) + (G*m2/distance(r2, r3)**3)*(y2-y3)\n\n dr13 = v_z1\n dr14 = v_z2\n dr15 = v_z3\n\n dr16 = (G*m2/distance(r1, r2)**3)*(z2-z2) + (G*m3/distance(r1, r3)**3)*(z3-z1)\n dr17 = (G*m3/distance(r2, r3)**3)*(z1-z2) + (G*m1/distance(r2, r1)**3)*(z1-z2)\n dr18 = (G*m1/distance(r1, r3)**3)*(z1-z3) + (G*m2/distance(r2, r3)**3)*(z2-z3)\n\n dr = np.array([dr1, dr2, dr3, dr4, dr5, dr6,\n dr7, dr8, dr9, dr10, dr11, dr12,\n dr13, dr14, dr15, dr16, dr17, dr18])\n\n return dr","def G(U):\n n = U.shape[0]\n G_U = np.zeros([n,1])\n DELTA_x = float(2*L)/(n-1)\n for i in range(n):\n G_U[i][0] = U[(i+1)%n][0]\n G_U[i][0] -= U[(i-1)%n][0]\n G_U[i][0] /= (2* DELTA_x)\n G_U[i][0] += (float(epsilon) * (U[(i+1)%n][0]- U[(i-1)%n][0]) * (U[(i-1)%n][0]+U[(i+1)%n][0]+ U[i][0])/ (4* DELTA_x))\n G_U[i][0] += (float(epsilon) * (U[(i+2)%n][0]- 2*U[(i+1)%n][0]+ 2*U[(i-1)%n][0]- U[(i-2)%n][0]) / (12*( DELTA_x**3)))\n return G_U","def _calpara(self):\n self.up = math.exp(self.sigma*math.sqrt(self.deltatime))\n self.down = math.exp(-self.sigma*math.sqrt(self.deltatime))\n self.upprob = (math.exp((self.r-self.d)*self.deltatime)-self.down)/(self.up-self.down)","def roemer_delay(epoch, ecl_latitude, ecl_longitude, ephemeris='de432s'):\n\n # before computing anythin, set the ephemeris context to be value \n # supplied at the function call.\n solar_system_ephemeris.set(ephemeris)\n time = Time(epoch, format='mjd')\n\n # now comoute the required position vectors.\n r_earth = get_body_barycentric('earth', time)\n s_pulsar = pulsar_position_ecliptic(ecl_latitude, ecl_longitude)\n\n # finally, compute and return the delay.\n delay = r_earth.dot(s_pulsar).to(u.m) / c\n\n return delay","def P2G_func(self, dt, P):\n p_C = ti.static(self.p_C)\n p_v = ti.static(self.p_v)\n p_x = ti.static(self.p_x)\n g_m = ti.static(self.g_m)\n g_v = ti.static(self.g_v)\n p_F = ti.static(self.p_F)\n p_Jp = ti.static(self.p_Jp)\n\n base = ti.floor(g_m.getG(p_x[P] - 0.5 * g_m.dx)).cast(Int)\n fx = g_m.getG(p_x[P]) - base.cast(Float)\n\n # Here we adopt quadratic kernels\n w = [0.5 * (1.5 - fx) ** 2, 0.75 - (fx - 1) ** 2, 0.5 * (fx - 0.5) ** 2]\n # dw = [fx - 1.5, -2.0 * (fx - 1), fx - 0.5]\n\n # # TODO affine would do this in P2G.. why\n # p_F[P] = (ti.Matrix.identity(Int, self.dim) + dt * p_C[P]) @ p_F[P]\n\n force = ti.Matrix.zero(Float, self.dim, self.dim)\n # want to decrease branching\n if self.p_material_id[P] == MaType.elastic:\n force = self.elasticP2Gpp(P, dt)\n elif self.p_material_id[P] == MaType.liquid:\n force = self.liquidP2Gpp(P, dt)\n elif self.p_material_id[P] == MaType.snow:\n force = self.snowP2Gpp(P, dt)\n elif self.p_material_id[P] == MaType.sand:\n force = self.sandP2Gpp(P, dt)\n\n affine = force + self.cfg.p_mass * p_C[P]\n for offset in ti.static(ti.grouped(self.stencil_range3())):\n # print(\"P2G: \", offset)\n dpos = g_m.getW(offset.cast(Float) - fx)\n\n weight = 1.0\n for d in ti.static(range(self.dim)):\n weight *= w[offset[d]][d]\n\n # dweight = ts.vecND(self.dim, self.cfg.inv_dx)\n # for d1 in ti.static(range(self.dim)):\n # for d2 in ti.static(range(self.dim)):\n # if d1 == d2:\n # dweight[d1] *= dw[offset[d2]][d2]\n # else:\n # dweight[d1] *= w[offset[d2]][d2]\n\n # force = - self.cfg.p_vol * kirchoff @ dweight\n # TODO ? AFFINE\n # g_v[base + offset] += self.cfg.p_mass * weight * (p_v[P] + p_C[P] @ dpos) # momentum transfer\n # TODO Got lots of simultaneous atomic here\n g_v[base + offset] += weight * (self.cfg.p_mass * self.p_v[P] + affine @ dpos)\n g_m[base + offset] += weight * self.cfg.p_mass\n\n # g_v[base + offset] += dt * force","def gibbs_(dict_, T):\n\tdST = dict_['S298'] + CpT(dict_, T)[0]\n\t\t\n\tdHT = dict_['dH298'] + CpT(dict_, T)[1]/1000\n\t\t\n\treturn (dHT - T*dST/1000)","def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\n t = 0.0\n # Establish lists with initial position and velocity components and time.\n x_list = [x]\n y_list = [y]\n z_list = [z]\n vx_list = [vx]\n vy_list = [vy]\n vz_list = [vz]\n t_list = [t]\n\n # Set up visual elements.\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\n ball.trail = visual.curve(color=ball.color)\n\n while y >= 0.0:\n visual.rate(100) # Limit to no more than 100 iterations per second.\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\n x_list.append(x)\n y_list.append(y)\n z_list.append(z)\n vx_list.append(vx)\n vy_list.append(vy)\n vz_list.append(vz)\n t_list.append(t)\n ball.pos = (x,y,z)\n ball.trail.append(pos=ball.pos)\n\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list","def compute_gdp_mu(sampling_rate, sigma, steps):\n return sampling_rate * np.sqrt(steps * (np.exp(1 / sigma**2) - 1) )","def delayA(self):\n omgPlusAe = self.omega()+self.nu()\n et = self.ecc()\n sinOmg = np.sin(self.omega())\n cosOmg = np.cos(self.omega())\n aDelay = self.A0*(np.sin(omgPlusAe)+et*sinOmg)+\\\n self.B0*(np.cos(omgPlusAe)+et*cosOmg)\n return aDelay","def g(self, RD):\n g = 1 / np.sqrt((1 + 3 * np.power(self.q, 2)) / np.power(np.pi, 2)) \n \n return g","def M_g(self):\n\n print(\"\", file=self.logfile)\n print(\"Updating g\", file=self.logfile)\n M_mu1 = np.lib.stride_tricks.as_strided(self.mu_pad,\n shape=[self.P+1, self.L_h],\n strides=[self.mu_pad.strides[-1], self.mu_pad.strides[-1]])\n\n M_mu1 = M_mu1[::-1,:]\n M_mu2 = np.transpose(M_mu1[1:,:])\n M_mu1 = M_mu1*self.e2\n\n M_mu = np.dot(M_mu1, M_mu2)\n v_mu = M_mu[0,:]\n M_mu = M_mu[1:,:]\n\n M_R = np.zeros((self.P,self.P+1))\n for p in range(1,self.P+1):\n for q in range(0,self.P+1):\n M_R[p-1,q] = np.sum(np.diag(self.R, q-p)[:self.L_h-max(p,q)]*self.e2[max(p,q):self.L_h])\n\n v_R = M_R[:,0]\n M_R = M_R[:,1:]\n\n self.alpha_g = np.dot(np.linalg.inv(M_mu + M_R), v_mu+v_R)\n self.A = np.concatenate([[1], -self.alpha_g])\n\n self._propagate_A()","def g(z):\n return 1. / (1. + np.exp(-z))","def sgdgc(cost, params, lr=1.0, max_magnitude=5.0, infDecay=0.1):\n grads = T.grad(cost=cost, wrt=params)\n updates = []\n\n norm = norm_gs(params, grads)\n sqrtnorm = T.sqrt(norm)\n #not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\n\n for p, g in zip(params, grads):\n #g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\n updates.append((p, p - lr * g * adj_norm_gs)) \n \n return updates, norm","def sgdmgc(cost, params, lr=1.0, alpha=0.1, max_magnitude=5.0, infDecay=0.1):\n grads = T.grad(cost=cost, wrt=params)\n updates = []\n\n norm = norm_gs(params, grads)\n sqrtnorm = T.sqrt(norm)\n not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\n\n for p, g in zip(params, grads):\n v = shared(p.get_value() * 0.)\n g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\n v_new = v * (1.0 - alpha) - alpha * lr * g\n updates.append((v, v_new))\n updates.append((p, p + v_new ))\n \n return updates, norm","def acceleration_n_pendulum(t, state, kwargs, g = -9.81):\n # \"Parallel simulation of large scale multibody systems\" by Kloppel et al.\n #Source: https://onlinelibrary.wiley.com/doi/pdf/10.1002/pamm.201510327\n L = kwargs['L']\n N = len(state)//2\n last = N-1\n \n A = [ sin(state[i]) * (N-i) * g / L[i] for i in range(N) ]\n for i in range(N):\n total = 0\n for j in range(i):\n total += sin( state[j] - state[i] ) * state[N+j] ** 2\n A[i] += (N-i) * total\n for j in range(i+1,N):\n A[i] += (N-j) * sin( state[j] - state[i] ) * state[N+j] ** 2\n \n M = [ [ 0 for j in range(N) ] for i in range(N) ]\n for i in range(N):\n for j in range(N):\n M[i][j] = (N - max(i,j)) * cos(state[j]-state[i])\n \n M = np.asarray(M)\n M = np.linalg.inv(M)\n d_state = state.copy()\n d_state[:N] = state[N:]\n d_state[N:] = np.dot(M,A)\n return d_state","def fGasBulkModulus(GasGravity, Temperature, Pressure):\n\tGasConstant = 8.314\n\tTemp = Temperature + 273.16 # Deg K\n\tPress = (Pressure / 145.038) # MPa\n\tPr = Press / (4.892 - (0.4048 * GasGravity))\n\tTr = Temp / (94.72 + (170.75 * GasGravity))\n\tA = 0.03 + (0.00527 * ((3.5 - Tr)**3))\n\tB = (0.642 * Tr) - (0.007 * (Tr**4)) - 0.52\n\tC = 0.109 * ((3.85 - Tr)**2)\n\tD = exp(-((0.45 + (8 * ((0.56 - (1 / Tr))**2))) * ((Pr ** 1.2) / Tr)))\n\tZ = (A * Pr) + B + (C * D)\n\tRg = ((28.8 * GasGravity * Press) / (Z * GasConstant * Temp))\n\tG = 0.85 + (5.6 / (Pr + 2)) + (27.1 / ((Pr + 3.5)**2)) - (8.7 * exp(-0.65 * (Pr + 1)))\n\tM = (1.2 * (-1 * (0.45 + (8 * ((0.56 - (1 / Tr))**2))) * ((Pr**0.2) / Tr)))\n\tF = (C * D * M) + A\n\treturn 1e6 * (((Press * G) / (1-(Pr * F / Z)))) # Pa","def timeintegrand(z,omegalambda,omegam,omegak):\n\n return 1./((1+z)*adotovera(z,omegalambda,omegam,omegak))","def gaussianPulse(self, sigma, delay, amplitude=1.):\n def gaussianFunction(t, t0, sigma, amp=1):\n v = amp * numpy.exp(-(t - float(t0))**2 / (2 * sigma**2))\n return v\n\n shape = zeros(20000)\n for t in range(int(delay - 2 * sigma), int(delay + 2 * sigma)):\n shape[t] = gaussianFunction(t, delay, sigma, amp=amplitude)\n return shape","def cost(self):\n\t\treturn self.g + self.h","def backward_G(self):\n # First, G(A) should fake the discriminator\n if self.TPN_enabled:\n fake_AB = torch.cat((self.true_time_layer, self.real_A, self.fake_B), 1)\n else:\n fake_AB = torch.cat((self.real_A, self.fake_B), 1)\n pred_fake = self.netD(fake_AB)\n self.loss_G_GAN = self.criterionGAN(pred_fake, True)\n \n # Second, G(A) = B\n # Weighted L1 Loss\n if self.opt.lambda_L2 > 0: # If lambda_L2 is not > 0, no need to perform extra computation\n fake_B_tumour = self.fake_B.clone().detach()\n real_B_tumour = self.real_B.clone().detach()\n fake_B_tumour[fake_B_tumour < 0.5] = 0\n real_B_tumour[fake_B_tumour < 0.5] = 0\n self.loss_G_L1 = self.opt.lambda_L1 * (self.criterionL1(self.fake_B, self.real_B) * (1 - self.opt.lambda_L2) + \\\n self.criterionL1(fake_B_tumour, real_B_tumour) * self.opt.lambda_L2)\n else:\n ### ORIGINAL ###\n self.loss_G_L1 = self.criterionL1(self.fake_B, self.real_B) * self.opt.lambda_L1\n\n # TPN Loss\n if self.TPN_enabled:\n true_time_tensor = torch.ones(self.fake_time.shape) * self.true_time\n self.loss_G_TPN = self.criterionL1(true_time_tensor, self.fake_time.cpu()) * self.opt.gamma\n # combine loss and calculate gradients\n self.loss_G = self.loss_G_GAN + self.loss_G_L1 + self.loss_G_TPN.to(self.device)\n else:\n # combine loss and calculate gradients\n self.loss_G = self.loss_G_GAN + self.loss_G_L1\n\n self.loss_G.backward()","def expected_g(self):\n raise NotImplementedError()\n # \\sum_{b} \\gamma_b\n trm2 = self.mf_gamma.sum(axis=2)\n E_g = self.mf_gamma / trm2[:,:,None]\n return E_g","def _reward(self):\n # Clock reward -----------------------------------------------------------------\n A, B = self.get_von_mises(0.0, self.ratio, self.kappa)\n phi = self.phase / self.cycle_len\n #print('Cycles completed = ', self.cycle_complete)\n\n #print('A, B = ', (A,B))\n\n phi_FL = self.wrap(phi + self.theta_FL)\n phi_FR = self.wrap(phi + self.theta_FR)\n phi_RL = self.wrap(phi + self.theta_RL)\n phi_RR = self.wrap(phi + self.theta_RR)\n\n #print(phi_FL)\n #print(phi_FR)\n #print(phi_RL)\n #print(phi_RR)\n\n FL_swing = self.in_swing(A, B, phi_FL)\n FR_swing = self.in_swing(A, B, phi_FR)\n RL_swing = self.in_swing(A, B, phi_RL)\n RR_swing = self.in_swing(A, B, phi_RR)\n\n #print('Time since reset = ', self.rex.GetTimeSinceReset())\n #print('phase phi = ', phi)\n #print('FL swing = ', FL_swing)\n #print('FR swing = ', FR_swing)\n #print('RL swing = ', RL_swing)\n #print('RR swing = ', RR_swing)\n\n if FL_swing:\n c_swing_frc_FL = 1\n c_swing_spd_FL = 0\n else:\n c_swing_frc_FL = 0\n c_swing_spd_FL = 1\n\n if FR_swing:\n c_swing_frc_FR = 1\n c_swing_spd_FR = 0\n else:\n c_swing_frc_FR = 0\n c_swing_spd_FR = 1\n\n if RL_swing:\n c_swing_frc_RL = 1\n c_swing_spd_RL = 0\n else:\n c_swing_frc_RL = 0\n c_swing_spd_RL = 1\n\n if RR_swing:\n c_swing_frc_RR = 1\n c_swing_spd_RR = 0\n else:\n c_swing_frc_RR = 0\n c_swing_spd_RR = 1\n\n FL_foot_force, FR_foot_force, RL_foot_force, RR_foot_force = self.get_contact_forces()\n FL_vel, FR_vel, RL_vel, RR_vel = self.get_foot_velocities()\n\n FL_penalty = c_swing_frc_FL*FL_foot_force + c_swing_spd_FL*FL_vel\n FR_penalty = c_swing_frc_FR*FR_foot_force + c_swing_spd_FR*FR_vel\n RL_penalty = c_swing_frc_RL*RL_foot_force + c_swing_spd_RL*RL_vel\n RR_penalty = c_swing_frc_RR*RR_foot_force + c_swing_spd_RR*RR_vel\n\n foot_penalties = FL_penalty + FR_penalty + RL_penalty + RR_penalty\n \n # Deviation Penalties ----------------------------------------------------------\n # Base height\n base_height = self.rex.GetBasePosition()[-1]\n height_err = np.abs(base_height - self.height_des)\n \n if height_err < 0.02:\n height_err = 0\n\n # Speed \n vx, vy, _ = p.getBaseVelocity(bodyUniqueId=self.rex.quadruped)[0]\n vx = -vx # in rex, forward is the negative x direction\n x_vel_err = 4*np.abs(vx - self.speed) # higher emphasis on x velocity error\n y_vel_err = np.abs(vy - self.side_speed)\n\n # Orientation\n orient_curr = self.rex.GetBaseOrientation()\n orient_des = [0, 0, 0, 1] # not exact, but shouldn't be too far from this\n orient_err = 6 * (1 - np.inner(orient_curr, orient_des)**2 )\n\n shoulder_orient_des = [0, 0, 0, 1]\n FL_sh, FR_sh, RL_sh, RR_sh = self.get_shoulder_orientation()\n\n # quaternion similarity: 1 - <q1, q2>**2 == 0 when 100% similar\n # good when error < 0.01 (individually)\n # put HUGE penalty on this\n shoulder_err = 20 * ((1 - np.inner(shoulder_orient_des, FL_sh)**2) + \n (1 - np.inner(shoulder_orient_des, FR_sh)**2) +\n (1 - np.inner(shoulder_orient_des, RL_sh)**2) + \n (1 - np.inner(shoulder_orient_des, RR_sh)**2))\n\n # Energy Penalties --------------------------------------------------------------\n energy_penalty = np.abs(np.dot(self.rex.GetMotorTorques(),\n self.rex.GetMotorVelocities())) * self._time_step\n\n # Acceleration\n a_trans, a_rot = self.get_base_accelerations()\n accel_penalty = 0.15 * np.abs(a_trans.sum() + a_rot.sum())\n\n # need to encourage exploration: current issue --> Rex is stuck at origin\n # because positive rewards all the time\n # need lim error --> 0, reward > 0 \n\n beta = -0.75\n\n reward = beta + \\\n 0.200 * np.exp(-orient_err - shoulder_err) + \\\n 0.275 * np.exp(-foot_penalties) + \\\n 0.075 * np.exp(-height_err) + \\\n 0.250 * np.exp(-x_vel_err) + \\\n 0.100 * np.exp(-y_vel_err) + \\\n 0.075 * np.exp(-accel_penalty) + \\\n 0.025 * np.exp(-energy_penalty)\n\n\n return reward","def calc_f_g(mu, x, t, ro, inv_a):\n z = inv_a*pow(x,2)\n f = 1 - pow(x,2)/ro*stump_C(z) \n g = t - 1/sqrt(mu)*pow(x,3)*stump_S(z)\n return f, g","def _g(X, g, n):\n if n == 3:\n n = 3.001 # for numerical stability\n xi = 1 + X**2\n hyp2f1_term = hyp2f1((n - 3) / 2, g / 2, n / 2, 1 / xi)\n beta_term_1 = beta((n - 3) / 2, (3-g)/2)\n beta_term_2 = beta((n-3)/2, 1.5)\n return 0.5 * (beta_term_1 - beta_term_2 * hyp2f1_term * xi ** ((3-n)/2))","def leapfrog_step(R,V,M,G,dt0,U0,E0 ):\r\n # kick \r\n U = total_potential_energy(R,M,G)\r\n acc = acceleration(R,M,G)\r\n Vn = V + acc*dt0*(U/U0)**(-3/2) # new velocity\r\n \r\n # drift\r\n K = total_kinetic_energy(Vn,M)\r\n\r\n R_cotemp = R + Vn * dt0/2 * ((E0-K)/U0)**(-3/2) # new R, cotemporal with V\r\n Rn = R_cotemp + Vn * dt0/2 * ((E0-K)/U0)**(-3/2) # new R, half-step from V\r\n\r\n return Rn, R_cotemp, Vn, dt0*(U/U0)**(-3/2)","def g_2(thetas,aa,time):\n\treturn 2.0*(cos(2.0*thetas)/sin(thetas)) * ((1.0 - aa)*(1.0 - aa)*(time*time + 2.0)*(time*time + 2.0))","def expected_log_g(self):\n raise NotImplementedError()\n E_lng = np.zeros_like(self.mf_gamma)\n\n # \\psi(\\sum_{b} \\gamma_b)\n trm2 = psi(self.mf_gamma.sum(axis=2))\n for b in xrange(self.B):\n E_lng[:,:,b] = psi(self.mf_gamma[:,:,b]) - trm2\n\n return E_lng","def update(self, sim, dt):\n #growth kinetics\n self.division_timer += dt\n #you can grow unless you are in the A state meaning apoptosis\n if(self.division_timer >= self.division_time and self._division):\n #now you can divide\n if(self.state == \"T1\"):\n #change the current sytate to D\n self.state = \"NSC\"\n self._division = False\n self.division_time = 36\n #progenitor time is faster with concentration factor\n\n #add the concentration\n source, consump_rate = self.get_gradient_source_sink_coeff(\"TNF\")\n self.set_gradient_source_sink_coeff(\"TNF\", 50.0*source, 1.0*consump_rate)\n## #get neighbors\n## nbs = sim.network.neighbors(self)\n## #get the total\n## tot = len(nbs)\n## mn_count = 0\n## for i in range(0, tot):\n## if(nbs[i].state == \"MN\" or nbs[i].state == \"T2\"): \n## mn_count += 1\n## norm_mn = float(mn_count) / float(tot)\n## if(norm_mn < self._p2):\n## self.division_time = 36*(norm_mn) # in hours\n## self.division_time = max(self.division_time, 1) \n## else:\n## \n## print(norm_mn, self.division_time)\n #also set the current consumption rate\n## source, consump_rate = self.get_gradient_source_sink_coeff(\"EGF\")\n## self.set_gradient_source_sink_coeff(\"EGF\", source, 1.0*consump_rate)\n if(self.state == \"T2\"):\n #change the current sytate to D\n self.state = \"MN\"\n self.division_time = 56 #in hours\n #also set the current consumption rate\n source, consump_rate = self.get_gradient_source_sink_coeff(\"EGF\")\n self.set_gradient_source_sink_coeff(\"EGF\", 50.0*source, 1.0*consump_rate)\n if(self.state == \"T3\"):\n #change the current sytate to D\n self.state = \"G\"\n self.division_time = 56 #in hours\n #also set the current consumption rate\n## source, consump_rate = self.get_gradient_source_sink_coeff(\"EGF\")\n## self.set_gradient_source_sink_coeff(\"EGF\", source, 1.0*consump_rate)\n #get the location\n #pick a random point on a sphere\n location = RandomPointOnSphere()*self.radius/2.0 + self.location\n #get the radius\n radius = self.radius\n #get the ID\n ID = sim.get_ID()\n #make the object\n sc = NueronalStemCell(location, radius, ID, self.state,\n division_time = self.division_time,\n params = [self._p1, self._p2,\n self._p3, self._p4, self._p5,\n self._p6, self.p7])\n #copy secretion to NSC progeny\n if(self.state == \"NSC\"):\n source, consump_rate = self.get_gradient_source_sink_coeff(\"TNF\")\n sc.set_gradient_source_sink_coeff(\"TNF\", 50.0*source, 1.0*consump_rate)\n sc._division = False\n #set its soluble count\n## sc.sol_count = self.sol_count / 2.\n## self.sol_count = self.sol_count / 2.\n #copy over all of the coefficients to the new cells\n## prod_cons = self.get_gradient_source_sink_coeff(\"O2\")\n## sc.set_gradient_source_sink_coeff(\"O2\", prod_cons[0], prod_cons[1])\n prod_cons = self.get_gradient_source_sink_coeff(\"EGF\")\n sc.set_gradient_source_sink_coeff(\"EGF\", prod_cons[0], prod_cons[1]) \n #add it to the imsulation\n sim.add_object_to_addition_queue(sc)\n #reset the division time\n self.division_timer = 0\n \n if(self.state == \"U\"):\n #HANDLE DIFFERENTIATION\n #RANDOM RULE\n x = rand.random()\n prob = self._p1 #probability of turning into a NSC\n #longer before the differentiation starts\n if(x < prob):\n #differentiation occurs\n self.state = \"T1\"\n #also add a proabability to differentiate directly to a mn\n n1 = self._p4\n## #get neighbors\n## nbs = sim.network.neighbors(self)\n## #get the total\n## tot = len(nbs)\n## mn_count = 0\n## if(tot > 0):\n## #count up the states fo all fo these\n## for i in range(0, tot):\n## if(nbs[i].state == \"MN\" or nbs[i].state == \"T2\"): \n## mn_count += 1\n #get the value fo the gradient and make differntiation inversly\n #inversly correlated with the proportion present\n norm_mn = self.get_gradient_value(\"EGF\")\n #probability of turning into a motor nueron\n n1 = self._p4\n## #normalize the result\n## if(tot != 0):\n## norm_mn = float(mn_count) / float(tot)\n## else:\n## norm_mn = 0\n #calculate the probability\n prob_MN = 1 - (1.*norm_mn**n1)/(self._p2**n1 + norm_mn**n1)\n x1 = rand.random()\n if(x1 <= self._p1*prob_MN):\n #differentiation occurs towards a motor nueron\n self.state = \"T2\"\n \n if(self.state == \"NSC\"):\n #HANDLE DIFFERENTIATION\n #RANDOM RULE\n x1 = rand.random()\n x2 = rand.random()\n #Find all the motor nuerons\n## #get neighbors\n## nbs = sim.network.neighbors(self)\n## #get the total\n## tot = len(nbs)\n## mn_count = 0\n## if(tot > 0):\n## #count up the states fo all fo these\n## for i in range(0, tot):\n## if(nbs[i].state == \"MN\" or nbs[i].state == \"T2\"): \n## mn_count += 1\n## #normalize the result\n## norm_mn = float(mn_count) / float(tot)\n #Make differerntiationd ependant on the gradient value\n norm_mn = self.get_gradient_value(\"EGF\")\n #set the paramaters\n n1 = self._p4\n #update the division time\n## self.division_time = norm_mn * 38 #in hours takes care of the feedback\n #depends on other motor nuerons\n prob_MN = 1 - (1.*norm_mn**n1)/(self._p3**n1 + norm_mn**n1) #probability of turning into a motor nueron\n## prob_G = (1.*norm_mn**n2)/(self._p3**n1 + norm_mn**n2) #of turning into a glial cell\n prob_G = self._p5\n #longer before the differentiation starts\n if(x1 <= prob_MN and x2 > prob_G):\n #differentiation occurs towards a motor nueron\n self.state = \"T2\"\n if(x1 > prob_MN and x2 <= prob_G):\n #differentiation occurs towards a glial cell\n self.state = \"T3\"\n #check to see if division enabled\n if(self._division == False):\n #check for mitotic speed up\n a = self._p6\n b = self._p7\n norm_nsc = self.get_gradient_value(\"TNF\")\n prob_divide = (1.*norm_nsc**b)/(a**b + norm_nsc**b)\n r = rand.random()\n if(r <= x):\n self._division = True","def theta_v_time():\n pass","def space_decay_rate(self):\n dt = (datetime.datetime.utcnow() - self.initial_time).total_seconds() # delta t\n ds = self.available_space() - self.initial_space_remaining # delta space\n return ds / dt","def gravity(self,satellite):\n\n G =0.1\n dist_x = self.x - satellite.x\n dist_y = self.y - satellite.y\n distance = math.hypot(dist_x,dist_y)\n\n dist_x /= distance\n dist_y /= distance\n\n force = G * (satellite.mass * self.mass)/(math.pow(distance,2))\n satellite.dx += (dist_x * force)\n satellite.dy += (dist_y * force)","def velocity(M, r, G=6.67e-11):\n\n if M < 0:\n return print(f\"The given mass is negative\")\n\n if r < 0:\n print(f\"The given distance is negative\")\n\n if G < 0:\n print(f\"The gravitational constant is negative\")\n\n return np.sqrt(G*M/r)","def g_0(thetas,aa,time):\n\treturn 2.0*(1.0/sin(thetas)) * ((1. +3.*aa)*(1. + 3.*aa)*time*time*time*time + 2.*(1. + 2.0*aa + 2.0*aa + 3.0*aa*aa) *time*time + 2.0 * (1.0+aa) * (1.0 + aa))","def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\n t = t + dt\n x = x + vx*dt\n y = y + vy*dt\n z = z + vz*dt\n\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\n vx = vx - B2/m*v*vx*dt\n vy = vy - g*dt - B2/m*v*vy*dt\n\n return t, x, y, z, vx, vy, vz","def _draw_node_delay(self):\n node_list = self.G.nodes()\n n_nodes = len(node_list)\n node_delay = rd.exponential(1./self.gamma, size=n_nodes)\n self._node_delay = np.zeros(self.n_nodes)\n for n, d in zip(node_list, node_delay):\n self._node_delay[n] = d","def target_velocity(self, time):\n \"\"\"\n start_point = self.points[self.cur_start]\n cur_target = self.points[(self.cur_start + 1) % 4]\n total_time = self.total_time / 4\n avg_vel = (cur_target - start_point)/ total_time\n return avg_vel\n \"\"\"\n total_time = self.total_time\n if time <= self.total_time/4:\n return self.path1.target_velocity(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/2:\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= self.total_time/4*3:\n return self.path3.target_velocity(time - (total_time/2 + 1))\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n\n else:\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))","def compute_g(self, i, j):\n #Compute variance and mean denominator (same denominator for both)\n g_next = 0\n if (i+1 < self.nb_days-1):\n g_next = self.g_heat[i+1,j]\n\n denominator = 2 * self.sigma2\n numerator_mean = self.sigma2 * (self.g_heat[i-1,j] + g_next)\n if (self.u_heat > self.temperatures[i]):\n denominator = denominator + self.sigma_g_star_2[0, j] * ((self.temperatures[i] - self.u_heat)**2)\n numerator_mean = numerator_mean + \\\n self.sigma_g_star_2[0, j] * (self.temperatures[i] - self.u_heat) * (self.consumptions[i] - self.s[i,j] * self.kappa[self.daytypes[i]])\n\n #Mean\n mean = numerator_mean / denominator\n\n #Compute variance numerator\n variance_numerator = (self.sigma2 * self.sigma_g_star_2[0, j])\n #Variance\n variance = variance_numerator / denominator\n\n self.g_heat[i,j] = self.truncated_norm(-inf, 0, mean, variance)","def test_GBL_tau_star():\n z = 1.0\n\n # Fully ionized H and He\n x_ionH = 1.0\n x_ionHe = 2.0\n\n cosmo = {}\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\n cosmo['h'] = 0.65\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\n cosmo['Y_He'] = 0.24\n cd.set_omega_k_0(cosmo)\n\n tau_inst, tau_star = cr.optical_depth_instant(z, \n x_ionH=x_ionH, \n x_ionHe=x_ionHe, \n return_tau_star=True,\n **cosmo)\n print(\"tau_star = %.7f\" % (tau_star))\n print(\"tau_star/(h Omega_b) = %.7f =? 0.061\" % \n (tau_star / (cosmo['h'] * cosmo['omega_b_0'])))\n\n ntest.assert_approx_equal(tau_star / (cosmo['h'] * cosmo['omega_b_0']),\n 0.061,\n 2)\n\n print(\"(1 - Y_He/2) = %.3f =? 0.88\" % (1. - (cosmo['Y_He']/2.)))\n ntest.assert_approx_equal((1. - (cosmo['Y_He']/2.)),\n 0.88,\n 7)\n\n H_0 = cc.H100_s * cosmo['h']\n\n # s^-1 * Mpc s^-1 * Mpc^2 / Mpc^3 msun^-1 s^-2 / Msun -> \n tau_star_explicit = ((1. - (cosmo['Y_He']/2.)) * \n ((3. * H_0 * cosmo['omega_b_0'] * cc.c_light_Mpc_s *\n cc.sigma_T_Mpc) / \n (8. * math.pi * cc.G_const_Mpc_Msun_s * \n (cc.m_p_g/cc.M_sun_g))))\n\n print(\"tau_star_explicit = %.7f =? tau_star\" % (tau_star_explicit))\n ntest.assert_approx_equal(tau_star, tau_star_explicit, 3)","def get_fractional_degradation(bt):\n\n\n\n NomIch = 0.125 # Nominal charge current\n NomId = 0.25 # Nominal discharge current\n NomSoC = 0.5 # Nominal state of charge_mode\n NomDoD = 1.0 # Nominal depth of discharge\n B = 5 #Battery capacity\n qt = 5 * 0.5 # Amount of energy in the battery at the start\n # Determin charge of discharge\n if bt > 0:\n Id = bt/(B*1) # time interval differnece is 1\n Ich = NomIch\n else:\n Ich = bt/(B*1)\n Id = NomId\n\n #Calculate average State of Charge\n SoC = 100 * (qt - 0.5*bt)/B\n\n #Calculate Depth of Discharge\n DoD = 100 * bt /B\n\n # Functions\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\n nCL = nCL1 * nCL2 * nCL3\n Fractional_D = (0.5/3650)/ nCL\n return Fractional_D","def delayToNextPacket(self):\n delay = -(1.0 / (self.mPacketsPerSecond)) * np.log(1 - np.random.uniform())\n # exponential distribution in seconds\n return round(delay * Constants.TICKS_PER_SECOND)\n #return (Math.round(delay * Main.TICKS_PER_SECOND))","def get_delay(self, pid1, pid2, is_block):\n is_slow = self.node_is_slow[pid1] or self.node_is_slow[pid2]\n p = random.uniform(Parameters.p_min, Parameters.p_max)\n c = Parameters.c_low if is_slow else Parameters.c_high\n m = Parameters.m if is_block else 0\n d = random.expovariate(c / Parameters.d)\n return (p + m/c + d)","def bethe_gf_omega(z, t=1.0):\n half_bandwidth = 2 * t\n z_rel = z / half_bandwidth\n return 2. / half_bandwidth * z_rel * (1 - np.sqrt(1 - 1 / (z_rel * z_rel)))","def sigma0_RG(self):\n sigma = np.sqrt(self.cosmo.gs_spectral_moment(l=0,RG=self.RG))\n return sigma","def acc_grav(j,rA,mA,hA,W=kernel.W_M4star):\n assert rA.shape[0] == mA.shape[0] == hA.shape[0], \"arrays are mismatched\"\n N = len(mA)\n\n tot = 0\n for i in range(N):\n if i != j:\n\n r_ij = rA[j,:] - rA[i,:]\n r_ij1 = np.linalg.norm(r_ij)\n m_i = mA[i]\n h_ij = 0.5 * (hA[i] + hA[j])\n\n tot += m_i * (r_ij/r_ij**3) * W(r_ij1,h_ij)\n\n return - tot * G","def delayS(self):\n e = self.ecc()\n cE = np.cos(self.E())\n sE = np.sin(self.E())\n sOmega = np.sin(self.omega())\n cOmega = np.cos(self.omega())\n TM2 = self.M2.value*Tsun\n\n sDelay = -2*TM2* np.log(1-e*cE-self.SINI*(sOmega*(cE-e)+\n (1-e**2)**0.5*cOmega*sE))\n return sDelay","def triggerCondition(cls, state):\n x1, x2 = state\n y = cls.X2toY(x1, x2)\n norm = np.math.sqrt(x1**2 + y**2)\n\n # calculate next trigger step\n dt = (29 * x1 + norm**2) / (5.36 * norm * x1**2 + norm**2) * cls.tau_trigger\n return dt"],"string":"[\n \"def test_gravitation(self):\\n with PhysicsEngineHarness('tests/massive-objects.json') as physics_engine:\\n # In this case, the first entity is very massive and the second\\n # entity should gravitate towards the first entity.\\n t0 = 1\\n t1 = 2\\n initial = physics_engine.get_state(t0)\\n moved = physics_engine.get_state(t1)\\n # https://www.wolframalpha.com/input/?i=1e30+kg+*+G+%2F+(1e8+m)%5E2\\n # According to the above, this should be somewhere between 6500 and\\n # 7000 m/s after one second.\\n self.assertTrue(moved[1].vx > 5000,\\n msg=f'vx is actually {moved[1].vx}')\\n\\n # Test the internal math that the internal derive function is doing\\n # the right calculations. Break out your SPH4U physics equations!!\\n y0 = initial\\n # Note that dy.X is actually the velocity at 0,\\n # and dy.VX is acceleration.\\n dy = PhysicsState(\\n ode_solver.simulation_differential_function(\\n 0, y0.y0(), y0._proto_state, physics_engine.M, physics_engine._artificials),\\n y0._proto_state)\\n self.assertEqual(len(dy.X), 2)\\n self.assertAlmostEqual(dy.X[0], y0.VX[0])\\n self.assertAlmostEqual(dy.Y[0], y0.VY[0])\\n self.assertEqual(round(abs(dy.VX[0])),\\n round(common.G * initial[1].mass\\n / (y0.X[0] - y0.X[1]) ** 2))\\n self.assertAlmostEqual(dy.VY[0], 0)\\n\\n self.assertAlmostEqual(dy.X[1], y0.VX[1])\\n self.assertAlmostEqual(dy.Y[1], y0.VY[1])\\n self.assertEqual(round(abs(dy.VX[1])),\\n round(common.G * initial[0].mass\\n / (y0.X[1] - y0.X[0]) ** 2))\\n self.assertAlmostEqual(dy.VY[1], 0)\",\n \"def compute_gravity(self):\\r\\n # compute the gravity from the Gauss form.\\r\\n # if it fails, marks divergence\\r\\n try:\\r\\n self.gravsolver.solve()\\r\\n except:\\r\\n print(\\\"GRAVITY DIVERGED\\\")\\r\\n\\r\\n # write to log\\r\\n self.logfile.write(\\\"%s: STOPPED DUE TO DIVERGENCE IN GRAVITY \\\\n\\\" %\\r\\n (self.convert_time(time.time() -\\r\\n self.start_time)))\\r\\n self.diverged = True # set diverged to True, break the run\\r\\n return\\r\\n\\r\\n # split and update the gravity function with the answers\\r\\n # note the gravscale\\r\\n gravg, gravs = self.gravgs.split()\\r\\n\\r\\n # assign the result to the gravity function\\r\\n self.gravity.assign(project(gravg/self.gravscale, self.V))\",\n \"def get_gravitational_attraction(self, rocket_mass, altitude):\\n return self.gravitational_constant * self.earth_mass * rocket_mass / (\\n self.earth_radius + altitude + self.base_altitude) ** 2\",\n \"def calc_grav(self):\\n if self.change_y == 0:\\n self.change_y = 1\\n else:\\n self.change_y += .35\\n \\n # See if we are on the ground.\\n if self.rect.y >= SCREEN_HEIGHT:\\n self.level.game_over()\",\n \"def calculate_delay(self, velocity):\\n if velocity > 0:\\n rps = velocity / 1.444\\n delay = (1 / (200 * float(rps))) / 2\\n return delay\\n else:\\n return 0\",\n \"def gravity():\\n\\tg = _scene.gravity()\\n\\treturn Vector3(g[0], g[1], g[2])\",\n \"def _get_delta_time(r0):\\n\\n s1 = random() # To pick time\\n epsilon = 0.001 # To avoid division by zero\\n lam = (1 / (r0 + epsilon))\\n return lam * pow(e, -lam * s1)\",\n \"def _compute_gravity_torque(self, curr_date):\\n if self._to_add[0]:\\n # return gravity gradient torque in satellite frame\\n body2inertial = self.earth.getBodyFrame().getTransformTo(self.in_frame, curr_date)\\n body2sat = self.inertial2Sat.applyTo(body2inertial.getRotation())\\n body2satRot = PyRotation(body2sat.q0,\\n body2sat.q1,\\n body2sat.q2,\\n body2sat.q3)\\n sat2bodyRot = body2satRot.revert()\\n body2sat = body2satRot.getMatrix()\\n sat2body = sat2bodyRot.getMatrix()\\n\\n satM = self.spacecraft_state.getMass()\\n mCub = self.inCub['dm'] * satM\\n # add booms\\n if \\\"dm_boom\\\" in self.inCub:\\n mCub = np.concatenate((mCub, self.inCub['dm_boom']), axis=0) # boom store with mass\\n CoM = self.inCub['CoM_np']\\n\\n dmPos_s = CoM + self.satPos_s\\n\\n gNewton = (-self.muGM / np.linalg.norm(dmPos_s,\\n axis=1,\\n keepdims=True)**3) * dmPos_s\\n\\n # rotate vectors:\\n dmPos_b = np.einsum('ij,kj->ki', sat2body, dmPos_s)\\n\\n gDist = np.empty(dmPos_b.shape)\\n for i in xrange(0, dmPos_b.shape[0]):\\n gDist[i, :] = np.asarray(\\n self.GravityModel.gradient(curr_date,\\n Vector3D(float(dmPos_b[i, 0]),\\n float(dmPos_b[i, 1]),\\n float(dmPos_b[i, 2])),\\n self.muGM))\\n\\n gDist_s = np.einsum('ij,kj->ki', body2sat, gDist)\\n\\n gT = np.sum(np.cross(CoM, mCub*(gNewton + gDist_s)), axis=0)\\n\\n self._gTorque = Vector3D(float(gT[0]), float(gT[1]), float(gT[2]))\\n\\n else:\\n self._gTorque = Vector3D.ZERO\",\n \"def _calc_grav(self):\\n if self.change_y == 0:\\n self.change_y = 1\\n else:\\n self.change_y += 1.35\\n\\n # See if we are on the ground.\\n # if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0:\\n # self.change_y = 0\\n # self.rect.y = SCREEN_HEIGHT - self.rect.height\",\n \"def calcGravity(self, seconds):\\n if self.change_y == 0:\\n self.change_y = 1\\n else:\\n self.change_y += .35\\n \\n # See if we are on the ground.\\n if self.rect.y >= SCR_HEIGHT - self.rect.height and self.change_y >= 0:\\n self.change_y = 0\\n self.rect.y = SCR_HEIGHT - self.rect.height\",\n \"def delayR(self): # Is this needed?\\n\\n rDelay = self.a1()/c.c*(self.sOmg*(self.cosEcc_A-self.er) \\\\\\n +(1-self.eTheta()**2)**0.5*self.cOmg*self.sinEcc_A)\\n return rDelay.decompose()\",\n \"def delayE(self):\\n sinE = np.sin(self.E())\\n return self.GAMMA\",\n \"def calc_grav(self):\\n if self.change_y == 0:\\n self.change_y = 1\\n\\n else:\\n self.change_y += .35\\n\\n # See if we are on the ground.\\n\\n if (self.rect.y >= constants.SCREEN_HEIGHT - self.rect.height and self.change_y >= 0):\\n self.change_y = 0\\n self.rect.y = constants.SCREEN_HEIGHT - self.rect.height\",\n \"def calc_grav(self):\\n if self.change_y == 0:\\n self.change_y = 1\\n\\n else:\\n self.change_y += .35\\n\\n # See if we are on the ground.\\n\\n if (self.rect.y >= constants.SCREEN_HEIGHT - self.rect.height and self.change_y >= 0):\\n self.change_y = 0\\n self.rect.y = constants.SCREEN_HEIGHT - self.rect.height\",\n \"def standard_gravity():\\n mu = 3.986004418E14\\n return mu\",\n \"def delay(self):\\r\\n return self.relative_phases / (2 * np.pi * self.frequencies)\",\n \"def delay(self):\\r\\n return self.relative_phases / (2 * np.pi * self.frequencies)\",\n \"def calc_gpm(pulse_count):\\n # PATRICK --- WE NEED TO FIGURE THIS OUT FOR THE ACTUAL FLOW RATE (LPM and GPM)\\n # FROM THE NUMBER OF PULSES AND THE TOTAL TIME IN SECONDS THAT HAVE ELAPSED\\n\\n # From the sensor specification data sheet:\\n # Calculate Liters per minute using sensor specification\\n # F = Constant * units of flow (liter per min) * time (seconds)\\n # ~ 330 pulse/liter\\n\\n # To calculate Liters per minute\\n constant = 10 # PATRICK NEED TO FIGURE THE CONSTANT VALUE OUT\\n time_seconds = 60 # since this function is called every minute\\n lpm = round((constant * (pulse_count / 330.0) / (time_seconds / 60)), 2)\\n\\n # Convert lpm to gpm\\n gpm = round(lpm * 0.26417205236)\\n return gpm\",\n \"def calc_gravitational_energy(self):\\n\\n star = self.star\\n\\n K, N = star.mesh_size\\n mu = star.mu_coords\\n r = star.r_coords\\n\\n def S1(j):\\n return np.sum((mu[2::2] - mu[:-2:2]) * (star.rho[:-2:2, j] * star.Phi[:-2:2, j] +\\n 4 * star.rho[1:-1:2, j] * star.Phi[1:-1:2, j] +\\n star.rho[2::2, j] * star.Phi[2::2, j])) / 6\\n\\n W = 0\\n\\n for j in range(0, N - 2, 2):\\n W += (r[j + 2] - r[j]) * (r[j]**2 * S1(j) +\\n 4 * r[j + 1]**2 * S1(j + 1) +\\n r[j + 2]**2 * S1(j + 2))\\n\\n return -1 / 3 * np.pi * W\",\n \"def calc_gravitational_energy(self):\\n\\n star = self.star\\n\\n M, K, N = star.mesh_size\\n ph = star.phi_coords\\n mu = star.mu_coords\\n r = star.r_coords\\n\\n def S1(j, k):\\n sum = 0\\n\\n for i in range(0, M - 2, 2):\\n sum += (1 / 6) * (ph[i + 2] - ph[i]) * (star.rho[i, j, k] * star.Phi[i, j, k] + 4 *\\n star.rho[i + 1, j, k] * star.Phi[i + 1, j, k] +\\n star.rho[i + 2, j, k] * star.Phi[i + 2, j, k])\\n return 2 * sum\\n\\n def S2(k):\\n sum = 0\\n\\n for j in range(0, K - 2, 2):\\n sum += (1 / 6) * (mu[j + 2] - mu[j]) * \\\\\\n (S1(j, k) + 4 * S1(j + 1, k) + S1(j + 2, k))\\n\\n return 2 * sum\\n\\n W = 0\\n\\n for k in range(0, N - 2, 2):\\n W -= 0.5 * (1 / 6) * (r[k + 2] - r[k]) * (r[k]**2 * S2(k) +\\n 4 * r[k + 1]**2 * S2(k + 1) +\\n r[k + 2]**2 * S2(k + 2))\\n\\n return W\",\n \"def calc_grav(self):\\n if self.change_y == 0:\\n self.change_y = 1\\n else:\\n self.change_y += .35\\n \\n # See if the sprite is on the ground.\\n if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0:\\n self.change_y = 0\\n self.rect.y = SCREEN_HEIGHT - self.rect.height\",\n \"def _g(self, x):\\n e_x = math.exp(-self._alpha * x)\\n return (1.0 / (1 + e_x))\",\n \"def gravity_gradients(self, p):\\n Le = self._Le(p)\\n wf = self._wf(p)\\n EeLe = np.einsum(\\\"i...,i\\\", self.Ee, Le)\\n FfWf = np.einsum(\\\"i...,i\\\", self.Ff, wf)\\n return G * self.d * (EeLe - FfWf)\",\n \"def __gravity__(self, dt):\\n t = dt - self.airtime\\n self.velocity += self.gravity * t\",\n \"def gmean_diff(self) -> float:\\n sim_log = np.log1p(self.predicted)\\n obs_log = np.log1p(self.true)\\n return float(np.exp(gmean(sim_log) - gmean(obs_log)))\",\n \"def time(self) -> float:\\n return self.state.game_loop / 22.4 # / (1/1.4) * (1/16)\",\n \"def compute_gains(self, t, add_noise=True):\\n #get the basis funtion at a time step\\n basis, Dbasis = self.get_basis(t)\\n\\n if t < self._time_steps-1:\\n basis_t_dt, _ = self.get_basis(t+1)\\n else:\\n basis_t_dt = np.zeros_like(basis)\\n\\n\\n #part 1 equation 46\\n B_pseudo = np.linalg.pinv(self._B)\\n\\n #equation 12 for t\\n Sigma_t = np.dot(np.dot(basis, self._sigma_W), basis.T)\\n\\n #equation 12 for t+dt\\n Sigma_t_dt = np.dot(np.dot(basis_t_dt, self._sigma_W), basis_t_dt.T)\\n\\n #Cross correlation between t, t+dt, Equation 49\\n Ct = np.dot(np.dot(basis, self._sigma_W), basis_t_dt.T)\\n\\n #System noise Equation 51\\n Sigma_s = (1./self._dt)* ( Sigma_t_dt - np.dot( np.dot( Ct.T, np.linalg.inv(Sigma_t) ), Ct) )\\n\\n #control noise Equation 52\\n Sigma_u = np.dot(np.dot(B_pseudo, Sigma_s), B_pseudo.T)\\n\\n #part 2 equation 46\\n tmp1 = np.dot(np.dot(Dbasis, self._sigma_W), basis.T)\\n\\n #part 3 equation 46\\n tmp2 = np.dot(self._A, Sigma_t) + 0.5*Sigma_s\\n\\n #compute feedback gain; complete equation 46\\n K = np.dot( np.dot(B_pseudo, (tmp1-tmp2) ), np.linalg.inv(Sigma_t))\\n\\n #part 1 equation 48\\n tmp3 = np.dot(Dbasis, self._mean_W)\\n\\n #part 2 equation 48\\n tmp4 = np.dot( (self._A + np.dot(self._B, K)), np.dot(basis, self._mean_W) )\\n\\n #compute feedforward gain; complete equation 48\\n k = np.dot(B_pseudo, (tmp3-tmp4))\\n\\n return K, k, Sigma_u\",\n \"def accelerationCalcX(x,y):\\r\\n global G # the gravitational constant is initialised like this so that it can be used in this function\\r\\n global massEarth #the same goes for the mass of the Earth\\r\\n return (-G*massEarth*x)/((x**2+y**2)**(3/2)) # here from Newton's law of gravitation we return the acceleration on a projectile in the x direction\\r\",\n \"def _compute_gravity_torque(self):\\n pass\",\n \"def gVI(g,rBC,lBC,time,npts):\\n #Important coeffcients\\n global gamma\\n gamma = g\\n global alpha\\n alpha = (gamma+1)/(gamma-1)\\n global beta\\n beta = (2*gamma)/(gamma-1)\\n global epsilon\\n epsilon = (2*gamma)/(gamma+1)\\n #Boundary conditions\\n global lbc\\n lbc = lBC\\n global rbc\\n rbc = rBC\\n #Time\\n global t\\n t = time\\n #points\\n global numPts\\n numPts = npts\\n #Speed of sound for states 1 and 5\\n global cL\\n cL = np.sqrt(gamma*lbc[0]/lbc[1])\\n global cR\\n cR = np.sqrt(gamma*rbc[0]/rbc[1])\",\n \"def g(r):\\n return np.cos(r) / (np.exp(0.4 * (r - 8)) + 1)\",\n \"def run_grav(self):\\n\\n # Solucao direta\\n self.prod_w = []\\n self.prod_o = []\\n t0 = time.time()\\n # self.set_volumes_in_primal()\\n self.set_sat_in()\\n self.set_lamb_2()\\n self.set_global_problem_vf_3_gr1_bif()\\n self.Pf = self.solve_linear_problem(self.trans_fine, self.b, len(self.all_fine_vols_ic))\\n self.organize_Pf()\\n del self.Pf\\n self.mb.tag_set_data(self.pf_tag, self.all_fine_vols, np.asarray(self.Pf_all))\\n del self.Pf_all\\n self.test_conservation_fine()\\n # self.store_flux_pf_gr_bif = self.create_flux_vector_pf_gr_bif_1()\\n\\n \\\"\\\"\\\"\\n ################################################################\\n # Solucao Multiescala\\n self.calculate_restriction_op_2()\\n self.calculate_prolongation_op_het()\\n self.organize_op()\\n self.Tc = self.modificar_matriz(self.pymultimat(self.pymultimat(self.trilOR, self.trans_fine, self.nf_ic), self.trilOP, self.nf_ic), self.nc, self.nc)\\n self.Qc = self.modificar_vetor(self.multimat_vector(self.trilOR, self.nf_ic, self.b), self.nc)\\n self.Pc = self.solve_linear_problem(self.Tc, self.Qc, self.nc)\\n self.set_Pc()\\n self.Pms = self.multimat_vector(self.trilOP, self.nf_ic, self.Pc)\\n\\n del self.trilOP\\n del self.trilOR\\n del self.Tc\\n del self.Qc\\n del self.Pc\\n\\n self.organize_Pms()\\n del self.Pms\\n self.mb.tag_set_data(self.pms_tag, self.all_fine_vols, np.asarray(self.Pms_all))\\n del self.Pms_all\\n self.erro()\\n\\n self.test_conservation_coarse_gr()\\n # self.Neuman_problem_6_gr()\\n # self.store_flux_pms_gr = self.create_flux_vector_pms_gr()\\n ####################################################################\\n \\\"\\\"\\\"\\n\\n\\n\\n\\n\\n\\n\\n print('acaboooou')\\n self.mb.write_file('new_out_bif_gr.vtk')\\n\\n\\n shutil.copytree(self.caminho1, self.pasta)\",\n \"def weber_velocity(weber_number, reynolds_number, d=2e-3):\\n sigma = 0.07\\n rho_g = 1.225\\n u_l = velocity_calculator(reynolds_number)\\n u_g = np.sqrt((weber_number*sigma)/(d*rho_g))+u_l\\n return u_g\",\n \"def method_compute_timestep(self):\\n\\n myg = self.cc_data.grid\\n\\n cfl = self.rp.get_param(\\\"driver.cfl\\\")\\n\\n u = self.cc_data.get_var(\\\"x-velocity\\\")\\n v = self.cc_data.get_var(\\\"y-velocity\\\")\\n\\n # the timestep is min(dx/|u|, dy|v|)\\n xtmp = ytmp = 1.e33\\n if not abs(u).max() == 0:\\n xtmp = myg.dx/abs(u.v()).max()\\n if not abs(v).max() == 0:\\n ytmp = myg.dy/abs(v.v()).max()\\n\\n dt = cfl*min(xtmp, ytmp)\\n\\n # We need an alternate timestep that accounts for buoyancy, to\\n # handle the case where the velocity is initially zero.\\n rho = self.cc_data.get_var(\\\"density\\\")\\n rho0 = self.base[\\\"rho0\\\"]\\n rhoprime = self.make_prime(rho, rho0)\\n\\n g = self.rp.get_param(\\\"lm-atmosphere.grav\\\")\\n\\n F_buoy = (abs(rhoprime*g).v()/rho.v()).max()\\n\\n dt_buoy = np.sqrt(2.0*myg.dx/F_buoy)\\n\\n self.dt = min(dt, dt_buoy)\\n if self.verbose > 0:\\n print(f\\\"timestep is {dt}\\\")\",\n \"def geometric_brownian_motion_log_returns(param):\\n assert isinstance(param, ModelParameters)\\n gbmprocess = np.array(brownian_motion_log_returns(param))\\n sigma_pow_mu_delta = (param.drift - 0.5 * math.pow(param.vol, 2.0)) * param.time_rate\\n return gbmprocess + sigma_pow_mu_delta\",\n \"def backward_G(self):\\n mask = self.mask*0.5 + 0.5\\n\\n self.loss_G_SH = self.criterionS(self.pr_SH*mask, self.gt_SH*mask) * self.opt.lambda_S\\n self.loss_G = self.loss_G_SH\\n\\n if not self.opt.no_brightness:\\n self.loss_G_BA = self.criterionBA(self.pr_BA*mask, self.gt_BA*mask) * self.opt.lambda_BA\\n self.loss_G_BC = 0\\n for i in range(25):\\n gt_BC = self.gt_BC[i][:, :2]\\n bc_num = int(self.gt_BC[i][0, 3].item())\\n pr_BC = self.pr_BC[i]\\n loss_G_BC = util.min_loss_BC_NoBatch(pr_BC, gt_BC, bc_num, self.criterionBC)\\n loss_G_BC = loss_G_BC * self.opt.lambda_BC / 25.0\\n self.loss_G_BC += loss_G_BC\\n\\n loss_B = self.loss_G_BA + self.loss_G_BC\\n self.loss_G += loss_B\\n\\n # Third, LTM Regularization\\n if self.opt.reg_LTM:\\n ltm_mean = torch.mean(self.ltm, dim=0, keepdim=True) # [1, 75, 256, 256]\\n ltm_mean = ltm_mean.expand(self.ltm.size(0), ltm_mean.size(1), ltm_mean.size(2), ltm_mean.size(3)) # [25, 75, 256, 256]\\n self.loss_LTMReg = self.criterionReg(self.ltm, ltm_mean) * self.opt.lambda_regLTM\\n self.loss_G += self.loss_LTMReg\\n\\n\\n self.loss_G.backward()\",\n \"def _compute_gravity_torque(self, curr_date):\\n if self._to_add[0]:\\n body2inertial = self.earth.getBodyFrame().getTransformTo(self.in_frame, curr_date)\\n body2sat = self.inertial2Sat.applyTo(body2inertial.getRotation())\\n sat2body = body2sat.revert()\\n\\n satM = self.state_observer.spacecraftState.getMass()\\n mCub = self.inCub['mass_frac'] * satM\\n\\n self._gTorque = Vector3D.ZERO\\n\\n for CoM in self.inCub['CoM']:\\n\\n S_dmPos = self.satPos_s.add(CoM)\\n\\n r2 = S_dmPos.getNormSq()\\n gNewton = Vector3D(-self.muGM / (sqrt(r2) * r2), S_dmPos)\\n\\n B_dmPos = sat2body.applyTo(S_dmPos)\\n\\n gDist = Vector3D(self.GravityModel.gradient(curr_date,\\n B_dmPos,\\n self.muGM))\\n\\n g_Dist_s = body2sat.applyTo(gDist)\\n\\n dmForce = Vector3D(mCub, gNewton.add(g_Dist_s))\\n self._gTorque = self._gTorque.add(self.V3_cross(CoM, dmForce))\\n\\n else:\\n self._gTorque = Vector3D.ZERO\",\n \"def spin_gap(B, g_ex):\\n\\n return mu_bohr * g_ex * B / k_b\",\n \"def ObserverGravity(latitude, height):\\n s2 = math.sin(math.radians(latitude)) ** 2\\n g0 = 9.7803253359 * (1.0 + 0.00193185265241*s2) / math.sqrt(1.0 - 0.00669437999013*s2)\\n return g0 * (1.0 - (3.15704e-07 - 2.10269e-09*s2)*height + 7.37452e-14*height*height)\",\n \"def reward_function(self):\\r\\n def R(state, decision, nodes):\\r\\n return -1.0/1000*nodes['G'].get_preds_value(state)*(decision['G:R_1']+decision['G:L'])\\r\\n \\r\\n return R\",\n \"def _calc_g(self, lambdify=True):\\n g = None\\n g_func = None\\n # check to see if we have our gravity term saved in file\\n g, g_func = self._load_from_file('g', lambdify)\\n\\n if g is None and g_func is None:\\n # if no saved file was loaded, generate function\\n print('Generating gravity compensation function')\\n\\n # get the Jacobians for each link's COM\\n J_links = [self._calc_J('link%s' % ii, x=self.x_zeros,\\n lambdify=False)\\n for ii in range(self.N_LINKS)]\\n J_joints = [self._calc_J('joint%s' % ii, x=self.x_zeros,\\n lambdify=False)\\n for ii in range(self.N_JOINTS)]\\n\\n # sum together the effects of each arm segment's inertia\\n g = sp.zeros(self.N_JOINTS, 1)\\n for ii in range(self.N_LINKS):\\n # transform each inertia matrix into joint space\\n g += (J_links[ii].T * self._M_LINKS[ii] * self.gravity)\\n # sum together the effects of each joint's inertia on each motor\\n for ii in range(self.N_JOINTS):\\n # transform each inertia matrix into joint space\\n g += (J_joints[ii].T * self._M_JOINTS[ii] * self.gravity)\\n g = sp.Matrix(g)\\n\\n # save to file\\n abr_control.utils.os_utils.makedirs(\\n '%s/g' % self.config_folder)\\n cloudpickle.dump(g, open(\\n '%s/g/g' % self.config_folder, 'wb'))\\n\\n if lambdify is False:\\n # if should return expression not function\\n return g\\n\\n if g_func is None:\\n g_func = self._generate_and_save_function(\\n filename='g', expression=g,\\n parameters=self.q)\\n return g_func\",\n \"def generalisedDecayConstant(ep, epp, g, G, Q_decay):\\n # Calculate the total branching from the excited state to all ground states\\n sum_decay_channels_epg = 0\\n sum_decay_channels_eppg = 0\\n for gp in G:\\n for q in Q_decay:\\n sum_decay_channels_epg += abs(coupling(ep, gp, q)*coupling(ep, gp, q))\\n sum_decay_channels_eppg += abs(coupling(epp, gp, q)*coupling(epp, gp, q))\\n\\n # Calculate the decay constants separately\\n gamma_epg = 0\\n gamma_eppg = 0\\n for q in Q_decay:\\n gamma_epg += abs(coupling(ep, g, q)*coupling(ep, g, q))\\n gamma_eppg += abs(coupling(epp, g, q)*coupling(epp, g, q))\\n\\n gamma_epg = gamma_epg/(sum_decay_channels_epg)\\n gamma_eppg = gamma_eppg/(sum_decay_channels_eppg)\\n\\n # Calculate the generalised decay constant\\n gamma_epeppg = np.power(gamma_epg*gamma_eppg, 0.5)\\n # Calculate the sign: only one polarisation will result in non-zero coupling so can sum over all\\n for q in Q_decay:\\n if(coupling(ep, g, q)*coupling(epp, g, q) < 0): \\n gamma_epeppg = -1*gamma_epeppg\\n return gamma_epeppg\",\n \"def Gtilde(x):\\n gt1 = 1.808 * cbrt(x) / np.sqrt(1 + 3.4 * cbrt(x) ** 2.)\\n gt2 = 1 + 2.210 * cbrt(x) ** 2. + 0.347 * cbrt(x) ** 4.\\n gt3 = 1 + 1.353 * cbrt(x) ** 2. + 0.217 * cbrt(x) ** 4.\\n return gt1 * (gt2 / gt3) * np.exp(-x)\",\n \"def GJframe():\\n beta0 = pomega.Vect() * (1 / pomega[3])\\n pomega.Boost(-beta0)\\n pbeam.Boost(-beta0)\\n ptarg.Boost(-beta0)\\n precoil.Boost(-beta0)\\n theta0 = pbeam.Theta()\\n phi0 = pbeam.Phi()\\n pbeam.RotateZ(-phi0)\\n ptarg.RotateZ(-phi0)\\n precoil.RotateZ(-phi0)\\n pbeam.RotateY(-theta0)\\n precoil.RotateY(-theta0)\\n psi0 = precoil.Phi()\\n ptarg.RotateZ(-psi0)\\n precoil.RotateZ(-psi0)\\n for g in range(0, 3):\\n pgamma[g].Boost(-beta0)\\n pgamma[g].RotateZ(-phi0)\\n pgamma[g].RotateY(-theta0)\\n pgamma[g].RotateZ(-psi0)\",\n \"def gravity(self, second_object):\\n # Fg = F12 = F21 = G(m1)(m2)/r^2\\n m1, m2 = self.mass, second_object.mass\\n r = self.radial_distance(second_object)\\n return (self.G*m1*m2)/pow(r, 2)\",\n \"def calc_D(state):\\n\\t\\tif t < thresh:\\n\\t\\t\\tstate.D_g[t] = 0.5\\n\\t\\t\\tstate.D_n[t] = 0.5\\n\\t\\telse:\\n\\t\\t\\tif mod == \\\"constant\\\":\\n\\t\\t\\t\\tstate.D_g[t] = D\\n\\t\\t\\t\\tstate.D_n[t] = 1-D\\n\\t\\t\\tif mod == \\\"value\\\":\\n\\t\\t\\t\\t# NOTE: if rmag and lmag is 1/0, can just use V\\n\\t\\t\\t\\t# average of two actions\\n\\t\\t\\t\\tV = np.mean(1/2*(state.QG[t,:] - state.QN[t,:])) # state average(?) \\n\\t\\t\\t\\tV = 1/(1 + np.exp(-V*k)) # translate between 0 and 1\\n\\t\\t\\t\\tstate.D_g[t] = V \\n\\t\\t\\t\\tstate.D_n[t] = 1 - V\\n\\t\\treturn state\",\n \"def leapfrog(params, momentum, log_prob_func, steps=10, step_size=0.1, jitter=0.01, normalizing_const=1., softabs_const=1e6, explicit_binding_const=100, fixed_point_threshold=1e-20, fixed_point_max_iterations=6, jitter_max_tries=10, inv_mass=None, ham_func=None, sampler=Sampler.HMC, integrator=Integrator.IMPLICIT, metric=Metric.HESSIAN, store_on_GPU = True, debug=False, pass_grad = None):\\n\\n params = params.clone(); momentum = momentum.clone()\\n # TodO detach graph when storing ret_params for memory saving\\n if sampler == Sampler.HMC and integrator != Integrator.SPLITTING and integrator != Integrator.SPLITTING_RAND and integrator != Integrator.SPLITTING_KMID:\\n def params_grad(p):\\n p = p.detach().requires_grad_()\\n log_prob = log_prob_func(p)\\n # log_prob.backward()\\n p = collect_gradients(log_prob, p, pass_grad)\\n # print(p.grad.std())\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n return p.grad\\n ret_params = []\\n ret_momenta = []\\n momentum += 0.5 * step_size * params_grad(params)\\n for n in range(steps):\\n if inv_mass is None:\\n params = params + step_size * momentum #/normalizing_const\\n else:\\n #Assum G is diag here so 1/Mass = G inverse\\n if type(inv_mass) is list:\\n i = 0\\n for block in inv_mass:\\n it = block[0].shape[0]\\n params[i:it+i] = params[i:it+i] + step_size * torch.matmul(block,momentum[i:it+i].view(-1,1)).view(-1) #/normalizing_const\\n i += it\\n elif len(inv_mass.shape) == 2:\\n params = params + step_size * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params = params + step_size * inv_mass * momentum #/normalizing_const\\n p_grad = params_grad(params)\\n momentum += step_size * p_grad\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n # only need last for Hamiltoninian check (see p.14) https://arxiv.org/pdf/1206.1901.pdf\\n ret_momenta[-1] = ret_momenta[-1] - 0.5 * step_size * p_grad.clone()\\n # import pdb; pdb.set_trace()\\n return ret_params, ret_momenta\\n elif sampler == Sampler.RMHMC and (integrator == Integrator.IMPLICIT or integrator == Integrator.S3):\\n if integrator is not Integrator.S3:\\n ham_func = None\\n # Else we are doing semi sep and need auxiliary for Riemann version.\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\\n\\n def fixed_point_momentum(params, momentum):\\n momentum_old = momentum.clone()\\n # print('s')\\n for i in range(fixed_point_max_iterations):\\n momentum_prev = momentum.clone()\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n # import pdb; pdb.set_trace()\\n raise util.LogProbError()\\n # import pdb; pdb.set_trace()\\n # break\\n\\n momentum = momentum_old - 0.5 * step_size * params.grad\\n momenta_diff = torch.max((momentum_prev-momentum)**2)\\n if momenta_diff < fixed_point_threshold:\\n break\\n if debug == 1:\\n print('Converged (momentum), iterations: {}, momenta_diff: {}'.format(i, momenta_diff))\\n return momentum\\n\\n def fixed_point_params(params, momentum):\\n params_old = params.clone()\\n momentum = momentum.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n momentum = collect_gradients(ham,momentum)\\n momentum_grad_old = momentum.grad.clone()\\n for i in range(fixed_point_max_iterations):\\n params_prev = params.clone()\\n momentum = momentum.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n momentum = collect_gradients(ham,momentum)#collect_gradients(ham, params)\\n params = params_old + 0.5 * step_size * momentum.grad + 0.5 * step_size * momentum_grad_old\\n params_diff = torch.max((params_prev-params)**2)\\n if params_diff < fixed_point_threshold:\\n break\\n if debug == 1:\\n print('Converged (params), iterations: {}, params_diff: {}'.format(i, params_diff))\\n return params\\n ret_params = []\\n ret_momenta = []\\n for n in range(steps):\\n # import pdb; pdb.set_trace()\\n momentum = fixed_point_momentum(params, momentum)\\n params = fixed_point_params(params, momentum)\\n\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n raise util.LogProbError()\\n # break\\n momentum -= 0.5 * step_size * params.grad\\n\\n ret_params.append(params)\\n ret_momenta.append(momentum)\\n return ret_params, ret_momenta\\n\\n elif sampler == Sampler.RMHMC and integrator == Integrator.EXPLICIT:\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\\n\\n #During leapfrog define integrator as implict when passing into riemannian_hamiltonian\\n leapfrog_hamiltonian_flag = Integrator.IMPLICIT\\n def hamAB_grad_params(params,momentum):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n # import pdb; pdb.set_trace()\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n raise util.LogProbError()\\n # import pdb; pdb.set_trace()\\n # break\\n\\n return params.grad\\n def hamAB_grad_momentum(params,momentum):\\n momentum = momentum.detach().requires_grad_()\\n params = params.detach().requires_grad_()\\n # Can't detach p as we still need grad to do derivatives\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n # import pdb; pdb.set_trace()\\n momentum = collect_gradients(ham,momentum)\\n return momentum.grad\\n ret_params = []\\n ret_momenta = []\\n params_copy = params.clone()\\n momentum_copy = momentum.clone()\\n for n in range(steps):\\n # \\\\phi_{H_A}\\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\\n # \\\\phi_{H_B}\\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\\n # \\\\phi_{H_C}\\n c = torch.cos(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\\n s = torch.sin(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\\n # params_add = params + params_copy\\n # params_sub = params - params_copy\\n # momentum_add = momentum + momentum_copy\\n # momentum_sub = momentum - momentum_copy\\n # ### CHECK IF THE VALUES ON THE RIGHT NEED TO BE THE OLD OR UPDATED ones\\n # ### INSTINCT IS THAT USING UPDATED ONES IS BETTER\\n # params = 0.5 * ((params_add) + c*(params_sub) + s*(momentum_sub))\\n # momentum = 0.5 * ((momentum_add) - s*(params_sub) + c*(momentum_sub))\\n # params_copy = 0.5 * ((params_add) - c*(params_sub) - s*(momentum_sub))\\n # momentum_copy = 0.5 * ((momentum_add) + s*(params_sub) - c*(momentum_sub))\\n params = 0.5 * ((params+params_copy) + c*(params-params_copy) + s*(momentum-momentum_copy))\\n momentum = 0.5 * ((momentum+momentum_copy) - s*(params-params_copy) + c*(momentum-momentum_copy))\\n params_copy = 0.5 * ((params+params_copy) - c*(params-params_copy) - s*(momentum-momentum_copy))\\n momentum_copy = 0.5 * ((momentum+momentum_copy) + s*(params-params_copy) - c*(momentum-momentum_copy))\\n\\n\\n # \\\\phi_{H_B}\\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\\n # \\\\phi_{H_A}\\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n return [ret_params,params_copy], [ret_momenta, momentum_copy]\\n\\n # PAGE 35 MCMC Using Hamiltonian dynamics (Neal 2011)\\n elif sampler == Sampler.HMC and (integrator == Integrator.SPLITTING or integrator == Integrator.SPLITTING_RAND or Integrator.SPLITTING_KMID):\\n if type(log_prob_func) is not list:\\n raise RuntimeError('For splitting log_prob_func must be list of functions')\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for splitting')\\n\\n def params_grad(p,log_prob_func):\\n # OLD:\\n # p = p.detach().requires_grad_()\\n # log_prob = log_prob_func(p)\\n # # log_prob.backward()\\n # p = collect_gradients(log_prob, p)\\n # grad = p.grad\\n # # For removing GPU memory for large data sets.\\n # del p, log_prob\\n # torch.cuda.empty_cache()\\n\\n p = p.detach().requires_grad_()\\n log_prob = log_prob_func(p)\\n # Need to check memory issues in collect_gradients\\n grad = torch.autograd.grad(log_prob,p)[0]\\n # For removing GPU memory for large data sets.\\n del p, log_prob, log_prob_func\\n torch.cuda.empty_cache()\\n return grad\\n\\n params = params.detach() # Detach as we do not need to remember graph until we pass into log_prob\\n ret_params = []\\n ret_momenta = []\\n if integrator == Integrator.SPLITTING:\\n M = len(log_prob_func)\\n K_div = (M - 1) * 2\\n if M == 1:\\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\\n for n in range(steps):\\n # Symmetric loop to ensure reversible\\n for m in range(M):\\n # print('p ',n)\\n grad = params_grad(params,log_prob_func[m])\\n with torch.no_grad():\\n momentum += 0.5 * step_size * grad\\n del grad\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n if m < M-1:\\n # print('q ',n)\\n if inv_mass is None:\\n params += (step_size/K_div) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\\n for m in reversed(range(M)):\\n # print('p ', n )\\n grad = params_grad(params,log_prob_func[m])\\n with torch.no_grad():\\n momentum += 0.5 * step_size * grad\\n del grad\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n if m > 0:\\n # print('q ', n-1)\\n if inv_mass is None:\\n params += (step_size/K_div) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\\n\\n if store_on_GPU:\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n else:\\n ret_params.append(params.clone().cpu())\\n ret_momenta.append(momentum.clone().cpu())\\n elif integrator == Integrator.SPLITTING_RAND:\\n M = len(log_prob_func)\\n idx = torch.randperm(M)\\n for n in range(steps):\\n # \\\"Labelling of subsets is randomised for each iteration\\\"\\n # idx = torch.randperm(M)\\n for m in range(M):\\n # print('p ',n)\\n momentum += 0.5 * step_size * params_grad(params, log_prob_func[idx[m]])\\n # print('q ',n)\\n if inv_mass is None:\\n params += (step_size/M) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/M) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/M) * inv_mass * momentum #/normalizing_const\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[idx[m]])\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n # import pdb; pdb.set_trace()\\n\\n\\n elif integrator == Integrator.SPLITTING_KMID:\\n M = len(log_prob_func)\\n if M == 1:\\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\\n for n in range(steps):\\n # Symmetric loop to ensure reversible\\n for m in range(M):\\n # print('p ',n)\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\\n\\n if inv_mass is None:\\n params = params + (step_size) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params = params + (step_size) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params = params + (step_size) * inv_mass * momentum #/normalizing_const\\n\\n for m in reversed(range(M)):\\n # print('p ', n )\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n\\n return ret_params, ret_momenta\\n\\n else:\\n raise NotImplementedError()\",\n \"def get_rm(g):\\n return 1 / g\",\n \"def gdm(x0,gradient,learning_rate=0.01,momentum_weight=0.9,iterations=100,\\n initial_momentum=0,**kwargs):\\n momentum = initial_momentum\\n for i in range(iterations):\\n momentum = momentum_weight*momentum+(1-momentum_weight)*gradient(x0)\\n x0 -= learning_rate*momentum\\n return x0, momentum\",\n \"def accelerationCalcY(x,y):\\r\\n global G #glabel variables are initialised\\r\\n global massEarth\\r\\n return (-G*massEarth*y)/((x**2+y**2)**(3/2))# here from Newton's law of gravitation we return the acceleration on a projectile in the y direction\\r\",\n \"def gravitation_force(self, other):\\n force = ((CONSTANTS.G * self.mass * other.mass) /\\n (self.distance(other) ** 2))\\n return force\",\n \"def mv_delay(self):\\n return self._TERRAINS[self.terrain]['delay']\",\n \"def DDdelay(self):\\n return self.delayInverse()+self.delayS()+self.delayA()\",\n \"def g(self, x):\\n return x * (1 - x)\",\n \"def derivative(r, t, G=6.67e-11, AU=1.496e+11,\\n m1=5.972e+24, m2=6.417e+23, m3=1.989e+30,\\n a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n if G < 0:\\n print(f\\\"The gravitational constant is negative\\\")\\n\\n if AU < 0:\\n print(f\\\"The Astronomical unit is negative\\\")\\n\\n if m1 < 0:\\n print(f\\\"The mass of the first body is negative\\\")\\n\\n if m2 < 0:\\n print(f\\\"The mass of the second body is negative\\\")\\n\\n if m3 < 0:\\n print(f\\\"The mass of the third body is negative\\\")\\n\\n if a1 < 0:\\n print(f\\\"The distance of body 1 from the body center is negative\\\")\\n\\n if a2 < 0:\\n print(f\\\"The distance of body 2 from the body center is negative\\\")\\n\\n x1 = r[0]\\n y1 = r[1]\\n v_x1 = r[2]\\n v_y1 = r[3]\\n\\n x2 = r[4]\\n y2 = r[5]\\n v_x2 = r[6]\\n v_y2 = r[7]\\n\\n x3 = r[8]\\n y3 = r[9]\\n v_x3 = r[10]\\n v_y3 = r[11]\\n\\n z1 = r[12]\\n z2 = r[13]\\n z3 = r[14]\\n\\n v_z1 = r[15]\\n v_z2 = r[16]\\n v_z3 = r[17]\\n\\n r1 = np.array([x1, y1, z1])\\n r2 = np.array([x2, y2, z2])\\n r3 = np.array([x3, y3, z3])\\n\\n dr1 = v_x1\\n dr2 = v_y1\\n\\n dr3 = (G*m2/distance(r1, r2)**3)*(x2-x1) + (G*m3/distance(r1, r3)**3)*(x3-x1)\\n dr4 = (G*m2/distance(r1, r2)**3)*(y2-y1) + (G*m3/distance(r1, r3)**3)*(y3-y1)\\n\\n dr5 = v_x2\\n dr6 = v_y2\\n\\n dr7 = (G*m1/distance(r1, r2)**3)*(x1-x2) + (G*m3/distance(r2, r3)**3)*(x3-x2)\\n dr8 = (G*m1/distance(r1, r2)**3)*(y1-y2) + (G*m3/distance(r2, r3)**3)*(y3-y2)\\n\\n dr9 = v_x3\\n dr10 = v_y3\\n\\n dr11 = (G*m1/distance(r1, r3)**3)*(x1-x3) + (G*m2/distance(r2, r3)**3)*(x2-x3)\\n dr12 = (G*m1/distance(r1, r3)**3)*(y1-y3) + (G*m2/distance(r2, r3)**3)*(y2-y3)\\n\\n dr13 = v_z1\\n dr14 = v_z2\\n dr15 = v_z3\\n\\n dr16 = (G*m2/distance(r1, r2)**3)*(z2-z2) + (G*m3/distance(r1, r3)**3)*(z3-z1)\\n dr17 = (G*m3/distance(r2, r3)**3)*(z1-z2) + (G*m1/distance(r2, r1)**3)*(z1-z2)\\n dr18 = (G*m1/distance(r1, r3)**3)*(z1-z3) + (G*m2/distance(r2, r3)**3)*(z2-z3)\\n\\n dr = np.array([dr1, dr2, dr3, dr4, dr5, dr6,\\n dr7, dr8, dr9, dr10, dr11, dr12,\\n dr13, dr14, dr15, dr16, dr17, dr18])\\n\\n return dr\",\n \"def G(U):\\n n = U.shape[0]\\n G_U = np.zeros([n,1])\\n DELTA_x = float(2*L)/(n-1)\\n for i in range(n):\\n G_U[i][0] = U[(i+1)%n][0]\\n G_U[i][0] -= U[(i-1)%n][0]\\n G_U[i][0] /= (2* DELTA_x)\\n G_U[i][0] += (float(epsilon) * (U[(i+1)%n][0]- U[(i-1)%n][0]) * (U[(i-1)%n][0]+U[(i+1)%n][0]+ U[i][0])/ (4* DELTA_x))\\n G_U[i][0] += (float(epsilon) * (U[(i+2)%n][0]- 2*U[(i+1)%n][0]+ 2*U[(i-1)%n][0]- U[(i-2)%n][0]) / (12*( DELTA_x**3)))\\n return G_U\",\n \"def _calpara(self):\\n self.up = math.exp(self.sigma*math.sqrt(self.deltatime))\\n self.down = math.exp(-self.sigma*math.sqrt(self.deltatime))\\n self.upprob = (math.exp((self.r-self.d)*self.deltatime)-self.down)/(self.up-self.down)\",\n \"def roemer_delay(epoch, ecl_latitude, ecl_longitude, ephemeris='de432s'):\\n\\n # before computing anythin, set the ephemeris context to be value \\n # supplied at the function call.\\n solar_system_ephemeris.set(ephemeris)\\n time = Time(epoch, format='mjd')\\n\\n # now comoute the required position vectors.\\n r_earth = get_body_barycentric('earth', time)\\n s_pulsar = pulsar_position_ecliptic(ecl_latitude, ecl_longitude)\\n\\n # finally, compute and return the delay.\\n delay = r_earth.dot(s_pulsar).to(u.m) / c\\n\\n return delay\",\n \"def P2G_func(self, dt, P):\\n p_C = ti.static(self.p_C)\\n p_v = ti.static(self.p_v)\\n p_x = ti.static(self.p_x)\\n g_m = ti.static(self.g_m)\\n g_v = ti.static(self.g_v)\\n p_F = ti.static(self.p_F)\\n p_Jp = ti.static(self.p_Jp)\\n\\n base = ti.floor(g_m.getG(p_x[P] - 0.5 * g_m.dx)).cast(Int)\\n fx = g_m.getG(p_x[P]) - base.cast(Float)\\n\\n # Here we adopt quadratic kernels\\n w = [0.5 * (1.5 - fx) ** 2, 0.75 - (fx - 1) ** 2, 0.5 * (fx - 0.5) ** 2]\\n # dw = [fx - 1.5, -2.0 * (fx - 1), fx - 0.5]\\n\\n # # TODO affine would do this in P2G.. why\\n # p_F[P] = (ti.Matrix.identity(Int, self.dim) + dt * p_C[P]) @ p_F[P]\\n\\n force = ti.Matrix.zero(Float, self.dim, self.dim)\\n # want to decrease branching\\n if self.p_material_id[P] == MaType.elastic:\\n force = self.elasticP2Gpp(P, dt)\\n elif self.p_material_id[P] == MaType.liquid:\\n force = self.liquidP2Gpp(P, dt)\\n elif self.p_material_id[P] == MaType.snow:\\n force = self.snowP2Gpp(P, dt)\\n elif self.p_material_id[P] == MaType.sand:\\n force = self.sandP2Gpp(P, dt)\\n\\n affine = force + self.cfg.p_mass * p_C[P]\\n for offset in ti.static(ti.grouped(self.stencil_range3())):\\n # print(\\\"P2G: \\\", offset)\\n dpos = g_m.getW(offset.cast(Float) - fx)\\n\\n weight = 1.0\\n for d in ti.static(range(self.dim)):\\n weight *= w[offset[d]][d]\\n\\n # dweight = ts.vecND(self.dim, self.cfg.inv_dx)\\n # for d1 in ti.static(range(self.dim)):\\n # for d2 in ti.static(range(self.dim)):\\n # if d1 == d2:\\n # dweight[d1] *= dw[offset[d2]][d2]\\n # else:\\n # dweight[d1] *= w[offset[d2]][d2]\\n\\n # force = - self.cfg.p_vol * kirchoff @ dweight\\n # TODO ? AFFINE\\n # g_v[base + offset] += self.cfg.p_mass * weight * (p_v[P] + p_C[P] @ dpos) # momentum transfer\\n # TODO Got lots of simultaneous atomic here\\n g_v[base + offset] += weight * (self.cfg.p_mass * self.p_v[P] + affine @ dpos)\\n g_m[base + offset] += weight * self.cfg.p_mass\\n\\n # g_v[base + offset] += dt * force\",\n \"def gibbs_(dict_, T):\\n\\tdST = dict_['S298'] + CpT(dict_, T)[0]\\n\\t\\t\\n\\tdHT = dict_['dH298'] + CpT(dict_, T)[1]/1000\\n\\t\\t\\n\\treturn (dHT - T*dST/1000)\",\n \"def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):\\n t = 0.0\\n # Establish lists with initial position and velocity components and time.\\n x_list = [x]\\n y_list = [y]\\n z_list = [z]\\n vx_list = [vx]\\n vy_list = [vy]\\n vz_list = [vz]\\n t_list = [t]\\n\\n # Set up visual elements.\\n mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)\\n plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)\\n ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)\\n ball.trail = visual.curve(color=ball.color)\\n\\n while y >= 0.0:\\n visual.rate(100) # Limit to no more than 100 iterations per second.\\n t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)\\n x_list.append(x)\\n y_list.append(y)\\n z_list.append(z)\\n vx_list.append(vx)\\n vy_list.append(vy)\\n vz_list.append(vz)\\n t_list.append(t)\\n ball.pos = (x,y,z)\\n ball.trail.append(pos=ball.pos)\\n\\n return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list\",\n \"def compute_gdp_mu(sampling_rate, sigma, steps):\\n return sampling_rate * np.sqrt(steps * (np.exp(1 / sigma**2) - 1) )\",\n \"def delayA(self):\\n omgPlusAe = self.omega()+self.nu()\\n et = self.ecc()\\n sinOmg = np.sin(self.omega())\\n cosOmg = np.cos(self.omega())\\n aDelay = self.A0*(np.sin(omgPlusAe)+et*sinOmg)+\\\\\\n self.B0*(np.cos(omgPlusAe)+et*cosOmg)\\n return aDelay\",\n \"def g(self, RD):\\n g = 1 / np.sqrt((1 + 3 * np.power(self.q, 2)) / np.power(np.pi, 2)) \\n \\n return g\",\n \"def M_g(self):\\n\\n print(\\\"\\\", file=self.logfile)\\n print(\\\"Updating g\\\", file=self.logfile)\\n M_mu1 = np.lib.stride_tricks.as_strided(self.mu_pad,\\n shape=[self.P+1, self.L_h],\\n strides=[self.mu_pad.strides[-1], self.mu_pad.strides[-1]])\\n\\n M_mu1 = M_mu1[::-1,:]\\n M_mu2 = np.transpose(M_mu1[1:,:])\\n M_mu1 = M_mu1*self.e2\\n\\n M_mu = np.dot(M_mu1, M_mu2)\\n v_mu = M_mu[0,:]\\n M_mu = M_mu[1:,:]\\n\\n M_R = np.zeros((self.P,self.P+1))\\n for p in range(1,self.P+1):\\n for q in range(0,self.P+1):\\n M_R[p-1,q] = np.sum(np.diag(self.R, q-p)[:self.L_h-max(p,q)]*self.e2[max(p,q):self.L_h])\\n\\n v_R = M_R[:,0]\\n M_R = M_R[:,1:]\\n\\n self.alpha_g = np.dot(np.linalg.inv(M_mu + M_R), v_mu+v_R)\\n self.A = np.concatenate([[1], -self.alpha_g])\\n\\n self._propagate_A()\",\n \"def g(z):\\n return 1. / (1. + np.exp(-z))\",\n \"def sgdgc(cost, params, lr=1.0, max_magnitude=5.0, infDecay=0.1):\\n grads = T.grad(cost=cost, wrt=params)\\n updates = []\\n\\n norm = norm_gs(params, grads)\\n sqrtnorm = T.sqrt(norm)\\n #not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\\n\\n for p, g in zip(params, grads):\\n #g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\\n updates.append((p, p - lr * g * adj_norm_gs)) \\n \\n return updates, norm\",\n \"def sgdmgc(cost, params, lr=1.0, alpha=0.1, max_magnitude=5.0, infDecay=0.1):\\n grads = T.grad(cost=cost, wrt=params)\\n updates = []\\n\\n norm = norm_gs(params, grads)\\n sqrtnorm = T.sqrt(norm)\\n not_finite = T.or_(T.isnan(sqrtnorm), T.isinf(sqrtnorm))\\n adj_norm_gs = T.switch(T.ge(sqrtnorm, max_magnitude), max_magnitude / sqrtnorm, 1.)\\n\\n for p, g in zip(params, grads):\\n v = shared(p.get_value() * 0.)\\n g = T.switch(not_finite, infDecay * p, g * adj_norm_gs)\\n v_new = v * (1.0 - alpha) - alpha * lr * g\\n updates.append((v, v_new))\\n updates.append((p, p + v_new ))\\n \\n return updates, norm\",\n \"def acceleration_n_pendulum(t, state, kwargs, g = -9.81):\\n # \\\"Parallel simulation of large scale multibody systems\\\" by Kloppel et al.\\n #Source: https://onlinelibrary.wiley.com/doi/pdf/10.1002/pamm.201510327\\n L = kwargs['L']\\n N = len(state)//2\\n last = N-1\\n \\n A = [ sin(state[i]) * (N-i) * g / L[i] for i in range(N) ]\\n for i in range(N):\\n total = 0\\n for j in range(i):\\n total += sin( state[j] - state[i] ) * state[N+j] ** 2\\n A[i] += (N-i) * total\\n for j in range(i+1,N):\\n A[i] += (N-j) * sin( state[j] - state[i] ) * state[N+j] ** 2\\n \\n M = [ [ 0 for j in range(N) ] for i in range(N) ]\\n for i in range(N):\\n for j in range(N):\\n M[i][j] = (N - max(i,j)) * cos(state[j]-state[i])\\n \\n M = np.asarray(M)\\n M = np.linalg.inv(M)\\n d_state = state.copy()\\n d_state[:N] = state[N:]\\n d_state[N:] = np.dot(M,A)\\n return d_state\",\n \"def fGasBulkModulus(GasGravity, Temperature, Pressure):\\n\\tGasConstant = 8.314\\n\\tTemp = Temperature + 273.16 # Deg K\\n\\tPress = (Pressure / 145.038) # MPa\\n\\tPr = Press / (4.892 - (0.4048 * GasGravity))\\n\\tTr = Temp / (94.72 + (170.75 * GasGravity))\\n\\tA = 0.03 + (0.00527 * ((3.5 - Tr)**3))\\n\\tB = (0.642 * Tr) - (0.007 * (Tr**4)) - 0.52\\n\\tC = 0.109 * ((3.85 - Tr)**2)\\n\\tD = exp(-((0.45 + (8 * ((0.56 - (1 / Tr))**2))) * ((Pr ** 1.2) / Tr)))\\n\\tZ = (A * Pr) + B + (C * D)\\n\\tRg = ((28.8 * GasGravity * Press) / (Z * GasConstant * Temp))\\n\\tG = 0.85 + (5.6 / (Pr + 2)) + (27.1 / ((Pr + 3.5)**2)) - (8.7 * exp(-0.65 * (Pr + 1)))\\n\\tM = (1.2 * (-1 * (0.45 + (8 * ((0.56 - (1 / Tr))**2))) * ((Pr**0.2) / Tr)))\\n\\tF = (C * D * M) + A\\n\\treturn 1e6 * (((Press * G) / (1-(Pr * F / Z)))) # Pa\",\n \"def timeintegrand(z,omegalambda,omegam,omegak):\\n\\n return 1./((1+z)*adotovera(z,omegalambda,omegam,omegak))\",\n \"def gaussianPulse(self, sigma, delay, amplitude=1.):\\n def gaussianFunction(t, t0, sigma, amp=1):\\n v = amp * numpy.exp(-(t - float(t0))**2 / (2 * sigma**2))\\n return v\\n\\n shape = zeros(20000)\\n for t in range(int(delay - 2 * sigma), int(delay + 2 * sigma)):\\n shape[t] = gaussianFunction(t, delay, sigma, amp=amplitude)\\n return shape\",\n \"def cost(self):\\n\\t\\treturn self.g + self.h\",\n \"def backward_G(self):\\n # First, G(A) should fake the discriminator\\n if self.TPN_enabled:\\n fake_AB = torch.cat((self.true_time_layer, self.real_A, self.fake_B), 1)\\n else:\\n fake_AB = torch.cat((self.real_A, self.fake_B), 1)\\n pred_fake = self.netD(fake_AB)\\n self.loss_G_GAN = self.criterionGAN(pred_fake, True)\\n \\n # Second, G(A) = B\\n # Weighted L1 Loss\\n if self.opt.lambda_L2 > 0: # If lambda_L2 is not > 0, no need to perform extra computation\\n fake_B_tumour = self.fake_B.clone().detach()\\n real_B_tumour = self.real_B.clone().detach()\\n fake_B_tumour[fake_B_tumour < 0.5] = 0\\n real_B_tumour[fake_B_tumour < 0.5] = 0\\n self.loss_G_L1 = self.opt.lambda_L1 * (self.criterionL1(self.fake_B, self.real_B) * (1 - self.opt.lambda_L2) + \\\\\\n self.criterionL1(fake_B_tumour, real_B_tumour) * self.opt.lambda_L2)\\n else:\\n ### ORIGINAL ###\\n self.loss_G_L1 = self.criterionL1(self.fake_B, self.real_B) * self.opt.lambda_L1\\n\\n # TPN Loss\\n if self.TPN_enabled:\\n true_time_tensor = torch.ones(self.fake_time.shape) * self.true_time\\n self.loss_G_TPN = self.criterionL1(true_time_tensor, self.fake_time.cpu()) * self.opt.gamma\\n # combine loss and calculate gradients\\n self.loss_G = self.loss_G_GAN + self.loss_G_L1 + self.loss_G_TPN.to(self.device)\\n else:\\n # combine loss and calculate gradients\\n self.loss_G = self.loss_G_GAN + self.loss_G_L1\\n\\n self.loss_G.backward()\",\n \"def expected_g(self):\\n raise NotImplementedError()\\n # \\\\sum_{b} \\\\gamma_b\\n trm2 = self.mf_gamma.sum(axis=2)\\n E_g = self.mf_gamma / trm2[:,:,None]\\n return E_g\",\n \"def _reward(self):\\n # Clock reward -----------------------------------------------------------------\\n A, B = self.get_von_mises(0.0, self.ratio, self.kappa)\\n phi = self.phase / self.cycle_len\\n #print('Cycles completed = ', self.cycle_complete)\\n\\n #print('A, B = ', (A,B))\\n\\n phi_FL = self.wrap(phi + self.theta_FL)\\n phi_FR = self.wrap(phi + self.theta_FR)\\n phi_RL = self.wrap(phi + self.theta_RL)\\n phi_RR = self.wrap(phi + self.theta_RR)\\n\\n #print(phi_FL)\\n #print(phi_FR)\\n #print(phi_RL)\\n #print(phi_RR)\\n\\n FL_swing = self.in_swing(A, B, phi_FL)\\n FR_swing = self.in_swing(A, B, phi_FR)\\n RL_swing = self.in_swing(A, B, phi_RL)\\n RR_swing = self.in_swing(A, B, phi_RR)\\n\\n #print('Time since reset = ', self.rex.GetTimeSinceReset())\\n #print('phase phi = ', phi)\\n #print('FL swing = ', FL_swing)\\n #print('FR swing = ', FR_swing)\\n #print('RL swing = ', RL_swing)\\n #print('RR swing = ', RR_swing)\\n\\n if FL_swing:\\n c_swing_frc_FL = 1\\n c_swing_spd_FL = 0\\n else:\\n c_swing_frc_FL = 0\\n c_swing_spd_FL = 1\\n\\n if FR_swing:\\n c_swing_frc_FR = 1\\n c_swing_spd_FR = 0\\n else:\\n c_swing_frc_FR = 0\\n c_swing_spd_FR = 1\\n\\n if RL_swing:\\n c_swing_frc_RL = 1\\n c_swing_spd_RL = 0\\n else:\\n c_swing_frc_RL = 0\\n c_swing_spd_RL = 1\\n\\n if RR_swing:\\n c_swing_frc_RR = 1\\n c_swing_spd_RR = 0\\n else:\\n c_swing_frc_RR = 0\\n c_swing_spd_RR = 1\\n\\n FL_foot_force, FR_foot_force, RL_foot_force, RR_foot_force = self.get_contact_forces()\\n FL_vel, FR_vel, RL_vel, RR_vel = self.get_foot_velocities()\\n\\n FL_penalty = c_swing_frc_FL*FL_foot_force + c_swing_spd_FL*FL_vel\\n FR_penalty = c_swing_frc_FR*FR_foot_force + c_swing_spd_FR*FR_vel\\n RL_penalty = c_swing_frc_RL*RL_foot_force + c_swing_spd_RL*RL_vel\\n RR_penalty = c_swing_frc_RR*RR_foot_force + c_swing_spd_RR*RR_vel\\n\\n foot_penalties = FL_penalty + FR_penalty + RL_penalty + RR_penalty\\n \\n # Deviation Penalties ----------------------------------------------------------\\n # Base height\\n base_height = self.rex.GetBasePosition()[-1]\\n height_err = np.abs(base_height - self.height_des)\\n \\n if height_err < 0.02:\\n height_err = 0\\n\\n # Speed \\n vx, vy, _ = p.getBaseVelocity(bodyUniqueId=self.rex.quadruped)[0]\\n vx = -vx # in rex, forward is the negative x direction\\n x_vel_err = 4*np.abs(vx - self.speed) # higher emphasis on x velocity error\\n y_vel_err = np.abs(vy - self.side_speed)\\n\\n # Orientation\\n orient_curr = self.rex.GetBaseOrientation()\\n orient_des = [0, 0, 0, 1] # not exact, but shouldn't be too far from this\\n orient_err = 6 * (1 - np.inner(orient_curr, orient_des)**2 )\\n\\n shoulder_orient_des = [0, 0, 0, 1]\\n FL_sh, FR_sh, RL_sh, RR_sh = self.get_shoulder_orientation()\\n\\n # quaternion similarity: 1 - <q1, q2>**2 == 0 when 100% similar\\n # good when error < 0.01 (individually)\\n # put HUGE penalty on this\\n shoulder_err = 20 * ((1 - np.inner(shoulder_orient_des, FL_sh)**2) + \\n (1 - np.inner(shoulder_orient_des, FR_sh)**2) +\\n (1 - np.inner(shoulder_orient_des, RL_sh)**2) + \\n (1 - np.inner(shoulder_orient_des, RR_sh)**2))\\n\\n # Energy Penalties --------------------------------------------------------------\\n energy_penalty = np.abs(np.dot(self.rex.GetMotorTorques(),\\n self.rex.GetMotorVelocities())) * self._time_step\\n\\n # Acceleration\\n a_trans, a_rot = self.get_base_accelerations()\\n accel_penalty = 0.15 * np.abs(a_trans.sum() + a_rot.sum())\\n\\n # need to encourage exploration: current issue --> Rex is stuck at origin\\n # because positive rewards all the time\\n # need lim error --> 0, reward > 0 \\n\\n beta = -0.75\\n\\n reward = beta + \\\\\\n 0.200 * np.exp(-orient_err - shoulder_err) + \\\\\\n 0.275 * np.exp(-foot_penalties) + \\\\\\n 0.075 * np.exp(-height_err) + \\\\\\n 0.250 * np.exp(-x_vel_err) + \\\\\\n 0.100 * np.exp(-y_vel_err) + \\\\\\n 0.075 * np.exp(-accel_penalty) + \\\\\\n 0.025 * np.exp(-energy_penalty)\\n\\n\\n return reward\",\n \"def calc_f_g(mu, x, t, ro, inv_a):\\n z = inv_a*pow(x,2)\\n f = 1 - pow(x,2)/ro*stump_C(z) \\n g = t - 1/sqrt(mu)*pow(x,3)*stump_S(z)\\n return f, g\",\n \"def _g(X, g, n):\\n if n == 3:\\n n = 3.001 # for numerical stability\\n xi = 1 + X**2\\n hyp2f1_term = hyp2f1((n - 3) / 2, g / 2, n / 2, 1 / xi)\\n beta_term_1 = beta((n - 3) / 2, (3-g)/2)\\n beta_term_2 = beta((n-3)/2, 1.5)\\n return 0.5 * (beta_term_1 - beta_term_2 * hyp2f1_term * xi ** ((3-n)/2))\",\n \"def leapfrog_step(R,V,M,G,dt0,U0,E0 ):\\r\\n # kick \\r\\n U = total_potential_energy(R,M,G)\\r\\n acc = acceleration(R,M,G)\\r\\n Vn = V + acc*dt0*(U/U0)**(-3/2) # new velocity\\r\\n \\r\\n # drift\\r\\n K = total_kinetic_energy(Vn,M)\\r\\n\\r\\n R_cotemp = R + Vn * dt0/2 * ((E0-K)/U0)**(-3/2) # new R, cotemporal with V\\r\\n Rn = R_cotemp + Vn * dt0/2 * ((E0-K)/U0)**(-3/2) # new R, half-step from V\\r\\n\\r\\n return Rn, R_cotemp, Vn, dt0*(U/U0)**(-3/2)\",\n \"def g_2(thetas,aa,time):\\n\\treturn 2.0*(cos(2.0*thetas)/sin(thetas)) * ((1.0 - aa)*(1.0 - aa)*(time*time + 2.0)*(time*time + 2.0))\",\n \"def expected_log_g(self):\\n raise NotImplementedError()\\n E_lng = np.zeros_like(self.mf_gamma)\\n\\n # \\\\psi(\\\\sum_{b} \\\\gamma_b)\\n trm2 = psi(self.mf_gamma.sum(axis=2))\\n for b in xrange(self.B):\\n E_lng[:,:,b] = psi(self.mf_gamma[:,:,b]) - trm2\\n\\n return E_lng\",\n \"def update(self, sim, dt):\\n #growth kinetics\\n self.division_timer += dt\\n #you can grow unless you are in the A state meaning apoptosis\\n if(self.division_timer >= self.division_time and self._division):\\n #now you can divide\\n if(self.state == \\\"T1\\\"):\\n #change the current sytate to D\\n self.state = \\\"NSC\\\"\\n self._division = False\\n self.division_time = 36\\n #progenitor time is faster with concentration factor\\n\\n #add the concentration\\n source, consump_rate = self.get_gradient_source_sink_coeff(\\\"TNF\\\")\\n self.set_gradient_source_sink_coeff(\\\"TNF\\\", 50.0*source, 1.0*consump_rate)\\n## #get neighbors\\n## nbs = sim.network.neighbors(self)\\n## #get the total\\n## tot = len(nbs)\\n## mn_count = 0\\n## for i in range(0, tot):\\n## if(nbs[i].state == \\\"MN\\\" or nbs[i].state == \\\"T2\\\"): \\n## mn_count += 1\\n## norm_mn = float(mn_count) / float(tot)\\n## if(norm_mn < self._p2):\\n## self.division_time = 36*(norm_mn) # in hours\\n## self.division_time = max(self.division_time, 1) \\n## else:\\n## \\n## print(norm_mn, self.division_time)\\n #also set the current consumption rate\\n## source, consump_rate = self.get_gradient_source_sink_coeff(\\\"EGF\\\")\\n## self.set_gradient_source_sink_coeff(\\\"EGF\\\", source, 1.0*consump_rate)\\n if(self.state == \\\"T2\\\"):\\n #change the current sytate to D\\n self.state = \\\"MN\\\"\\n self.division_time = 56 #in hours\\n #also set the current consumption rate\\n source, consump_rate = self.get_gradient_source_sink_coeff(\\\"EGF\\\")\\n self.set_gradient_source_sink_coeff(\\\"EGF\\\", 50.0*source, 1.0*consump_rate)\\n if(self.state == \\\"T3\\\"):\\n #change the current sytate to D\\n self.state = \\\"G\\\"\\n self.division_time = 56 #in hours\\n #also set the current consumption rate\\n## source, consump_rate = self.get_gradient_source_sink_coeff(\\\"EGF\\\")\\n## self.set_gradient_source_sink_coeff(\\\"EGF\\\", source, 1.0*consump_rate)\\n #get the location\\n #pick a random point on a sphere\\n location = RandomPointOnSphere()*self.radius/2.0 + self.location\\n #get the radius\\n radius = self.radius\\n #get the ID\\n ID = sim.get_ID()\\n #make the object\\n sc = NueronalStemCell(location, radius, ID, self.state,\\n division_time = self.division_time,\\n params = [self._p1, self._p2,\\n self._p3, self._p4, self._p5,\\n self._p6, self.p7])\\n #copy secretion to NSC progeny\\n if(self.state == \\\"NSC\\\"):\\n source, consump_rate = self.get_gradient_source_sink_coeff(\\\"TNF\\\")\\n sc.set_gradient_source_sink_coeff(\\\"TNF\\\", 50.0*source, 1.0*consump_rate)\\n sc._division = False\\n #set its soluble count\\n## sc.sol_count = self.sol_count / 2.\\n## self.sol_count = self.sol_count / 2.\\n #copy over all of the coefficients to the new cells\\n## prod_cons = self.get_gradient_source_sink_coeff(\\\"O2\\\")\\n## sc.set_gradient_source_sink_coeff(\\\"O2\\\", prod_cons[0], prod_cons[1])\\n prod_cons = self.get_gradient_source_sink_coeff(\\\"EGF\\\")\\n sc.set_gradient_source_sink_coeff(\\\"EGF\\\", prod_cons[0], prod_cons[1]) \\n #add it to the imsulation\\n sim.add_object_to_addition_queue(sc)\\n #reset the division time\\n self.division_timer = 0\\n \\n if(self.state == \\\"U\\\"):\\n #HANDLE DIFFERENTIATION\\n #RANDOM RULE\\n x = rand.random()\\n prob = self._p1 #probability of turning into a NSC\\n #longer before the differentiation starts\\n if(x < prob):\\n #differentiation occurs\\n self.state = \\\"T1\\\"\\n #also add a proabability to differentiate directly to a mn\\n n1 = self._p4\\n## #get neighbors\\n## nbs = sim.network.neighbors(self)\\n## #get the total\\n## tot = len(nbs)\\n## mn_count = 0\\n## if(tot > 0):\\n## #count up the states fo all fo these\\n## for i in range(0, tot):\\n## if(nbs[i].state == \\\"MN\\\" or nbs[i].state == \\\"T2\\\"): \\n## mn_count += 1\\n #get the value fo the gradient and make differntiation inversly\\n #inversly correlated with the proportion present\\n norm_mn = self.get_gradient_value(\\\"EGF\\\")\\n #probability of turning into a motor nueron\\n n1 = self._p4\\n## #normalize the result\\n## if(tot != 0):\\n## norm_mn = float(mn_count) / float(tot)\\n## else:\\n## norm_mn = 0\\n #calculate the probability\\n prob_MN = 1 - (1.*norm_mn**n1)/(self._p2**n1 + norm_mn**n1)\\n x1 = rand.random()\\n if(x1 <= self._p1*prob_MN):\\n #differentiation occurs towards a motor nueron\\n self.state = \\\"T2\\\"\\n \\n if(self.state == \\\"NSC\\\"):\\n #HANDLE DIFFERENTIATION\\n #RANDOM RULE\\n x1 = rand.random()\\n x2 = rand.random()\\n #Find all the motor nuerons\\n## #get neighbors\\n## nbs = sim.network.neighbors(self)\\n## #get the total\\n## tot = len(nbs)\\n## mn_count = 0\\n## if(tot > 0):\\n## #count up the states fo all fo these\\n## for i in range(0, tot):\\n## if(nbs[i].state == \\\"MN\\\" or nbs[i].state == \\\"T2\\\"): \\n## mn_count += 1\\n## #normalize the result\\n## norm_mn = float(mn_count) / float(tot)\\n #Make differerntiationd ependant on the gradient value\\n norm_mn = self.get_gradient_value(\\\"EGF\\\")\\n #set the paramaters\\n n1 = self._p4\\n #update the division time\\n## self.division_time = norm_mn * 38 #in hours takes care of the feedback\\n #depends on other motor nuerons\\n prob_MN = 1 - (1.*norm_mn**n1)/(self._p3**n1 + norm_mn**n1) #probability of turning into a motor nueron\\n## prob_G = (1.*norm_mn**n2)/(self._p3**n1 + norm_mn**n2) #of turning into a glial cell\\n prob_G = self._p5\\n #longer before the differentiation starts\\n if(x1 <= prob_MN and x2 > prob_G):\\n #differentiation occurs towards a motor nueron\\n self.state = \\\"T2\\\"\\n if(x1 > prob_MN and x2 <= prob_G):\\n #differentiation occurs towards a glial cell\\n self.state = \\\"T3\\\"\\n #check to see if division enabled\\n if(self._division == False):\\n #check for mitotic speed up\\n a = self._p6\\n b = self._p7\\n norm_nsc = self.get_gradient_value(\\\"TNF\\\")\\n prob_divide = (1.*norm_nsc**b)/(a**b + norm_nsc**b)\\n r = rand.random()\\n if(r <= x):\\n self._division = True\",\n \"def theta_v_time():\\n pass\",\n \"def space_decay_rate(self):\\n dt = (datetime.datetime.utcnow() - self.initial_time).total_seconds() # delta t\\n ds = self.available_space() - self.initial_space_remaining # delta space\\n return ds / dt\",\n \"def gravity(self,satellite):\\n\\n G =0.1\\n dist_x = self.x - satellite.x\\n dist_y = self.y - satellite.y\\n distance = math.hypot(dist_x,dist_y)\\n\\n dist_x /= distance\\n dist_y /= distance\\n\\n force = G * (satellite.mass * self.mass)/(math.pow(distance,2))\\n satellite.dx += (dist_x * force)\\n satellite.dy += (dist_y * force)\",\n \"def velocity(M, r, G=6.67e-11):\\n\\n if M < 0:\\n return print(f\\\"The given mass is negative\\\")\\n\\n if r < 0:\\n print(f\\\"The given distance is negative\\\")\\n\\n if G < 0:\\n print(f\\\"The gravitational constant is negative\\\")\\n\\n return np.sqrt(G*M/r)\",\n \"def g_0(thetas,aa,time):\\n\\treturn 2.0*(1.0/sin(thetas)) * ((1. +3.*aa)*(1. + 3.*aa)*time*time*time*time + 2.*(1. + 2.0*aa + 2.0*aa + 3.0*aa*aa) *time*time + 2.0 * (1.0+aa) * (1.0 + aa))\",\n \"def do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega):\\n t = t + dt\\n x = x + vx*dt\\n y = y + vy*dt\\n z = z + vz*dt\\n\\n vz = vz - S0*vx*omega/m*dt # update vz first to use current value of vx\\n v = math.sqrt(vx*vx + vy*vy + vz*vz)\\n vx = vx - B2/m*v*vx*dt\\n vy = vy - g*dt - B2/m*v*vy*dt\\n\\n return t, x, y, z, vx, vy, vz\",\n \"def _draw_node_delay(self):\\n node_list = self.G.nodes()\\n n_nodes = len(node_list)\\n node_delay = rd.exponential(1./self.gamma, size=n_nodes)\\n self._node_delay = np.zeros(self.n_nodes)\\n for n, d in zip(node_list, node_delay):\\n self._node_delay[n] = d\",\n \"def target_velocity(self, time):\\n \\\"\\\"\\\"\\n start_point = self.points[self.cur_start]\\n cur_target = self.points[(self.cur_start + 1) % 4]\\n total_time = self.total_time / 4\\n avg_vel = (cur_target - start_point)/ total_time\\n return avg_vel\\n \\\"\\\"\\\"\\n total_time = self.total_time\\n if time <= self.total_time/4:\\n return self.path1.target_velocity(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/2:\\n return self.path2.target_velocity(time - (total_time/4 + 0.5))\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= self.total_time/4*3:\\n return self.path3.target_velocity(time - (total_time/2 + 1))\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n\\n else:\\n return self.path4.target_velocity(time - (total_time/4*3 + 1.5))\",\n \"def compute_g(self, i, j):\\n #Compute variance and mean denominator (same denominator for both)\\n g_next = 0\\n if (i+1 < self.nb_days-1):\\n g_next = self.g_heat[i+1,j]\\n\\n denominator = 2 * self.sigma2\\n numerator_mean = self.sigma2 * (self.g_heat[i-1,j] + g_next)\\n if (self.u_heat > self.temperatures[i]):\\n denominator = denominator + self.sigma_g_star_2[0, j] * ((self.temperatures[i] - self.u_heat)**2)\\n numerator_mean = numerator_mean + \\\\\\n self.sigma_g_star_2[0, j] * (self.temperatures[i] - self.u_heat) * (self.consumptions[i] - self.s[i,j] * self.kappa[self.daytypes[i]])\\n\\n #Mean\\n mean = numerator_mean / denominator\\n\\n #Compute variance numerator\\n variance_numerator = (self.sigma2 * self.sigma_g_star_2[0, j])\\n #Variance\\n variance = variance_numerator / denominator\\n\\n self.g_heat[i,j] = self.truncated_norm(-inf, 0, mean, variance)\",\n \"def test_GBL_tau_star():\\n z = 1.0\\n\\n # Fully ionized H and He\\n x_ionH = 1.0\\n x_ionHe = 2.0\\n\\n cosmo = {}\\n cosmo['omega_M_0'] = numpy.array([[0.3],[0.6],[1.0]])\\n cosmo['omega_lambda_0'] = 1. - cosmo['omega_M_0']\\n cosmo['h'] = 0.65\\n cosmo['omega_b_0'] = 0.02 / cosmo['h']**2.\\n cosmo['Y_He'] = 0.24\\n cd.set_omega_k_0(cosmo)\\n\\n tau_inst, tau_star = cr.optical_depth_instant(z, \\n x_ionH=x_ionH, \\n x_ionHe=x_ionHe, \\n return_tau_star=True,\\n **cosmo)\\n print(\\\"tau_star = %.7f\\\" % (tau_star))\\n print(\\\"tau_star/(h Omega_b) = %.7f =? 0.061\\\" % \\n (tau_star / (cosmo['h'] * cosmo['omega_b_0'])))\\n\\n ntest.assert_approx_equal(tau_star / (cosmo['h'] * cosmo['omega_b_0']),\\n 0.061,\\n 2)\\n\\n print(\\\"(1 - Y_He/2) = %.3f =? 0.88\\\" % (1. - (cosmo['Y_He']/2.)))\\n ntest.assert_approx_equal((1. - (cosmo['Y_He']/2.)),\\n 0.88,\\n 7)\\n\\n H_0 = cc.H100_s * cosmo['h']\\n\\n # s^-1 * Mpc s^-1 * Mpc^2 / Mpc^3 msun^-1 s^-2 / Msun -> \\n tau_star_explicit = ((1. - (cosmo['Y_He']/2.)) * \\n ((3. * H_0 * cosmo['omega_b_0'] * cc.c_light_Mpc_s *\\n cc.sigma_T_Mpc) / \\n (8. * math.pi * cc.G_const_Mpc_Msun_s * \\n (cc.m_p_g/cc.M_sun_g))))\\n\\n print(\\\"tau_star_explicit = %.7f =? tau_star\\\" % (tau_star_explicit))\\n ntest.assert_approx_equal(tau_star, tau_star_explicit, 3)\",\n \"def get_fractional_degradation(bt):\\n\\n\\n\\n NomIch = 0.125 # Nominal charge current\\n NomId = 0.25 # Nominal discharge current\\n NomSoC = 0.5 # Nominal state of charge_mode\\n NomDoD = 1.0 # Nominal depth of discharge\\n B = 5 #Battery capacity\\n qt = 5 * 0.5 # Amount of energy in the battery at the start\\n # Determin charge of discharge\\n if bt > 0:\\n Id = bt/(B*1) # time interval differnece is 1\\n Ich = NomIch\\n else:\\n Ich = bt/(B*1)\\n Id = NomId\\n\\n #Calculate average State of Charge\\n SoC = 100 * (qt - 0.5*bt)/B\\n\\n #Calculate Depth of Discharge\\n DoD = 100 * bt /B\\n\\n # Functions\\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\\n nCL = nCL1 * nCL2 * nCL3\\n Fractional_D = (0.5/3650)/ nCL\\n return Fractional_D\",\n \"def delayToNextPacket(self):\\n delay = -(1.0 / (self.mPacketsPerSecond)) * np.log(1 - np.random.uniform())\\n # exponential distribution in seconds\\n return round(delay * Constants.TICKS_PER_SECOND)\\n #return (Math.round(delay * Main.TICKS_PER_SECOND))\",\n \"def get_delay(self, pid1, pid2, is_block):\\n is_slow = self.node_is_slow[pid1] or self.node_is_slow[pid2]\\n p = random.uniform(Parameters.p_min, Parameters.p_max)\\n c = Parameters.c_low if is_slow else Parameters.c_high\\n m = Parameters.m if is_block else 0\\n d = random.expovariate(c / Parameters.d)\\n return (p + m/c + d)\",\n \"def bethe_gf_omega(z, t=1.0):\\n half_bandwidth = 2 * t\\n z_rel = z / half_bandwidth\\n return 2. / half_bandwidth * z_rel * (1 - np.sqrt(1 - 1 / (z_rel * z_rel)))\",\n \"def sigma0_RG(self):\\n sigma = np.sqrt(self.cosmo.gs_spectral_moment(l=0,RG=self.RG))\\n return sigma\",\n \"def acc_grav(j,rA,mA,hA,W=kernel.W_M4star):\\n assert rA.shape[0] == mA.shape[0] == hA.shape[0], \\\"arrays are mismatched\\\"\\n N = len(mA)\\n\\n tot = 0\\n for i in range(N):\\n if i != j:\\n\\n r_ij = rA[j,:] - rA[i,:]\\n r_ij1 = np.linalg.norm(r_ij)\\n m_i = mA[i]\\n h_ij = 0.5 * (hA[i] + hA[j])\\n\\n tot += m_i * (r_ij/r_ij**3) * W(r_ij1,h_ij)\\n\\n return - tot * G\",\n \"def delayS(self):\\n e = self.ecc()\\n cE = np.cos(self.E())\\n sE = np.sin(self.E())\\n sOmega = np.sin(self.omega())\\n cOmega = np.cos(self.omega())\\n TM2 = self.M2.value*Tsun\\n\\n sDelay = -2*TM2* np.log(1-e*cE-self.SINI*(sOmega*(cE-e)+\\n (1-e**2)**0.5*cOmega*sE))\\n return sDelay\",\n \"def triggerCondition(cls, state):\\n x1, x2 = state\\n y = cls.X2toY(x1, x2)\\n norm = np.math.sqrt(x1**2 + y**2)\\n\\n # calculate next trigger step\\n dt = (29 * x1 + norm**2) / (5.36 * norm * x1**2 + norm**2) * cls.tau_trigger\\n return dt\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68207735","0.6423103","0.6103835","0.60187733","0.59844357","0.59758383","0.59610367","0.5958875","0.5919561","0.5867162","0.5851209","0.58429337","0.5788291","0.5788291","0.5756704","0.5749892","0.5749892","0.5729351","0.57071257","0.56512266","0.56450576","0.5644826","0.56130284","0.5601485","0.55994445","0.55986595","0.55972373","0.55771565","0.5552571","0.5533901","0.5533657","0.5529783","0.55228496","0.55085677","0.5507589","0.5495566","0.5486394","0.5483722","0.54586065","0.54582053","0.5455201","0.54499483","0.5439167","0.54336995","0.5433081","0.5430997","0.542106","0.5416652","0.5405466","0.54027146","0.5396146","0.539165","0.5390769","0.53893596","0.53865683","0.536877","0.5363651","0.53602463","0.5360234","0.53468657","0.5346166","0.5343697","0.5338244","0.53337795","0.5330291","0.5328309","0.5321642","0.53163815","0.5308277","0.530769","0.52976125","0.52877736","0.5282395","0.5280671","0.526667","0.52559555","0.5249106","0.52467704","0.5245488","0.52419114","0.52343994","0.52331626","0.52244836","0.52233654","0.5223091","0.52200824","0.521924","0.5212707","0.5210927","0.52097386","0.52094114","0.5207361","0.5203973","0.51858735","0.518486","0.5184016","0.51826733","0.51793903","0.5170077","0.51696825"],"string":"[\n \"0.68207735\",\n \"0.6423103\",\n \"0.6103835\",\n \"0.60187733\",\n \"0.59844357\",\n \"0.59758383\",\n \"0.59610367\",\n \"0.5958875\",\n \"0.5919561\",\n \"0.5867162\",\n \"0.5851209\",\n \"0.58429337\",\n \"0.5788291\",\n \"0.5788291\",\n \"0.5756704\",\n \"0.5749892\",\n \"0.5749892\",\n \"0.5729351\",\n \"0.57071257\",\n \"0.56512266\",\n \"0.56450576\",\n \"0.5644826\",\n \"0.56130284\",\n \"0.5601485\",\n \"0.55994445\",\n \"0.55986595\",\n \"0.55972373\",\n \"0.55771565\",\n \"0.5552571\",\n \"0.5533901\",\n \"0.5533657\",\n \"0.5529783\",\n \"0.55228496\",\n \"0.55085677\",\n \"0.5507589\",\n \"0.5495566\",\n \"0.5486394\",\n \"0.5483722\",\n \"0.54586065\",\n \"0.54582053\",\n \"0.5455201\",\n \"0.54499483\",\n \"0.5439167\",\n \"0.54336995\",\n \"0.5433081\",\n \"0.5430997\",\n \"0.542106\",\n \"0.5416652\",\n \"0.5405466\",\n \"0.54027146\",\n \"0.5396146\",\n \"0.539165\",\n \"0.5390769\",\n \"0.53893596\",\n \"0.53865683\",\n \"0.536877\",\n \"0.5363651\",\n \"0.53602463\",\n \"0.5360234\",\n \"0.53468657\",\n \"0.5346166\",\n \"0.5343697\",\n \"0.5338244\",\n \"0.53337795\",\n \"0.5330291\",\n \"0.5328309\",\n \"0.5321642\",\n \"0.53163815\",\n \"0.5308277\",\n \"0.530769\",\n \"0.52976125\",\n \"0.52877736\",\n \"0.5282395\",\n \"0.5280671\",\n \"0.526667\",\n \"0.52559555\",\n \"0.5249106\",\n \"0.52467704\",\n \"0.5245488\",\n \"0.52419114\",\n \"0.52343994\",\n \"0.52331626\",\n \"0.52244836\",\n \"0.52233654\",\n \"0.5223091\",\n \"0.52200824\",\n \"0.521924\",\n \"0.5212707\",\n \"0.5210927\",\n \"0.52097386\",\n \"0.52094114\",\n \"0.5207361\",\n \"0.5203973\",\n \"0.51858735\",\n \"0.518486\",\n \"0.5184016\",\n \"0.51826733\",\n \"0.51793903\",\n \"0.5170077\",\n \"0.51696825\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71809274"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6495,"cells":{"query":{"kind":"string","value":"out = dense( shape=shape, init=None, paramset=None)"},"document":{"kind":"string","value":"def dense(x, outdim, initializer=tf.glorot_uniform, bias=False, name=None):\n if x.ndim == 4:\n x = x.flat2d()\n\n assert x.ndim == 2\n\n outshape = not isinstance(outdim, int)\n if outshape:\n dim = [-1] + list(outdim)\n outdim = np.prod(outdim)\n\n shape = [x.dims[-1], outdim]\n W = tf.get_weight('W', shape=shape, initializer=initializer(shape))\n # W = tf.get_weight('W', initializer=initializer(shape))\n out = x.dot(W)\n if bias:\n b = tf.get_bias('b', shape=(outdim,), initializer=tf.zeros_initializer())\n out = tf.nn.bias_add(out, b)\n\n if outshape:\n # make reshape\n out = out.reshape(dim)\n\n return tf.identity(out, name=name)"},"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 dense(in_layer):\n return Dense(neurons,\n kernel_initializer=initializer())(in_layer)","def init_dense(self, layer):\n pass","def dense(name, x, w=None, output_dim=128, initializer=tf.contrib.layers.xavier_initializer(), l2_strength=0.0,\n bias=0.0, activation=None, batchnorm_enabled=False, dropout_keep_prob=-1, is_training=True):\n with tf.variable_scope(name) as scope:\n dense_o_b = dense_p(scope, x=x, w=w, output_dim=output_dim, initializer=initializer,\n l2_strength=l2_strength, bias=bias)\n\n if batchnorm_enabled:\n dense_o_bn = tf.layers.batch_normalization(dense_o_b, training=is_training)\n else:\n dense_o_bn = dense_o_b\n\n if activation is None:\n dense_a = dense_o_bn\n else:\n dense_a = activation(dense_o_bn)\n\n if dropout_keep_prob != -1:\n dense_o_dr = tf.nn.dropout(dense_a, keep_prob=dropout_keep_prob)\n else:\n dense_o_dr = dense_a\n\n dense_o = dense_o_dr\n\n return dense_o","def dense(input, out_dims=None, dropout_keep_prob=1.0, nonlin=True, trainable=True):\n input = tf.nn.dropout(input, dropout_keep_prob)\n # Initial number of values for each residue\n in_dims = input.get_shape()[-1].value\n out_dims = in_dims if out_dims is None else out_dims\n # Weights of the dense layer\n W = tf.Variable(initializer(\"he\", [in_dims, out_dims]), name=\"w\", trainable=trainable)\n b = tf.Variable(initializer(\"zero\", [out_dims]), name=\"b\", trainable=trainable)\n # Operation performed in the dense layer\n Z = tf.matmul(input, W) + b\n if (nonlin):\n nonlin = nonlinearity(\"relu\")\n Z = nonlin(Z)\n Z = tf.nn.dropout(Z, dropout_keep_prob)\n return Z","def initialize_dense(input_size, output_size):\n # TODO: replace the initialization constant 0.01 in a more systematic approach\n return np.random.randn(output_size, input_size) * 0.01","def dense_nn(x):\n dense_1 = tf.nn.dropout(tf.nn.relu(dense(x, input_dim, n_l1, 'dense_1')), keep_prob=0.25)\n dense_2 = tf.nn.dropout(tf.nn.relu(dense(dense_1, n_l1, n_l2, 'dense_2')), keep_prob=0.25)\n dense_3 = dense(dense_2, n_l2, n_labels, 'dense_3')\n return dense_3","def dense(x, \n num_outputs,\n STD=0.01,\n keep_prob=None,\n activation=None,\n bn=False,\n phase=None):\n output = tf.identity(x)\n \n if keep_prob is not None:\n output = tf.layers.dropout(output, rate=keep_prob, training=phase)\n\n output = slim.fully_connected(output, num_outputs, activation_fn=None, \\\n weights_initializer=tf.truncated_normal_initializer(stddev=STD))\n\n if bn:\n output = tf.layers.batch_normalization(output, training=phase)\n \n if activation: \n output = activation(output)\n \n return output","def build_dense(self): # Pass state_size and action_size\n model = Sequential()\n model.add(Dense(24, input_dim = grid_size*grid_size+2, activation = 'relu'))\n model.add(Dense(24, activation = 'relu'))\n model.add(Dense(len(ACTIONS), activation = 'linear'))\n model.compile(loss = 'mse', optimizer = RMSprop(lr = alpha))\n\n return model","def dense(x, size, name, weight_init=xavier):\n w = tf.get_variable(name + \"/w\", [x.get_shape()[1], size], initializer=weight_init)\n b = tf.get_variable(name + \"/b\", [size], initializer=tf.constant_initializer(0.0))\n return tf.matmul(x, w) + b","def dense(self, input_tensor, units, name, activation='linear'):\n with tf.variable_scope('Dense', name):\n init_w = tf.truncated_normal(shape=(self.num_channels(input_tensor),\n units), dtype=tf.float32)\n w = tf.Variable(init_w)\n b = tf.Variable(tf.random_uniform(shape=(units, ), dtype=tf.float32))\n\n out_layer = tf.matmul(input_tensor, w) + b\n out_layer = self.activations[activation](out_layer)\n return out_layer","def dense(x,num_nodes,activation='relu',name='',bias_init_val=0,reuse=None):\n input_shape = x.get_shape()\n with tf.variable_scope('dense',reuse=reuse):\n \tW=tf.get_variable('W'+name,initializer=tf.random_normal(stddev=.01,shape=[int(input_shape[-1]),num_nodes]))\n \tb=tf.get_variable('b'+name,initializer=tf.constant(bias_init_val,shape = [num_nodes],dtype=tf.float32))\n \n logits = tf.matmul(x,W)+b\n \n if activation == None:\n y = logits\n elif activation == 'relu':\n y = tf.nn.relu(logits)\n elif activation == 'sigmoid':\n y = tf.nn.sigmoid(logits)\n else:\n raise ValueError(\"Enter a valid activation function\")\n \n return y","def __init__(self, incoming, n_units, flatten_input=False, W=tf.zeros, b=tf.zeros, a=tf.sigmoid, name='DenseLayer'):\n super(DenseLayer, self).__init__()\n with tf.variable_scope(name) as self.layer_scope:\n self.incoming, self.incoming_shape = get_input(incoming)\n \n if (len(self.incoming_shape) > 2) and flatten_input:\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\n elif len(self.incoming_shape) == 4:\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\n elif len(self.incoming_shape) >= 5:\n incoming_shape = [self.incoming_shape[0], self.incoming_shape[1], np.prod(self.incoming_shape[2:])]\n else:\n incoming_shape = self.incoming_shape\n \n # Set init for W\n W = tofov(W, shape=[incoming_shape[-1], n_units], var_params=dict(name='W_dense'))\n \n # Set init for b\n if b is not None:\n b = tofov(b, [n_units], var_params=dict(name='b_dense'))\n \n self.a = a\n self.b = b\n self.W = W\n \n self.n_units = n_units\n self.flatten_input = flatten_input\n self.incoming_shape = incoming_shape\n \n self.out = tf.zeros(self.get_output_shape())\n self.name = name","def mlp(x, output_size, hidden_sizes=[64], activation=tf.tanh, output_activation=None):\n for size in hidden_sizes:\n x = tf.layers.dense(x, size, activation=activation)\n return tf.layers.dense(x, output_size, activation=output_activation)","def model(self, inputs):\n h1 = dense(inputs, self.weights[0], self.biases[0], tf.nn.relu) #hidden layer 1\n h2 = dense(h1, self.weights[1], self.biases[1], tf.nn.relu) #hidden layer 2\n\n out = dense(h2, self.weights[2], self.biases[2])\n\n return out","def build_dense_network(model,\n input_dim,\n dense_layers,\n nodes_per_layer=None,\n hidden_act='relu',\n output_act='sigmoid',\n dropout_layers=None):\n\n if nodes_per_layer is None:\n nodes = [10] * dense_layers\n else:\n nodes = nodes_per_layer\n\n if dropout_layers is None:\n do_layers = [0] * dense_layers\n else:\n do_layers = dropout_layers\n\n model.add(Dense(nodes[0], input_dim=input_dim,\n activation=hidden_act))\n\n if dense_layers > 1:\n for l in range(1, dense_layers - 1):\n if do_layers[l - 1] != 0:\n model.add(Dropout(do_layers[l - 1]))\n\n model.add(Dense(nodes[l], activation=hidden_act))\n\n model.add(Dense(1, activation=output_act))\n\n return model","def mlp(x, hidden_sizes=(32,), activation=tf.tanh, output_activation=None):\n for h in hidden_sizes[:-1]:\n x = tf.layers.dense(x, units=h, activation=activation)\n return tf.layers.dense(x, units=hidden_sizes[-1], activation=output_activation)","def initialize_dense_cost(height, width):\n cost = sparse.initialize_dense_cost_cpp(height, width)\n return cost","def dense_block(x):\n h1 = _conv_block(x, 32)\n h1 = tf.keras.layers.Concatenate()([x, h1])\n\n h2 = _conv_block(h1, 32)\n h2 = tf.keras.layers.Concatenate()([x, h1, h2])\n\n h3 = _conv_block(h2, 32)\n h3 = tf.keras.layers.Concatenate()([x, h1, h2, h3])\n\n h4 = _conv_block(h3, 32)\n h4 = tf.keras.layers.Concatenate()([x, h1, h2, h3, h4])\n\n h5 = _conv_block(h4, 32, activation=False)\n\n h5 = tf.keras.layers.Lambda(lambda x: x * 0.2)(h5)\n h = tf.keras.layers.Add()([h5, x])\n\n return h","def __init__(self, hidden_units, act_fn=activation_fn, output_shape=1, out_activation=None, out_layer=True):\n super().__init__()\n for u in hidden_units:\n self.add(GaussianNoise(0.4)) # Or use kwargs\n self.add(Dense(u, act_fn))\n if out_layer:\n self.add(GaussianNoise(0.4))\n self.add(Dense(output_shape, out_activation))","def build_model(input_classes,output_classes):\n dimensions = 20\n inputs = []\n embedded_outputs = []\n for i in input_classes:\n input_layer = Input((1,))\n inputs.append(input_layer)\n embedder = Embedding(input_dim=i,output_dim=dimensions,input_length=1,embeddings_constraint=UnitNorm(axis=0))\n embedded_layer = embedder(input_layer)\n embedded_outputs.append(embedded_layer)\n\n embedded_concats = Concatenate()(embedded_outputs)\n flatten_layer = Flatten()\n\n dense_layer = Dense(output_classes)\n\n flattened_output = flatten_layer(embedded_concats)\n dense_output = dense_layer(flattened_output)\n\n # dense_output = dense_layer(embedded_concats)\n\n model = Model(inputs,dense_output)\n print(model.summary())\n model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')\n\n return model","def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2,num_hidden_units_3, num_code_units, batch_size=BATCH_SIZE):\n shape = tuple([None]+list(input_shape[1:]))\n print(shape)\n l_in = lasagne.layers.InputLayer(shape=shape)\n\n l_hidden_1 = lasagne.layers.DenseLayer(\n l_in,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_2 = lasagne.layers.DenseLayer(\n l_hidden_1,\n num_units=num_hidden_units_2,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_hidden_2,\n num_units=num_hidden_units_3,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_code_layer = lasagne.layers.DenseLayer(\n l_hidden_3,\n num_units=num_code_units,\n nonlinearity=lasagne.nonlinearities.softmax,\n )\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_code_layer,\n num_units=num_hidden_units_3,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_4 = lasagne.layers.DenseLayer(\n l_hidden_3,\n num_units=num_hidden_units_2,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_hidden_5 = lasagne.layers.DenseLayer(\n l_hidden_4,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n l_out = lasagne.layers.DenseLayer(\n l_hidden_5,\n num_units=output_dim,\n nonlinearity=None,\n )\n\n return l_out","def sparse_to_dense(self, tensor: tf.Tensor, output_shape: tf.TensorShape) -> tf.Tensor:\n return tf.scatter_nd(self.observations_index, tensor, output_shape)","def add_dense_layer(self, _input, in_size, out_size):\n weight = tf.Variable(tf.truncated_normal(\n [in_size, out_size], stddev=0.01))\n bias = tf.Variable(tf.constant(0.1, shape=[out_size]))\n return tf.matmul(_input, weight) + bias","def dense(x, n1, n2, name):\n with tf.name_scope(name):\n weights = tf.Variable(tf.random_normal(shape=[n1, n2], mean=0., stddev=0.01), name='weights')\n bias = tf.Variable(tf.zeros(shape=[n2]), name='bias')\n output = tf.add(tf.matmul(x, weights), bias, name='output')\n return output","def dense_layer(self, img, weights, bias):\n # 1: Flattening step\n img_w, img_h, img_c = img.shape\n flat = img.reshape((img_w * img_h * img_c, 1))\n # 2: dense/relu layer\n z = (weights[0].dot(flat) + bias[0]) / (weights[0][0].shape[0] + 1)\n z[z <= 0] = 0 # ReLU\n output = (weights[1].dot(z) + bias[1]) / (weights[1][0].shape[0] + 1)\n # 3: softmax\n return softmax(output), z, flat","def build_dense_network(data, hidden_layers, **kwargs):\n # Input layer\n with tf.variable_scope(\"layer_1\"): \n weights = tf.get_variable(\"weights\", shape = [input_shape[-1] + 1\n , hidden_layers[0]], initializer = tf.variance_scaling_initializer())\n\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([data, tf.ones(dtype = tf.float32\n , shape = (tf.shape(data)[0], 1))], axis = 1) # concat\n , weights, name = \"multiply\") # matmul\n , α, name = \"output\") # leaky relu\n\n # DROP-OUT after the activation func\n output = tf.nn.dropout(output, keep_prob=δ, name = \"output\") \n\n # Hidden layers 1 to len(hidden_layers) - 1\n for i in range(2, len(hidden_layers)-1+2):\n\n with tf.variable_scope(f\"layer_{i}\"):\n n_nodes = hidden_layers[i-1]\n\n weights = tf.get_variable(\"weights\", shape = [hidden_layers[i-2]+1, hidden_layers[i-1]], initializer = tf.variance_scaling_initializer())\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \"multiply\"), α, name = \"output\")\n\n # DROP-OUT after the activation func\n output = tf.nn.dropout(output, keep_prob=δ, name = \"output\") \n\n # Output layer\n with tf.variable_scope(f\"layer_{len(hidden_layers)+1}\"):\n\n weights = tf.get_variable(\"weights\", shape = (hidden_layers[1]+1, n_summaries), initializer = tf.variance_scaling_initializer())\n output = tf.identity(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \"multiply\"), name = \"output\")\n # NO DROP-OUT in the last layer\n\n\n return output","def __init__(self, config_data, dims, layer_num, params):\n self.use_bias = params['use_bias']\n self.in_dims = params['in_dims']\n self.out_dims = params['out_dims']\n self.use_bias = params['use_bias']\n self.num_outputs = params['num_outputs']\n self.dims = dims\n self.layer_num = layer_num\n self.activation = config_data[\"activation\"]\n self.layer_type = config_data[\"type\"]\n self.name = config_data[\"name\"]\n self.params = []\n # following two parameters not used in dense layers\n # they will be set to one in dense layers\n self.kernel_size = params['kernel_size'] # only used in conv layers\n self.stride = params['stride'] # only used in conv layers","def flatten_and_dense(X,out_channels,*args,activation = 'relu', initialise_weights = False):\n \n shape = X.shape\n X = torch.reshape(X,(-1,1)) # Flatten\n if initialise_weights:\n weights = torch.Tensor(np.random.uniform(-0.01,0.01, size = (out_channels,len(X))))\n weights.requires_grad = False\n bias = torch.Tensor(np.random.uniform(-0.01,0.01, size = (out_channels,1)))\n else:\n weights = args[0]\n bias = args[1]\n if activation == 'sigmoid':\n output = sigmoid(weights.mm(X) + bias)\n elif activation == 'relu':\n output = relu(weights.mm(X) + bias)\n else:\n output = weights.mm(X) + bias # No activation applied -> Typically done before the softmax\n if not initialise_weights:\n \n return output\n else:\n output_shape = output.shape\n return output,weights,bias,output_shape","def DenseModel(optimizer='sgd'):\n model = Sequential([Dense(3, input_shape=(5184,), activation='softmax')])\n model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])\n return model","def add_dense_layer(self, input_tensor, output_size, activation_fn=None,\n name = None):\n return tf.layers.dense(input_tensor, output_size, activation=activation_fn,\n kernel_initializer=tf.contrib.layers.variance_scaling_initializer(),\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\n name=name)","def dense_block(X, neurons_per_layer, add_noise, hidden_activation):\n Y = Dense(neurons_per_layer)(X)\n\n if add_noise:\n Y = GaussianDropout(0.005)(Y)\n\n Y = LayerNormalization()(Y)\n Y = hidden_activation(Y)\n return Concatenate()([X, Y])","def dense(inputs, activation,\n num_outputs,\n out_caps_dims,\n routing_method='EMRouting',\n coordinate_addition=False,\n reuse=None,\n name=None):\n name = \"dense\" if name is None else name\n with tf.variable_scope(name) as scope:\n if reuse:\n scope.reuse()\n if coordinate_addition and len(inputs.shape) == 6 and len(activation.shape) == 4:\n vote = transforming(inputs, num_outputs=num_outputs, out_caps_dims=out_caps_dims)\n with tf.name_scope(\"coodinate_addition\"):\n batch_size, in_height, in_width, in_channels, _, out_caps_height, out_caps_width = cl.shape(vote)\n num_inputs = in_height * in_width * in_channels\n\n zeros = np.zeros((in_height, out_caps_width - 1))\n coord_offset_h = ((np.arange(in_height) + 0.5) / in_height).reshape([in_height, 1])\n coord_offset_h = np.concatenate([zeros, coord_offset_h], axis=-1)\n zeros = np.zeros((out_caps_height - 1, out_caps_width))\n coord_offset_h = np.stack([np.concatenate([coord_offset_h[i:(i + 1), :], zeros], axis=0) for i in range(in_height)], axis=0)\n coord_offset_h = coord_offset_h.reshape((1, in_height, 1, 1, 1, out_caps_height, out_caps_width))\n\n zeros = np.zeros((1, in_width))\n coord_offset_w = ((np.arange(in_width) + 0.5) / in_width).reshape([1, in_width])\n coord_offset_w = np.concatenate([zeros, coord_offset_w, zeros, zeros], axis=0)\n zeros = np.zeros((out_caps_height, out_caps_width - 1))\n coord_offset_w = np.stack([np.concatenate([zeros, coord_offset_w[:, i:(i + 1)]], axis=1) for i in range(in_width)], axis=0)\n coord_offset_w = coord_offset_w.reshape((1, 1, in_width, 1, 1, out_caps_height, out_caps_width))\n\n vote = vote + tf.constant(coord_offset_h + coord_offset_w, dtype=tf.float32)\n\n vote = tf.reshape(vote, shape=[batch_size, num_inputs, num_outputs] + out_caps_dims)\n activation = tf.reshape(activation, shape=[batch_size, num_inputs])\n\n elif len(inputs.shape) == 4 and len(activation.shape) == 2:\n vote = transforming(inputs, num_outputs=num_outputs, out_caps_dims=out_caps_dims)\n\n else:\n raise TypeError(\"Wrong rank for inputs or activation\")\n\n pose, activation = routing(vote, activation, routing_method)\n # pose, activation = cl.core.gluing(vote, activation)\n assert len(pose.shape) == 4\n assert len(activation.shape) == 2\n\n return(pose, activation)","def output(x_tensor, num_outputs):\n # TODO: Implement Function\n y = tf.layers.dense(x_tensor,num_outputs)\n return y","def dense(x, n1, n2, name):\n with tf.variable_scope(name, reuse=None):\n # np.random.seed(1)\n tf.set_random_seed(1)\n weights = tf.get_variable(\"weights\", shape=[n1, n2],\n initializer=tf.random_normal_initializer(mean=0., stddev=0.01))\n bias = tf.get_variable(\"bias\", shape=[n2], initializer=tf.constant_initializer(0.0))\n out = tf.add(tf.matmul(x, weights), bias, name='matmul')\n return out","def build_mlp(input_data, output_data, n_neurons=[512, 256, 128]):\n input_layer = keras.layers.Input([input_data.shape[-1]], name='input-layer')\n for i, n_unit in enumerate(n_neurons):\n if i == 0:\n x = keras.layers.Dense(units=n_unit, activation='relu', name='hidden-layer'+str(i+1))(input_layer)\n else:\n x = keras.layers.Dense(units=n_unit, activation='relu', name='hidden-layer'+str(i+1))(x)\n \n output_layer = keras.layers.Dense(units=output_data.shape[-1],activation='softmax' , name='output-layer')(x)\n model = keras.models.Model(inputs=input_layer, outputs=output_layer)\n return model","def __init__(self, input_dim: int, output_dim: int):\n\n super().__init__()\n\n self.input_dim = input_dim\n self.output_dim = output_dim\n\n self.batchNorm1 = layers.BatchNormalization()\n self.dense1 = layers.Dense(\n 64, input_shape=(input_dim+output_dim,),\n kernel_initializer=random_uniform(-np.sqrt(1/input_dim), np.sqrt(1/input_dim))\n )\n self.relu1 = layers.Activation('relu')\n self.dense2 = layers.Dense(32, kernel_initializer=random_uniform(-np.sqrt(1/64), np.sqrt(1/64)))\n self.relu2 = layers.Activation('relu')\n self.dense3 = layers.Dense(output_dim, kernel_initializer=random_uniform(-np.sqrt(1/32), np.sqrt(1/32)))","def fully_conn(x_tensor, num_outputs, name=\"fc\"):\n with tf.name_scope(name):\n return tf.layers.dense(x_tensor, num_outputs)","def __init__(self, input_size, hidden_sizes, output_size, std=1e-4, bstd=1e-4):\r\n num_hidden_layers = len(hidden_sizes)\r\n \r\n # initialize weight matrices\r\n self.weights = []\r\n if num_hidden_layers > 0:\r\n for i in xrange(num_hidden_layers):\r\n if i == 0:\r\n self.weights.append(std * np.random.randn(input_size, hidden_sizes[0]))\r\n else:\r\n self.weights.append(std * np.random.randn(hidden_sizes[i-1], hidden_sizes[i]))\r\n self.weights.append(std * np.random.randn(hidden_sizes[-1], output_size))\r\n else:\r\n self.weights.append(std * np.random.randn(input_size, output_size))\r\n \r\n # initialize bias vectors\r\n self.biases = []\r\n for i in xrange(num_hidden_layers):\r\n self.biases.append(bstd * np.random.randn(hidden_sizes[i]))\r\n self.biases.append(bstd * np.random.randn(output_size))","def __call__(self, inputs_shape):\n assert not self._achieve_init\n self.W = 2 * np.random.randn(self._units, inputs_shape) / np.sqrt(inputs_shape)\n self.b = np.zeros((self._units, 1))\n super(Dense, self).__call__()","def build_mlp(x, output_size, scope, n_layers, size, activation=tf.tanh, output_activation=None, regularizer=None):\n i = 0\n for i in range(n_layers):\n x = tf.layers.dense(inputs=x,units=size, activation=activation, name='fc{}'.format(i), kernel_regularizer=regularizer, bias_regularizer=regularizer)\n\n x = tf.layers.dense(inputs=x, units=output_size, activation=output_activation, name='fc{}'.format(i + 1), kernel_regularizer=regularizer, bias_regularizer=regularizer)\n return x","def dense_bn_act(inputs, units, activation, kernel_init, noise=False, noise_std=0.5):\n _tmp = tf.layers.dense(inputs=inputs, units=units, activation=None, kernel_initializer=kernel_init)\n _tmp = tf.contrib.layers.batch_norm(_tmp, center=True, scale=True, is_training=phase)\n _tmp = activation(_tmp)\n if noise:\n _tmp = gaussian_noise_layer(_tmp, noise_std, phase)\n\n return _tmp","def build(self, input_shape: tf.Tensor):\n self.dense = tf.keras.layers.Dense(self.channels, input_shape=input_shape)\n self.bn = tf.keras.layers.BatchNormalization(momentum=self.momentum)","def dense(x, n1, n2, name):\n with tf.variable_scope(name, reuse=None):\n weights = tf.get_variable(\"weights\", shape=[n1, n2],\n initializer=tf.random_normal_initializer(mean=0., stddev=0.01))\n bias = tf.get_variable(\"bias\", shape=[n2], initializer=tf.constant_initializer(0.0))\n out = tf.add(tf.matmul(x, weights), bias, name='matmul')\n return out","def generative_model(self):\n activation = tf.nn.relu\n if self.linear:\n activation = None\n\n # p(x | z, s)\n if self.batch is not None:\n h = tf.concat([self.z, self.batch], 1)\n else:\n h = self.z\n \n #h = dense(h, self.n_hidden,\n # activation=tf.nn.relu, bn=True, keep_prob=self.dropout_rate, phase=self.training_phase)\n h = dense(h, self.n_hidden,\n activation=activation, bn=True, keep_prob=None, phase=self.training_phase)\n \n for layer in range(2, self.n_layers + 1):\n if self.batch is not None:\n h = tf.concat([h, self.batch], 1)\n h = dense(h, self.n_hidden, activation=activation, \\\n bn=True, keep_prob=self.dropout_rate, phase=self.training_phase)\n\n if self.batch is not None:\n h = tf.concat([h, self.batch], 1) \n \n #mean gamma\n self.px_scale = dense(h, self.n_input, activation=tf.nn.softmax, \\\n bn=False, keep_prob=None, phase=self.training_phase)\n \n #dispersion\n if self.dispersion == \"gene-cell\":\n self.px_r = dense(h, self.n_input, activation=None, \\\n bn=False, keep_prob=None, phase=self.training_phase)\n elif self.dispersion == \"gene\":\n self.px_r = tf.Variable(tf.random_normal([self.n_input]), name=\"r\")\n else:\n if self.dispersion is False:\n self.px_r = tf.ones([self.n_input])\n else:\n if self.batch_ind is None:\n raise ValueError(\"batch dispersion with no batch info\")\n else:\n self.px_r = tf.Variable(tf.random_normal([self.num_batches, self.n_input]), name=\"r\")\n\n \n #mean poisson\n self.px_rate = self.px_scale \n if self.scalings:\n self.px_rate = self.px_scale * tf.exp(self.library)\n\n #dropout\n if self.zi:\n self.px_dropout = dense(h, self.n_input, activation=None, \\\n bn=False, keep_prob=None, phase=self.training_phase)","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n mean = 0\n std_dev = 0.0001\n #print(in_features)\n #print(out_features)\n # create weight matrices\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\n #print(weight.shape)\n grad_weight = np.zeros((in_features, out_features))\n\n # create biases (in batches)\n bias = np.zeros(out_features)\n grad_bias = np.zeros(out_features)\n\n self.params = {'weight': weight, 'bias': bias}\n self.grads = {'weight': bias, 'bias': grad_bias}\n\n ########################\n # END OF YOUR CODE #\n #######################","def xlarge_model(optimizer='rmsprop', init='glorot_uniform', dropout=0.2):\n model = Sequential()\n model.add(Dropout(dropout, input_shape=(12,)))\n #model.add(Dense(18, input_dim=12, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\n model.add(Dense(16, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\n model.add(Dropout(dropout))\n model.add(Dense(16, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\n model.add(Dropout(dropout))\n model.add(Dense(16, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\n model.add(Dropout(dropout))\n model.add(Dense(1, kernel_initializer=init))\n # Compile model\n model.compile(loss='mean_squared_error', optimizer=optimizer)\n return model","def singlevar_model(optimizer='rmsprop', init='glorot_uniform', dropout=0.2):\n model = keras.models.Sequential()\n model.add(Dense(1, input_dim=1, kernel_initializer=init, activation='relu'))\n model.add(Dropout(dropout))\n model.add(Dense(1, kernel_initializer=init))\n # Compile model\n model.compile(loss='mean_squared_error', optimizer=optimizer)\n return model","def __init__(self, numpy_rng, input, n_in, hidden_layers_sizes, n_out):\n # instance variables\n self.numpy_rng = numpy_rng\n self.input = input\n self.n_in = n_in\n self.hidden_layers_sizes = hidden_layers_sizes\n self.n_layers = len(hidden_layers_sizes)\n self.n_out = n_out\n\n self.hidden_layers = []\n self.params = []\n\n self.initialize_variables()\n\n\n ################\n ## Prediction ##\n ################\n self.y_pred = self.logistic_regression_layer.y_pred","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def build_model(input_dim, hidden_neurons, output_dim):\n\tmodel = Sequential([\n \tDense(hidden_neurons, input_dim=input_dim),\n Activation('relu'),\n Dropout(0.2),\n Dense(hidden_neurons),\n Activation('relu'),\n Dropout(0.2),\n Dense(output_dim, activation='softmax')\n ])\n\n\tmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\treturn model","def __init__(self, dim_in, dim_out, weight_decay, dropout=0.,\r\n act=lambda x:x, bias=True, model_pretrain=None, **kwargs):\r\n super(Dense, self).__init__(**kwargs)\r\n self.dropout = dropout\r\n self.act = F_ACT[act]\r\n self.bias = bias\r\n self.dim_in = dim_in\r\n self.dim_out = dim_out\r\n self.weight_decay = weight_decay\r\n\r\n with tf.variable_scope(self.name + '_vars'):\r\n if model_pretrain is None:\r\n self.vars['weights'] = tf.get_variable('weights', shape=(dim_in, dim_out),\r\n dtype=DTYPE,\r\n initializer=tf.contrib.layers.xavier_initializer(),\r\n regularizer=tf.contrib.layers.l2_regularizer(self.weight_decay))\r\n if self.bias:\r\n self.vars['bias'] = zeros([dim_out],name='bias')\r\n else:\r\n self.vars['weights'] = trained(model_pretrain[0], name='weight')\r\n if self.bias:\r\n self.vars['bias'] = trained(model_pretrain[1], name='bias')\r\n if self.logging:\r\n self._log_vars()","def __init__(self, units, activation=tf.nn.softmax):\n\n super(MyDense, self).__init__()\n\n self.units = units\n self.activation = activation","def MLP(input_h, num_layers, out_dim, name=\"MLP\", activation=tf.nn.relu, reuse=None):\n with tf.variable_scope(name, reuse=reuse):\n h = input_h\n for i in range(num_layers):\n h = tf.layers.dense(\n h, out_dim, \n use_bias=True, activation=activation,\n name=\"mlp{}\".format(i),\n reuse = reuse\n )\n h = tf.layers.dense(\n h, out_dim, use_bias=True, name=\"mlp_out\", reuse=reuse\n )\n return h","def __init__(self, input_size, output_size, hidden_sizes=[],\r\n learning_rate=2.0, weight_scale=0.1, converge=0.01,\r\n random_seed=None):\r\n if random_seed is not None:\r\n seed(random_seed)\r\n\r\n weight_func = partial(normal, 0, weight_scale)\r\n self.converge = converge\r\n self.layers = []\r\n self.layers.append([InputNode(\"in_\" + str(i)) for i in range(input_size)])\r\n for i,layer_size in enumerate(hidden_sizes):\r\n self.layers.append([SigmoidNode(\"hidden_\"+str(i)+\"-\"+str(j),\r\n learning_rate) for j in range(layer_size)])\r\n self.layers.append([SigmoidNode(\"out_\"+str(i), learning_rate) for i\r\n in range(output_size)])\r\n\r\n # densely connect consecutive layers\r\n for source_layer, dest_layer in zip(self.layers, self.layers[1:]):\r\n for source, dest in product(source_layer, dest_layer):\r\n edge = Edge(source, dest, weight_func)\r\n source.out_edges.append(edge)\r\n dest.in_edges.append(edge)\r\n\r\n # connect each node to bias\r\n self.bias = BiasNode()\r\n for layer in self.layers[1:]:\r\n for node in layer:\r\n e = Edge(self.bias, node, weight_func)\r\n node.in_edges.append(e)\r\n self.bias.out_edges.append(e)","def sparse_to_dense(sp_indices, output_shape, values, default_value=0):\n\n assert len(sp_indices) == len(values), \\\n 'Length of sp_indices is not equal to length of values'\n\n array = np.ones(output_shape) * default_value\n for idx, value in zip(sp_indices, values):\n array[tuple(idx)] = value\n return array","def vae_decoder(self):\n return stax.serial(\n stax.Dense(self.hidden_dims[1], W_init=stax.randn()),\n stax.Relu,\n stax.Dense(self.hidden_dims[0], W_init=stax.randn()),\n stax.Relu,\n stax.Dense(self.out_dim, W_init=stax.randn()) \n )","def _identity_dense(d, dtype=complex):\n return np.eye(d, dtype=dtype)","def output(x_tensor, num_outputs, name=\"output\"):\n with tf.name_scope(name):\n return tf.layers.dense(x_tensor, num_outputs)","def __init__(\n self,\n units,\n activation=None,\n use_bias=True,\n kernel_initializer='glorot_uniform',\n bias_initializer='zeros',\n kernel_regularizer=None,\n bias_regularizer=None,\n **kwargs\n ):\n super(Dense, self).__init__(**kwargs)\n self.input_dim = kwargs.get('input_dim', None)\n self.units = int(units)\n self.activation = activations.get(activation)\n self.use_bias = use_bias\n self.kernel_initializer = initializers.get(kernel_initializer)\n self.bias_initializer = initializers.get(bias_initializer)\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\n self.bias_regularizer = regularizers.get(bias_regularizer)\n self.input_spec = InputSpec(min_ndim=2)\n self.kernel = None\n self.bias = None","def create_dense_model(\n input_shape: Tuple[int, int] = (64, 64),\n n_hidden: int = 1,\n n_units: int = 7,\n activation: Union[str, Callable] = \"relu\",\n optimizer: Union[str, tf.keras.optimizers.Optimizer] = \"adam\",\n loss: Union[str, tf.keras.losses.Loss] = \"binary_crossentropy\",\n metrics=None,\n) -> tf.keras.Model:\n model = tf.keras.models.Sequential()\n model.add(tf.keras.layers.Flatten(input_shape=input_shape))\n for _ in range(n_hidden):\n model.add(tf.keras.layers.Dense(n_units, activation=activation))\n model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))\n model.compile(optimizer=optimizer, loss=loss, metrics=metrics)\n return model","def __init__(self, input, n_in, n_out):\r\n # start-snippet-1\r\n # initialize with 0 the weights W as a matrix of shape (n_in, n_out)\r\n self.W = theano.shared(value=np.zeros((n_in, n_out), dtype=theano.config.floatX), name='W', borrow=True)\r\n # initialize the biases b as a vector of n_out 0s\r\n self.b = theano.shared(value=np.zeros((n_out,), dtype=theano.config.floatX), name='b', borrow=True)\r\n\r\n # symbolic expression for computing the matrix of class-membership\r\n # probabilities\r\n # Where:\r\n # W is a matrix where column-k represent the separation hyperplane for class-k\r\n # x is a matrix where row-j represents input training sample-j\r\n # b is a vector where element-k represent the free parameter of hyperplane-k\r\n # p_y_given_x is a matrix\r\n self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)\r\n\r\n # symbolic description of how to compute prediction as class whose\r\n # probability is maximal\r\n self.y_pred = T.argmax(self.p_y_given_x, axis=1)\r\n self.y_pred_prob = T.max(self.p_y_given_x, axis=1)\r\n\r\n # parameters of the model\r\n self.params = [self.W, self.b]\r\n\r\n # keep track of model input\r\n self.input = input","def todense(self):\n d = np.zeros(self.shape)\n for index,value in zip(self.index, self.value):\n d[index] = value\n return d","def __create_dense_net(nb_classes, img_input, include_top, depth=40,\n nb_dense_block=3, growth_rate=12, nb_filter=-1,\n nb_layers_per_block=-1, bottleneck=False,\n reduction=0.0, dropout_rate=None, weight_decay=1e-4,\n subsample_initial_block=False, activation='softmax'):\n\n concat_axis = 1 if K.image_data_format() == 'channels_first' else -1\n\n if reduction != 0.0:\n assert 0.0 < reduction <= 1.0, \\\n 'reduction value must lie between 0.0 and 1.0'\n\n # layers in each dense block\n if type(nb_layers_per_block) is list or \\\n type(nb_layers_per_block) is tuple:\n nb_layers = list(nb_layers_per_block) # Convert tuple to list\n\n assert len(nb_layers) == nb_dense_block, \\\n 'If list, nb_layer is used as provided. ' \\\n 'Note that list size must be (nb_dense_block)'\n final_nb_layer = nb_layers[-1]\n nb_layers = nb_layers[:-1]\n else:\n if nb_layers_per_block == -1:\n assert (depth - 4) % 3 == 0, \\\n 'Depth must be 3 N + 4 if nb_layers_per_block == -1'\n count = int((depth - 4) / 3)\n\n if bottleneck:\n count = count // 2\n\n nb_layers = [count for _ in range(nb_dense_block)]\n final_nb_layer = count\n else:\n final_nb_layer = nb_layers_per_block\n nb_layers = [nb_layers_per_block] * nb_dense_block\n\n # compute initial nb_filter if -1, else accept users initial nb_filter\n if nb_filter <= 0:\n nb_filter = 2 * growth_rate\n\n # compute compression factor\n compression = 1.0 - reduction\n\n # Initial convolution\n if subsample_initial_block:\n initial_kernel = (7, 7)\n initial_strides = (2, 2)\n else:\n initial_kernel = (3, 3)\n initial_strides = (1, 1)\n\n x = Conv2D(nb_filter, initial_kernel, kernel_initializer='he_normal',\n padding='same', strides=initial_strides, use_bias=False,\n kernel_regularizer=l2(weight_decay))(img_input)\n\n if subsample_initial_block:\n x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5,\n fused=fuse)(x)\n x = Activation('relu')(x)\n x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)\n\n # Add dense blocks\n for block_idx in range(nb_dense_block - 1):\n x, nb_filter = __dense_block(\n x, nb_layers[block_idx], nb_filter, growth_rate,\n bottleneck=bottleneck, dropout_rate=dropout_rate,\n weight_decay=weight_decay\n )\n # add transition_block\n x = __transition_block(x, nb_filter, compression=compression,\n weight_decay=weight_decay)\n nb_filter = int(nb_filter * compression)\n\n # The last dense_block does not have a transition_block\n x, nb_filter = __dense_block(\n x, final_nb_layer, nb_filter, growth_rate, bottleneck=bottleneck,\n dropout_rate=dropout_rate, weight_decay=weight_decay\n )\n\n x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5, fused=fuse)(x)\n x = Activation('relu')(x)\n x = GlobalAveragePooling2D()(x)\n\n if include_top:\n x = Dense(nb_classes, activation=activation)(x)\n\n return x","def bprop_sparse_tensor_get_dense_shape(sparse_tensor, out, dout):\n return (zeros_like(sparse_tensor),)","def __init__(self, inputLayerSize, outputLayerSize, \\\n hiddenLayerSize):\n #Network hyperparameters - neurons per layer - **not altered by training**\n self.inputLayerSize = inputLayerSize\n self.outputLayerSize = outputLayerSize\n self.hiddenLayerSize = hiddenLayerSize\n self.num_params = inputLayerSize * hiddenLayerSize + \\\n hiddenLayerSize * outputLayerSize + hiddenLayerSize \\\n + outputLayerSize\n #--Weights--\n #w_ih - weights of synapses linking input -> hidden\n self.w_ih = np.random.randn( self.inputLayerSize, \\\n self.hiddenLayerSize)\n #w_ho - weights of synapses linking hidden -> output\n self.w_ho = np.random.randn( self.hiddenLayerSize, \\\n self.outputLayerSize)\n \n #--Biases--\n #b_h - biases of hidden layer\n self.b_h = np.random.randn( self.hiddenLayerSize )\n #b_o - biases of output layer\n self.b_o = np.random.randn( self.outputLayerSize )","def __init__(self, inputSize, outputSize, hiddenSize): \n\n self.inputSize = inputSize\n self.outputSize = outputSize\n self.hiddenSize = hiddenSize \n \n # Initialize random weight with range [-0.5, 0.5]\n self.weight = np.matrix(np.random.uniform(-0.5, 0.5, (self.hiddenSize, self.inputSize)))\n\n # Initialize random bias with range [0, 1]\n self.bias = np.matrix(np.random.uniform(0, 1, (1, self.hiddenSize)))\n \n self.H = 0\n self.beta = 0","def build_mlp(input_placeholder, output_size, scope, n_layers, size, activation=tf.tanh, output_activation=None):\n output_placeholder = input_placeholder\n with tf.variable_scope(scope):\n for _ in range(n_layers):\n output_placeholder = tf.layers.dense(output_placeholder, size, activation=activation) # HINT: use tf.layers.dense (specify <input>, <size>, activation=<?>)\n output_placeholder = tf.layers.dense(output_placeholder, output_size, activation=output_activation) # HINT: use tf.layers.dense (specify <input>, <size>, activation=<?>)\n return output_placeholder","def denseFeature(self, feat):\n return {'feat': feat}","def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\n network = Sequential()\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\n return network","def __init__(self, input, n_in, n_out):\r\n # start-snippet-1\r\n\r\n # initialize with 0 the weights W as a matrix of shape (n_in, n_out)\r\n self.W = theano.shared( value=numpy.zeros( (n_in, n_out), dtype=theano.config.floatX ), name='W', borrow=True )\r\n\r\n # initialize the baises b as a vector of n_out 0s\r\n self.b = theano.shared(value=numpy.zeros( (n_out,), dtype=theano.config.floatX ), name='b', borrow=True )\r\n\r\n # symbolic expression for computing the matrix of class-membership probabilities where:\r\n # W is a matrix where column-k represent the separation hyper plain for class-k\r\n # x is a matrix where row-j represents input training sample-j\r\n # b is a vector where element-k represent the free parameter of hyper plane-k\r\n self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)\r\n\r\n # symbolic description of how to compute prediction as class whose probability is maximal\r\n self.y_pred = T.argmax(self.p_y_given_x, axis=1)\r\n # end-snippet-1\r\n\r\n # parameters of the model\r\n self.params = [self.W, self.b]\r\n\r\n # keep track of model input\r\n self.input = input","def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\n shape = tuple([None]+list(input_shape[1:]))\n print(shape)\n l_in = lasagne.layers.InputLayer(shape=shape)\n\n print(\"Input shape: \",lasagne.layers.get_output_shape(l_in))\n\n # print(shaped_units)\n # shaped_units = shaped_units[0]\n shaped_units = 2800\n\n # print(shape)\n\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\n l_in, \n num_filters=8,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n print(\"Conv 2D shape: \",lasagne.layers.get_output_shape(l_conv2D_1))\n\n l_reshape_1 = lasagne.layers.ReshapeLayer(\n l_conv2D_1,\n shape=(([0], -1))\n )\n\n print(\"Reshape 1 shape: \", lasagne.layers.get_output_shape(l_reshape_1))\n\n l_hidden_1 = lasagne.layers.DenseLayer(\n l_reshape_1,\n num_units= num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 1 shape: \", lasagne.layers.get_output_shape(l_hidden_1))\n\n l_code_layer = lasagne.layers.DenseLayer(\n l_hidden_1,\n num_units=num_code_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Code layer shape: \",lasagne.layers.get_output_shape(l_code_layer))\n\n l_hidden_2 = lasagne.layers.DenseLayer(\n l_code_layer,\n num_units=num_hidden_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 2 shape: \",lasagne.layers.get_output_shape(l_hidden_2))\n\n l_hidden_3 = lasagne.layers.DenseLayer(\n l_hidden_2,\n num_units=shaped_units,\n nonlinearity=lasagne.nonlinearities.rectify,\n )\n\n print(\"Hidden 3 shape: \",lasagne.layers.get_output_shape(l_hidden_3))\n\n l_reshape_2 = lasagne.layers.ReshapeLayer(\n l_hidden_3,\n shape=(([0],8,7,50))\n )\n\n print(\"Reshape 2 shape: \",lasagne.layers.get_output_shape(l_reshape_2))\n\n l_out = lasagne.layers.Conv2DLayer(\n l_reshape_2, \n num_filters=1,\n filter_size=filter_size, \n stride=(1, 1), \n border_mode=\"valid\", \n untie_biases=False, \n nonlinearity=None,\n )\n\n # print(\"Deconv shape: \",lasagne.layers.get_output_shape(l_deconv2D_1))\n\n print(\"Output shape: \",lasagne.layers.get_output_shape(l_out))\n\n return l_out","def model_d(input_shape=(None, 28, 28, 1), nb_classes=10):\n\n # Define a fully connected model (it's different than the black-box)\n layers = [Flatten(),\n Linear(200),\n ReLU(),\n Dropout(0.5),\n Linear(200),\n ReLU(),\n Linear(nb_classes),\n Softmax()]\n\n return DefenseMLP(layers, input_shape)","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n \n self.grads = {'weight': np.zeros((out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n ########################\n # END OF YOUR CODE #\n #######################","def mlp(\n\t# input_shape: Tuple[int, ...],\n\t# output_shape: Tuple[int, ...],\n\t# layer_size: int = 128,\n\t# dropout_amount: float = 0.2,\n\t# num_layers: int = 3, \n\tnet_config: Dict\n)->Model:\n\tactivation_fn = net_config[\"hyperparams\"][\"activation_fn\"]\n\tinput_s = net_config[\"shapes\"][\"input_shape\"]\n\toutput_s = net_config[\"shapes\"][\"output_shape\"]\n\n\tinputs = keras.Input(shape=(input_s,))\n\tdense = layers.Dense(64, activation=\"relu\")\n\tx = dense(inputs)\n\tlayer1 = layers.Dense(64, activation=activation_fn)(x)\n\tlayer2 = layers.Dense(64, activation=activation_fn)(layer1)\n\toutputs = layers.Dense(output_s)(layer2)\n\tmodel = keras.Model(inputs=inputs, outputs=outputs, name=\"house_pred\")\n\t\n\treturn model","def __init__(self):\n super(Model, self).__init__()\n\n self.batch_size = 200\n self.hidden_size = 264\n self.optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\n\n self.dense_1 = tf.keras.layers.Dense(self.hidden_size, activation='relu')\n self.dense_2 = tf.keras.layers.Dense(self.hidden_size, activation='relu')","def __init__(self, rng, pool_shape, input_shape, pooler=T.max, depooler='random'):\n \n self.pool_shape = pool_shape\n self.input_shape = input_shape\n self.output_shape = (input_shape[0], input_shape[1], input_shape[2]//self.pool_shape[0])\n self.theano_rng = RandomStreams(rng.randint(2 ** 30))\n self.pooler = pooler \n self.depooler = depooler\n self.params = []","def __init__(self):\n self.out = None\n self.in_shape = None\n self.work_shape = None","def __init__(self, input, n_in, n_out):\r\n\r\n # initialize with 0 the weights W as a matrix of shape (n_in, n_out)\r\n self.W = theano.shared(value=numpy.zeros((n_in, n_out),\r\n dtype=theano.config.floatX),\r\n name='W', borrow=True)\r\n # initialize the baises b as a vector of n_out 0s\r\n self.b = theano.shared(value=numpy.zeros((n_out,),\r\n dtype=theano.config.floatX),\r\n name='b', borrow=True)\r\n\r\n # compute vector of class-membership probabilities in symbolic form\r\n self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)\r\n\r\n # compute prediction as class whose probability is maximal in\r\n # symbolic form\r\n self.y_pred = T.argmax(self.p_y_given_x, axis=1)\r\n\r\n # parameters of the model\r\n self.params = [self.W, self.b]","def softmax_to_dense(sparse, dim):\n dtype = sparse.dtype\n device = sparse.device\n dense = to_dense(sparse, fill_value=-float('inf'))\n r = F.softmax(dense, dim)\n # softmax on empty lines results nan, replace with zeros to match the definition\n r[r != r] = 0\n return r","def fully_conn(x_tensor, num_outputs):\n # TODO: Implement Function\n y = tf.layers.dense(x_tensor,units = num_outputs,activation=tf.nn.relu)\n return y","def __init__(self, hidden_dims, input_dim=3*32*32, num_classes=10,\n dropout=1, normalization=None, reg=0.0,\n weight_scale=1e-2, dtype=np.float32, seed=None):\n self.normalization = normalization\n self.use_dropout = dropout != 1\n self.reg = reg\n self.num_layers = 1 + len(hidden_dims)\n self.dtype = dtype\n self.params = {}\n\n ############################################################################\n # TODO: Initialize the parameters of the network, storing all values in #\n # the self.params dictionary. Store weights and biases for the first layer #\n # in W1 and b1; for the second layer use W2 and b2, etc. #\n # When using batch normalization, store scale and shift parameters for the #\n # first layer in gamma1 and beta1; for the second layer use gamma2 and #\n # beta2, etc. Scale parameters should be initialized to ones and shift #\n # parameters should be initialized to zeros. #\n ############################################################################\n input_size = input_dim\n for i in range(len(hidden_dims)):\n output_size = hidden_dims[i]\n self.params['W' + str(i+1)] = np.random.randn(input_size,output_size) * weight_scale\n self.params['b' + str(i+1)] = np.zeros(output_size)\n if self.normalization:\n self.params['gamma' + str(i+1)] = np.ones(output_size)\n self.params['beta' + str(i+1)] = np.zeros(output_size)\n input_size = output_size # 下一层的输入\n # 输出层，没有BN操作\n self.params['W' + str(self.num_layers)] = np.random.randn(input_size,num_classes) * weight_scale\n self.params['b' + str(self.num_layers)] = np.zeros(num_classes)\n # When using dropout we need to pass a dropout_param dictionary to each\n # dropout layer so that the layer knows the dropout probability and the mode\n # (train / test). You can pass the same dropout_param to each dropout layer.\n self.dropout_param = {}\n if self.use_dropout:\n self.dropout_param = {'mode': 'train', 'p': dropout}\n if seed is not None:\n self.dropout_param['seed'] = seed\n\n # With batch normalization we need to keep track of running means and\n # variances, so we need to pass a special bn_param object to each batch\n # normalization layer. You should pass self.bn_params[0] to the forward pass\n # of the first batch normalization layer, self.bn_params[1] to the forward\n # pass of the second batch normalization layer, etc.\n self.bn_params = []\n if self.normalization=='batchnorm':\n self.bn_params = [{'mode': 'train'} for i in range(self.num_layers - 1)]\n if self.normalization=='layernorm':\n self.bn_params = [{} for i in range(self.num_layers - 1)]\n\n # Cast all parameters to the correct datatype\n for k, v in self.params.items():\n self.params[k] = v.astype(dtype)","def _build_network(self,\n input_dim,\n dense_layers,\n nodes_per_layer=None,\n hidden_act='relu',\n output_act='sigmoid',\n dropout_layers=None):\n\n if nodes_per_layer is None:\n nodes = [10] * dense_layers\n else:\n nodes = nodes_per_layer\n\n if dropout_layers is None:\n do_layers = [0] * dense_layers\n else:\n do_layers = dropout_layers\n\n self.model.add(Dense(nodes[0], input_dim=input_dim,\n activation=hidden_act))\n\n if dense_layers > 1:\n for l in range(1, dense_layers - 1):\n if do_layers[l - 1] != 0:\n self.model.add(Dropout(do_layers[l - 1]))\n\n self.model.add(Dense(nodes[l], activation=hidden_act))\n\n self.model.add(Dense(1, activation=output_act))","def get_bprop_sparse_to_dense(self):\n\n def bprop(indices, values, dense_shape, out, dout):\n return zeros_like(indices), dout, zeros_like(dense_shape)\n\n return bprop","def to_dense(self):\n rep = self.rep\n\n if rep.fmt == 'dense':\n return self\n\n return self.from_rep(rep.to_dfm_or_ddm())","def create_cnn2D(input_shape, classes, conv_layers=4, filters=32, \n kernel_size=(3,3), padding='same', pool_size=(2,2), \n conv_activation=\"relu\", dropout_rate=0.0, \n dense_activation='softmax', global_avg_pool=True,\n optimizer=\"Adam\", loss=\"categorical_crossentropy\", \n **hyper_params):\n dropout_layers = conv_layers // 2 # dropout for each layer\n pooling_layers = conv_layers - 1\n \n model = keras.Sequential()\n for i in range(conv_layers):\n model.add(Conv2D(filters, kernel_size, padding=padding, \n activation=conv_activation))\n filters *= 2\n if (i + 1) <= pooling_layers:\n model.add(MaxPooling2D(pool_size))\n if (i + 1) <= dropout_layers:\n model.add(Dropout(rate=dropout_rate))\n \n if global_avg_pool:\n model.add(GlobalAveragePooling2D())\n \n if classes == 2:\n model.add(Dense(1, activation=dense_activation))\n else:\n model.add(Dense(classes, activation=dense_activation))\n model.build(input_shape=input_shape)\n \n if optimizer.lower() == \"sgd\":\n optimizer = keras.optimizers.SGD(**hyper_params)\n elif optimizer.lower() == \"adam\":\n optimizer = keras.optimizers.Adam(**hyper_params)\n \n model.compile(optimizer=optimizer, loss=loss.lower(), metrics=[\"accuracy\"])\n \n return model","def __init__(self,\n dense: np.ndarray = None,\n H: np.ndarray = None,\n M: np.ndarray = None,\n dense_shape=None,\n ground_state=None):\n\n self.dense_shape = dense_shape if dense_shape else dense.shape\n\n if ground_state is None:\n self.ground_state = np.zeros(self.dense_shape[2], dtype=dense.dtype if dense is not None else M.dtype)\n else:\n if len(ground_state) != self.dense_shape[2]:\n raise ValueError(\"One ground-state value must be provided for each channel\")\n self.ground_state = ground_state\n\n if dense is not None:\n self._from_dense(dense)\n else:\n self.H = H\n self.M = M","def dense_kwargs(weight_matrix):\n return {\"kernel_initializer\": initializers.Constant(weight_matrix)}","def create_classifier(in_dim, hid_dim, out_dim):\n W = np.ones((in_dim, hid_dim))\n b = np.ones(hid_dim)\n U = np.ones((hid_dim, out_dim))\n b_tag = np.ones(out_dim)\n\n W = np.random.randn(W.shape[0], W.shape[1])\n U = np.random.randn(U.shape[0], U.shape[1])\n b = np.random.randn(b.shape[0])\n b_tag = np.random.randn(b_tag.shape[0])\n params = [W, b, U, b_tag]\n return params","def cvxopt2dense(value):\n return np.array(value)","def __init__(self, attribute_size, output_size, n_hidden_layers=2, n_hidden_neurons=30):\n self.n_hidden_layers = n_hidden_layers\n self.n_hidden_neurons = n_hidden_neurons\n self.attribute_size = attribute_size\n self.output_size = output_size\n\n X = T.fmatrix()\n Y = T.fmatrix()\n\n self.w_h = nnet.init_weights((self.attribute_size, self.n_hidden_neurons))\n self.w_h2 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\n self.w_o = nnet.init_weights((self.n_hidden_neurons, self.output_size))\n\n if self.n_hidden_layers == 2:\n\n noise_py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\n py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\n\n cost = nnet.rmse(noise_py_x, Y)\n params = [self.w_h, self.w_h2, self.w_o]\n updates = nnet.RMSprop(cost, params, lr=0.001)\n\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\n\n elif self.n_hidden_layers == 3:\n\n self.w_h3 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\n\n noise_py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\n py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\n\n cost = nnet.rmse(noise_py_x, Y)\n params = [self.w_h, self.w_h2, self.w_h3, self.w_o]\n updates = nnet.RMSprop(cost, params, lr=0.001)\n\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)","def __init__(self, in_features, out_features):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n self.in_features = in_features\n self.out_features = out_features\n\n self.__MEAN = 0\n self.__STD = 0.0001\n\n self.params = {\n 'weight': np.random.normal(loc=self.__MEAN, scale=self.__STD, size=(out_features, in_features)), \n 'bias': np.zeros(out_features),\n }\n self.grads = {\n 'weight': None, \n 'bias': None,\n }\n\n self.input_cache = None\n ########################\n # END OF YOUR CODE #\n #######################","def dense_reparameterization(\n inputs,\n units,\n activation=None,\n activity_regularizer=None,\n trainable=True,\n kernel_posterior_fn=default_mean_field_normal_fn(),\n kernel_posterior_tensor_fn=lambda d: d.sample(),\n kernel_prior_fn=lambda dtype, *args: normal_lib.Normal( # pylint: disable=g-long-lambda\n loc=dtype.as_numpy_dtype(0.), scale=dtype.as_numpy_dtype(1.)),\n kernel_divergence_fn=lambda q, p, ignore: kl_lib.kl_divergence(q, p),\n bias_posterior_fn=default_mean_field_normal_fn(is_singular=True),\n bias_posterior_tensor_fn=lambda d: d.sample(),\n bias_prior_fn=None,\n bias_divergence_fn=lambda q, p, ignore: kl_lib.kl_divergence(q, p),\n name=None,\n reuse=None):\n layer = DenseReparameterization(\n units,\n activation=activation,\n activity_regularizer=activity_regularizer,\n trainable=trainable,\n kernel_posterior_fn=kernel_posterior_fn,\n kernel_posterior_tensor_fn=kernel_posterior_tensor_fn,\n kernel_prior_fn=kernel_prior_fn,\n kernel_divergence_fn=kernel_divergence_fn,\n bias_posterior_fn=bias_posterior_fn,\n bias_posterior_tensor_fn=bias_posterior_tensor_fn,\n bias_prior_fn=bias_prior_fn,\n bias_divergence_fn=bias_divergence_fn,\n name=name,\n dtype=inputs.dtype.base_dtype,\n _scope=name,\n _reuse=reuse)\n return layer.apply(inputs)","def DenseNet(self, input_shape, nb_dense_block=4, growth_rate=48, nb_filter=96, reduction=0.0,\n\t\t\t\t\t\t\t dropout_rate=0.25, weight_decay=1e-4, classes=1000, weights_path=None,\n\t\t\t\t\t\t\t include_top=True):\n\t\teps = 1.1e-5\n\n\t\t# compute compression factor\n\t\tcompression = 1.0 - reduction\n\n\t\t# Handle Dimension Ordering for different backends\n\t\tif K.image_dim_ordering() == \"tf\":\n\t\t\tself.concat_axis = 3\n\t\telse:\n\t\t\tself.concat_axis = 1\n\t\timg_input = Input(shape=input_shape, name=\"data\")\n\n\t\t# From architecture for ImageNet (Table 1 in the paper)\n\t\tnb_filter = 64\n\t\tnb_layers = [6,12,24,16] # For DenseNet-121\n\n\t\t# Initial convolution\n\t\tx = ZeroPadding2D((3, 3), name=\"conv1_zeropadding\")(img_input)\n\t\tx = Conv2D(nb_filter, (7, 7), strides=(2, 2), name=\"conv1\", use_bias=False)(x)\n\t\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=\"conv1_bn\")(x)\n\t\tx = Scale(axis=self.concat_axis, name=\"conv1_scale\")(x)\n\t\tx = Activation(\"relu\", name=\"relu1\")(x)\n\t\tx = ZeroPadding2D((1, 1), name=\"pool1_zeropadding\")(x)\n\t\tx = MaxPooling2D((3, 3), strides=(2, 2), name=\"pool1\")(x)\n\n\t\t# Add dense blocks\n\t\tfor block_idx in range(nb_dense_block - 1):\n\t\t\tstage = block_idx+2\n\t\t\tx, nb_filter = self.__dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)\n\n\t\t\t# Add __transition_block\n\t\t\tx = self.__transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay)\n\t\t\tnb_filter = int(nb_filter * compression)\n\n\t\tfinal_stage = stage + 1\n\t\tx, nb_filter = self.__dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)\n\n\t\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=\"conv\"+str(final_stage)+\"_blk_bn\")(x)\n\t\tx = Scale(axis=self.concat_axis, name=\"conv\"+str(final_stage)+\"_blk_scale\")(x)\n\t\tx = Activation(\"relu\", name=\"relu\"+str(final_stage)+\"_blk\")(x)\n\t\tif include_top:\n\t\t\tx = GlobalAveragePooling2D(name=\"pool\"+str(final_stage))(x)\n\n\t\t\tx = Dense(classes, name=\"fc6\")(x)\n\t\t\tx = Activation(\"softmax\", name=\"prob\")(x)\n\n\t\tmodel = keras.models.Model(img_input, x, name=\"densenet\")\n\n\t\tif weights_path is not None:\n\t\t\tmodel.load_weights(weights_path, by_name=True)\n\n\t\treturn model","def __init__(self,\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\n in2hid: tuple, in2out: tuple,\n hid2hid: tuple, hid2out: tuple,\n hidden_biases: np.ndarray, output_biases: np.ndarray,\n rnn_array: np.ndarray, rnn_map: np.ndarray,\n activation,\n batch_size: int = 1,\n initial_read: np.ndarray = None,\n dtype=np.float64,\n ):\n # Storing the input arguments (needed later on)\n self.act_f = activation\n self.dtype = dtype\n self.rnn_idx: np.ndarray = rnn_idx\n self.n_inputs: int = len(input_idx)\n self.n_hidden: int = len(hidden_idx)\n self.n_rnn: int = len(rnn_idx)\n self.n_outputs: int = len(output_idx)\n self.bs: int = batch_size\n \n # Setup the rnn_map\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\n for i, m in enumerate(rnn_map):\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\n \n # Placeholders, initialized during reset\n self.rnn_state: np.ndarray = None # State of the RNNs\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\n self.output_act: np.ndarray = None # Activations of the output nodes\n \n # Do not create the hidden-related matrices if hidden-nodes do not exist\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\n if self.n_hidden > 0:\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\n self.rnn_array: np.ndarray = rnn_array\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\n \n # Fill in the biases\n if self.n_hidden > 0:\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\n \n # Put network to initial (default) state\n self.reset(initial_read=initial_read)","def mlp_model2():\n model = Sequential()\n model.add(Dense(256, activation='relu', input_shape=(X_train_scaled.shape[1], )))\n model.add(Dropout(0.2))\n model.add(Dense(128, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(64, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(32, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(FLAGS.nb_classes, activation='softmax'))\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n\n model.summary()\n return model","def train_etd(X, num_hidden=10, random_seed=0, sparse=False, kernel=False):\n #svd = TruncatedSVD(n_components=num_hidden, n_iter=7, random_state=random_seed);\n svd = PCA(n_components=num_hidden);\n svd.fit(np.reshape(X, (X.shape[0], -1)));\n embed_func = lambda y : svd.transform(np.reshape(y, (y.shape[0], -1)))\n return embed_func","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\n\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def medium2_model(optimizer='rmsprop', init='glorot_uniform', dropout=0.25):\n model = Sequential()\n model.add(Dropout(dropout, input_shape=(12,)))\n model.add(Dense(32, input_dim=12, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(4)))\n model.add(Dropout(dropout))\n model.add(Dense(32, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(4)))\n model.add(Dropout(dropout))\n model.add(Dense(1, kernel_initializer=init))\n # Compile model\n model.compile(loss='mean_squared_error', optimizer=optimizer)\n return model","def get_core_net(embedding_size=128, vocab_size=20000, nout=10, dropout_rate = 0.5, activation_function = 1):\n if activation_function == 1:\n af = Tanh()\n if activation_function == 2:\n af = Explin(alpha=0)\n if activation_function == 3:\n af = Logistic()\n if activation_function == 4:\n af = Normalizer()\n\n \n embedding_dim = embedding_size\n uni = Uniform(low=-0.1/embedding_dim, high=0.1/embedding_dim)\n glorot = GlorotUniform()\n\n enc = [\n LookupTable(vocab_size=vocab_size, embedding_dim=embedding_dim, init=uni, pad_idx=0, update=True),\n LSTM(embedding_size, glorot, activation=af, gate_activation=Logistic(), reset_cells=True),\n RecurrentSum(),\n ]\n\n dec = [\n Dropout(keep=dropout_rate),\n Affine(nout, glorot, bias=glorot, activation=Softmax())\n ]\n\n cost, opt = get_cost_opt()\n return (enc, dec), cost, opt","def prepare_dense_label(input_batch, new_size, one_hot=True):\n with tf.name_scope('label_encode'):\n print(input_batch)\n # input_batch = tf.image.resize_nearest_neighbor(input_batch, new_size) # as labels are integer numbers, need to use NN interpolation\n # input_batch = tf.squeeze(input_batch, squeeze_dims=[3]) # reducing the channel dimension.\n # if one_hot:\n # input_batch = tf.one_hot(input_batch, depth=n_classes, axis=2)\n return input_batch"],"string":"[\n \"def dense(in_layer):\\n return Dense(neurons,\\n kernel_initializer=initializer())(in_layer)\",\n \"def init_dense(self, layer):\\n pass\",\n \"def dense(name, x, w=None, output_dim=128, initializer=tf.contrib.layers.xavier_initializer(), l2_strength=0.0,\\n bias=0.0, activation=None, batchnorm_enabled=False, dropout_keep_prob=-1, is_training=True):\\n with tf.variable_scope(name) as scope:\\n dense_o_b = dense_p(scope, x=x, w=w, output_dim=output_dim, initializer=initializer,\\n l2_strength=l2_strength, bias=bias)\\n\\n if batchnorm_enabled:\\n dense_o_bn = tf.layers.batch_normalization(dense_o_b, training=is_training)\\n else:\\n dense_o_bn = dense_o_b\\n\\n if activation is None:\\n dense_a = dense_o_bn\\n else:\\n dense_a = activation(dense_o_bn)\\n\\n if dropout_keep_prob != -1:\\n dense_o_dr = tf.nn.dropout(dense_a, keep_prob=dropout_keep_prob)\\n else:\\n dense_o_dr = dense_a\\n\\n dense_o = dense_o_dr\\n\\n return dense_o\",\n \"def dense(input, out_dims=None, dropout_keep_prob=1.0, nonlin=True, trainable=True):\\n input = tf.nn.dropout(input, dropout_keep_prob)\\n # Initial number of values for each residue\\n in_dims = input.get_shape()[-1].value\\n out_dims = in_dims if out_dims is None else out_dims\\n # Weights of the dense layer\\n W = tf.Variable(initializer(\\\"he\\\", [in_dims, out_dims]), name=\\\"w\\\", trainable=trainable)\\n b = tf.Variable(initializer(\\\"zero\\\", [out_dims]), name=\\\"b\\\", trainable=trainable)\\n # Operation performed in the dense layer\\n Z = tf.matmul(input, W) + b\\n if (nonlin):\\n nonlin = nonlinearity(\\\"relu\\\")\\n Z = nonlin(Z)\\n Z = tf.nn.dropout(Z, dropout_keep_prob)\\n return Z\",\n \"def initialize_dense(input_size, output_size):\\n # TODO: replace the initialization constant 0.01 in a more systematic approach\\n return np.random.randn(output_size, input_size) * 0.01\",\n \"def dense_nn(x):\\n dense_1 = tf.nn.dropout(tf.nn.relu(dense(x, input_dim, n_l1, 'dense_1')), keep_prob=0.25)\\n dense_2 = tf.nn.dropout(tf.nn.relu(dense(dense_1, n_l1, n_l2, 'dense_2')), keep_prob=0.25)\\n dense_3 = dense(dense_2, n_l2, n_labels, 'dense_3')\\n return dense_3\",\n \"def dense(x, \\n num_outputs,\\n STD=0.01,\\n keep_prob=None,\\n activation=None,\\n bn=False,\\n phase=None):\\n output = tf.identity(x)\\n \\n if keep_prob is not None:\\n output = tf.layers.dropout(output, rate=keep_prob, training=phase)\\n\\n output = slim.fully_connected(output, num_outputs, activation_fn=None, \\\\\\n weights_initializer=tf.truncated_normal_initializer(stddev=STD))\\n\\n if bn:\\n output = tf.layers.batch_normalization(output, training=phase)\\n \\n if activation: \\n output = activation(output)\\n \\n return output\",\n \"def build_dense(self): # Pass state_size and action_size\\n model = Sequential()\\n model.add(Dense(24, input_dim = grid_size*grid_size+2, activation = 'relu'))\\n model.add(Dense(24, activation = 'relu'))\\n model.add(Dense(len(ACTIONS), activation = 'linear'))\\n model.compile(loss = 'mse', optimizer = RMSprop(lr = alpha))\\n\\n return model\",\n \"def dense(x, size, name, weight_init=xavier):\\n w = tf.get_variable(name + \\\"/w\\\", [x.get_shape()[1], size], initializer=weight_init)\\n b = tf.get_variable(name + \\\"/b\\\", [size], initializer=tf.constant_initializer(0.0))\\n return tf.matmul(x, w) + b\",\n \"def dense(self, input_tensor, units, name, activation='linear'):\\n with tf.variable_scope('Dense', name):\\n init_w = tf.truncated_normal(shape=(self.num_channels(input_tensor),\\n units), dtype=tf.float32)\\n w = tf.Variable(init_w)\\n b = tf.Variable(tf.random_uniform(shape=(units, ), dtype=tf.float32))\\n\\n out_layer = tf.matmul(input_tensor, w) + b\\n out_layer = self.activations[activation](out_layer)\\n return out_layer\",\n \"def dense(x,num_nodes,activation='relu',name='',bias_init_val=0,reuse=None):\\n input_shape = x.get_shape()\\n with tf.variable_scope('dense',reuse=reuse):\\n \\tW=tf.get_variable('W'+name,initializer=tf.random_normal(stddev=.01,shape=[int(input_shape[-1]),num_nodes]))\\n \\tb=tf.get_variable('b'+name,initializer=tf.constant(bias_init_val,shape = [num_nodes],dtype=tf.float32))\\n \\n logits = tf.matmul(x,W)+b\\n \\n if activation == None:\\n y = logits\\n elif activation == 'relu':\\n y = tf.nn.relu(logits)\\n elif activation == 'sigmoid':\\n y = tf.nn.sigmoid(logits)\\n else:\\n raise ValueError(\\\"Enter a valid activation function\\\")\\n \\n return y\",\n \"def __init__(self, incoming, n_units, flatten_input=False, W=tf.zeros, b=tf.zeros, a=tf.sigmoid, name='DenseLayer'):\\n super(DenseLayer, self).__init__()\\n with tf.variable_scope(name) as self.layer_scope:\\n self.incoming, self.incoming_shape = get_input(incoming)\\n \\n if (len(self.incoming_shape) > 2) and flatten_input:\\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\\n elif len(self.incoming_shape) == 4:\\n incoming_shape = [self.incoming_shape[0], np.prod(self.incoming_shape[1:])]\\n elif len(self.incoming_shape) >= 5:\\n incoming_shape = [self.incoming_shape[0], self.incoming_shape[1], np.prod(self.incoming_shape[2:])]\\n else:\\n incoming_shape = self.incoming_shape\\n \\n # Set init for W\\n W = tofov(W, shape=[incoming_shape[-1], n_units], var_params=dict(name='W_dense'))\\n \\n # Set init for b\\n if b is not None:\\n b = tofov(b, [n_units], var_params=dict(name='b_dense'))\\n \\n self.a = a\\n self.b = b\\n self.W = W\\n \\n self.n_units = n_units\\n self.flatten_input = flatten_input\\n self.incoming_shape = incoming_shape\\n \\n self.out = tf.zeros(self.get_output_shape())\\n self.name = name\",\n \"def mlp(x, output_size, hidden_sizes=[64], activation=tf.tanh, output_activation=None):\\n for size in hidden_sizes:\\n x = tf.layers.dense(x, size, activation=activation)\\n return tf.layers.dense(x, output_size, activation=output_activation)\",\n \"def model(self, inputs):\\n h1 = dense(inputs, self.weights[0], self.biases[0], tf.nn.relu) #hidden layer 1\\n h2 = dense(h1, self.weights[1], self.biases[1], tf.nn.relu) #hidden layer 2\\n\\n out = dense(h2, self.weights[2], self.biases[2])\\n\\n return out\",\n \"def build_dense_network(model,\\n input_dim,\\n dense_layers,\\n nodes_per_layer=None,\\n hidden_act='relu',\\n output_act='sigmoid',\\n dropout_layers=None):\\n\\n if nodes_per_layer is None:\\n nodes = [10] * dense_layers\\n else:\\n nodes = nodes_per_layer\\n\\n if dropout_layers is None:\\n do_layers = [0] * dense_layers\\n else:\\n do_layers = dropout_layers\\n\\n model.add(Dense(nodes[0], input_dim=input_dim,\\n activation=hidden_act))\\n\\n if dense_layers > 1:\\n for l in range(1, dense_layers - 1):\\n if do_layers[l - 1] != 0:\\n model.add(Dropout(do_layers[l - 1]))\\n\\n model.add(Dense(nodes[l], activation=hidden_act))\\n\\n model.add(Dense(1, activation=output_act))\\n\\n return model\",\n \"def mlp(x, hidden_sizes=(32,), activation=tf.tanh, output_activation=None):\\n for h in hidden_sizes[:-1]:\\n x = tf.layers.dense(x, units=h, activation=activation)\\n return tf.layers.dense(x, units=hidden_sizes[-1], activation=output_activation)\",\n \"def initialize_dense_cost(height, width):\\n cost = sparse.initialize_dense_cost_cpp(height, width)\\n return cost\",\n \"def dense_block(x):\\n h1 = _conv_block(x, 32)\\n h1 = tf.keras.layers.Concatenate()([x, h1])\\n\\n h2 = _conv_block(h1, 32)\\n h2 = tf.keras.layers.Concatenate()([x, h1, h2])\\n\\n h3 = _conv_block(h2, 32)\\n h3 = tf.keras.layers.Concatenate()([x, h1, h2, h3])\\n\\n h4 = _conv_block(h3, 32)\\n h4 = tf.keras.layers.Concatenate()([x, h1, h2, h3, h4])\\n\\n h5 = _conv_block(h4, 32, activation=False)\\n\\n h5 = tf.keras.layers.Lambda(lambda x: x * 0.2)(h5)\\n h = tf.keras.layers.Add()([h5, x])\\n\\n return h\",\n \"def __init__(self, hidden_units, act_fn=activation_fn, output_shape=1, out_activation=None, out_layer=True):\\n super().__init__()\\n for u in hidden_units:\\n self.add(GaussianNoise(0.4)) # Or use kwargs\\n self.add(Dense(u, act_fn))\\n if out_layer:\\n self.add(GaussianNoise(0.4))\\n self.add(Dense(output_shape, out_activation))\",\n \"def build_model(input_classes,output_classes):\\n dimensions = 20\\n inputs = []\\n embedded_outputs = []\\n for i in input_classes:\\n input_layer = Input((1,))\\n inputs.append(input_layer)\\n embedder = Embedding(input_dim=i,output_dim=dimensions,input_length=1,embeddings_constraint=UnitNorm(axis=0))\\n embedded_layer = embedder(input_layer)\\n embedded_outputs.append(embedded_layer)\\n\\n embedded_concats = Concatenate()(embedded_outputs)\\n flatten_layer = Flatten()\\n\\n dense_layer = Dense(output_classes)\\n\\n flattened_output = flatten_layer(embedded_concats)\\n dense_output = dense_layer(flattened_output)\\n\\n # dense_output = dense_layer(embedded_concats)\\n\\n model = Model(inputs,dense_output)\\n print(model.summary())\\n model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')\\n\\n return model\",\n \"def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2,num_hidden_units_3, num_code_units, batch_size=BATCH_SIZE):\\n shape = tuple([None]+list(input_shape[1:]))\\n print(shape)\\n l_in = lasagne.layers.InputLayer(shape=shape)\\n\\n l_hidden_1 = lasagne.layers.DenseLayer(\\n l_in,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_2 = lasagne.layers.DenseLayer(\\n l_hidden_1,\\n num_units=num_hidden_units_2,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_hidden_2,\\n num_units=num_hidden_units_3,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_code_layer = lasagne.layers.DenseLayer(\\n l_hidden_3,\\n num_units=num_code_units,\\n nonlinearity=lasagne.nonlinearities.softmax,\\n )\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_code_layer,\\n num_units=num_hidden_units_3,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_4 = lasagne.layers.DenseLayer(\\n l_hidden_3,\\n num_units=num_hidden_units_2,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_hidden_5 = lasagne.layers.DenseLayer(\\n l_hidden_4,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n l_out = lasagne.layers.DenseLayer(\\n l_hidden_5,\\n num_units=output_dim,\\n nonlinearity=None,\\n )\\n\\n return l_out\",\n \"def sparse_to_dense(self, tensor: tf.Tensor, output_shape: tf.TensorShape) -> tf.Tensor:\\n return tf.scatter_nd(self.observations_index, tensor, output_shape)\",\n \"def add_dense_layer(self, _input, in_size, out_size):\\n weight = tf.Variable(tf.truncated_normal(\\n [in_size, out_size], stddev=0.01))\\n bias = tf.Variable(tf.constant(0.1, shape=[out_size]))\\n return tf.matmul(_input, weight) + bias\",\n \"def dense(x, n1, n2, name):\\n with tf.name_scope(name):\\n weights = tf.Variable(tf.random_normal(shape=[n1, n2], mean=0., stddev=0.01), name='weights')\\n bias = tf.Variable(tf.zeros(shape=[n2]), name='bias')\\n output = tf.add(tf.matmul(x, weights), bias, name='output')\\n return output\",\n \"def dense_layer(self, img, weights, bias):\\n # 1: Flattening step\\n img_w, img_h, img_c = img.shape\\n flat = img.reshape((img_w * img_h * img_c, 1))\\n # 2: dense/relu layer\\n z = (weights[0].dot(flat) + bias[0]) / (weights[0][0].shape[0] + 1)\\n z[z <= 0] = 0 # ReLU\\n output = (weights[1].dot(z) + bias[1]) / (weights[1][0].shape[0] + 1)\\n # 3: softmax\\n return softmax(output), z, flat\",\n \"def build_dense_network(data, hidden_layers, **kwargs):\\n # Input layer\\n with tf.variable_scope(\\\"layer_1\\\"): \\n weights = tf.get_variable(\\\"weights\\\", shape = [input_shape[-1] + 1\\n , hidden_layers[0]], initializer = tf.variance_scaling_initializer())\\n\\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([data, tf.ones(dtype = tf.float32\\n , shape = (tf.shape(data)[0], 1))], axis = 1) # concat\\n , weights, name = \\\"multiply\\\") # matmul\\n , α, name = \\\"output\\\") # leaky relu\\n\\n # DROP-OUT after the activation func\\n output = tf.nn.dropout(output, keep_prob=δ, name = \\\"output\\\") \\n\\n # Hidden layers 1 to len(hidden_layers) - 1\\n for i in range(2, len(hidden_layers)-1+2):\\n\\n with tf.variable_scope(f\\\"layer_{i}\\\"):\\n n_nodes = hidden_layers[i-1]\\n\\n weights = tf.get_variable(\\\"weights\\\", shape = [hidden_layers[i-2]+1, hidden_layers[i-1]], initializer = tf.variance_scaling_initializer())\\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \\\"multiply\\\"), α, name = \\\"output\\\")\\n\\n # DROP-OUT after the activation func\\n output = tf.nn.dropout(output, keep_prob=δ, name = \\\"output\\\") \\n\\n # Output layer\\n with tf.variable_scope(f\\\"layer_{len(hidden_layers)+1}\\\"):\\n\\n weights = tf.get_variable(\\\"weights\\\", shape = (hidden_layers[1]+1, n_summaries), initializer = tf.variance_scaling_initializer())\\n output = tf.identity(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \\\"multiply\\\"), name = \\\"output\\\")\\n # NO DROP-OUT in the last layer\\n\\n\\n return output\",\n \"def __init__(self, config_data, dims, layer_num, params):\\n self.use_bias = params['use_bias']\\n self.in_dims = params['in_dims']\\n self.out_dims = params['out_dims']\\n self.use_bias = params['use_bias']\\n self.num_outputs = params['num_outputs']\\n self.dims = dims\\n self.layer_num = layer_num\\n self.activation = config_data[\\\"activation\\\"]\\n self.layer_type = config_data[\\\"type\\\"]\\n self.name = config_data[\\\"name\\\"]\\n self.params = []\\n # following two parameters not used in dense layers\\n # they will be set to one in dense layers\\n self.kernel_size = params['kernel_size'] # only used in conv layers\\n self.stride = params['stride'] # only used in conv layers\",\n \"def flatten_and_dense(X,out_channels,*args,activation = 'relu', initialise_weights = False):\\n \\n shape = X.shape\\n X = torch.reshape(X,(-1,1)) # Flatten\\n if initialise_weights:\\n weights = torch.Tensor(np.random.uniform(-0.01,0.01, size = (out_channels,len(X))))\\n weights.requires_grad = False\\n bias = torch.Tensor(np.random.uniform(-0.01,0.01, size = (out_channels,1)))\\n else:\\n weights = args[0]\\n bias = args[1]\\n if activation == 'sigmoid':\\n output = sigmoid(weights.mm(X) + bias)\\n elif activation == 'relu':\\n output = relu(weights.mm(X) + bias)\\n else:\\n output = weights.mm(X) + bias # No activation applied -> Typically done before the softmax\\n if not initialise_weights:\\n \\n return output\\n else:\\n output_shape = output.shape\\n return output,weights,bias,output_shape\",\n \"def DenseModel(optimizer='sgd'):\\n model = Sequential([Dense(3, input_shape=(5184,), activation='softmax')])\\n model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])\\n return model\",\n \"def add_dense_layer(self, input_tensor, output_size, activation_fn=None,\\n name = None):\\n return tf.layers.dense(input_tensor, output_size, activation=activation_fn,\\n kernel_initializer=tf.contrib.layers.variance_scaling_initializer(),\\n kernel_regularizer=tf.contrib.layers.l1_l2_regularizer(),\\n name=name)\",\n \"def dense_block(X, neurons_per_layer, add_noise, hidden_activation):\\n Y = Dense(neurons_per_layer)(X)\\n\\n if add_noise:\\n Y = GaussianDropout(0.005)(Y)\\n\\n Y = LayerNormalization()(Y)\\n Y = hidden_activation(Y)\\n return Concatenate()([X, Y])\",\n \"def dense(inputs, activation,\\n num_outputs,\\n out_caps_dims,\\n routing_method='EMRouting',\\n coordinate_addition=False,\\n reuse=None,\\n name=None):\\n name = \\\"dense\\\" if name is None else name\\n with tf.variable_scope(name) as scope:\\n if reuse:\\n scope.reuse()\\n if coordinate_addition and len(inputs.shape) == 6 and len(activation.shape) == 4:\\n vote = transforming(inputs, num_outputs=num_outputs, out_caps_dims=out_caps_dims)\\n with tf.name_scope(\\\"coodinate_addition\\\"):\\n batch_size, in_height, in_width, in_channels, _, out_caps_height, out_caps_width = cl.shape(vote)\\n num_inputs = in_height * in_width * in_channels\\n\\n zeros = np.zeros((in_height, out_caps_width - 1))\\n coord_offset_h = ((np.arange(in_height) + 0.5) / in_height).reshape([in_height, 1])\\n coord_offset_h = np.concatenate([zeros, coord_offset_h], axis=-1)\\n zeros = np.zeros((out_caps_height - 1, out_caps_width))\\n coord_offset_h = np.stack([np.concatenate([coord_offset_h[i:(i + 1), :], zeros], axis=0) for i in range(in_height)], axis=0)\\n coord_offset_h = coord_offset_h.reshape((1, in_height, 1, 1, 1, out_caps_height, out_caps_width))\\n\\n zeros = np.zeros((1, in_width))\\n coord_offset_w = ((np.arange(in_width) + 0.5) / in_width).reshape([1, in_width])\\n coord_offset_w = np.concatenate([zeros, coord_offset_w, zeros, zeros], axis=0)\\n zeros = np.zeros((out_caps_height, out_caps_width - 1))\\n coord_offset_w = np.stack([np.concatenate([zeros, coord_offset_w[:, i:(i + 1)]], axis=1) for i in range(in_width)], axis=0)\\n coord_offset_w = coord_offset_w.reshape((1, 1, in_width, 1, 1, out_caps_height, out_caps_width))\\n\\n vote = vote + tf.constant(coord_offset_h + coord_offset_w, dtype=tf.float32)\\n\\n vote = tf.reshape(vote, shape=[batch_size, num_inputs, num_outputs] + out_caps_dims)\\n activation = tf.reshape(activation, shape=[batch_size, num_inputs])\\n\\n elif len(inputs.shape) == 4 and len(activation.shape) == 2:\\n vote = transforming(inputs, num_outputs=num_outputs, out_caps_dims=out_caps_dims)\\n\\n else:\\n raise TypeError(\\\"Wrong rank for inputs or activation\\\")\\n\\n pose, activation = routing(vote, activation, routing_method)\\n # pose, activation = cl.core.gluing(vote, activation)\\n assert len(pose.shape) == 4\\n assert len(activation.shape) == 2\\n\\n return(pose, activation)\",\n \"def output(x_tensor, num_outputs):\\n # TODO: Implement Function\\n y = tf.layers.dense(x_tensor,num_outputs)\\n return y\",\n \"def dense(x, n1, n2, name):\\n with tf.variable_scope(name, reuse=None):\\n # np.random.seed(1)\\n tf.set_random_seed(1)\\n weights = tf.get_variable(\\\"weights\\\", shape=[n1, n2],\\n initializer=tf.random_normal_initializer(mean=0., stddev=0.01))\\n bias = tf.get_variable(\\\"bias\\\", shape=[n2], initializer=tf.constant_initializer(0.0))\\n out = tf.add(tf.matmul(x, weights), bias, name='matmul')\\n return out\",\n \"def build_mlp(input_data, output_data, n_neurons=[512, 256, 128]):\\n input_layer = keras.layers.Input([input_data.shape[-1]], name='input-layer')\\n for i, n_unit in enumerate(n_neurons):\\n if i == 0:\\n x = keras.layers.Dense(units=n_unit, activation='relu', name='hidden-layer'+str(i+1))(input_layer)\\n else:\\n x = keras.layers.Dense(units=n_unit, activation='relu', name='hidden-layer'+str(i+1))(x)\\n \\n output_layer = keras.layers.Dense(units=output_data.shape[-1],activation='softmax' , name='output-layer')(x)\\n model = keras.models.Model(inputs=input_layer, outputs=output_layer)\\n return model\",\n \"def __init__(self, input_dim: int, output_dim: int):\\n\\n super().__init__()\\n\\n self.input_dim = input_dim\\n self.output_dim = output_dim\\n\\n self.batchNorm1 = layers.BatchNormalization()\\n self.dense1 = layers.Dense(\\n 64, input_shape=(input_dim+output_dim,),\\n kernel_initializer=random_uniform(-np.sqrt(1/input_dim), np.sqrt(1/input_dim))\\n )\\n self.relu1 = layers.Activation('relu')\\n self.dense2 = layers.Dense(32, kernel_initializer=random_uniform(-np.sqrt(1/64), np.sqrt(1/64)))\\n self.relu2 = layers.Activation('relu')\\n self.dense3 = layers.Dense(output_dim, kernel_initializer=random_uniform(-np.sqrt(1/32), np.sqrt(1/32)))\",\n \"def fully_conn(x_tensor, num_outputs, name=\\\"fc\\\"):\\n with tf.name_scope(name):\\n return tf.layers.dense(x_tensor, num_outputs)\",\n \"def __init__(self, input_size, hidden_sizes, output_size, std=1e-4, bstd=1e-4):\\r\\n num_hidden_layers = len(hidden_sizes)\\r\\n \\r\\n # initialize weight matrices\\r\\n self.weights = []\\r\\n if num_hidden_layers > 0:\\r\\n for i in xrange(num_hidden_layers):\\r\\n if i == 0:\\r\\n self.weights.append(std * np.random.randn(input_size, hidden_sizes[0]))\\r\\n else:\\r\\n self.weights.append(std * np.random.randn(hidden_sizes[i-1], hidden_sizes[i]))\\r\\n self.weights.append(std * np.random.randn(hidden_sizes[-1], output_size))\\r\\n else:\\r\\n self.weights.append(std * np.random.randn(input_size, output_size))\\r\\n \\r\\n # initialize bias vectors\\r\\n self.biases = []\\r\\n for i in xrange(num_hidden_layers):\\r\\n self.biases.append(bstd * np.random.randn(hidden_sizes[i]))\\r\\n self.biases.append(bstd * np.random.randn(output_size))\",\n \"def __call__(self, inputs_shape):\\n assert not self._achieve_init\\n self.W = 2 * np.random.randn(self._units, inputs_shape) / np.sqrt(inputs_shape)\\n self.b = np.zeros((self._units, 1))\\n super(Dense, self).__call__()\",\n \"def build_mlp(x, output_size, scope, n_layers, size, activation=tf.tanh, output_activation=None, regularizer=None):\\n i = 0\\n for i in range(n_layers):\\n x = tf.layers.dense(inputs=x,units=size, activation=activation, name='fc{}'.format(i), kernel_regularizer=regularizer, bias_regularizer=regularizer)\\n\\n x = tf.layers.dense(inputs=x, units=output_size, activation=output_activation, name='fc{}'.format(i + 1), kernel_regularizer=regularizer, bias_regularizer=regularizer)\\n return x\",\n \"def dense_bn_act(inputs, units, activation, kernel_init, noise=False, noise_std=0.5):\\n _tmp = tf.layers.dense(inputs=inputs, units=units, activation=None, kernel_initializer=kernel_init)\\n _tmp = tf.contrib.layers.batch_norm(_tmp, center=True, scale=True, is_training=phase)\\n _tmp = activation(_tmp)\\n if noise:\\n _tmp = gaussian_noise_layer(_tmp, noise_std, phase)\\n\\n return _tmp\",\n \"def build(self, input_shape: tf.Tensor):\\n self.dense = tf.keras.layers.Dense(self.channels, input_shape=input_shape)\\n self.bn = tf.keras.layers.BatchNormalization(momentum=self.momentum)\",\n \"def dense(x, n1, n2, name):\\n with tf.variable_scope(name, reuse=None):\\n weights = tf.get_variable(\\\"weights\\\", shape=[n1, n2],\\n initializer=tf.random_normal_initializer(mean=0., stddev=0.01))\\n bias = tf.get_variable(\\\"bias\\\", shape=[n2], initializer=tf.constant_initializer(0.0))\\n out = tf.add(tf.matmul(x, weights), bias, name='matmul')\\n return out\",\n \"def generative_model(self):\\n activation = tf.nn.relu\\n if self.linear:\\n activation = None\\n\\n # p(x | z, s)\\n if self.batch is not None:\\n h = tf.concat([self.z, self.batch], 1)\\n else:\\n h = self.z\\n \\n #h = dense(h, self.n_hidden,\\n # activation=tf.nn.relu, bn=True, keep_prob=self.dropout_rate, phase=self.training_phase)\\n h = dense(h, self.n_hidden,\\n activation=activation, bn=True, keep_prob=None, phase=self.training_phase)\\n \\n for layer in range(2, self.n_layers + 1):\\n if self.batch is not None:\\n h = tf.concat([h, self.batch], 1)\\n h = dense(h, self.n_hidden, activation=activation, \\\\\\n bn=True, keep_prob=self.dropout_rate, phase=self.training_phase)\\n\\n if self.batch is not None:\\n h = tf.concat([h, self.batch], 1) \\n \\n #mean gamma\\n self.px_scale = dense(h, self.n_input, activation=tf.nn.softmax, \\\\\\n bn=False, keep_prob=None, phase=self.training_phase)\\n \\n #dispersion\\n if self.dispersion == \\\"gene-cell\\\":\\n self.px_r = dense(h, self.n_input, activation=None, \\\\\\n bn=False, keep_prob=None, phase=self.training_phase)\\n elif self.dispersion == \\\"gene\\\":\\n self.px_r = tf.Variable(tf.random_normal([self.n_input]), name=\\\"r\\\")\\n else:\\n if self.dispersion is False:\\n self.px_r = tf.ones([self.n_input])\\n else:\\n if self.batch_ind is None:\\n raise ValueError(\\\"batch dispersion with no batch info\\\")\\n else:\\n self.px_r = tf.Variable(tf.random_normal([self.num_batches, self.n_input]), name=\\\"r\\\")\\n\\n \\n #mean poisson\\n self.px_rate = self.px_scale \\n if self.scalings:\\n self.px_rate = self.px_scale * tf.exp(self.library)\\n\\n #dropout\\n if self.zi:\\n self.px_dropout = dense(h, self.n_input, activation=None, \\\\\\n bn=False, keep_prob=None, phase=self.training_phase)\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n mean = 0\\n std_dev = 0.0001\\n #print(in_features)\\n #print(out_features)\\n # create weight matrices\\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\\n #print(weight.shape)\\n grad_weight = np.zeros((in_features, out_features))\\n\\n # create biases (in batches)\\n bias = np.zeros(out_features)\\n grad_bias = np.zeros(out_features)\\n\\n self.params = {'weight': weight, 'bias': bias}\\n self.grads = {'weight': bias, 'bias': grad_bias}\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def xlarge_model(optimizer='rmsprop', init='glorot_uniform', dropout=0.2):\\n model = Sequential()\\n model.add(Dropout(dropout, input_shape=(12,)))\\n #model.add(Dense(18, input_dim=12, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\\n model.add(Dense(16, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\\n model.add(Dropout(dropout))\\n model.add(Dense(16, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\\n model.add(Dropout(dropout))\\n model.add(Dense(16, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(3)))\\n model.add(Dropout(dropout))\\n model.add(Dense(1, kernel_initializer=init))\\n # Compile model\\n model.compile(loss='mean_squared_error', optimizer=optimizer)\\n return model\",\n \"def singlevar_model(optimizer='rmsprop', init='glorot_uniform', dropout=0.2):\\n model = keras.models.Sequential()\\n model.add(Dense(1, input_dim=1, kernel_initializer=init, activation='relu'))\\n model.add(Dropout(dropout))\\n model.add(Dense(1, kernel_initializer=init))\\n # Compile model\\n model.compile(loss='mean_squared_error', optimizer=optimizer)\\n return model\",\n \"def __init__(self, numpy_rng, input, n_in, hidden_layers_sizes, n_out):\\n # instance variables\\n self.numpy_rng = numpy_rng\\n self.input = input\\n self.n_in = n_in\\n self.hidden_layers_sizes = hidden_layers_sizes\\n self.n_layers = len(hidden_layers_sizes)\\n self.n_out = n_out\\n\\n self.hidden_layers = []\\n self.params = []\\n\\n self.initialize_variables()\\n\\n\\n ################\\n ## Prediction ##\\n ################\\n self.y_pred = self.logistic_regression_layer.y_pred\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def build_model(input_dim, hidden_neurons, output_dim):\\n\\tmodel = Sequential([\\n \\tDense(hidden_neurons, input_dim=input_dim),\\n Activation('relu'),\\n Dropout(0.2),\\n Dense(hidden_neurons),\\n Activation('relu'),\\n Dropout(0.2),\\n Dense(output_dim, activation='softmax')\\n ])\\n\\n\\tmodel.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\treturn model\",\n \"def __init__(self, dim_in, dim_out, weight_decay, dropout=0.,\\r\\n act=lambda x:x, bias=True, model_pretrain=None, **kwargs):\\r\\n super(Dense, self).__init__(**kwargs)\\r\\n self.dropout = dropout\\r\\n self.act = F_ACT[act]\\r\\n self.bias = bias\\r\\n self.dim_in = dim_in\\r\\n self.dim_out = dim_out\\r\\n self.weight_decay = weight_decay\\r\\n\\r\\n with tf.variable_scope(self.name + '_vars'):\\r\\n if model_pretrain is None:\\r\\n self.vars['weights'] = tf.get_variable('weights', shape=(dim_in, dim_out),\\r\\n dtype=DTYPE,\\r\\n initializer=tf.contrib.layers.xavier_initializer(),\\r\\n regularizer=tf.contrib.layers.l2_regularizer(self.weight_decay))\\r\\n if self.bias:\\r\\n self.vars['bias'] = zeros([dim_out],name='bias')\\r\\n else:\\r\\n self.vars['weights'] = trained(model_pretrain[0], name='weight')\\r\\n if self.bias:\\r\\n self.vars['bias'] = trained(model_pretrain[1], name='bias')\\r\\n if self.logging:\\r\\n self._log_vars()\",\n \"def __init__(self, units, activation=tf.nn.softmax):\\n\\n super(MyDense, self).__init__()\\n\\n self.units = units\\n self.activation = activation\",\n \"def MLP(input_h, num_layers, out_dim, name=\\\"MLP\\\", activation=tf.nn.relu, reuse=None):\\n with tf.variable_scope(name, reuse=reuse):\\n h = input_h\\n for i in range(num_layers):\\n h = tf.layers.dense(\\n h, out_dim, \\n use_bias=True, activation=activation,\\n name=\\\"mlp{}\\\".format(i),\\n reuse = reuse\\n )\\n h = tf.layers.dense(\\n h, out_dim, use_bias=True, name=\\\"mlp_out\\\", reuse=reuse\\n )\\n return h\",\n \"def __init__(self, input_size, output_size, hidden_sizes=[],\\r\\n learning_rate=2.0, weight_scale=0.1, converge=0.01,\\r\\n random_seed=None):\\r\\n if random_seed is not None:\\r\\n seed(random_seed)\\r\\n\\r\\n weight_func = partial(normal, 0, weight_scale)\\r\\n self.converge = converge\\r\\n self.layers = []\\r\\n self.layers.append([InputNode(\\\"in_\\\" + str(i)) for i in range(input_size)])\\r\\n for i,layer_size in enumerate(hidden_sizes):\\r\\n self.layers.append([SigmoidNode(\\\"hidden_\\\"+str(i)+\\\"-\\\"+str(j),\\r\\n learning_rate) for j in range(layer_size)])\\r\\n self.layers.append([SigmoidNode(\\\"out_\\\"+str(i), learning_rate) for i\\r\\n in range(output_size)])\\r\\n\\r\\n # densely connect consecutive layers\\r\\n for source_layer, dest_layer in zip(self.layers, self.layers[1:]):\\r\\n for source, dest in product(source_layer, dest_layer):\\r\\n edge = Edge(source, dest, weight_func)\\r\\n source.out_edges.append(edge)\\r\\n dest.in_edges.append(edge)\\r\\n\\r\\n # connect each node to bias\\r\\n self.bias = BiasNode()\\r\\n for layer in self.layers[1:]:\\r\\n for node in layer:\\r\\n e = Edge(self.bias, node, weight_func)\\r\\n node.in_edges.append(e)\\r\\n self.bias.out_edges.append(e)\",\n \"def sparse_to_dense(sp_indices, output_shape, values, default_value=0):\\n\\n assert len(sp_indices) == len(values), \\\\\\n 'Length of sp_indices is not equal to length of values'\\n\\n array = np.ones(output_shape) * default_value\\n for idx, value in zip(sp_indices, values):\\n array[tuple(idx)] = value\\n return array\",\n \"def vae_decoder(self):\\n return stax.serial(\\n stax.Dense(self.hidden_dims[1], W_init=stax.randn()),\\n stax.Relu,\\n stax.Dense(self.hidden_dims[0], W_init=stax.randn()),\\n stax.Relu,\\n stax.Dense(self.out_dim, W_init=stax.randn()) \\n )\",\n \"def _identity_dense(d, dtype=complex):\\n return np.eye(d, dtype=dtype)\",\n \"def output(x_tensor, num_outputs, name=\\\"output\\\"):\\n with tf.name_scope(name):\\n return tf.layers.dense(x_tensor, num_outputs)\",\n \"def __init__(\\n self,\\n units,\\n activation=None,\\n use_bias=True,\\n kernel_initializer='glorot_uniform',\\n bias_initializer='zeros',\\n kernel_regularizer=None,\\n bias_regularizer=None,\\n **kwargs\\n ):\\n super(Dense, self).__init__(**kwargs)\\n self.input_dim = kwargs.get('input_dim', None)\\n self.units = int(units)\\n self.activation = activations.get(activation)\\n self.use_bias = use_bias\\n self.kernel_initializer = initializers.get(kernel_initializer)\\n self.bias_initializer = initializers.get(bias_initializer)\\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\\n self.bias_regularizer = regularizers.get(bias_regularizer)\\n self.input_spec = InputSpec(min_ndim=2)\\n self.kernel = None\\n self.bias = None\",\n \"def create_dense_model(\\n input_shape: Tuple[int, int] = (64, 64),\\n n_hidden: int = 1,\\n n_units: int = 7,\\n activation: Union[str, Callable] = \\\"relu\\\",\\n optimizer: Union[str, tf.keras.optimizers.Optimizer] = \\\"adam\\\",\\n loss: Union[str, tf.keras.losses.Loss] = \\\"binary_crossentropy\\\",\\n metrics=None,\\n) -> tf.keras.Model:\\n model = tf.keras.models.Sequential()\\n model.add(tf.keras.layers.Flatten(input_shape=input_shape))\\n for _ in range(n_hidden):\\n model.add(tf.keras.layers.Dense(n_units, activation=activation))\\n model.add(tf.keras.layers.Dense(10, activation=\\\"softmax\\\"))\\n model.compile(optimizer=optimizer, loss=loss, metrics=metrics)\\n return model\",\n \"def __init__(self, input, n_in, n_out):\\r\\n # start-snippet-1\\r\\n # initialize with 0 the weights W as a matrix of shape (n_in, n_out)\\r\\n self.W = theano.shared(value=np.zeros((n_in, n_out), dtype=theano.config.floatX), name='W', borrow=True)\\r\\n # initialize the biases b as a vector of n_out 0s\\r\\n self.b = theano.shared(value=np.zeros((n_out,), dtype=theano.config.floatX), name='b', borrow=True)\\r\\n\\r\\n # symbolic expression for computing the matrix of class-membership\\r\\n # probabilities\\r\\n # Where:\\r\\n # W is a matrix where column-k represent the separation hyperplane for class-k\\r\\n # x is a matrix where row-j represents input training sample-j\\r\\n # b is a vector where element-k represent the free parameter of hyperplane-k\\r\\n # p_y_given_x is a matrix\\r\\n self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)\\r\\n\\r\\n # symbolic description of how to compute prediction as class whose\\r\\n # probability is maximal\\r\\n self.y_pred = T.argmax(self.p_y_given_x, axis=1)\\r\\n self.y_pred_prob = T.max(self.p_y_given_x, axis=1)\\r\\n\\r\\n # parameters of the model\\r\\n self.params = [self.W, self.b]\\r\\n\\r\\n # keep track of model input\\r\\n self.input = input\",\n \"def todense(self):\\n d = np.zeros(self.shape)\\n for index,value in zip(self.index, self.value):\\n d[index] = value\\n return d\",\n \"def __create_dense_net(nb_classes, img_input, include_top, depth=40,\\n nb_dense_block=3, growth_rate=12, nb_filter=-1,\\n nb_layers_per_block=-1, bottleneck=False,\\n reduction=0.0, dropout_rate=None, weight_decay=1e-4,\\n subsample_initial_block=False, activation='softmax'):\\n\\n concat_axis = 1 if K.image_data_format() == 'channels_first' else -1\\n\\n if reduction != 0.0:\\n assert 0.0 < reduction <= 1.0, \\\\\\n 'reduction value must lie between 0.0 and 1.0'\\n\\n # layers in each dense block\\n if type(nb_layers_per_block) is list or \\\\\\n type(nb_layers_per_block) is tuple:\\n nb_layers = list(nb_layers_per_block) # Convert tuple to list\\n\\n assert len(nb_layers) == nb_dense_block, \\\\\\n 'If list, nb_layer is used as provided. ' \\\\\\n 'Note that list size must be (nb_dense_block)'\\n final_nb_layer = nb_layers[-1]\\n nb_layers = nb_layers[:-1]\\n else:\\n if nb_layers_per_block == -1:\\n assert (depth - 4) % 3 == 0, \\\\\\n 'Depth must be 3 N + 4 if nb_layers_per_block == -1'\\n count = int((depth - 4) / 3)\\n\\n if bottleneck:\\n count = count // 2\\n\\n nb_layers = [count for _ in range(nb_dense_block)]\\n final_nb_layer = count\\n else:\\n final_nb_layer = nb_layers_per_block\\n nb_layers = [nb_layers_per_block] * nb_dense_block\\n\\n # compute initial nb_filter if -1, else accept users initial nb_filter\\n if nb_filter <= 0:\\n nb_filter = 2 * growth_rate\\n\\n # compute compression factor\\n compression = 1.0 - reduction\\n\\n # Initial convolution\\n if subsample_initial_block:\\n initial_kernel = (7, 7)\\n initial_strides = (2, 2)\\n else:\\n initial_kernel = (3, 3)\\n initial_strides = (1, 1)\\n\\n x = Conv2D(nb_filter, initial_kernel, kernel_initializer='he_normal',\\n padding='same', strides=initial_strides, use_bias=False,\\n kernel_regularizer=l2(weight_decay))(img_input)\\n\\n if subsample_initial_block:\\n x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5,\\n fused=fuse)(x)\\n x = Activation('relu')(x)\\n x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x)\\n\\n # Add dense blocks\\n for block_idx in range(nb_dense_block - 1):\\n x, nb_filter = __dense_block(\\n x, nb_layers[block_idx], nb_filter, growth_rate,\\n bottleneck=bottleneck, dropout_rate=dropout_rate,\\n weight_decay=weight_decay\\n )\\n # add transition_block\\n x = __transition_block(x, nb_filter, compression=compression,\\n weight_decay=weight_decay)\\n nb_filter = int(nb_filter * compression)\\n\\n # The last dense_block does not have a transition_block\\n x, nb_filter = __dense_block(\\n x, final_nb_layer, nb_filter, growth_rate, bottleneck=bottleneck,\\n dropout_rate=dropout_rate, weight_decay=weight_decay\\n )\\n\\n x = BatchNormalization(axis=concat_axis, epsilon=1.1e-5, fused=fuse)(x)\\n x = Activation('relu')(x)\\n x = GlobalAveragePooling2D()(x)\\n\\n if include_top:\\n x = Dense(nb_classes, activation=activation)(x)\\n\\n return x\",\n \"def bprop_sparse_tensor_get_dense_shape(sparse_tensor, out, dout):\\n return (zeros_like(sparse_tensor),)\",\n \"def __init__(self, inputLayerSize, outputLayerSize, \\\\\\n hiddenLayerSize):\\n #Network hyperparameters - neurons per layer - **not altered by training**\\n self.inputLayerSize = inputLayerSize\\n self.outputLayerSize = outputLayerSize\\n self.hiddenLayerSize = hiddenLayerSize\\n self.num_params = inputLayerSize * hiddenLayerSize + \\\\\\n hiddenLayerSize * outputLayerSize + hiddenLayerSize \\\\\\n + outputLayerSize\\n #--Weights--\\n #w_ih - weights of synapses linking input -> hidden\\n self.w_ih = np.random.randn( self.inputLayerSize, \\\\\\n self.hiddenLayerSize)\\n #w_ho - weights of synapses linking hidden -> output\\n self.w_ho = np.random.randn( self.hiddenLayerSize, \\\\\\n self.outputLayerSize)\\n \\n #--Biases--\\n #b_h - biases of hidden layer\\n self.b_h = np.random.randn( self.hiddenLayerSize )\\n #b_o - biases of output layer\\n self.b_o = np.random.randn( self.outputLayerSize )\",\n \"def __init__(self, inputSize, outputSize, hiddenSize): \\n\\n self.inputSize = inputSize\\n self.outputSize = outputSize\\n self.hiddenSize = hiddenSize \\n \\n # Initialize random weight with range [-0.5, 0.5]\\n self.weight = np.matrix(np.random.uniform(-0.5, 0.5, (self.hiddenSize, self.inputSize)))\\n\\n # Initialize random bias with range [0, 1]\\n self.bias = np.matrix(np.random.uniform(0, 1, (1, self.hiddenSize)))\\n \\n self.H = 0\\n self.beta = 0\",\n \"def build_mlp(input_placeholder, output_size, scope, n_layers, size, activation=tf.tanh, output_activation=None):\\n output_placeholder = input_placeholder\\n with tf.variable_scope(scope):\\n for _ in range(n_layers):\\n output_placeholder = tf.layers.dense(output_placeholder, size, activation=activation) # HINT: use tf.layers.dense (specify <input>, <size>, activation=<?>)\\n output_placeholder = tf.layers.dense(output_placeholder, output_size, activation=output_activation) # HINT: use tf.layers.dense (specify <input>, <size>, activation=<?>)\\n return output_placeholder\",\n \"def denseFeature(self, feat):\\n return {'feat': feat}\",\n \"def create_base_network(NumberOfFeatures, NumberOfClasses,init_mode='glorot_normal'):\\n network = Sequential()\\n network.add(Dense(44, activation='sigmoid', kernel_initializer=init_mode,input_dim=NumberOfFeatures))\\n# network.add(Dense(22, activation='sigmoid',kernel_initializer=init_mode))\\n network.add(Dense(NumberOfClasses, activation='softmax',kernel_initializer=init_mode))\\n return network\",\n \"def __init__(self, input, n_in, n_out):\\r\\n # start-snippet-1\\r\\n\\r\\n # initialize with 0 the weights W as a matrix of shape (n_in, n_out)\\r\\n self.W = theano.shared( value=numpy.zeros( (n_in, n_out), dtype=theano.config.floatX ), name='W', borrow=True )\\r\\n\\r\\n # initialize the baises b as a vector of n_out 0s\\r\\n self.b = theano.shared(value=numpy.zeros( (n_out,), dtype=theano.config.floatX ), name='b', borrow=True )\\r\\n\\r\\n # symbolic expression for computing the matrix of class-membership probabilities where:\\r\\n # W is a matrix where column-k represent the separation hyper plain for class-k\\r\\n # x is a matrix where row-j represents input training sample-j\\r\\n # b is a vector where element-k represent the free parameter of hyper plane-k\\r\\n self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)\\r\\n\\r\\n # symbolic description of how to compute prediction as class whose probability is maximal\\r\\n self.y_pred = T.argmax(self.p_y_given_x, axis=1)\\r\\n # end-snippet-1\\r\\n\\r\\n # parameters of the model\\r\\n self.params = [self.W, self.b]\\r\\n\\r\\n # keep track of model input\\r\\n self.input = input\",\n \"def model(input_shape, output_dim, num_hidden_units,num_hidden_units_2, num_code_units, filter_size, batch_size=BATCH_SIZE):\\n shape = tuple([None]+list(input_shape[1:]))\\n print(shape)\\n l_in = lasagne.layers.InputLayer(shape=shape)\\n\\n print(\\\"Input shape: \\\",lasagne.layers.get_output_shape(l_in))\\n\\n # print(shaped_units)\\n # shaped_units = shaped_units[0]\\n shaped_units = 2800\\n\\n # print(shape)\\n\\n l_conv2D_1 = lasagne.layers.Conv2DLayer(\\n l_in, \\n num_filters=8,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n print(\\\"Conv 2D shape: \\\",lasagne.layers.get_output_shape(l_conv2D_1))\\n\\n l_reshape_1 = lasagne.layers.ReshapeLayer(\\n l_conv2D_1,\\n shape=(([0], -1))\\n )\\n\\n print(\\\"Reshape 1 shape: \\\", lasagne.layers.get_output_shape(l_reshape_1))\\n\\n l_hidden_1 = lasagne.layers.DenseLayer(\\n l_reshape_1,\\n num_units= num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 1 shape: \\\", lasagne.layers.get_output_shape(l_hidden_1))\\n\\n l_code_layer = lasagne.layers.DenseLayer(\\n l_hidden_1,\\n num_units=num_code_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Code layer shape: \\\",lasagne.layers.get_output_shape(l_code_layer))\\n\\n l_hidden_2 = lasagne.layers.DenseLayer(\\n l_code_layer,\\n num_units=num_hidden_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 2 shape: \\\",lasagne.layers.get_output_shape(l_hidden_2))\\n\\n l_hidden_3 = lasagne.layers.DenseLayer(\\n l_hidden_2,\\n num_units=shaped_units,\\n nonlinearity=lasagne.nonlinearities.rectify,\\n )\\n\\n print(\\\"Hidden 3 shape: \\\",lasagne.layers.get_output_shape(l_hidden_3))\\n\\n l_reshape_2 = lasagne.layers.ReshapeLayer(\\n l_hidden_3,\\n shape=(([0],8,7,50))\\n )\\n\\n print(\\\"Reshape 2 shape: \\\",lasagne.layers.get_output_shape(l_reshape_2))\\n\\n l_out = lasagne.layers.Conv2DLayer(\\n l_reshape_2, \\n num_filters=1,\\n filter_size=filter_size, \\n stride=(1, 1), \\n border_mode=\\\"valid\\\", \\n untie_biases=False, \\n nonlinearity=None,\\n )\\n\\n # print(\\\"Deconv shape: \\\",lasagne.layers.get_output_shape(l_deconv2D_1))\\n\\n print(\\\"Output shape: \\\",lasagne.layers.get_output_shape(l_out))\\n\\n return l_out\",\n \"def model_d(input_shape=(None, 28, 28, 1), nb_classes=10):\\n\\n # Define a fully connected model (it's different than the black-box)\\n layers = [Flatten(),\\n Linear(200),\\n ReLU(),\\n Dropout(0.5),\\n Linear(200),\\n ReLU(),\\n Linear(nb_classes),\\n Softmax()]\\n\\n return DefenseMLP(layers, input_shape)\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n \\n self.grads = {'weight': np.zeros((out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def mlp(\\n\\t# input_shape: Tuple[int, ...],\\n\\t# output_shape: Tuple[int, ...],\\n\\t# layer_size: int = 128,\\n\\t# dropout_amount: float = 0.2,\\n\\t# num_layers: int = 3, \\n\\tnet_config: Dict\\n)->Model:\\n\\tactivation_fn = net_config[\\\"hyperparams\\\"][\\\"activation_fn\\\"]\\n\\tinput_s = net_config[\\\"shapes\\\"][\\\"input_shape\\\"]\\n\\toutput_s = net_config[\\\"shapes\\\"][\\\"output_shape\\\"]\\n\\n\\tinputs = keras.Input(shape=(input_s,))\\n\\tdense = layers.Dense(64, activation=\\\"relu\\\")\\n\\tx = dense(inputs)\\n\\tlayer1 = layers.Dense(64, activation=activation_fn)(x)\\n\\tlayer2 = layers.Dense(64, activation=activation_fn)(layer1)\\n\\toutputs = layers.Dense(output_s)(layer2)\\n\\tmodel = keras.Model(inputs=inputs, outputs=outputs, name=\\\"house_pred\\\")\\n\\t\\n\\treturn model\",\n \"def __init__(self):\\n super(Model, self).__init__()\\n\\n self.batch_size = 200\\n self.hidden_size = 264\\n self.optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)\\n\\n self.dense_1 = tf.keras.layers.Dense(self.hidden_size, activation='relu')\\n self.dense_2 = tf.keras.layers.Dense(self.hidden_size, activation='relu')\",\n \"def __init__(self, rng, pool_shape, input_shape, pooler=T.max, depooler='random'):\\n \\n self.pool_shape = pool_shape\\n self.input_shape = input_shape\\n self.output_shape = (input_shape[0], input_shape[1], input_shape[2]//self.pool_shape[0])\\n self.theano_rng = RandomStreams(rng.randint(2 ** 30))\\n self.pooler = pooler \\n self.depooler = depooler\\n self.params = []\",\n \"def __init__(self):\\n self.out = None\\n self.in_shape = None\\n self.work_shape = None\",\n \"def __init__(self, input, n_in, n_out):\\r\\n\\r\\n # initialize with 0 the weights W as a matrix of shape (n_in, n_out)\\r\\n self.W = theano.shared(value=numpy.zeros((n_in, n_out),\\r\\n dtype=theano.config.floatX),\\r\\n name='W', borrow=True)\\r\\n # initialize the baises b as a vector of n_out 0s\\r\\n self.b = theano.shared(value=numpy.zeros((n_out,),\\r\\n dtype=theano.config.floatX),\\r\\n name='b', borrow=True)\\r\\n\\r\\n # compute vector of class-membership probabilities in symbolic form\\r\\n self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)\\r\\n\\r\\n # compute prediction as class whose probability is maximal in\\r\\n # symbolic form\\r\\n self.y_pred = T.argmax(self.p_y_given_x, axis=1)\\r\\n\\r\\n # parameters of the model\\r\\n self.params = [self.W, self.b]\",\n \"def softmax_to_dense(sparse, dim):\\n dtype = sparse.dtype\\n device = sparse.device\\n dense = to_dense(sparse, fill_value=-float('inf'))\\n r = F.softmax(dense, dim)\\n # softmax on empty lines results nan, replace with zeros to match the definition\\n r[r != r] = 0\\n return r\",\n \"def fully_conn(x_tensor, num_outputs):\\n # TODO: Implement Function\\n y = tf.layers.dense(x_tensor,units = num_outputs,activation=tf.nn.relu)\\n return y\",\n \"def __init__(self, hidden_dims, input_dim=3*32*32, num_classes=10,\\n dropout=1, normalization=None, reg=0.0,\\n weight_scale=1e-2, dtype=np.float32, seed=None):\\n self.normalization = normalization\\n self.use_dropout = dropout != 1\\n self.reg = reg\\n self.num_layers = 1 + len(hidden_dims)\\n self.dtype = dtype\\n self.params = {}\\n\\n ############################################################################\\n # TODO: Initialize the parameters of the network, storing all values in #\\n # the self.params dictionary. Store weights and biases for the first layer #\\n # in W1 and b1; for the second layer use W2 and b2, etc. #\\n # When using batch normalization, store scale and shift parameters for the #\\n # first layer in gamma1 and beta1; for the second layer use gamma2 and #\\n # beta2, etc. Scale parameters should be initialized to ones and shift #\\n # parameters should be initialized to zeros. #\\n ############################################################################\\n input_size = input_dim\\n for i in range(len(hidden_dims)):\\n output_size = hidden_dims[i]\\n self.params['W' + str(i+1)] = np.random.randn(input_size,output_size) * weight_scale\\n self.params['b' + str(i+1)] = np.zeros(output_size)\\n if self.normalization:\\n self.params['gamma' + str(i+1)] = np.ones(output_size)\\n self.params['beta' + str(i+1)] = np.zeros(output_size)\\n input_size = output_size # 下一层的输入\\n # 输出层，没有BN操作\\n self.params['W' + str(self.num_layers)] = np.random.randn(input_size,num_classes) * weight_scale\\n self.params['b' + str(self.num_layers)] = np.zeros(num_classes)\\n # When using dropout we need to pass a dropout_param dictionary to each\\n # dropout layer so that the layer knows the dropout probability and the mode\\n # (train / test). You can pass the same dropout_param to each dropout layer.\\n self.dropout_param = {}\\n if self.use_dropout:\\n self.dropout_param = {'mode': 'train', 'p': dropout}\\n if seed is not None:\\n self.dropout_param['seed'] = seed\\n\\n # With batch normalization we need to keep track of running means and\\n # variances, so we need to pass a special bn_param object to each batch\\n # normalization layer. You should pass self.bn_params[0] to the forward pass\\n # of the first batch normalization layer, self.bn_params[1] to the forward\\n # pass of the second batch normalization layer, etc.\\n self.bn_params = []\\n if self.normalization=='batchnorm':\\n self.bn_params = [{'mode': 'train'} for i in range(self.num_layers - 1)]\\n if self.normalization=='layernorm':\\n self.bn_params = [{} for i in range(self.num_layers - 1)]\\n\\n # Cast all parameters to the correct datatype\\n for k, v in self.params.items():\\n self.params[k] = v.astype(dtype)\",\n \"def _build_network(self,\\n input_dim,\\n dense_layers,\\n nodes_per_layer=None,\\n hidden_act='relu',\\n output_act='sigmoid',\\n dropout_layers=None):\\n\\n if nodes_per_layer is None:\\n nodes = [10] * dense_layers\\n else:\\n nodes = nodes_per_layer\\n\\n if dropout_layers is None:\\n do_layers = [0] * dense_layers\\n else:\\n do_layers = dropout_layers\\n\\n self.model.add(Dense(nodes[0], input_dim=input_dim,\\n activation=hidden_act))\\n\\n if dense_layers > 1:\\n for l in range(1, dense_layers - 1):\\n if do_layers[l - 1] != 0:\\n self.model.add(Dropout(do_layers[l - 1]))\\n\\n self.model.add(Dense(nodes[l], activation=hidden_act))\\n\\n self.model.add(Dense(1, activation=output_act))\",\n \"def get_bprop_sparse_to_dense(self):\\n\\n def bprop(indices, values, dense_shape, out, dout):\\n return zeros_like(indices), dout, zeros_like(dense_shape)\\n\\n return bprop\",\n \"def to_dense(self):\\n rep = self.rep\\n\\n if rep.fmt == 'dense':\\n return self\\n\\n return self.from_rep(rep.to_dfm_or_ddm())\",\n \"def create_cnn2D(input_shape, classes, conv_layers=4, filters=32, \\n kernel_size=(3,3), padding='same', pool_size=(2,2), \\n conv_activation=\\\"relu\\\", dropout_rate=0.0, \\n dense_activation='softmax', global_avg_pool=True,\\n optimizer=\\\"Adam\\\", loss=\\\"categorical_crossentropy\\\", \\n **hyper_params):\\n dropout_layers = conv_layers // 2 # dropout for each layer\\n pooling_layers = conv_layers - 1\\n \\n model = keras.Sequential()\\n for i in range(conv_layers):\\n model.add(Conv2D(filters, kernel_size, padding=padding, \\n activation=conv_activation))\\n filters *= 2\\n if (i + 1) <= pooling_layers:\\n model.add(MaxPooling2D(pool_size))\\n if (i + 1) <= dropout_layers:\\n model.add(Dropout(rate=dropout_rate))\\n \\n if global_avg_pool:\\n model.add(GlobalAveragePooling2D())\\n \\n if classes == 2:\\n model.add(Dense(1, activation=dense_activation))\\n else:\\n model.add(Dense(classes, activation=dense_activation))\\n model.build(input_shape=input_shape)\\n \\n if optimizer.lower() == \\\"sgd\\\":\\n optimizer = keras.optimizers.SGD(**hyper_params)\\n elif optimizer.lower() == \\\"adam\\\":\\n optimizer = keras.optimizers.Adam(**hyper_params)\\n \\n model.compile(optimizer=optimizer, loss=loss.lower(), metrics=[\\\"accuracy\\\"])\\n \\n return model\",\n \"def __init__(self,\\n dense: np.ndarray = None,\\n H: np.ndarray = None,\\n M: np.ndarray = None,\\n dense_shape=None,\\n ground_state=None):\\n\\n self.dense_shape = dense_shape if dense_shape else dense.shape\\n\\n if ground_state is None:\\n self.ground_state = np.zeros(self.dense_shape[2], dtype=dense.dtype if dense is not None else M.dtype)\\n else:\\n if len(ground_state) != self.dense_shape[2]:\\n raise ValueError(\\\"One ground-state value must be provided for each channel\\\")\\n self.ground_state = ground_state\\n\\n if dense is not None:\\n self._from_dense(dense)\\n else:\\n self.H = H\\n self.M = M\",\n \"def dense_kwargs(weight_matrix):\\n return {\\\"kernel_initializer\\\": initializers.Constant(weight_matrix)}\",\n \"def create_classifier(in_dim, hid_dim, out_dim):\\n W = np.ones((in_dim, hid_dim))\\n b = np.ones(hid_dim)\\n U = np.ones((hid_dim, out_dim))\\n b_tag = np.ones(out_dim)\\n\\n W = np.random.randn(W.shape[0], W.shape[1])\\n U = np.random.randn(U.shape[0], U.shape[1])\\n b = np.random.randn(b.shape[0])\\n b_tag = np.random.randn(b_tag.shape[0])\\n params = [W, b, U, b_tag]\\n return params\",\n \"def cvxopt2dense(value):\\n return np.array(value)\",\n \"def __init__(self, attribute_size, output_size, n_hidden_layers=2, n_hidden_neurons=30):\\n self.n_hidden_layers = n_hidden_layers\\n self.n_hidden_neurons = n_hidden_neurons\\n self.attribute_size = attribute_size\\n self.output_size = output_size\\n\\n X = T.fmatrix()\\n Y = T.fmatrix()\\n\\n self.w_h = nnet.init_weights((self.attribute_size, self.n_hidden_neurons))\\n self.w_h2 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\\n self.w_o = nnet.init_weights((self.n_hidden_neurons, self.output_size))\\n\\n if self.n_hidden_layers == 2:\\n\\n noise_py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\\n py_x = nnet.model_reg(X, self.w_h, self.w_h2, self.w_o, 0, 0)\\n\\n cost = nnet.rmse(noise_py_x, Y)\\n params = [self.w_h, self.w_h2, self.w_o]\\n updates = nnet.RMSprop(cost, params, lr=0.001)\\n\\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\\n\\n elif self.n_hidden_layers == 3:\\n\\n self.w_h3 = nnet.init_weights((self.n_hidden_neurons, self.n_hidden_neurons))\\n\\n noise_py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\\n py_x = nnet.model_reg3(X, self.w_h, self.w_h2, self.w_h3, self.w_o, 0, 0)\\n\\n cost = nnet.rmse(noise_py_x, Y)\\n params = [self.w_h, self.w_h2, self.w_h3, self.w_o]\\n updates = nnet.RMSprop(cost, params, lr=0.001)\\n\\n self.train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)\\n self.predict_ = theano.function(inputs=[X], outputs=py_x, allow_input_downcast=True)\",\n \"def __init__(self, in_features, out_features):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n self.in_features = in_features\\n self.out_features = out_features\\n\\n self.__MEAN = 0\\n self.__STD = 0.0001\\n\\n self.params = {\\n 'weight': np.random.normal(loc=self.__MEAN, scale=self.__STD, size=(out_features, in_features)), \\n 'bias': np.zeros(out_features),\\n }\\n self.grads = {\\n 'weight': None, \\n 'bias': None,\\n }\\n\\n self.input_cache = None\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def dense_reparameterization(\\n inputs,\\n units,\\n activation=None,\\n activity_regularizer=None,\\n trainable=True,\\n kernel_posterior_fn=default_mean_field_normal_fn(),\\n kernel_posterior_tensor_fn=lambda d: d.sample(),\\n kernel_prior_fn=lambda dtype, *args: normal_lib.Normal( # pylint: disable=g-long-lambda\\n loc=dtype.as_numpy_dtype(0.), scale=dtype.as_numpy_dtype(1.)),\\n kernel_divergence_fn=lambda q, p, ignore: kl_lib.kl_divergence(q, p),\\n bias_posterior_fn=default_mean_field_normal_fn(is_singular=True),\\n bias_posterior_tensor_fn=lambda d: d.sample(),\\n bias_prior_fn=None,\\n bias_divergence_fn=lambda q, p, ignore: kl_lib.kl_divergence(q, p),\\n name=None,\\n reuse=None):\\n layer = DenseReparameterization(\\n units,\\n activation=activation,\\n activity_regularizer=activity_regularizer,\\n trainable=trainable,\\n kernel_posterior_fn=kernel_posterior_fn,\\n kernel_posterior_tensor_fn=kernel_posterior_tensor_fn,\\n kernel_prior_fn=kernel_prior_fn,\\n kernel_divergence_fn=kernel_divergence_fn,\\n bias_posterior_fn=bias_posterior_fn,\\n bias_posterior_tensor_fn=bias_posterior_tensor_fn,\\n bias_prior_fn=bias_prior_fn,\\n bias_divergence_fn=bias_divergence_fn,\\n name=name,\\n dtype=inputs.dtype.base_dtype,\\n _scope=name,\\n _reuse=reuse)\\n return layer.apply(inputs)\",\n \"def DenseNet(self, input_shape, nb_dense_block=4, growth_rate=48, nb_filter=96, reduction=0.0,\\n\\t\\t\\t\\t\\t\\t\\t dropout_rate=0.25, weight_decay=1e-4, classes=1000, weights_path=None,\\n\\t\\t\\t\\t\\t\\t\\t include_top=True):\\n\\t\\teps = 1.1e-5\\n\\n\\t\\t# compute compression factor\\n\\t\\tcompression = 1.0 - reduction\\n\\n\\t\\t# Handle Dimension Ordering for different backends\\n\\t\\tif K.image_dim_ordering() == \\\"tf\\\":\\n\\t\\t\\tself.concat_axis = 3\\n\\t\\telse:\\n\\t\\t\\tself.concat_axis = 1\\n\\t\\timg_input = Input(shape=input_shape, name=\\\"data\\\")\\n\\n\\t\\t# From architecture for ImageNet (Table 1 in the paper)\\n\\t\\tnb_filter = 64\\n\\t\\tnb_layers = [6,12,24,16] # For DenseNet-121\\n\\n\\t\\t# Initial convolution\\n\\t\\tx = ZeroPadding2D((3, 3), name=\\\"conv1_zeropadding\\\")(img_input)\\n\\t\\tx = Conv2D(nb_filter, (7, 7), strides=(2, 2), name=\\\"conv1\\\", use_bias=False)(x)\\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=\\\"conv1_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=\\\"conv1_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=\\\"relu1\\\")(x)\\n\\t\\tx = ZeroPadding2D((1, 1), name=\\\"pool1_zeropadding\\\")(x)\\n\\t\\tx = MaxPooling2D((3, 3), strides=(2, 2), name=\\\"pool1\\\")(x)\\n\\n\\t\\t# Add dense blocks\\n\\t\\tfor block_idx in range(nb_dense_block - 1):\\n\\t\\t\\tstage = block_idx+2\\n\\t\\t\\tx, nb_filter = self.__dense_block(x, stage, nb_layers[block_idx], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)\\n\\n\\t\\t\\t# Add __transition_block\\n\\t\\t\\tx = self.__transition_block(x, stage, nb_filter, compression=compression, dropout_rate=dropout_rate, weight_decay=weight_decay)\\n\\t\\t\\tnb_filter = int(nb_filter * compression)\\n\\n\\t\\tfinal_stage = stage + 1\\n\\t\\tx, nb_filter = self.__dense_block(x, final_stage, nb_layers[-1], nb_filter, growth_rate, dropout_rate=dropout_rate, weight_decay=weight_decay)\\n\\n\\t\\tx = BatchNormalization(epsilon=eps, axis=self.concat_axis, name=\\\"conv\\\"+str(final_stage)+\\\"_blk_bn\\\")(x)\\n\\t\\tx = Scale(axis=self.concat_axis, name=\\\"conv\\\"+str(final_stage)+\\\"_blk_scale\\\")(x)\\n\\t\\tx = Activation(\\\"relu\\\", name=\\\"relu\\\"+str(final_stage)+\\\"_blk\\\")(x)\\n\\t\\tif include_top:\\n\\t\\t\\tx = GlobalAveragePooling2D(name=\\\"pool\\\"+str(final_stage))(x)\\n\\n\\t\\t\\tx = Dense(classes, name=\\\"fc6\\\")(x)\\n\\t\\t\\tx = Activation(\\\"softmax\\\", name=\\\"prob\\\")(x)\\n\\n\\t\\tmodel = keras.models.Model(img_input, x, name=\\\"densenet\\\")\\n\\n\\t\\tif weights_path is not None:\\n\\t\\t\\tmodel.load_weights(weights_path, by_name=True)\\n\\n\\t\\treturn model\",\n \"def __init__(self,\\n input_idx: np.ndarray, hidden_idx: np.ndarray, rnn_idx: np.ndarray, output_idx: np.ndarray,\\n in2hid: tuple, in2out: tuple,\\n hid2hid: tuple, hid2out: tuple,\\n hidden_biases: np.ndarray, output_biases: np.ndarray,\\n rnn_array: np.ndarray, rnn_map: np.ndarray,\\n activation,\\n batch_size: int = 1,\\n initial_read: np.ndarray = None,\\n dtype=np.float64,\\n ):\\n # Storing the input arguments (needed later on)\\n self.act_f = activation\\n self.dtype = dtype\\n self.rnn_idx: np.ndarray = rnn_idx\\n self.n_inputs: int = len(input_idx)\\n self.n_hidden: int = len(hidden_idx)\\n self.n_rnn: int = len(rnn_idx)\\n self.n_outputs: int = len(output_idx)\\n self.bs: int = batch_size\\n \\n # Setup the rnn_map\\n rnn_map_temp = [] # Numpy-append has unwanted behaviour\\n for i, m in enumerate(rnn_map):\\n rnn_map_temp.append(np.tile(rnn_map[i], (batch_size, 1)))\\n self.rnn_map: np.ndarray = np.asarray(rnn_map_temp, dtype=bool)\\n \\n # Placeholders, initialized during reset\\n self.rnn_state: np.ndarray = None # State of the RNNs\\n self.hidden_act: np.ndarray = None # Activations of the hidden nodes\\n self.output_act: np.ndarray = None # Activations of the output nodes\\n \\n # Do not create the hidden-related matrices if hidden-nodes do not exist\\n # If they do not exist, a single matrix directly mapping inputs to outputs is only used\\n if self.n_hidden > 0:\\n self.in2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_inputs), in2hid, dtype=dtype)\\n self.hid2hid: np.ndarray = dense_from_coo((self.n_hidden, self.n_hidden), hid2hid, dtype=dtype)\\n self.hid2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_hidden), hid2out, dtype=dtype)\\n self.rnn_array: np.ndarray = rnn_array\\n self.in2out: np.ndarray = dense_from_coo((self.n_outputs, self.n_inputs), in2out, dtype=dtype)\\n \\n # Fill in the biases\\n if self.n_hidden > 0:\\n self.hidden_biases: np.ndarray = np.asarray(hidden_biases, dtype=dtype)\\n self.output_biases: np.ndarray = np.asarray(output_biases, dtype=dtype)\\n \\n # Put network to initial (default) state\\n self.reset(initial_read=initial_read)\",\n \"def mlp_model2():\\n model = Sequential()\\n model.add(Dense(256, activation='relu', input_shape=(X_train_scaled.shape[1], )))\\n model.add(Dropout(0.2))\\n model.add(Dense(128, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(64, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(32, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(FLAGS.nb_classes, activation='softmax'))\\n model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n\\n model.summary()\\n return model\",\n \"def train_etd(X, num_hidden=10, random_seed=0, sparse=False, kernel=False):\\n #svd = TruncatedSVD(n_components=num_hidden, n_iter=7, random_state=random_seed);\\n svd = PCA(n_components=num_hidden);\\n svd.fit(np.reshape(X, (X.shape[0], -1)));\\n embed_func = lambda y : svd.transform(np.reshape(y, (y.shape[0], -1)))\\n return embed_func\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n\\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\\n\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def medium2_model(optimizer='rmsprop', init='glorot_uniform', dropout=0.25):\\n model = Sequential()\\n model.add(Dropout(dropout, input_shape=(12,)))\\n model.add(Dense(32, input_dim=12, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(4)))\\n model.add(Dropout(dropout))\\n model.add(Dense(32, kernel_initializer=init, activation='relu', kernel_constraint=maxnorm(4)))\\n model.add(Dropout(dropout))\\n model.add(Dense(1, kernel_initializer=init))\\n # Compile model\\n model.compile(loss='mean_squared_error', optimizer=optimizer)\\n return model\",\n \"def get_core_net(embedding_size=128, vocab_size=20000, nout=10, dropout_rate = 0.5, activation_function = 1):\\n if activation_function == 1:\\n af = Tanh()\\n if activation_function == 2:\\n af = Explin(alpha=0)\\n if activation_function == 3:\\n af = Logistic()\\n if activation_function == 4:\\n af = Normalizer()\\n\\n \\n embedding_dim = embedding_size\\n uni = Uniform(low=-0.1/embedding_dim, high=0.1/embedding_dim)\\n glorot = GlorotUniform()\\n\\n enc = [\\n LookupTable(vocab_size=vocab_size, embedding_dim=embedding_dim, init=uni, pad_idx=0, update=True),\\n LSTM(embedding_size, glorot, activation=af, gate_activation=Logistic(), reset_cells=True),\\n RecurrentSum(),\\n ]\\n\\n dec = [\\n Dropout(keep=dropout_rate),\\n Affine(nout, glorot, bias=glorot, activation=Softmax())\\n ]\\n\\n cost, opt = get_cost_opt()\\n return (enc, dec), cost, opt\",\n \"def prepare_dense_label(input_batch, new_size, one_hot=True):\\n with tf.name_scope('label_encode'):\\n print(input_batch)\\n # input_batch = tf.image.resize_nearest_neighbor(input_batch, new_size) # as labels are integer numbers, need to use NN interpolation\\n # input_batch = tf.squeeze(input_batch, squeeze_dims=[3]) # reducing the channel dimension.\\n # if one_hot:\\n # input_batch = tf.one_hot(input_batch, depth=n_classes, axis=2)\\n return input_batch\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7653407","0.6918959","0.6870725","0.6866443","0.67675555","0.6675576","0.6606242","0.6437295","0.636316","0.6265649","0.62594026","0.6241238","0.62202615","0.61882836","0.6177038","0.61097765","0.61029375","0.6090636","0.6085418","0.6082854","0.6075049","0.60584986","0.60444593","0.5983648","0.5971185","0.5968747","0.5954731","0.5946613","0.5939085","0.592506","0.59146804","0.5910814","0.5897047","0.58951557","0.5890548","0.58892655","0.58592314","0.585146","0.5820589","0.5815846","0.58121496","0.57954234","0.5793806","0.5793792","0.5783709","0.57662773","0.5760073","0.57594395","0.57542795","0.57446325","0.57438356","0.57391804","0.573688","0.57264286","0.57200307","0.5701646","0.5696305","0.5694748","0.56943333","0.569102","0.568973","0.56882876","0.56868047","0.567101","0.56692845","0.5668691","0.566797","0.5657987","0.56525785","0.5635322","0.56340176","0.5605387","0.56036925","0.55932117","0.55901456","0.55884403","0.558757","0.5584105","0.55840623","0.55810827","0.55807126","0.55681604","0.5565244","0.5563245","0.55595666","0.5549699","0.5549515","0.5544392","0.5543631","0.5543629","0.5533992","0.5528122","0.552812","0.5526705","0.55235887","0.5517878","0.5514488","0.55116475","0.55087095","0.54985285"],"string":"[\n \"0.7653407\",\n \"0.6918959\",\n \"0.6870725\",\n \"0.6866443\",\n \"0.67675555\",\n \"0.6675576\",\n \"0.6606242\",\n \"0.6437295\",\n \"0.636316\",\n \"0.6265649\",\n \"0.62594026\",\n \"0.6241238\",\n \"0.62202615\",\n \"0.61882836\",\n \"0.6177038\",\n \"0.61097765\",\n \"0.61029375\",\n \"0.6090636\",\n \"0.6085418\",\n \"0.6082854\",\n \"0.6075049\",\n \"0.60584986\",\n \"0.60444593\",\n \"0.5983648\",\n \"0.5971185\",\n \"0.5968747\",\n \"0.5954731\",\n \"0.5946613\",\n \"0.5939085\",\n \"0.592506\",\n \"0.59146804\",\n \"0.5910814\",\n \"0.5897047\",\n \"0.58951557\",\n \"0.5890548\",\n \"0.58892655\",\n \"0.58592314\",\n \"0.585146\",\n \"0.5820589\",\n \"0.5815846\",\n \"0.58121496\",\n \"0.57954234\",\n \"0.5793806\",\n \"0.5793792\",\n \"0.5783709\",\n \"0.57662773\",\n \"0.5760073\",\n \"0.57594395\",\n \"0.57542795\",\n \"0.57446325\",\n \"0.57438356\",\n \"0.57391804\",\n \"0.573688\",\n \"0.57264286\",\n \"0.57200307\",\n \"0.5701646\",\n \"0.5696305\",\n \"0.5694748\",\n \"0.56943333\",\n \"0.569102\",\n \"0.568973\",\n \"0.56882876\",\n \"0.56868047\",\n \"0.567101\",\n \"0.56692845\",\n \"0.5668691\",\n \"0.566797\",\n \"0.5657987\",\n \"0.56525785\",\n \"0.5635322\",\n \"0.56340176\",\n \"0.5605387\",\n \"0.56036925\",\n \"0.55932117\",\n \"0.55901456\",\n \"0.55884403\",\n \"0.558757\",\n \"0.5584105\",\n \"0.55840623\",\n \"0.55810827\",\n \"0.55807126\",\n \"0.55681604\",\n \"0.5565244\",\n \"0.5563245\",\n \"0.55595666\",\n \"0.5549699\",\n \"0.5549515\",\n \"0.5544392\",\n \"0.5543631\",\n \"0.5543629\",\n \"0.5533992\",\n \"0.5528122\",\n \"0.552812\",\n \"0.5526705\",\n \"0.55235887\",\n \"0.5517878\",\n \"0.5514488\",\n \"0.55116475\",\n \"0.55087095\",\n \"0.54985285\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6904602"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":6496,"cells":{"query":{"kind":"string","value":"leaky_relu see also pleaky"},"document":{"kind":"string","value":"def leaky(x, slope=0.01, name=None):\n return tf.maximum(x, x*slope, name=name)"},"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 convert_leaky_relu(g, op, block):\n\n alpha = op.attr(\"alpha\")\n x = g.get_node(op.input(\"X\")[0])\n out = _op.nn.leaky_relu(x, alpha=alpha)\n g.add_node(op.output(\"Out\")[0], out)","def leaky_rel(x, alpha=0.1):\r\n return tf.nn.leaky_relu(x, alpha=alpha)","def leaky_relu(self, x, name, leak=0.2):\r\n return tf.maximum(x, leak * x, name=name)","def model_with_leaky_relu():\n inputs = tf.keras.Input(shape=(8, 8, 3,))\n x = tf.keras.layers.Conv2D(8, (2, 2))(inputs)\n x = tf.nn.leaky_relu(x, alpha=.4)\n x = tf.keras.layers.Conv2D(4, (2, 2))(x)\n x = tf.keras.layers.Flatten()(x)\n outputs = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\"model_with_leaky_relu\")(x)\n return outputs","def lrelu(x, leak=1e-3, name=None):\n return tf.maximum(x, leak * x, name=name)","def test_leaky_relu_activation(self):\n self.assertEqual(\n [-0.0050, 0.5000], list(af.LeakyRelu(0.01).output(np.array([-0.5, 0.5]))))\n self.assertEqual([0.01, 1], list(af.LeakyRelu(\n 0.01).derivative(np.array([-0.5, 0.5]))))","def _create_leakyrelu(cls, onnx_node, inputs, opset_version):\n alpha = onnx_node.getattr(\"alpha\", 0.01)\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\n opset_version)\n return _, forward(alpha)","def leaky_relu(x, alpha=0.01):\n return tf.maximum(x,alpha*x)","def test_model_with_leaky_relu(self):\n tf.compat.v1.reset_default_graph()\n _ = model_with_leaky_relu()\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), starting_op_names=['input_1'],\n output_op_names=['model_with_leaky_relu/Softmax'])\n self.assertTrue(validate_branch_ops(conn_graph))\n self.assertTrue(validate_product_tensor_lists(conn_graph))\n self.assertEqual(0, conn_graph.branch_count)\n self.assertEqual(7, len(conn_graph.get_all_ops()))\n\n # 6 products from inter module connections\n # 6 products from parameters\n self.assertEqual(12, len(conn_graph.get_all_products()))\n found_leaky_relu = False\n for op in conn_graph.get_all_ops().values():\n if op.type == 'LeakyRelu':\n found_leaky_relu = True\n self.assertTrue(found_leaky_relu)\n\n tf.compat.v1.reset_default_graph()","def leaky_relu(x, alpha, name=None):\n import tensorflow as tf\n with tf.name_scope(name, 'leaky_relu_{}'.format(alpha)):\n return tf.nn.relu(x) - alpha * tf.nn.relu(-x)","def make_leaky(net: nn.Module, leak: float = 0.2) -> nn.Module:\n def do_it(m: nn.Module) -> nn.Module:\n if isinstance(m, nn.ReLU):\n return nn.LeakyReLU(leak, m.inplace)\n return m\n\n return edit_model(net, do_it)","def leaky_relu(features, alpha=0.2, name=None):\n with ops.name_scope(name, \"LeakyRelu\", [features, alpha]) as name:\n features = ops.convert_to_tensor(features, name=\"features\")\n if features.dtype.is_integer:\n features = math_ops.cast(features, dtypes.float32)\n if isinstance(alpha, np.ndarray):\n alpha = alpha.item()\n return gen_nn_ops.leaky_relu(features, alpha=alpha, name=name)","def leaky_relu(x, slope=0.2):\n return LeakyReLU(slope)(x)","def init_leaky_relu(m, a=None):\n if not isinstance(m, torch.nn.Conv2d):\n return\n if a is None:\n a = nn.modules.activation.LeakyReLU().negative_slope\n nn.init.kaiming_uniform_(m.weight, a=a)","def _add_leaky_relu(hl_tensor, leaky_param):\n return tf.maximum(hl_tensor, tf.mul(leaky_param, hl_tensor))","def leaky_relu(input, negative_slope=0.01, inplace=False):\n return FunctionLib.apply(\n 'Relu', input.device, [input],\n outputs=[input if inplace else None], alpha=float(negative_slope))","def leaky_relu(x, alpha=0.01):\n return tf.maximum(x, tf.multiply(x, alpha))","def convert_leakyrelu(node, **kwargs):\n name, input_nodes, attrs = get_inputs(node, kwargs)\n initializer = kwargs[\"initializer\"]\n\n act_type = attrs.get(\"act_type\", \"leaky\")\n alpha = float(attrs.get(\"slope\", 0.25))\n\n act_name = {\"elu\": \"Elu\", \"leaky\": \"LeakyRelu\", \"prelu\": \"PRelu\",\n \"selu\": \"Selu\"}\n\n reshape_val_name = 'reshape' + str(kwargs[\"idx\"])\n input_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('int64')]\n\n reshape_value = np.array([1, -1, 1, 1], dtype='int64')\n dims = np.shape(reshape_value)\n\n shape_node = onnx.helper.make_tensor_value_info(reshape_val_name, input_type, dims)\n initializer.append(\n onnx.helper.make_tensor(\n name=reshape_val_name,\n data_type=input_type,\n dims=dims,\n vals=reshape_value,\n raw=False,\n )\n )\n\n slope_op_name = 'slope' + str(kwargs[\"idx\"])\n\n lr_node = []\n if act_type == \"prelu\" or act_type == \"selu\":\n reshape_slope_node = onnx.helper.make_node(\n 'Reshape',\n inputs=[input_nodes[1], reshape_val_name],\n outputs=[slope_op_name],\n name=slope_op_name\n )\n\n node = onnx.helper.make_node(\n act_name[act_type],\n inputs=[input_nodes[0], slope_op_name],\n outputs=[name],\n name=name)\n\n lr_node.append(shape_node)\n lr_node.append(reshape_slope_node)\n lr_node.append(node)\n else:\n node = onnx.helper.make_node(\n act_name[act_type],\n inputs=input_nodes,\n outputs=[name],\n name=name,\n alpha=alpha)\n lr_node.append(node)\n return lr_node","def leaky_relu(x, y, negative_slope=0, kernel_name=\"leaky_relu\"):\n\n # check input tensor shape\n shape = x.get(\"shape\")\n dtype = x.get(\"dtype\")\n check_shape(shape, param_name=\"x\")\n\n # check input tensor data_type\n check_list = [\"float16\", \"float32\", \"int32\", \"int8\"]\n check_dtype(dtype.lower(), check_list, param_name=\"x\")\n fuseshape = [1]\n fuseshape[0] = reduceIns(lambda x, y: x*y, shape)\n inp_dtype = dtype.lower()\n input_data_x = tvm.placeholder(fuseshape, name=\"input_data_x\",\n dtype=inp_dtype)\n\n with tvm.target.cce():\n\n res = leaky_relu_compute(input_data_x, y, negative_slope, kernel_name)\n sch = generic.auto_schedule(res)\n\n config = {\"name\": kernel_name,\n \"tensor_list\": [input_data_x, res]}\n te.lang.cce.cce_build_code(sch, config)","def test_leaky_relu(self):\n activation_name = 'LeakyReLU'\n args = {}\n\n activation = activation_factory.create(activation_name, **args)\n self.assertEqual(activation._get_name(), activation_name)","def conv_relu_pool_forward_naive(x, w, b, conv_param, pool_param):\n\ta, conv_cache = conv_forward_naive(x, w, b, conv_param)\n\ts, relu_cache = relu_forward(a)\n\tout, pool_cache = max_pool_forward_naive(s, pool_param)\n\tcache = (conv_cache, relu_cache, pool_cache)\n\treturn out, cache","def forward(self,x):\n x = x.transpose(1,2).contiguous()\n x = F.leaky_relu(self.fc1(x), 0.2)\n x = F.leaky_relu(self.bn2(self.fc2(x)), 0.2)\n x = F.leaky_relu(self.bn3(self.fc3(x)), 0.2)\n x = torch.sigmoid(self.fc4(x))\n return x.transpose(1,2)","def leakyrelu(x, negative_slope: float = 0.01):\n return np.max(x, 0) + negative_slope * np.min(-x, 0)","def _convert_to_leaky_relu_action(graph: Graph, matches: dict):\n mul_op = matches['mul_op']\n mul_value_data = matches['const_data']\n mul_data = matches['mul_data']\n input_data = matches['data']\n max_op = matches['max_op']\n max_data = max_op.out_node()\n\n # Check that all nodes satisfies conversion requirements\n if len(max_op.in_nodes()) > 2:\n log.debug('Maximum layer ({}) can not participate in conversion to leaky ReLU due to it has more than two '\n 'inputs ({})'.format(max_op.id, len(max_op.in_nodes())))\n return\n\n if mul_value_data.has_valid('value') and mul_value_data.value.size != 1:\n log.debug('Mul layer ({}) can not participate in conversion to leaky ReLU due to value {}'\n ''.format(mul_op.id, mul_value_data.soft_get('value')))\n return\n\n value = mul_value_data.value.item(0)\n\n if len(mul_data.out_nodes()) > 1:\n log.debug('Mul layer({}) can not participate in conversion to leaky ReLU due to it has more than one consumer'\n ''.format(mul_op.id))\n return\n\n # Disconnect data nodes from ops\n graph.remove_edge(max_op.id, max_data.id)\n graph.remove_edge(input_data.id, mul_op.id)\n graph.remove_edge(input_data.id, max_op.id)\n\n # Create new ReLU operation\n relu_op = LeakyReLU(graph, dict(name=\"LeakyReLU_\", negative_slope=value))\n relu_op.create_node_with_data(inputs=[input_data], data_nodes=max_data)\n\n log.debug('Successful conversion from {} {} to ReLU with negative slope (leaky ReLU)'\n ''.format(max_op.id, mul_op.id))","def conv_relu_pool_forward(x, w, b, conv_param, pool_param):\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\n s, relu_cache = relu_forward(a)\n out, pool_cache = max_pool_forward_fast(s, pool_param)\n cache = (conv_cache, relu_cache, pool_cache)\n return out, cache","def conv_relu_pool_forward(x, w, b, conv_param, pool_param):\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\n s, relu_cache = relu_forward(a)\n out, pool_cache = max_pool_forward_fast(s, pool_param)\n cache = (conv_cache, relu_cache, pool_cache)\n return out, cache","def leakrelu(Z):\n\n A = np.maximum(0.01 * Z, Z)\n\n assert (A.shape == Z.shape)\n\n return A","def lrelu(x):\r\n return max(0.1*x, x)","def lrelu(self):\n return self.add_layer(lrelu)","def conv_relu_forward_naive(x, w, b, conv_param):\n\ta, conv_cache = conv_forward_naive(x, w, b, conv_param)\n\tout, relu_cache = relu_forward(a)\n\tcache = (conv_cache, relu_cache)\n\treturn out, cache","def conv_relu_pool_backward_naive(dout, cache):\n\tconv_cache, relu_cache, pool_cache = cache\n\tds = max_pool_backward_naive(dout, pool_cache)\n\tda = relu_backward(ds, relu_cache)\n\tdx, dw, db = conv_backward_naive(da, conv_cache)\n\treturn dx, dw, db","def _relu(layer):\n return tf.nn.relu(layer)","def DarknetConv2D_BN_Leaky(*args, **kwargs):\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(DarknetConv2D(*args, **no_bias_kwargs), BatchNormalization(), LeakyReLU(alpha=0.1))","def __relu(x):\n return x if x > 0 else 0","def naive_relu(x):\n assert len(x.shape) == 2\n\n x = x.copy()\n for i in range(x.shape[0]):\n for j in range(x.shape[1]):\n x[i, j] = max(x[i, j], 0)\n\n return x","def DarknetConv2D_BN_Leaky(*args, **kwargs):\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(DarknetConv2D(*args, **no_bias_kwargs),\n tf.keras.layers.BatchNormalization(),\n tf.keras.layers.LeakyReLU(alpha=0.1))","def conv_relu_pool_backward(dout, cache):\n conv_cache, relu_cache, pool_cache = cache\n ds = layers.max_pool_backward_naive(dout, pool_cache)\n da = layers.relu_backward(ds, relu_cache)\n dx, dw, db = layers.conv_backward_naive(da, conv_cache)\n return dx, dw, db","def DarknetConv2D_BN_Leaky(*args, **kwargs):\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(\n DarknetConv2D(*args, **no_bias_kwargs),\n CustomBatchNormalization(),\n LeakyReLU(alpha=0.1))","def conv_relu_forward(x, w, b, conv_param):\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\n out, relu_cache = relu_forward(a)\n cache = (conv_cache, relu_cache)\n return out, cache","def conv_relu_forward(x, w, b, conv_param):\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\n out, relu_cache = relu_forward(a)\n cache = (conv_cache, relu_cache)\n return out, cache","def DarknetConv2D_BN_Leaky(*args, **kwargs):\n no_bias_kwargs = {'use_bias': False}\n no_bias_kwargs.update(kwargs)\n return compose(\n DarknetConv2D(*args, **no_bias_kwargs),\n BatchNormalization(),\n LeakyReLU(alpha=0.1))","def d_relu(x):\n\n return (x > 0) * 1","def conv_relu_pool_backward(dout, cache):\n conv_cache, relu_cache, pool_cache = cache\n ds = max_pool_backward_fast(dout, pool_cache)\n da = relu_backward(ds, relu_cache)\n dx, dw, db = conv_backward_fast(da, conv_cache)\n return dx, dw, db","def conv_relu_pool_backward(dout, cache):\n conv_cache, relu_cache, pool_cache = cache\n ds = max_pool_backward_fast(dout, pool_cache)\n da = relu_backward(ds, relu_cache)\n dx, dw, db = conv_backward_fast(da, conv_cache)\n return dx, dw, db","def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\r\n num_epochs=100, learning_rate=0.001, threshold=0.1):\r\n super(ReluNet, self).__init__()\r\n\r\n self.input_dim = input_dim\r\n self.output_dim = output_dim\r\n self.hidden_dim = hidden_dim\r\n self.num_layers = num_layers\r\n self.num_epochs = num_epochs\r\n self.threshold = threshold\r\n self.learning_rate = learning_rate\r\n\r\n\r\n \r\n self.layers = nn.ModuleList()\r\n self.layers.append(nn.Linear(input_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n for i in range(num_layers-1):\r\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n # output layer\r\n self.layers.append(nn.Linear(hidden_dim, output_dim))","def backward_deconvnet_relu(x):\n def grad(dy):\n return tf.nn.relu(dy)\n return tf.nn.relu(x), grad","def forward(self, x):\r\n\r\n y = self.conv1(x)\r\n y = self.bn1(y)\r\n y = F.relu(y, inplace = True)\r\n y = self.conv2(y)\r\n y = self.bn2(y)\r\n y = F.relu(y, inplace = True)\r\n\r\n return y","def _bn_relu(input):\n norm = BatchNormalization(axis=CHANNEL_AXIS)(input)\n return Activation(\"relu\")(norm)","def _bn_relu(input):\n norm = BatchNormalization(axis=CHANNEL_AXIS)(input)\n return Activation(\"relu\")(norm)","def relu(x, name):\n\n with tf.name_scope(name):\n outputs = tf.nn.relu(x)\n # Return layer's output\n return outputs","def _bn_relu(input):\n norm = BatchNormalization()(input)\n return Activation(\"relu\")(norm)","def _bn_relu(input):\n norm = BatchNormalization()(input)\n return Activation(\"relu\")(norm)","def fully_connected_relu(input, size):\n return tf.nn.relu(fully_connected(input, size))","def __drelu(x):\n return 0 if x <= 0 else 1","def _bn_relu(input):\n\tnorm = BatchNormalization(axis=3)(input)\n\treturn Activation(\"relu\")(norm)","def __call__(self, x):\n h = F.relu(self.l0(x))\n h = F.relu(self.l1(h))\n return self.l2(h)","def forward(self, x):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\n x = F.relu(self.batch3a(self.conv3a(x)))\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\n x = F.relu(self.batch4a(self.conv4a(x)))\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\n x = F.relu(self.batch5a(self.conv5a(x)))\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\n x = self.avgpool(x)\n x = x.reshape(x.shape[0], -1)\n out = self.fc1(x)\n\n# raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def conv_relu_backward_naive(dout, cache):\n\tconv_cache, relu_cache = cache\n\tda = relu_backward(dout, relu_cache)\n\tdx, dw, db = conv_backward_naive(da, conv_cache)\n\treturn dx, dw, db","def _bn_relu(input):\r\n norm = BatchNormalization(axis=3)(input)\r\n return Activation(\"relu\")(norm)","def relu_forward(x):\n #raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################\n out=np.maximum(0,x)\n cache=x\n return out,cache","def b1relu( regularizers, x):\n N, M, F = x.get_shape()\n b = _bias_variable(regularizers,[1, 1, int(F)], regularization=True)\n return tf.nn.relu(x + b)","def forward(self, input_image):\n c1 = self.conv1(input_image)\n c2 = self.conv2_bn(self.conv2(F.leaky_relu(c1, 0.1)))\n c3 = self.conv3_bn(self.conv3(F.leaky_relu(c2, 0.1)))\n c4 = self.conv4_bn(self.conv4(F.leaky_relu(c3, 0.1)))\n c5 = self.conv5(F.leaky_relu(c4, 0.1))\n\n if self.noise:\n c5 += Variable((0.01 * (torch.randn(c5.size()))).cuda())\n\n d1 = F.dropout(self.deconv1_bn(self.deconv1(F.leaky_relu(c5, 0.1))), 0.5, training=True)\n if self.residual:\n d1 = torch.cat([d1, c4], 1)\n d2 = F.dropout(self.deconv2_bn(self.deconv2(F.leaky_relu(d1, 0.1))), 0.5, training=True)\n if self.residual:\n d2 = torch.cat([d2, c3], 1)\n d3 = F.dropout(self.deconv3_bn(self.deconv3(F.leaky_relu(d2, 0.1))), 0.5, training=True)\n if self.residual:\n d3 = torch.cat([d3, c2], 1)\n d4 = self.deconv4_bn(self.deconv4(F.leaky_relu(d3, 0.1)))\n if self.residual:\n d4 = torch.cat([d4, c1], 1)\n d5 = self.deconv5(F.leaky_relu(d4, 0.1))\n out = F.tanh(d5)\n\n return out","def create_relu(x, bias):\n\n return tf.nn.relu(tf.nn.bias_add(x, bias))","def forward(self, x):\n # define feedforward behavior, applying activations as necessary\n out = self.leaky_relu(self.conv1(x))\n out = self.leaky_relu(self.conv2(out))\n out = self.leaky_relu(self.conv3(out))\n out = self.leaky_relu(self.conv4(out))\n\n out = self.res_blocks(out)\n\n out = self.leaky_relu(self.deconv1(out))\n out = self.leaky_relu(self.deconv2(out))\n out = self.leaky_relu(self.deconv3(out))\n\n # tanh applied to last layer\n out = F.tanh(self.out_layer(out))\n out = torch.clamp(out, min=-0.5, max=0.5)\n\n return out","def intermediate_layer(layer, filters, kernel_size):\n layer = Conv2D(filters=filters, kernel_size=kernel_size,\n strides=(2, 2), padding=\"same\")(layer)\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\n return layer","def affine_relu_forward(x, w, b):\n a, fc_cache = affine_forward(x, w, b)\n out, relu_cache = relu_forward(a)\n cache = (fc_cache, relu_cache)\n return out, cache","def affine_relu_forward(x, w, b):\n a, fc_cache = affine_forward(x, w, b)\n out, relu_cache = relu_forward(a)\n cache = (fc_cache, relu_cache)\n return out, cache","def affine_relu_forward(x, w, b):\n a, fc_cache = affine_forward(x, w, b)\n out, relu_cache = relu_forward(a)\n cache = (fc_cache, relu_cache)\n return out, cache","def affine_relu_forward(x, w, b):\n a, fc_cache = affine_forward(x, w, b)\n out, relu_cache = relu_forward(a)\n cache = (fc_cache, relu_cache)\n return out, cache","def relu_forward(x):\n out = None\n out = np.maximum(0.0, x)\n cache = x\n return out, cache","def forward(self, state):\r\n x = F.relu(self.linear1(state))\r\n x = F.relu(self.linear2(x))\r\n #x = torch.tanh(self.linear3(x))\r\n #x = F.relu(self.linear3(x))\r\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\r\n x = F.leaky_relu(self.linear3(x), 0.1)\r\n #x = F.softmax(self.linear3(x), dim=0)\r\n \r\n return x#.negativ_slope","def _bn_relu(self, input):\n depth = input.get_shape().as_list()[-1]\n\n # mean and variance calc on batch-height-width dimension\n mean, var = tf.nn.moments(input, axes=[0, 1, 2])\n beta = tf.Variable(tf.zeros([depth]), name='beta')\n gamma = self._get_weight_variable([depth], name='gamma')\n\n bn_out = tf.nn.batch_norm_with_global_normalization(input, mean, var, beta, gamma, 0.001,\n scale_after_normalization=True)\n\n out = tf.nn.relu(bn_out)\n\n return out","def forward(self, x):\n return self.relu(self.conv(x))","def conv_relu_backward(dout, cache):\n conv_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = conv_backward_fast(da, conv_cache)\n return dx, dw, db","def conv_relu_backward(dout, cache):\n conv_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = conv_backward_fast(da, conv_cache)\n return dx, dw, db","def Spp_Conv2D_BN_Leaky_Fast(x, num_filters):\n y1 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(x)\n y2 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(y1)\n y3 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(y2)\n\n y = compose(\n Concatenate(),\n DarknetConv2D_BN_Leaky(num_filters, (1,1)))([y3, y2, y1, x])\n return y","def forward(self, x):\n\n x = F.max_pool2d(F.relu(self.batch_norm1(self.conv1(x))), 3, stride=2, padding=1)\n x = F.max_pool2d(F.relu(self.batch_norm2(self.conv2(x))), 3, stride=2, padding=1)\n x = F.max_pool2d(F.relu(self.batch_norm3_b(self.conv3_b(F.relu(self.batch_norm3_a(self.conv3_a(x)))))), 3, stride=2, padding=1)\n x = F.max_pool2d(F.relu(self.batch_norm4_b(self.conv4_b(F.relu(self.batch_norm4_a(self.conv4_a(x)))))), 3, stride=2, padding=1)\n x = F.max_pool2d(F.relu(self.batch_norm5_b(self.conv5_b(F.relu(self.batch_norm5_a(self.conv5_a(x)))))), 3, stride=2, padding=1)\n x = self.avg_pool(x).view(-1,512)\n out = self.linear(x)\n\n return out","def guided_backpropagation_relu(x):\n def grad(dy):\n return tf.nn.relu(dy) * tf.cast(x > 0.0, x.dtype)\n return tf.nn.relu(x), grad","def relu_forward(x):\r\n cache = x\r\n out = np.maximum(0, x)\r\n return out, cache","def test_relu(self):\n activation_name = 'ReLU'\n args = {}\n\n activation = activation_factory.create(activation_name, **args)\n self.assertEqual(activation._get_name(), activation_name)\n\n x = torch.ones(10) * -1\n y = activation(x)\n self.assertEqual(len(torch.nonzero(y, as_tuple=False)), 0)","def brelu(self, x):\n return F.relu(x + self.bias)","def conv_relu_backward(dout, cache):\n conv_cache, relu_cache = cache\n da = layers.relu_backward(dout, relu_cache)\n dx, dw, db = layers.conv_backward_fast(da, conv_cache)\n return dx, dw, db","def forward(self, x): # pylint: disable=invalid-name\n\n residual = x\n\n out = self.conv1(x)\n out = self.bn1(out)\n\n out = self.relu(out)\n\n out = self.conv2(out)\n out = self.bn2(out)\n\n out = self.relu(out)\n\n out = self.conv3(out)\n out = self.bn3(out)\n\n if self.downsample is not None:\n residual = self.downsample(x)\n out += residual\n\n out = self.relu(out)\n out = self.maxpool(out)\n\n return out","def __call__(self, inputs):\n bias = self.param(\"bias\", self.bias_initializer,\n (1, 1, 1, inputs.shape[-2], inputs.shape[-1]))\n\n modulus_inputs = jnp.abs(inputs)\n return (nn.relu(modulus_inputs + bias) *\n (inputs / (modulus_inputs + self.epsilon)))","def affine_layernorm_relu_forward(x, w, b, gamma, beta, ln_param):\n fc_out, fc_cache = affine_forward(x, w, b)\n norm_out, norm_cache = layernorm_forward(fc_out, gamma, beta, ln_param)\n out, relu_cache = relu_forward(norm_out)\n cache = (fc_cache, norm_cache, relu_cache)\n return out, cache","def __call__(self, x):\n \n # Define the \"forward pass\" for this model based on the architecture detailed above.\n\n x = relu(self.conv1(x)[...,:-1,:])\n x = batchnorm(x, eps=1e-7)\n x = max_pool(x, (2, 2), 2)\n\n x = relu(self.conv2(x))\n x = batchnorm(x, eps=1e-7)\n x = max_pool(x, (2, 2), 2)\n\n x = relu(self.conv3(x)[...,:,:-1])\n x = batchnorm(x, eps=1e-7)\n x = max_pool(x, (2, 2), 2)\n\n x = relu(self.conv4(x)[...,:,:-1])\n x = batchnorm(x, eps=1e-7)\n x = max_pool(x, (2, 2), 2)\n\n x = relu(self.dense1(x.reshape(x.shape[0], -1)))\n return self.dense2(x)","def leakrelu_backward(dA, Z):\n\n # When z <= 0, dz = 0.01\n derivative = np.ones(Z.shape)\n derivative[Z < 0] = 0.01\n\n dZ = dA * derivative\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def relu(input, inplace=False):\n return FunctionLib.apply(\n 'Relu', input.device, [input],\n outputs=[input if inplace else None], alpha=0.)","def tf_activate(x, keep_prob = 1.0):\n method = \"relu\"\n x = tf.nn.dropout(x, keep_prob = keep_prob)\n if method == \"relu\":\n return tf.nn.relu(x)\n elif method == \"elu\":\n return tf.nn.elu(x)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def __init__(self, id, node_type=NodeType.HIDDEN, activation=F.relu, layer_type=nn.Conv2d,\n conv_window_size=3, conv_stride=1, max_pool_size=2):\n\n super(ModuleNEATNode, self).__init__(id, node_type)\n\n batch_norm_chance = 0.65 # chance that a new node will start with batch norm\n use_batch_norm = random.random() < batch_norm_chance\n\n dropout_chance = 0.2 # chance that a new node will start with drop out\n use_dropout = random.random() < dropout_chance\n\n max_pool_chance = 0.3 # chance that a new node will start with drop out\n use_max_pool = random.random() < max_pool_chance\n\n self.activation = Mutagen(F.relu, F.leaky_relu, torch.sigmoid, F.relu6,\n discreet_value=activation, name=\"activation function\",\n mutation_chance=0.15) # TODO try add in Selu, Elu\n\n conv_out_features = 25 + random.randint(0, 25)\n linear_out_features = 100 + random.randint(0, 100)\n\n linear_submutagens = \\\n {\n \"regularisation\": Mutagen(None, nn.BatchNorm1d,\n discreet_value=nn.BatchNorm1d if use_batch_norm else None,\n mutation_chance=0.15),\n\n \"dropout\": Mutagen(None, nn.Dropout, discreet_value=nn.Dropout if use_dropout else None, sub_mutagens=\n {\n nn.Dropout: {\n \"dropout_factor\": Mutagen(value_type=ValueType.CONTINUOUS, current_value=0.15, start_range=0,\n end_range=0.75)}\n }, mutation_chance=0.08),\n\n \"out_features\": Mutagen(value_type=ValueType.WHOLE_NUMBERS, current_value=linear_out_features,\n start_range=10,\n end_range=1024, name=\"num out features\", mutation_chance=0.22,\n distance_weighting=Props.LAYER_SIZE_COEFFICIENT if Config.allow_attribute_distance else 0)\n }\n\n conv_submutagens = {\n \"conv_window_size\": Mutagen(3, 5, 7, discreet_value=conv_window_size, mutation_chance=0.13),\n\n \"conv_stride\": Mutagen(value_type=ValueType.WHOLE_NUMBERS, current_value=conv_stride, start_range=1,\n end_range=5),\n\n \"reduction\": Mutagen(None, nn.MaxPool2d, discreet_value=nn.MaxPool2d if use_max_pool else None,\n sub_mutagens=\n {\n nn.MaxPool2d: {\"pool_size\": Mutagen(\n value_type=ValueType.WHOLE_NUMBERS, current_value=max_pool_size, start_range=2,\n end_range=5)}\n }, mutation_chance=0.15),\n\n \"regularisation\": Mutagen(None, nn.BatchNorm2d, discreet_value=nn.BatchNorm2d if use_batch_norm else None,\n mutation_chance=0.15),\n\n \"dropout\": Mutagen(None, nn.Dropout2d, discreet_value=nn.Dropout2d if use_dropout else None, sub_mutagens=\n {\n nn.Dropout2d: {\n \"dropout_factor\": Mutagen(value_type=ValueType.CONTINUOUS, current_value=0.1,\n start_range=0, end_range=0.75)}\n }, mutation_chance=0.08),\n\n \"out_features\": Mutagen(value_type=ValueType.WHOLE_NUMBERS, current_value=conv_out_features, start_range=1,\n end_range=100, name=\"num out features\", mutation_chance=0.22,\n distance_weighting=Props.LAYER_SIZE_COEFFICIENT if Config.allow_attribute_distance else 0)\n }\n\n if use_linears and not use_convs:\n self.layer_type = Mutagen(nn.Linear, discreet_value=nn.Linear,\n distance_weighting=Props.LAYER_TYPE_COEFFICIENT if Config.allow_attribute_distance else 0,\n sub_mutagens={nn.Linear: linear_submutagens}\n )\n if use_convs and not use_linears:\n self.layer_type = Mutagen(nn.Conv2d, discreet_value=nn.Conv2d,\n distance_weighting=Props.LAYER_TYPE_COEFFICIENT if Config.allow_attribute_distance else 0,\n sub_mutagens={nn.Conv2d: conv_submutagens})\n if use_convs and use_linears:\n self.layer_type = Mutagen(nn.Conv2d, nn.Linear, discreet_value=layer_type,\n distance_weighting=Props.LAYER_TYPE_COEFFICIENT if Config.allow_attribute_distance else 0,\n sub_mutagens={\n nn.Conv2d: conv_submutagens,\n nn.Linear: linear_submutagens\n }, name=\"deep layer type\", mutation_chance=0.08)","def forward(self, x):\n \n x = F.relu(self.conv1_bn(self.conv1(self.conv0_bn(x))))\n x = F.relu(self.conv2_bn(self.conv2(x)))\n x = F.relu(self.conv3_bn(self.conv3( self.maxpool2(x))))\n x = F.relu(self.conv4_bn(self.conv4( self.maxpool3(x))))\n x = self.maxpool4(x) \n x = x.view(-1, 1184)\n x = F.relu(self.fc1(x))\n x = self.dense1_bn(x)\n x = F.dropout(x, training=self.training)\n x = self.fc2(x)\n return F.log_softmax(x)","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = np.maximum(x,0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def dense(depth_in, depth_out, bias=True, lrelu=None):\r\n assert (depth_in>0 and depth_out>0)\r\n linr_ = nn.Linear(depth_in, depth_out, bias)\r\n if lrelu is not None:\r\n linr_ = nn.Sequential(linr_, \r\n nn.LeakyReLU(lrelu, inplace=True))\r\n return linr_","def forward(self, x):\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 return x","def soft_relu(x):\n return ((-x.abs()).exp() + 1.0).log() + torch.clip(x, min=0.0)","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = np.maximum(0, x)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache"],"string":"[\n \"def convert_leaky_relu(g, op, block):\\n\\n alpha = op.attr(\\\"alpha\\\")\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n out = _op.nn.leaky_relu(x, alpha=alpha)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def leaky_rel(x, alpha=0.1):\\r\\n return tf.nn.leaky_relu(x, alpha=alpha)\",\n \"def leaky_relu(self, x, name, leak=0.2):\\r\\n return tf.maximum(x, leak * x, name=name)\",\n \"def model_with_leaky_relu():\\n inputs = tf.keras.Input(shape=(8, 8, 3,))\\n x = tf.keras.layers.Conv2D(8, (2, 2))(inputs)\\n x = tf.nn.leaky_relu(x, alpha=.4)\\n x = tf.keras.layers.Conv2D(4, (2, 2))(x)\\n x = tf.keras.layers.Flatten()(x)\\n outputs = tf.keras.layers.Dense(10, activation=tf.nn.softmax, name=\\\"model_with_leaky_relu\\\")(x)\\n return outputs\",\n \"def lrelu(x, leak=1e-3, name=None):\\n return tf.maximum(x, leak * x, name=name)\",\n \"def test_leaky_relu_activation(self):\\n self.assertEqual(\\n [-0.0050, 0.5000], list(af.LeakyRelu(0.01).output(np.array([-0.5, 0.5]))))\\n self.assertEqual([0.01, 1], list(af.LeakyRelu(\\n 0.01).derivative(np.array([-0.5, 0.5]))))\",\n \"def _create_leakyrelu(cls, onnx_node, inputs, opset_version):\\n alpha = onnx_node.getattr(\\\"alpha\\\", 0.01)\\n _, forward = cls._common_onnx_node_to_singa_op(onnx_node, inputs,\\n opset_version)\\n return _, forward(alpha)\",\n \"def leaky_relu(x, alpha=0.01):\\n return tf.maximum(x,alpha*x)\",\n \"def test_model_with_leaky_relu(self):\\n tf.compat.v1.reset_default_graph()\\n _ = model_with_leaky_relu()\\n conn_graph = ConnectedGraph(tf.compat.v1.get_default_graph(), starting_op_names=['input_1'],\\n output_op_names=['model_with_leaky_relu/Softmax'])\\n self.assertTrue(validate_branch_ops(conn_graph))\\n self.assertTrue(validate_product_tensor_lists(conn_graph))\\n self.assertEqual(0, conn_graph.branch_count)\\n self.assertEqual(7, len(conn_graph.get_all_ops()))\\n\\n # 6 products from inter module connections\\n # 6 products from parameters\\n self.assertEqual(12, len(conn_graph.get_all_products()))\\n found_leaky_relu = False\\n for op in conn_graph.get_all_ops().values():\\n if op.type == 'LeakyRelu':\\n found_leaky_relu = True\\n self.assertTrue(found_leaky_relu)\\n\\n tf.compat.v1.reset_default_graph()\",\n \"def leaky_relu(x, alpha, name=None):\\n import tensorflow as tf\\n with tf.name_scope(name, 'leaky_relu_{}'.format(alpha)):\\n return tf.nn.relu(x) - alpha * tf.nn.relu(-x)\",\n \"def make_leaky(net: nn.Module, leak: float = 0.2) -> nn.Module:\\n def do_it(m: nn.Module) -> nn.Module:\\n if isinstance(m, nn.ReLU):\\n return nn.LeakyReLU(leak, m.inplace)\\n return m\\n\\n return edit_model(net, do_it)\",\n \"def leaky_relu(features, alpha=0.2, name=None):\\n with ops.name_scope(name, \\\"LeakyRelu\\\", [features, alpha]) as name:\\n features = ops.convert_to_tensor(features, name=\\\"features\\\")\\n if features.dtype.is_integer:\\n features = math_ops.cast(features, dtypes.float32)\\n if isinstance(alpha, np.ndarray):\\n alpha = alpha.item()\\n return gen_nn_ops.leaky_relu(features, alpha=alpha, name=name)\",\n \"def leaky_relu(x, slope=0.2):\\n return LeakyReLU(slope)(x)\",\n \"def init_leaky_relu(m, a=None):\\n if not isinstance(m, torch.nn.Conv2d):\\n return\\n if a is None:\\n a = nn.modules.activation.LeakyReLU().negative_slope\\n nn.init.kaiming_uniform_(m.weight, a=a)\",\n \"def _add_leaky_relu(hl_tensor, leaky_param):\\n return tf.maximum(hl_tensor, tf.mul(leaky_param, hl_tensor))\",\n \"def leaky_relu(input, negative_slope=0.01, inplace=False):\\n return FunctionLib.apply(\\n 'Relu', input.device, [input],\\n outputs=[input if inplace else None], alpha=float(negative_slope))\",\n \"def leaky_relu(x, alpha=0.01):\\n return tf.maximum(x, tf.multiply(x, alpha))\",\n \"def convert_leakyrelu(node, **kwargs):\\n name, input_nodes, attrs = get_inputs(node, kwargs)\\n initializer = kwargs[\\\"initializer\\\"]\\n\\n act_type = attrs.get(\\\"act_type\\\", \\\"leaky\\\")\\n alpha = float(attrs.get(\\\"slope\\\", 0.25))\\n\\n act_name = {\\\"elu\\\": \\\"Elu\\\", \\\"leaky\\\": \\\"LeakyRelu\\\", \\\"prelu\\\": \\\"PRelu\\\",\\n \\\"selu\\\": \\\"Selu\\\"}\\n\\n reshape_val_name = 'reshape' + str(kwargs[\\\"idx\\\"])\\n input_type = onnx.mapping.NP_TYPE_TO_TENSOR_TYPE[np.dtype('int64')]\\n\\n reshape_value = np.array([1, -1, 1, 1], dtype='int64')\\n dims = np.shape(reshape_value)\\n\\n shape_node = onnx.helper.make_tensor_value_info(reshape_val_name, input_type, dims)\\n initializer.append(\\n onnx.helper.make_tensor(\\n name=reshape_val_name,\\n data_type=input_type,\\n dims=dims,\\n vals=reshape_value,\\n raw=False,\\n )\\n )\\n\\n slope_op_name = 'slope' + str(kwargs[\\\"idx\\\"])\\n\\n lr_node = []\\n if act_type == \\\"prelu\\\" or act_type == \\\"selu\\\":\\n reshape_slope_node = onnx.helper.make_node(\\n 'Reshape',\\n inputs=[input_nodes[1], reshape_val_name],\\n outputs=[slope_op_name],\\n name=slope_op_name\\n )\\n\\n node = onnx.helper.make_node(\\n act_name[act_type],\\n inputs=[input_nodes[0], slope_op_name],\\n outputs=[name],\\n name=name)\\n\\n lr_node.append(shape_node)\\n lr_node.append(reshape_slope_node)\\n lr_node.append(node)\\n else:\\n node = onnx.helper.make_node(\\n act_name[act_type],\\n inputs=input_nodes,\\n outputs=[name],\\n name=name,\\n alpha=alpha)\\n lr_node.append(node)\\n return lr_node\",\n \"def leaky_relu(x, y, negative_slope=0, kernel_name=\\\"leaky_relu\\\"):\\n\\n # check input tensor shape\\n shape = x.get(\\\"shape\\\")\\n dtype = x.get(\\\"dtype\\\")\\n check_shape(shape, param_name=\\\"x\\\")\\n\\n # check input tensor data_type\\n check_list = [\\\"float16\\\", \\\"float32\\\", \\\"int32\\\", \\\"int8\\\"]\\n check_dtype(dtype.lower(), check_list, param_name=\\\"x\\\")\\n fuseshape = [1]\\n fuseshape[0] = reduceIns(lambda x, y: x*y, shape)\\n inp_dtype = dtype.lower()\\n input_data_x = tvm.placeholder(fuseshape, name=\\\"input_data_x\\\",\\n dtype=inp_dtype)\\n\\n with tvm.target.cce():\\n\\n res = leaky_relu_compute(input_data_x, y, negative_slope, kernel_name)\\n sch = generic.auto_schedule(res)\\n\\n config = {\\\"name\\\": kernel_name,\\n \\\"tensor_list\\\": [input_data_x, res]}\\n te.lang.cce.cce_build_code(sch, config)\",\n \"def test_leaky_relu(self):\\n activation_name = 'LeakyReLU'\\n args = {}\\n\\n activation = activation_factory.create(activation_name, **args)\\n self.assertEqual(activation._get_name(), activation_name)\",\n \"def conv_relu_pool_forward_naive(x, w, b, conv_param, pool_param):\\n\\ta, conv_cache = conv_forward_naive(x, w, b, conv_param)\\n\\ts, relu_cache = relu_forward(a)\\n\\tout, pool_cache = max_pool_forward_naive(s, pool_param)\\n\\tcache = (conv_cache, relu_cache, pool_cache)\\n\\treturn out, cache\",\n \"def forward(self,x):\\n x = x.transpose(1,2).contiguous()\\n x = F.leaky_relu(self.fc1(x), 0.2)\\n x = F.leaky_relu(self.bn2(self.fc2(x)), 0.2)\\n x = F.leaky_relu(self.bn3(self.fc3(x)), 0.2)\\n x = torch.sigmoid(self.fc4(x))\\n return x.transpose(1,2)\",\n \"def leakyrelu(x, negative_slope: float = 0.01):\\n return np.max(x, 0) + negative_slope * np.min(-x, 0)\",\n \"def _convert_to_leaky_relu_action(graph: Graph, matches: dict):\\n mul_op = matches['mul_op']\\n mul_value_data = matches['const_data']\\n mul_data = matches['mul_data']\\n input_data = matches['data']\\n max_op = matches['max_op']\\n max_data = max_op.out_node()\\n\\n # Check that all nodes satisfies conversion requirements\\n if len(max_op.in_nodes()) > 2:\\n log.debug('Maximum layer ({}) can not participate in conversion to leaky ReLU due to it has more than two '\\n 'inputs ({})'.format(max_op.id, len(max_op.in_nodes())))\\n return\\n\\n if mul_value_data.has_valid('value') and mul_value_data.value.size != 1:\\n log.debug('Mul layer ({}) can not participate in conversion to leaky ReLU due to value {}'\\n ''.format(mul_op.id, mul_value_data.soft_get('value')))\\n return\\n\\n value = mul_value_data.value.item(0)\\n\\n if len(mul_data.out_nodes()) > 1:\\n log.debug('Mul layer({}) can not participate in conversion to leaky ReLU due to it has more than one consumer'\\n ''.format(mul_op.id))\\n return\\n\\n # Disconnect data nodes from ops\\n graph.remove_edge(max_op.id, max_data.id)\\n graph.remove_edge(input_data.id, mul_op.id)\\n graph.remove_edge(input_data.id, max_op.id)\\n\\n # Create new ReLU operation\\n relu_op = LeakyReLU(graph, dict(name=\\\"LeakyReLU_\\\", negative_slope=value))\\n relu_op.create_node_with_data(inputs=[input_data], data_nodes=max_data)\\n\\n log.debug('Successful conversion from {} {} to ReLU with negative slope (leaky ReLU)'\\n ''.format(max_op.id, mul_op.id))\",\n \"def conv_relu_pool_forward(x, w, b, conv_param, pool_param):\\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\\n s, relu_cache = relu_forward(a)\\n out, pool_cache = max_pool_forward_fast(s, pool_param)\\n cache = (conv_cache, relu_cache, pool_cache)\\n return out, cache\",\n \"def conv_relu_pool_forward(x, w, b, conv_param, pool_param):\\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\\n s, relu_cache = relu_forward(a)\\n out, pool_cache = max_pool_forward_fast(s, pool_param)\\n cache = (conv_cache, relu_cache, pool_cache)\\n return out, cache\",\n \"def leakrelu(Z):\\n\\n A = np.maximum(0.01 * Z, Z)\\n\\n assert (A.shape == Z.shape)\\n\\n return A\",\n \"def lrelu(x):\\r\\n return max(0.1*x, x)\",\n \"def lrelu(self):\\n return self.add_layer(lrelu)\",\n \"def conv_relu_forward_naive(x, w, b, conv_param):\\n\\ta, conv_cache = conv_forward_naive(x, w, b, conv_param)\\n\\tout, relu_cache = relu_forward(a)\\n\\tcache = (conv_cache, relu_cache)\\n\\treturn out, cache\",\n \"def conv_relu_pool_backward_naive(dout, cache):\\n\\tconv_cache, relu_cache, pool_cache = cache\\n\\tds = max_pool_backward_naive(dout, pool_cache)\\n\\tda = relu_backward(ds, relu_cache)\\n\\tdx, dw, db = conv_backward_naive(da, conv_cache)\\n\\treturn dx, dw, db\",\n \"def _relu(layer):\\n return tf.nn.relu(layer)\",\n \"def DarknetConv2D_BN_Leaky(*args, **kwargs):\\n no_bias_kwargs = {'use_bias': False}\\n no_bias_kwargs.update(kwargs)\\n return compose(DarknetConv2D(*args, **no_bias_kwargs), BatchNormalization(), LeakyReLU(alpha=0.1))\",\n \"def __relu(x):\\n return x if x > 0 else 0\",\n \"def naive_relu(x):\\n assert len(x.shape) == 2\\n\\n x = x.copy()\\n for i in range(x.shape[0]):\\n for j in range(x.shape[1]):\\n x[i, j] = max(x[i, j], 0)\\n\\n return x\",\n \"def DarknetConv2D_BN_Leaky(*args, **kwargs):\\n no_bias_kwargs = {'use_bias': False}\\n no_bias_kwargs.update(kwargs)\\n return compose(DarknetConv2D(*args, **no_bias_kwargs),\\n tf.keras.layers.BatchNormalization(),\\n tf.keras.layers.LeakyReLU(alpha=0.1))\",\n \"def conv_relu_pool_backward(dout, cache):\\n conv_cache, relu_cache, pool_cache = cache\\n ds = layers.max_pool_backward_naive(dout, pool_cache)\\n da = layers.relu_backward(ds, relu_cache)\\n dx, dw, db = layers.conv_backward_naive(da, conv_cache)\\n return dx, dw, db\",\n \"def DarknetConv2D_BN_Leaky(*args, **kwargs):\\n no_bias_kwargs = {'use_bias': False}\\n no_bias_kwargs.update(kwargs)\\n return compose(\\n DarknetConv2D(*args, **no_bias_kwargs),\\n CustomBatchNormalization(),\\n LeakyReLU(alpha=0.1))\",\n \"def conv_relu_forward(x, w, b, conv_param):\\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\\n out, relu_cache = relu_forward(a)\\n cache = (conv_cache, relu_cache)\\n return out, cache\",\n \"def conv_relu_forward(x, w, b, conv_param):\\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\\n out, relu_cache = relu_forward(a)\\n cache = (conv_cache, relu_cache)\\n return out, cache\",\n \"def DarknetConv2D_BN_Leaky(*args, **kwargs):\\n no_bias_kwargs = {'use_bias': False}\\n no_bias_kwargs.update(kwargs)\\n return compose(\\n DarknetConv2D(*args, **no_bias_kwargs),\\n BatchNormalization(),\\n LeakyReLU(alpha=0.1))\",\n \"def d_relu(x):\\n\\n return (x > 0) * 1\",\n \"def conv_relu_pool_backward(dout, cache):\\n conv_cache, relu_cache, pool_cache = cache\\n ds = max_pool_backward_fast(dout, pool_cache)\\n da = relu_backward(ds, relu_cache)\\n dx, dw, db = conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def conv_relu_pool_backward(dout, cache):\\n conv_cache, relu_cache, pool_cache = cache\\n ds = max_pool_backward_fast(dout, pool_cache)\\n da = relu_backward(ds, relu_cache)\\n dx, dw, db = conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\\r\\n num_epochs=100, learning_rate=0.001, threshold=0.1):\\r\\n super(ReluNet, self).__init__()\\r\\n\\r\\n self.input_dim = input_dim\\r\\n self.output_dim = output_dim\\r\\n self.hidden_dim = hidden_dim\\r\\n self.num_layers = num_layers\\r\\n self.num_epochs = num_epochs\\r\\n self.threshold = threshold\\r\\n self.learning_rate = learning_rate\\r\\n\\r\\n\\r\\n \\r\\n self.layers = nn.ModuleList()\\r\\n self.layers.append(nn.Linear(input_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n for i in range(num_layers-1):\\r\\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n # output layer\\r\\n self.layers.append(nn.Linear(hidden_dim, output_dim))\",\n \"def backward_deconvnet_relu(x):\\n def grad(dy):\\n return tf.nn.relu(dy)\\n return tf.nn.relu(x), grad\",\n \"def forward(self, x):\\r\\n\\r\\n y = self.conv1(x)\\r\\n y = self.bn1(y)\\r\\n y = F.relu(y, inplace = True)\\r\\n y = self.conv2(y)\\r\\n y = self.bn2(y)\\r\\n y = F.relu(y, inplace = True)\\r\\n\\r\\n return y\",\n \"def _bn_relu(input):\\n norm = BatchNormalization(axis=CHANNEL_AXIS)(input)\\n return Activation(\\\"relu\\\")(norm)\",\n \"def _bn_relu(input):\\n norm = BatchNormalization(axis=CHANNEL_AXIS)(input)\\n return Activation(\\\"relu\\\")(norm)\",\n \"def relu(x, name):\\n\\n with tf.name_scope(name):\\n outputs = tf.nn.relu(x)\\n # Return layer's output\\n return outputs\",\n \"def _bn_relu(input):\\n norm = BatchNormalization()(input)\\n return Activation(\\\"relu\\\")(norm)\",\n \"def _bn_relu(input):\\n norm = BatchNormalization()(input)\\n return Activation(\\\"relu\\\")(norm)\",\n \"def fully_connected_relu(input, size):\\n return tf.nn.relu(fully_connected(input, size))\",\n \"def __drelu(x):\\n return 0 if x <= 0 else 1\",\n \"def _bn_relu(input):\\n\\tnorm = BatchNormalization(axis=3)(input)\\n\\treturn Activation(\\\"relu\\\")(norm)\",\n \"def __call__(self, x):\\n h = F.relu(self.l0(x))\\n h = F.relu(self.l1(h))\\n return self.l2(h)\",\n \"def forward(self, x):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\\n x = F.relu(self.batch3a(self.conv3a(x)))\\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\\n x = F.relu(self.batch4a(self.conv4a(x)))\\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\\n x = F.relu(self.batch5a(self.conv5a(x)))\\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\\n x = self.avgpool(x)\\n x = x.reshape(x.shape[0], -1)\\n out = self.fc1(x)\\n\\n# raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def conv_relu_backward_naive(dout, cache):\\n\\tconv_cache, relu_cache = cache\\n\\tda = relu_backward(dout, relu_cache)\\n\\tdx, dw, db = conv_backward_naive(da, conv_cache)\\n\\treturn dx, dw, db\",\n \"def _bn_relu(input):\\r\\n norm = BatchNormalization(axis=3)(input)\\r\\n return Activation(\\\"relu\\\")(norm)\",\n \"def relu_forward(x):\\n #raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\\n out=np.maximum(0,x)\\n cache=x\\n return out,cache\",\n \"def b1relu( regularizers, x):\\n N, M, F = x.get_shape()\\n b = _bias_variable(regularizers,[1, 1, int(F)], regularization=True)\\n return tf.nn.relu(x + b)\",\n \"def forward(self, input_image):\\n c1 = self.conv1(input_image)\\n c2 = self.conv2_bn(self.conv2(F.leaky_relu(c1, 0.1)))\\n c3 = self.conv3_bn(self.conv3(F.leaky_relu(c2, 0.1)))\\n c4 = self.conv4_bn(self.conv4(F.leaky_relu(c3, 0.1)))\\n c5 = self.conv5(F.leaky_relu(c4, 0.1))\\n\\n if self.noise:\\n c5 += Variable((0.01 * (torch.randn(c5.size()))).cuda())\\n\\n d1 = F.dropout(self.deconv1_bn(self.deconv1(F.leaky_relu(c5, 0.1))), 0.5, training=True)\\n if self.residual:\\n d1 = torch.cat([d1, c4], 1)\\n d2 = F.dropout(self.deconv2_bn(self.deconv2(F.leaky_relu(d1, 0.1))), 0.5, training=True)\\n if self.residual:\\n d2 = torch.cat([d2, c3], 1)\\n d3 = F.dropout(self.deconv3_bn(self.deconv3(F.leaky_relu(d2, 0.1))), 0.5, training=True)\\n if self.residual:\\n d3 = torch.cat([d3, c2], 1)\\n d4 = self.deconv4_bn(self.deconv4(F.leaky_relu(d3, 0.1)))\\n if self.residual:\\n d4 = torch.cat([d4, c1], 1)\\n d5 = self.deconv5(F.leaky_relu(d4, 0.1))\\n out = F.tanh(d5)\\n\\n return out\",\n \"def create_relu(x, bias):\\n\\n return tf.nn.relu(tf.nn.bias_add(x, bias))\",\n \"def forward(self, x):\\n # define feedforward behavior, applying activations as necessary\\n out = self.leaky_relu(self.conv1(x))\\n out = self.leaky_relu(self.conv2(out))\\n out = self.leaky_relu(self.conv3(out))\\n out = self.leaky_relu(self.conv4(out))\\n\\n out = self.res_blocks(out)\\n\\n out = self.leaky_relu(self.deconv1(out))\\n out = self.leaky_relu(self.deconv2(out))\\n out = self.leaky_relu(self.deconv3(out))\\n\\n # tanh applied to last layer\\n out = F.tanh(self.out_layer(out))\\n out = torch.clamp(out, min=-0.5, max=0.5)\\n\\n return out\",\n \"def intermediate_layer(layer, filters, kernel_size):\\n layer = Conv2D(filters=filters, kernel_size=kernel_size,\\n strides=(2, 2), padding=\\\"same\\\")(layer)\\n layer = LeakyReLU(alpha=LEAKY_RELU_ALPHA)(layer)\\n return layer\",\n \"def affine_relu_forward(x, w, b):\\n a, fc_cache = affine_forward(x, w, b)\\n out, relu_cache = relu_forward(a)\\n cache = (fc_cache, relu_cache)\\n return out, cache\",\n \"def affine_relu_forward(x, w, b):\\n a, fc_cache = affine_forward(x, w, b)\\n out, relu_cache = relu_forward(a)\\n cache = (fc_cache, relu_cache)\\n return out, cache\",\n \"def affine_relu_forward(x, w, b):\\n a, fc_cache = affine_forward(x, w, b)\\n out, relu_cache = relu_forward(a)\\n cache = (fc_cache, relu_cache)\\n return out, cache\",\n \"def affine_relu_forward(x, w, b):\\n a, fc_cache = affine_forward(x, w, b)\\n out, relu_cache = relu_forward(a)\\n cache = (fc_cache, relu_cache)\\n return out, cache\",\n \"def relu_forward(x):\\n out = None\\n out = np.maximum(0.0, x)\\n cache = x\\n return out, cache\",\n \"def forward(self, state):\\r\\n x = F.relu(self.linear1(state))\\r\\n x = F.relu(self.linear2(x))\\r\\n #x = torch.tanh(self.linear3(x))\\r\\n #x = F.relu(self.linear3(x))\\r\\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\\r\\n x = F.leaky_relu(self.linear3(x), 0.1)\\r\\n #x = F.softmax(self.linear3(x), dim=0)\\r\\n \\r\\n return x#.negativ_slope\",\n \"def _bn_relu(self, input):\\n depth = input.get_shape().as_list()[-1]\\n\\n # mean and variance calc on batch-height-width dimension\\n mean, var = tf.nn.moments(input, axes=[0, 1, 2])\\n beta = tf.Variable(tf.zeros([depth]), name='beta')\\n gamma = self._get_weight_variable([depth], name='gamma')\\n\\n bn_out = tf.nn.batch_norm_with_global_normalization(input, mean, var, beta, gamma, 0.001,\\n scale_after_normalization=True)\\n\\n out = tf.nn.relu(bn_out)\\n\\n return out\",\n \"def forward(self, x):\\n return self.relu(self.conv(x))\",\n \"def conv_relu_backward(dout, cache):\\n conv_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def conv_relu_backward(dout, cache):\\n conv_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def Spp_Conv2D_BN_Leaky_Fast(x, num_filters):\\n y1 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(x)\\n y2 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(y1)\\n y3 = MaxPooling2D(pool_size=(5,5), strides=(1,1), padding='same')(y2)\\n\\n y = compose(\\n Concatenate(),\\n DarknetConv2D_BN_Leaky(num_filters, (1,1)))([y3, y2, y1, x])\\n return y\",\n \"def forward(self, x):\\n\\n x = F.max_pool2d(F.relu(self.batch_norm1(self.conv1(x))), 3, stride=2, padding=1)\\n x = F.max_pool2d(F.relu(self.batch_norm2(self.conv2(x))), 3, stride=2, padding=1)\\n x = F.max_pool2d(F.relu(self.batch_norm3_b(self.conv3_b(F.relu(self.batch_norm3_a(self.conv3_a(x)))))), 3, stride=2, padding=1)\\n x = F.max_pool2d(F.relu(self.batch_norm4_b(self.conv4_b(F.relu(self.batch_norm4_a(self.conv4_a(x)))))), 3, stride=2, padding=1)\\n x = F.max_pool2d(F.relu(self.batch_norm5_b(self.conv5_b(F.relu(self.batch_norm5_a(self.conv5_a(x)))))), 3, stride=2, padding=1)\\n x = self.avg_pool(x).view(-1,512)\\n out = self.linear(x)\\n\\n return out\",\n \"def guided_backpropagation_relu(x):\\n def grad(dy):\\n return tf.nn.relu(dy) * tf.cast(x > 0.0, x.dtype)\\n return tf.nn.relu(x), grad\",\n \"def relu_forward(x):\\r\\n cache = x\\r\\n out = np.maximum(0, x)\\r\\n return out, cache\",\n \"def test_relu(self):\\n activation_name = 'ReLU'\\n args = {}\\n\\n activation = activation_factory.create(activation_name, **args)\\n self.assertEqual(activation._get_name(), activation_name)\\n\\n x = torch.ones(10) * -1\\n y = activation(x)\\n self.assertEqual(len(torch.nonzero(y, as_tuple=False)), 0)\",\n \"def brelu(self, x):\\n return F.relu(x + self.bias)\",\n \"def conv_relu_backward(dout, cache):\\n conv_cache, relu_cache = cache\\n da = layers.relu_backward(dout, relu_cache)\\n dx, dw, db = layers.conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def forward(self, x): # pylint: disable=invalid-name\\n\\n residual = x\\n\\n out = self.conv1(x)\\n out = self.bn1(out)\\n\\n out = self.relu(out)\\n\\n out = self.conv2(out)\\n out = self.bn2(out)\\n\\n out = self.relu(out)\\n\\n out = self.conv3(out)\\n out = self.bn3(out)\\n\\n if self.downsample is not None:\\n residual = self.downsample(x)\\n out += residual\\n\\n out = self.relu(out)\\n out = self.maxpool(out)\\n\\n return out\",\n \"def __call__(self, inputs):\\n bias = self.param(\\\"bias\\\", self.bias_initializer,\\n (1, 1, 1, inputs.shape[-2], inputs.shape[-1]))\\n\\n modulus_inputs = jnp.abs(inputs)\\n return (nn.relu(modulus_inputs + bias) *\\n (inputs / (modulus_inputs + self.epsilon)))\",\n \"def affine_layernorm_relu_forward(x, w, b, gamma, beta, ln_param):\\n fc_out, fc_cache = affine_forward(x, w, b)\\n norm_out, norm_cache = layernorm_forward(fc_out, gamma, beta, ln_param)\\n out, relu_cache = relu_forward(norm_out)\\n cache = (fc_cache, norm_cache, relu_cache)\\n return out, cache\",\n \"def __call__(self, x):\\n \\n # Define the \\\"forward pass\\\" for this model based on the architecture detailed above.\\n\\n x = relu(self.conv1(x)[...,:-1,:])\\n x = batchnorm(x, eps=1e-7)\\n x = max_pool(x, (2, 2), 2)\\n\\n x = relu(self.conv2(x))\\n x = batchnorm(x, eps=1e-7)\\n x = max_pool(x, (2, 2), 2)\\n\\n x = relu(self.conv3(x)[...,:,:-1])\\n x = batchnorm(x, eps=1e-7)\\n x = max_pool(x, (2, 2), 2)\\n\\n x = relu(self.conv4(x)[...,:,:-1])\\n x = batchnorm(x, eps=1e-7)\\n x = max_pool(x, (2, 2), 2)\\n\\n x = relu(self.dense1(x.reshape(x.shape[0], -1)))\\n return self.dense2(x)\",\n \"def leakrelu_backward(dA, Z):\\n\\n # When z <= 0, dz = 0.01\\n derivative = np.ones(Z.shape)\\n derivative[Z < 0] = 0.01\\n\\n dZ = dA * derivative\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def relu(input, inplace=False):\\n return FunctionLib.apply(\\n 'Relu', input.device, [input],\\n outputs=[input if inplace else None], alpha=0.)\",\n \"def tf_activate(x, keep_prob = 1.0):\\n method = \\\"relu\\\"\\n x = tf.nn.dropout(x, keep_prob = keep_prob)\\n if method == \\\"relu\\\":\\n return tf.nn.relu(x)\\n elif method == \\\"elu\\\":\\n return tf.nn.elu(x)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def __init__(self, id, node_type=NodeType.HIDDEN, activation=F.relu, layer_type=nn.Conv2d,\\n conv_window_size=3, conv_stride=1, max_pool_size=2):\\n\\n super(ModuleNEATNode, self).__init__(id, node_type)\\n\\n batch_norm_chance = 0.65 # chance that a new node will start with batch norm\\n use_batch_norm = random.random() < batch_norm_chance\\n\\n dropout_chance = 0.2 # chance that a new node will start with drop out\\n use_dropout = random.random() < dropout_chance\\n\\n max_pool_chance = 0.3 # chance that a new node will start with drop out\\n use_max_pool = random.random() < max_pool_chance\\n\\n self.activation = Mutagen(F.relu, F.leaky_relu, torch.sigmoid, F.relu6,\\n discreet_value=activation, name=\\\"activation function\\\",\\n mutation_chance=0.15) # TODO try add in Selu, Elu\\n\\n conv_out_features = 25 + random.randint(0, 25)\\n linear_out_features = 100 + random.randint(0, 100)\\n\\n linear_submutagens = \\\\\\n {\\n \\\"regularisation\\\": Mutagen(None, nn.BatchNorm1d,\\n discreet_value=nn.BatchNorm1d if use_batch_norm else None,\\n mutation_chance=0.15),\\n\\n \\\"dropout\\\": Mutagen(None, nn.Dropout, discreet_value=nn.Dropout if use_dropout else None, sub_mutagens=\\n {\\n nn.Dropout: {\\n \\\"dropout_factor\\\": Mutagen(value_type=ValueType.CONTINUOUS, current_value=0.15, start_range=0,\\n end_range=0.75)}\\n }, mutation_chance=0.08),\\n\\n \\\"out_features\\\": Mutagen(value_type=ValueType.WHOLE_NUMBERS, current_value=linear_out_features,\\n start_range=10,\\n end_range=1024, name=\\\"num out features\\\", mutation_chance=0.22,\\n distance_weighting=Props.LAYER_SIZE_COEFFICIENT if Config.allow_attribute_distance else 0)\\n }\\n\\n conv_submutagens = {\\n \\\"conv_window_size\\\": Mutagen(3, 5, 7, discreet_value=conv_window_size, mutation_chance=0.13),\\n\\n \\\"conv_stride\\\": Mutagen(value_type=ValueType.WHOLE_NUMBERS, current_value=conv_stride, start_range=1,\\n end_range=5),\\n\\n \\\"reduction\\\": Mutagen(None, nn.MaxPool2d, discreet_value=nn.MaxPool2d if use_max_pool else None,\\n sub_mutagens=\\n {\\n nn.MaxPool2d: {\\\"pool_size\\\": Mutagen(\\n value_type=ValueType.WHOLE_NUMBERS, current_value=max_pool_size, start_range=2,\\n end_range=5)}\\n }, mutation_chance=0.15),\\n\\n \\\"regularisation\\\": Mutagen(None, nn.BatchNorm2d, discreet_value=nn.BatchNorm2d if use_batch_norm else None,\\n mutation_chance=0.15),\\n\\n \\\"dropout\\\": Mutagen(None, nn.Dropout2d, discreet_value=nn.Dropout2d if use_dropout else None, sub_mutagens=\\n {\\n nn.Dropout2d: {\\n \\\"dropout_factor\\\": Mutagen(value_type=ValueType.CONTINUOUS, current_value=0.1,\\n start_range=0, end_range=0.75)}\\n }, mutation_chance=0.08),\\n\\n \\\"out_features\\\": Mutagen(value_type=ValueType.WHOLE_NUMBERS, current_value=conv_out_features, start_range=1,\\n end_range=100, name=\\\"num out features\\\", mutation_chance=0.22,\\n distance_weighting=Props.LAYER_SIZE_COEFFICIENT if Config.allow_attribute_distance else 0)\\n }\\n\\n if use_linears and not use_convs:\\n self.layer_type = Mutagen(nn.Linear, discreet_value=nn.Linear,\\n distance_weighting=Props.LAYER_TYPE_COEFFICIENT if Config.allow_attribute_distance else 0,\\n sub_mutagens={nn.Linear: linear_submutagens}\\n )\\n if use_convs and not use_linears:\\n self.layer_type = Mutagen(nn.Conv2d, discreet_value=nn.Conv2d,\\n distance_weighting=Props.LAYER_TYPE_COEFFICIENT if Config.allow_attribute_distance else 0,\\n sub_mutagens={nn.Conv2d: conv_submutagens})\\n if use_convs and use_linears:\\n self.layer_type = Mutagen(nn.Conv2d, nn.Linear, discreet_value=layer_type,\\n distance_weighting=Props.LAYER_TYPE_COEFFICIENT if Config.allow_attribute_distance else 0,\\n sub_mutagens={\\n nn.Conv2d: conv_submutagens,\\n nn.Linear: linear_submutagens\\n }, name=\\\"deep layer type\\\", mutation_chance=0.08)\",\n \"def forward(self, x):\\n \\n x = F.relu(self.conv1_bn(self.conv1(self.conv0_bn(x))))\\n x = F.relu(self.conv2_bn(self.conv2(x)))\\n x = F.relu(self.conv3_bn(self.conv3( self.maxpool2(x))))\\n x = F.relu(self.conv4_bn(self.conv4( self.maxpool3(x))))\\n x = self.maxpool4(x) \\n x = x.view(-1, 1184)\\n x = F.relu(self.fc1(x))\\n x = self.dense1_bn(x)\\n x = F.dropout(x, training=self.training)\\n x = self.fc2(x)\\n return F.log_softmax(x)\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = np.maximum(x,0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def dense(depth_in, depth_out, bias=True, lrelu=None):\\r\\n assert (depth_in>0 and depth_out>0)\\r\\n linr_ = nn.Linear(depth_in, depth_out, bias)\\r\\n if lrelu is not None:\\r\\n linr_ = nn.Sequential(linr_, \\r\\n nn.LeakyReLU(lrelu, inplace=True))\\r\\n return linr_\",\n \"def forward(self, x):\\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 return x\",\n \"def soft_relu(x):\\n return ((-x.abs()).exp() + 1.0).log() + torch.clip(x, min=0.0)\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = np.maximum(0, x)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77571315","0.7699009","0.7633883","0.75718963","0.74843746","0.7368186","0.73186827","0.7298966","0.7279396","0.7277081","0.72377855","0.7230744","0.7227955","0.7192606","0.71790683","0.7178993","0.7163494","0.6911991","0.6824623","0.6707451","0.6517727","0.6513651","0.64374524","0.6367015","0.63548535","0.63548535","0.6340955","0.6300279","0.6261585","0.623432","0.6223886","0.6204398","0.6198198","0.6169861","0.61328775","0.6117599","0.6113251","0.6101718","0.6088537","0.6088537","0.6075726","0.6065445","0.6049343","0.6049343","0.6004698","0.59682506","0.5967335","0.59632236","0.59632236","0.5942592","0.59380937","0.59380937","0.5933132","0.5932398","0.59317464","0.59182036","0.589747","0.58914334","0.588884","0.5886649","0.5882863","0.5874546","0.5873046","0.58501303","0.5840324","0.58373","0.58373","0.58373","0.58373","0.5798634","0.57887274","0.57849425","0.5777362","0.57589006","0.57589006","0.5752594","0.57509905","0.5738729","0.57344794","0.57258916","0.5713793","0.570209","0.5694503","0.5694016","0.56939733","0.5688565","0.56806767","0.5671896","0.5644575","0.5643435","0.5643435","0.5643435","0.5643435","0.5643435","0.5637603","0.5637105","0.5635067","0.563283","0.5632309","0.5630346","0.5614726"],"string":"[\n \"0.77571315\",\n \"0.7699009\",\n \"0.7633883\",\n \"0.75718963\",\n \"0.74843746\",\n \"0.7368186\",\n \"0.73186827\",\n \"0.7298966\",\n \"0.7279396\",\n \"0.7277081\",\n \"0.72377855\",\n \"0.7230744\",\n \"0.7227955\",\n \"0.7192606\",\n \"0.71790683\",\n \"0.7178993\",\n \"0.7163494\",\n \"0.6911991\",\n \"0.6824623\",\n \"0.6707451\",\n \"0.6517727\",\n \"0.6513651\",\n \"0.64374524\",\n \"0.6367015\",\n \"0.63548535\",\n \"0.63548535\",\n \"0.6340955\",\n \"0.6300279\",\n \"0.6261585\",\n \"0.623432\",\n \"0.6223886\",\n \"0.6204398\",\n \"0.6198198\",\n \"0.6169861\",\n \"0.61328775\",\n \"0.6117599\",\n \"0.6113251\",\n \"0.6101718\",\n \"0.6088537\",\n \"0.6088537\",\n \"0.6075726\",\n \"0.6065445\",\n \"0.6049343\",\n \"0.6049343\",\n \"0.6004698\",\n \"0.59682506\",\n \"0.5967335\",\n \"0.59632236\",\n \"0.59632236\",\n \"0.5942592\",\n \"0.59380937\",\n \"0.59380937\",\n \"0.5933132\",\n \"0.5932398\",\n \"0.59317464\",\n \"0.59182036\",\n \"0.589747\",\n \"0.58914334\",\n \"0.588884\",\n \"0.5886649\",\n \"0.5882863\",\n \"0.5874546\",\n \"0.5873046\",\n \"0.58501303\",\n \"0.5840324\",\n \"0.58373\",\n \"0.58373\",\n \"0.58373\",\n \"0.58373\",\n \"0.5798634\",\n \"0.57887274\",\n \"0.57849425\",\n \"0.5777362\",\n \"0.57589006\",\n \"0.57589006\",\n \"0.5752594\",\n \"0.57509905\",\n \"0.5738729\",\n \"0.57344794\",\n \"0.57258916\",\n \"0.5713793\",\n \"0.570209\",\n \"0.5694503\",\n \"0.5694016\",\n \"0.56939733\",\n \"0.5688565\",\n \"0.56806767\",\n \"0.5671896\",\n \"0.5644575\",\n \"0.5643435\",\n \"0.5643435\",\n \"0.5643435\",\n \"0.5643435\",\n \"0.5643435\",\n \"0.5637603\",\n \"0.5637105\",\n \"0.5635067\",\n \"0.563283\",\n \"0.5632309\",\n \"0.5630346\",\n \"0.5614726\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6497,"cells":{"query":{"kind":"string","value":"Compute softmax values for each sets of scores in x."},"document":{"kind":"string","value":"def __softmax2(self, x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()"},"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 softmax(self, scores):\n\n\n # for each sample, for each class ,caclulate\n # np.exp(scores) : still (n_samples, n_classes)\n\n # axis = 1\n # a00, a01, a02 as a sinlge one to perfrom np_sum\n # which is the same sample \n # sum_exp : still (n_samples, 1)\n\n # softmax = (n_samples, n_classes) / (n_samples, 1) = (n_samples, n_classes) \n\n sum_exp = np.sum(np.exp(scores), axis=1, keepdims=True)\n softmax = np.exp(scores) / sum_exp\n \n return softmax","def softmax(x):\n scoreMatExp = np.exp(np.asarray(x))\n return scoreMatExp / scoreMatExp.sum(0)","def softmax(scores):\n exp_score = np.exp(scores)\n return exp_score / np.sum(exp_score)","def _compute_softmax(scores):\n if not scores:\n return []\n\n max_score = None\n for score in scores:\n if max_score is None or score > max_score:\n max_score = score\n\n exp_scores = []\n total_sum = 0.0\n for score in scores:\n x = np.exp(score - max_score)\n exp_scores.append(x)\n total_sum += x\n\n probs = []\n for score in exp_scores:\n probs.append(score / total_sum)\n return probs","def _compute_softmax(scores):\n if not scores:\n return []\n\n max_score = None\n for score in scores:\n if max_score is None or score > max_score:\n max_score = score\n\n exp_scores = []\n total_sum = 0.0\n for score in scores:\n x = math.exp(score - max_score)\n exp_scores.append(x)\n total_sum += x\n\n probs = []\n for score in exp_scores:\n probs.append(score / total_sum)\n return probs","def _compute_softmax(scores):\n if not scores:\n return []\n\n max_score = None\n for score in scores:\n if max_score is None or score > max_score:\n max_score = score\n\n exp_scores = []\n total_sum = 0.0\n for score in scores:\n x = math.exp(score - max_score)\n exp_scores.append(x)\n total_sum += x\n\n probs = []\n for score in exp_scores:\n probs.append(score / total_sum)\n return probs","def _compute_softmax(scores):\n if not scores:\n return []\n\n max_score = None\n for score in scores:\n if max_score is None or score > max_score:\n max_score = score\n\n exp_scores = []\n total_sum = 0.0\n for score in scores:\n x = math.exp(score - max_score)\n exp_scores.append(x)\n total_sum += x\n\n probs = []\n for score in exp_scores:\n probs.append(score / total_sum)\n return probs","def _compute_softmax(scores):\n if not scores:\n return []\n\n max_score = None\n for score in scores:\n if max_score is None or score > max_score:\n max_score = score\n\n exp_scores = []\n total_sum = 0.0\n for score in scores:\n x = math.exp(score - max_score)\n exp_scores.append(x)\n total_sum += x\n\n probs = []\n for score in exp_scores:\n probs.append(score / total_sum)\n return probs","def softmax(self, x):\n\n out = np.zeros(x.shape)\n for i in range(x.shape[0]):\n max_x = x[i] - np.max(x[i])\n out[i] = np.exp(max_x) / np.sum(np.exp(max_x), axis=0)\n\n return out","def softmax(x):\n x = np.array(x)\n if x.ndim == 1:\n return column_softmax(x)\n else:\n ret_arr = np.array([column_softmax(col) for col in x.T])\n return ret_arr.T","def softmax(x):\n # (n_samples, n_classes)\n if len(x.shape) == 2:\n row_max = np.max(x, axis=1)\n x -= row_max.reshape((x.shape[0], 1))\n x = np.exp(x)\n row_sum = np.sum(x, axis=1)\n x /= row_sum.reshape((x.shape[0], 1))\n # (n_samples, n_tasks, n_classes)\n elif len(x.shape) == 3:\n row_max = np.max(x, axis=2)\n x -= row_max.reshape(x.shape[:2] + (1,))\n x = np.exp(x)\n row_sum = np.sum(x, axis=2)\n x /= row_sum.reshape(x.shape[:2] + (1,))\n return x","def softmax(self, x):\n\n #############################################################################\n # TODO: Implement the softmax function. #\n #############################################################################\n meanValue = np.mean(x, axis=1)\n x = (x.T - meanValue).T\n ExpValue = np.exp(x)\n totalExpValue = np.sum(np.exp(x), axis=1)\n\n probs = (ExpValue.T / totalExpValue).T\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n return probs","def softmax(x: npt.NDArray) -> npt.NDArray:\n row_wise_max = np.max(x, axis=1).reshape(-1, 1)\n exp_x = np.exp(x - row_wise_max)\n return exp_x / np.sum(exp_x, axis=1).reshape(-1, 1)","def softmax(x):\n # Compute and return softmax(x)\n denom = sum(np.exp(x))\n return [ np.exp(xi)/denom for xi in x ]","def softmax(x):\n xx = x\n x = x.reshape((-1, x.shape[-1]))\n e_x = np.exp(x - np.max(x, 1).reshape(-1, 1))\n res = e_x / e_x.sum(axis=1).reshape(-1, 1)\n return res.reshape(xx.shape)","def softmax(x):\n e_x = np.exp((x.transpose()-x.max(axis=1)).transpose())\n return e_x / np.sum(e_x,axis=1)[:,None]","def softmax(self, x):\n if x.ndim == 1:\n x = x.reshape((1, -1))\n max_x = np.max(x, axis=1).reshape((-1, 1))\n exp_x = np.exp(x - max_x)\n return exp_x / np.sum(exp_x, axis=1).reshape((-1, 1))","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return (e_x / e_x.sum()).tolist()","def softmax(x):\n \"\"\"\"\"\"\n return exp(x) / sum(exp(x), axis=0)","def softmax(x):\n output = []\n denomSum = 0\n for i in range(0, len(x)):\n denomSum += np.exp(x[i])\n\n for j in range(0, len(x)):\n output.append(np.exp(x[j]) / denomSum)\n return np.asarray(output)","def softmax(x):\n #pass # TODO: Compute and return softmax(x)\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)","def softmax(x): \n e_x = np.exp(x - np.max(x)) \n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n pass # TODO: Compute and return softmax(x)\n\n exp_x = np.exp(x)\n sum_x = np.sum(exp_x, axis=0)\n softmax = exp_x/sum_x\n \n return softmax","def softmax(x):\n shape = x.shape\n probs = np.exp(x - np.max(x, axis=len(shape) - 1, keepdims=True))\n probs /= np.sum(probs, axis=len(shape) - 1, keepdims=True)\n return probs","def _softmax(self, x):\n return np.exp(x - np.max(x)) / np.sum(np.exp(x - np.max(x)))","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)","def softmax(x):\r\n e_x = np.exp(x - np.max(x))\r\n return e_x / e_x.sum()","def softmax(x):\r\n e_x = np.exp(x - np.max(x))\r\n return e_x / e_x.sum()","def softmax(x):\r\n sum_c = np.sum(np.exp(x), axis=1)\r\n sum_c = np.expand_dims(sum_c, axis=1)\r\n pred_x = np.divide(np.exp(x), sum_c)\r\n return pred_x","def softmax(input):\n list_value = []\n len_compute = input.shape[-1]\n shape_input = input.shape\n for x in input.reshape(-1, len_compute):\n # print(x)\n e_x = np.exp(x - np.max(x))\n res = e_x / e_x.sum(axis=0)\n list_value.append(res)\n\n return np.array(list_value).reshape(shape_input)","def softmax(x):\n\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n shape = np.shape(x)\n numDim = len(shape)\n result = np.zeros_like(x, dtype=float)\n \n if numDim == 1:\n totalSum = 0\n # Sum (e^yi)\n for i in range(len(x)):\n totalSum = totalSum + exp(x[i])\n # e^yi / Sum (e^yi)\n for i in range(len(x)):\n result[i] = exp(x[i])/totalSum\n else:\n xDim = len(x[0])\n totalSum = np.zeros(xDim, dtype=float)\n \n # e^yi\n for i in range(len(x)):\n for j in range(len(x[i])):\n result[i,j] = exp(x[i,j])\n totalSum[j] = totalSum[j] + result[i,j]\n # e^yi / Sum (e^yi)\n for i in range(len(result)):\n for j in range(len(result[i])):\n result[i,j] = result[i,j] / totalSum[j]\n \n return result","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference","def softmax(x):\n npX = np.array(x)\n expX = np.exp(x)\n\n return expX/sum(expX)","def _softmax(self,x):\n e_x = np.exp(x - np.max(x))\n return np.nan_to_num(e_x / np.nan_to_num(e_x.sum(axis=0)))","def softmax(x):\n e_x = np.exp(x - np.max(x, axis=1).reshape(-1, 1))\n return e_x / np.sum(e_x, axis=1).reshape(-1, 1)","def softmax(x):\n # https://stackoverflow.com/questions/34968722/softmax-function-python\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum()","def softmax(x: np.array) -> Tuple[int, List[float]]:\n dist = np.exp(x) / np.sum(np.exp(x))\n y = np.argmax(dist)\n return int(y), dist","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=1)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)","def softmax(self, x):\n x_max = np.max(x, axis=-1, keepdims=True)\n e_x = np.exp(x - x_max)\n return e_x / e_x.sum(axis=-1, keepdims=True)","def softmax(x):\n x_exp = (x - x.max(1)[0].view(-1, 1)).exp()\n return x_exp / x_exp.sum(1).view(-1, 1)","def softmax(self, x):\n \"\"\" Meaning: avoid very large exponents by reducing the largest to zero\n and everything else to less than that\"\"\"\n ex = np.exp(x - np.max(x))\n return ex / np.sum(ex, axis = 1, keepdims=True) #Sums over rows np.sum([[0, 1], [0, 5]], axis=1) = array([1, 5])","def softmax(x):\r\n e_x = np.exp(x - np.max(x))\r\n return e_x / e_x.sum(axis=0) # only difference\r","def softmax(x): \n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n exps = np.exp(x - np.max(x, axis=0))\n return exps / exps.sum(axis=0)","def my_softmax(x):\n x = x - np.max(x)\n exp_x = np.exp(x)\n softmax_x = exp_x / np.sum(exp_x)\n return softmax_x","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference","def softmax_my(x):\r\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0) # only difference","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=1)","def softmax_loss(scores, y):\r\n N = scores.shape[0] # number of input data\r\n\r\n # compute data loss\r\n shifted_logits = scores - np.max(scores, axis=1, keepdims=True)\r\n Z = np.sum(np.exp(shifted_logits), axis=1, keepdims=True)\r\n log_probs = shifted_logits - np.log(Z)\r\n probs = np.exp(log_probs)\r\n loss = -np.sum(log_probs[range(N), y]) / N\r\n\r\n # Compute gradient of loss function w.r.t. scores\r\n dscores = probs.copy()\r\n dscores[range(N), y] -= 1\r\n dscores /= N\r\n \r\n return loss, dscores","def softmax(x):\n return np.exp(x) / np.sum(np.exp(x), axis=0)\n # return ( x / np.sum(x, axis=0) )","def softmax(x):\n e_x = np.exp(x - np.max(x))\n return old_div(e_x, e_x.sum())","def softmax(x):\n if type(x) == list:\n dim=len(x)\n norm = np.sum(np.exp(x))\n for idx in range(dim):\n x[idx] = np.exp(x[idx])/norm\n elif type(x) == np.ndarray:\n dim=x.shape\n for col in range(dim[1]):\n norm = np.sum(np.exp(x[:, col]))\n for idx in range(dim[0]):\n x[idx, col] = np.exp(x[idx, col])/norm\n else:\n raise Exception('incorrect input')\n return x","def softmax(x):\n e_yi = np.exp(x)\n suma_e_yj = sum(e_yi)\n soft = e_yi/suma_e_yj\n return soft","def softmax(x):\n return np.exp(x)/np.sum(np.exp(x),axis=0)","def softmax(x):\n return np.exp(x)/np.sum(np.exp(x),axis=0)","def softmax_my(x):\n dim = 1\n try:\n dim = x.ndim\n except AttributeError:\n return cal_1D_softmax(x)\n if dim == 1:\n return cal_1D_softmax(x)\n elif dim == 2:\n return cal_2D_softmax(x)","def softmax(x):\n e_x = np.exp(x - np.max(x))\n temp=e_x / e_x.sum(axis=0) # only difference\n \n if np.isnan(temp).any()==True:\n return [0.0,1.0,0.0]\n else:\n return temp","def softmax(x):\r\n e_x = np.exp(x - np.expand_dims(np.max(x, axis=-1), axis=-1))\r\n return e_x / np.expand_dims(e_x.sum(axis=-1), axis=-1) # only difference\r","def softmax(x, stable=0):\n if stable:\n e_x = np.exp(x - np.max(x, axis=0))\n return e_x / e_x.sum(axis=0)\n return np.exp(x) / np.sum(np.exp(x), axis=0)","def softmax(x1, x2, x3, beta):\n xs = np.array((x1, x2, x3))\n num = np.exp(xs * beta)\n den = np.exp(xs * beta).sum()\n return num / den"],"string":"[\n \"def softmax(self, scores):\\n\\n\\n # for each sample, for each class ,caclulate\\n # np.exp(scores) : still (n_samples, n_classes)\\n\\n # axis = 1\\n # a00, a01, a02 as a sinlge one to perfrom np_sum\\n # which is the same sample \\n # sum_exp : still (n_samples, 1)\\n\\n # softmax = (n_samples, n_classes) / (n_samples, 1) = (n_samples, n_classes) \\n\\n sum_exp = np.sum(np.exp(scores), axis=1, keepdims=True)\\n softmax = np.exp(scores) / sum_exp\\n \\n return softmax\",\n \"def softmax(x):\\n scoreMatExp = np.exp(np.asarray(x))\\n return scoreMatExp / scoreMatExp.sum(0)\",\n \"def softmax(scores):\\n exp_score = np.exp(scores)\\n return exp_score / np.sum(exp_score)\",\n \"def _compute_softmax(scores):\\n if not scores:\\n return []\\n\\n max_score = None\\n for score in scores:\\n if max_score is None or score > max_score:\\n max_score = score\\n\\n exp_scores = []\\n total_sum = 0.0\\n for score in scores:\\n x = np.exp(score - max_score)\\n exp_scores.append(x)\\n total_sum += x\\n\\n probs = []\\n for score in exp_scores:\\n probs.append(score / total_sum)\\n return probs\",\n \"def _compute_softmax(scores):\\n if not scores:\\n return []\\n\\n max_score = None\\n for score in scores:\\n if max_score is None or score > max_score:\\n max_score = score\\n\\n exp_scores = []\\n total_sum = 0.0\\n for score in scores:\\n x = math.exp(score - max_score)\\n exp_scores.append(x)\\n total_sum += x\\n\\n probs = []\\n for score in exp_scores:\\n probs.append(score / total_sum)\\n return probs\",\n \"def _compute_softmax(scores):\\n if not scores:\\n return []\\n\\n max_score = None\\n for score in scores:\\n if max_score is None or score > max_score:\\n max_score = score\\n\\n exp_scores = []\\n total_sum = 0.0\\n for score in scores:\\n x = math.exp(score - max_score)\\n exp_scores.append(x)\\n total_sum += x\\n\\n probs = []\\n for score in exp_scores:\\n probs.append(score / total_sum)\\n return probs\",\n \"def _compute_softmax(scores):\\n if not scores:\\n return []\\n\\n max_score = None\\n for score in scores:\\n if max_score is None or score > max_score:\\n max_score = score\\n\\n exp_scores = []\\n total_sum = 0.0\\n for score in scores:\\n x = math.exp(score - max_score)\\n exp_scores.append(x)\\n total_sum += x\\n\\n probs = []\\n for score in exp_scores:\\n probs.append(score / total_sum)\\n return probs\",\n \"def _compute_softmax(scores):\\n if not scores:\\n return []\\n\\n max_score = None\\n for score in scores:\\n if max_score is None or score > max_score:\\n max_score = score\\n\\n exp_scores = []\\n total_sum = 0.0\\n for score in scores:\\n x = math.exp(score - max_score)\\n exp_scores.append(x)\\n total_sum += x\\n\\n probs = []\\n for score in exp_scores:\\n probs.append(score / total_sum)\\n return probs\",\n \"def softmax(self, x):\\n\\n out = np.zeros(x.shape)\\n for i in range(x.shape[0]):\\n max_x = x[i] - np.max(x[i])\\n out[i] = np.exp(max_x) / np.sum(np.exp(max_x), axis=0)\\n\\n return out\",\n \"def softmax(x):\\n x = np.array(x)\\n if x.ndim == 1:\\n return column_softmax(x)\\n else:\\n ret_arr = np.array([column_softmax(col) for col in x.T])\\n return ret_arr.T\",\n \"def softmax(x):\\n # (n_samples, n_classes)\\n if len(x.shape) == 2:\\n row_max = np.max(x, axis=1)\\n x -= row_max.reshape((x.shape[0], 1))\\n x = np.exp(x)\\n row_sum = np.sum(x, axis=1)\\n x /= row_sum.reshape((x.shape[0], 1))\\n # (n_samples, n_tasks, n_classes)\\n elif len(x.shape) == 3:\\n row_max = np.max(x, axis=2)\\n x -= row_max.reshape(x.shape[:2] + (1,))\\n x = np.exp(x)\\n row_sum = np.sum(x, axis=2)\\n x /= row_sum.reshape(x.shape[:2] + (1,))\\n return x\",\n \"def softmax(self, x):\\n\\n #############################################################################\\n # TODO: Implement the softmax function. #\\n #############################################################################\\n meanValue = np.mean(x, axis=1)\\n x = (x.T - meanValue).T\\n ExpValue = np.exp(x)\\n totalExpValue = np.sum(np.exp(x), axis=1)\\n\\n probs = (ExpValue.T / totalExpValue).T\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return probs\",\n \"def softmax(x: npt.NDArray) -> npt.NDArray:\\n row_wise_max = np.max(x, axis=1).reshape(-1, 1)\\n exp_x = np.exp(x - row_wise_max)\\n return exp_x / np.sum(exp_x, axis=1).reshape(-1, 1)\",\n \"def softmax(x):\\n # Compute and return softmax(x)\\n denom = sum(np.exp(x))\\n return [ np.exp(xi)/denom for xi in x ]\",\n \"def softmax(x):\\n xx = x\\n x = x.reshape((-1, x.shape[-1]))\\n e_x = np.exp(x - np.max(x, 1).reshape(-1, 1))\\n res = e_x / e_x.sum(axis=1).reshape(-1, 1)\\n return res.reshape(xx.shape)\",\n \"def softmax(x):\\n e_x = np.exp((x.transpose()-x.max(axis=1)).transpose())\\n return e_x / np.sum(e_x,axis=1)[:,None]\",\n \"def softmax(self, x):\\n if x.ndim == 1:\\n x = x.reshape((1, -1))\\n max_x = np.max(x, axis=1).reshape((-1, 1))\\n exp_x = np.exp(x - max_x)\\n return exp_x / np.sum(exp_x, axis=1).reshape((-1, 1))\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return (e_x / e_x.sum()).tolist()\",\n \"def softmax(x):\\n \\\"\\\"\\\"\\\"\\\"\\\"\\n return exp(x) / sum(exp(x), axis=0)\",\n \"def softmax(x):\\n output = []\\n denomSum = 0\\n for i in range(0, len(x)):\\n denomSum += np.exp(x[i])\\n\\n for j in range(0, len(x)):\\n output.append(np.exp(x[j]) / denomSum)\\n return np.asarray(output)\",\n \"def softmax(x):\\n #pass # TODO: Compute and return softmax(x)\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0)\",\n \"def softmax(x): \\n e_x = np.exp(x - np.max(x)) \\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n pass # TODO: Compute and return softmax(x)\\n\\n exp_x = np.exp(x)\\n sum_x = np.sum(exp_x, axis=0)\\n softmax = exp_x/sum_x\\n \\n return softmax\",\n \"def softmax(x):\\n shape = x.shape\\n probs = np.exp(x - np.max(x, axis=len(shape) - 1, keepdims=True))\\n probs /= np.sum(probs, axis=len(shape) - 1, keepdims=True)\\n return probs\",\n \"def _softmax(self, x):\\n return np.exp(x - np.max(x)) / np.sum(np.exp(x - np.max(x)))\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0)\",\n \"def softmax(x):\\r\\n e_x = np.exp(x - np.max(x))\\r\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\r\\n e_x = np.exp(x - np.max(x))\\r\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\r\\n sum_c = np.sum(np.exp(x), axis=1)\\r\\n sum_c = np.expand_dims(sum_c, axis=1)\\r\\n pred_x = np.divide(np.exp(x), sum_c)\\r\\n return pred_x\",\n \"def softmax(input):\\n list_value = []\\n len_compute = input.shape[-1]\\n shape_input = input.shape\\n for x in input.reshape(-1, len_compute):\\n # print(x)\\n e_x = np.exp(x - np.max(x))\\n res = e_x / e_x.sum(axis=0)\\n list_value.append(res)\\n\\n return np.array(list_value).reshape(shape_input)\",\n \"def softmax(x):\\n\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n shape = np.shape(x)\\n numDim = len(shape)\\n result = np.zeros_like(x, dtype=float)\\n \\n if numDim == 1:\\n totalSum = 0\\n # Sum (e^yi)\\n for i in range(len(x)):\\n totalSum = totalSum + exp(x[i])\\n # e^yi / Sum (e^yi)\\n for i in range(len(x)):\\n result[i] = exp(x[i])/totalSum\\n else:\\n xDim = len(x[0])\\n totalSum = np.zeros(xDim, dtype=float)\\n \\n # e^yi\\n for i in range(len(x)):\\n for j in range(len(x[i])):\\n result[i,j] = exp(x[i,j])\\n totalSum[j] = totalSum[j] + result[i,j]\\n # e^yi / Sum (e^yi)\\n for i in range(len(result)):\\n for j in range(len(result[i])):\\n result[i,j] = result[i,j] / totalSum[j]\\n \\n return result\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0) # only difference\",\n \"def softmax(x):\\n npX = np.array(x)\\n expX = np.exp(x)\\n\\n return expX/sum(expX)\",\n \"def _softmax(self,x):\\n e_x = np.exp(x - np.max(x))\\n return np.nan_to_num(e_x / np.nan_to_num(e_x.sum(axis=0)))\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x, axis=1).reshape(-1, 1))\\n return e_x / np.sum(e_x, axis=1).reshape(-1, 1)\",\n \"def softmax(x):\\n # https://stackoverflow.com/questions/34968722/softmax-function-python\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum()\",\n \"def softmax(x: np.array) -> Tuple[int, List[float]]:\\n dist = np.exp(x) / np.sum(np.exp(x))\\n y = np.argmax(dist)\\n return int(y), dist\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=1)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0)\",\n \"def softmax(self, x):\\n x_max = np.max(x, axis=-1, keepdims=True)\\n e_x = np.exp(x - x_max)\\n return e_x / e_x.sum(axis=-1, keepdims=True)\",\n \"def softmax(x):\\n x_exp = (x - x.max(1)[0].view(-1, 1)).exp()\\n return x_exp / x_exp.sum(1).view(-1, 1)\",\n \"def softmax(self, x):\\n \\\"\\\"\\\" Meaning: avoid very large exponents by reducing the largest to zero\\n and everything else to less than that\\\"\\\"\\\"\\n ex = np.exp(x - np.max(x))\\n return ex / np.sum(ex, axis = 1, keepdims=True) #Sums over rows np.sum([[0, 1], [0, 5]], axis=1) = array([1, 5])\",\n \"def softmax(x):\\r\\n e_x = np.exp(x - np.max(x))\\r\\n return e_x / e_x.sum(axis=0) # only difference\\r\",\n \"def softmax(x): \\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n exps = np.exp(x - np.max(x, axis=0))\\n return exps / exps.sum(axis=0)\",\n \"def my_softmax(x):\\n x = x - np.max(x)\\n exp_x = np.exp(x)\\n softmax_x = exp_x / np.sum(exp_x)\\n return softmax_x\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0) # only difference\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0) # only difference\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0) # only difference\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0) # only difference\",\n \"def softmax_my(x):\\r\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return e_x / e_x.sum(axis=0) # only difference\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=1)\",\n \"def softmax_loss(scores, y):\\r\\n N = scores.shape[0] # number of input data\\r\\n\\r\\n # compute data loss\\r\\n shifted_logits = scores - np.max(scores, axis=1, keepdims=True)\\r\\n Z = np.sum(np.exp(shifted_logits), axis=1, keepdims=True)\\r\\n log_probs = shifted_logits - np.log(Z)\\r\\n probs = np.exp(log_probs)\\r\\n loss = -np.sum(log_probs[range(N), y]) / N\\r\\n\\r\\n # Compute gradient of loss function w.r.t. scores\\r\\n dscores = probs.copy()\\r\\n dscores[range(N), y] -= 1\\r\\n dscores /= N\\r\\n \\r\\n return loss, dscores\",\n \"def softmax(x):\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\\n # return ( x / np.sum(x, axis=0) )\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n return old_div(e_x, e_x.sum())\",\n \"def softmax(x):\\n if type(x) == list:\\n dim=len(x)\\n norm = np.sum(np.exp(x))\\n for idx in range(dim):\\n x[idx] = np.exp(x[idx])/norm\\n elif type(x) == np.ndarray:\\n dim=x.shape\\n for col in range(dim[1]):\\n norm = np.sum(np.exp(x[:, col]))\\n for idx in range(dim[0]):\\n x[idx, col] = np.exp(x[idx, col])/norm\\n else:\\n raise Exception('incorrect input')\\n return x\",\n \"def softmax(x):\\n e_yi = np.exp(x)\\n suma_e_yj = sum(e_yi)\\n soft = e_yi/suma_e_yj\\n return soft\",\n \"def softmax(x):\\n return np.exp(x)/np.sum(np.exp(x),axis=0)\",\n \"def softmax(x):\\n return np.exp(x)/np.sum(np.exp(x),axis=0)\",\n \"def softmax_my(x):\\n dim = 1\\n try:\\n dim = x.ndim\\n except AttributeError:\\n return cal_1D_softmax(x)\\n if dim == 1:\\n return cal_1D_softmax(x)\\n elif dim == 2:\\n return cal_2D_softmax(x)\",\n \"def softmax(x):\\n e_x = np.exp(x - np.max(x))\\n temp=e_x / e_x.sum(axis=0) # only difference\\n \\n if np.isnan(temp).any()==True:\\n return [0.0,1.0,0.0]\\n else:\\n return temp\",\n \"def softmax(x):\\r\\n e_x = np.exp(x - np.expand_dims(np.max(x, axis=-1), axis=-1))\\r\\n return e_x / np.expand_dims(e_x.sum(axis=-1), axis=-1) # only difference\\r\",\n \"def softmax(x, stable=0):\\n if stable:\\n e_x = np.exp(x - np.max(x, axis=0))\\n return e_x / e_x.sum(axis=0)\\n return np.exp(x) / np.sum(np.exp(x), axis=0)\",\n \"def softmax(x1, x2, x3, beta):\\n xs = np.array((x1, x2, x3))\\n num = np.exp(xs * beta)\\n den = np.exp(xs * beta).sum()\\n return num / den\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7796294","0.7760558","0.7759004","0.77567077","0.76577055","0.76577055","0.76577055","0.76577055","0.7585655","0.743143","0.7407772","0.73941606","0.7358175","0.73174125","0.72689486","0.72623265","0.72614294","0.7256868","0.723019","0.7214918","0.7201743","0.72012734","0.71731573","0.71583456","0.71556574","0.71381724","0.7137706","0.7133715","0.7127943","0.7127943","0.712776","0.712606","0.7125813","0.7125179","0.7123029","0.7114732","0.7109847","0.71012133","0.7100688","0.7095567","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.70900273","0.7065275","0.70645964","0.7061677","0.7061677","0.7061677","0.7061677","0.7061677","0.7048807","0.70437676","0.70403224","0.7034972","0.7024501","0.7015974","0.70131445","0.70117974","0.70117974","0.70117974","0.70117974","0.6990052","0.6985568","0.6985568","0.6985568","0.6985568","0.6985568","0.6985568","0.6985568","0.6985568","0.69800115","0.6979047","0.6978138","0.69743663","0.6973897","0.6956014","0.69533145","0.6952268","0.6952268","0.69503057","0.6943441","0.69424456","0.6928695","0.69170755"],"string":"[\n \"0.7796294\",\n \"0.7760558\",\n \"0.7759004\",\n \"0.77567077\",\n \"0.76577055\",\n \"0.76577055\",\n \"0.76577055\",\n \"0.76577055\",\n \"0.7585655\",\n \"0.743143\",\n \"0.7407772\",\n \"0.73941606\",\n \"0.7358175\",\n \"0.73174125\",\n \"0.72689486\",\n \"0.72623265\",\n \"0.72614294\",\n \"0.7256868\",\n \"0.723019\",\n \"0.7214918\",\n \"0.7201743\",\n \"0.72012734\",\n \"0.71731573\",\n \"0.71583456\",\n \"0.71556574\",\n \"0.71381724\",\n \"0.7137706\",\n \"0.7133715\",\n \"0.7127943\",\n \"0.7127943\",\n \"0.712776\",\n \"0.712606\",\n \"0.7125813\",\n \"0.7125179\",\n \"0.7123029\",\n \"0.7114732\",\n \"0.7109847\",\n \"0.71012133\",\n \"0.7100688\",\n \"0.7095567\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.70900273\",\n \"0.7065275\",\n \"0.70645964\",\n \"0.7061677\",\n \"0.7061677\",\n \"0.7061677\",\n \"0.7061677\",\n \"0.7061677\",\n \"0.7048807\",\n \"0.70437676\",\n \"0.70403224\",\n \"0.7034972\",\n \"0.7024501\",\n \"0.7015974\",\n \"0.70131445\",\n \"0.70117974\",\n \"0.70117974\",\n \"0.70117974\",\n \"0.70117974\",\n \"0.6990052\",\n \"0.6985568\",\n \"0.6985568\",\n \"0.6985568\",\n \"0.6985568\",\n \"0.6985568\",\n \"0.6985568\",\n \"0.6985568\",\n \"0.6985568\",\n \"0.69800115\",\n \"0.6979047\",\n \"0.6978138\",\n \"0.69743663\",\n \"0.6973897\",\n \"0.6956014\",\n \"0.69533145\",\n \"0.6952268\",\n \"0.6952268\",\n \"0.69503057\",\n \"0.6943441\",\n \"0.69424456\",\n \"0.6928695\",\n \"0.69170755\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":6498,"cells":{"query":{"kind":"string","value":"Gets the max timestamp that was set during the latest merge."},"document":{"kind":"string","value":"def get_max_ingest_timestamp(self):\n get_last_max_ts_config = bigquery.QueryJobConfig()\n get_last_max_ts_config.use_legacy_sql = False\n get_last_max_timestamp_query = self.bq_client.query(\n query='SELECT max(ingestTimestamp) as max_ingest_timestamp '\n 'FROM `{0:s}.{1:s}.{2:s}`'.format(self.project_id, self.dataset_id,\n self.temp_updates_table_id),\n job_config=get_last_max_ts_config,\n location='US')\n get_last_max_timestamp_query.result()\n results = list(get_last_max_timestamp_query)\n max_ingest_timestamp = results[0]['max_ingest_timestamp']\n if not max_ingest_timestamp:\n max_ingest_timestamp = INITIAL_TIMESTAMP\n\n return max_ingest_timestamp.strftime('%Y-%m-%d %H:%M:%S.%f %Z')"},"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 max_time(self):\n return self._ll_tree_sequence.get_max_time()","def last_timestamp(self):\n return self._last_timestamp","def last_timestamp(self):\n LOGGER.debug('Getting last_timestamp as: %s', self._last_timestamp)\n return self._last_timestamp","def max(self):\n\n return time_stat(self, stat=\"max\")","def max_time(self):\n return self._max_time","def get_last_timestamp(self):\n return self._frame_timestamp","def get_max_update_dt():\r\n from .utils import connect_to_pg\r\n conn = connect_to_pg()\r\n query = \"select max(updated_at) from scf.issues\"\r\n res = conn.execute(query)\r\n max_dt = res.fetchone()[0]\r\n print(max_dt)\r\n return max_dt","def last_updated(self):\n try:\n return max(self.station_usage, key=lambda x: x.last_update).dt_last_update\n except ValueError:\n return datetime.fromtimestamp(0)","def _get_maximum(self):\n return self._maximum","def get_last_time(self):\n \n return self._last","def maxtime(conn):\n c = conn.cursor()\n r = c.execute(\"SELECT max(time) as max_time FROM event WHERE bin_id not null\").fetchall()\n last_time = r[0]['max_time']\n return last_time","def max_time(self) -> str:\n return self._max_time","def get_end_time(self):\n return max([m.get_end_time() for m in self._mappers])","def get_max(self):\n return self.max[-1]","def get_last_entry_time():\r\n try:\r\n last_entry_time = list(mongo_coll_tweets.find().sort(\r\n [(\"_id\", -1)]).limit(1))[0][\"_id\"].generation_time\r\n except:\r\n last_entry_time = 0\r\n\r\n return last_entry_time","def get_last_spot_deposit_time(self) -> int:\n table = tables.SPOT_DEPOSIT_TABLE\n selection = f\"MAX({table.insertTime})\"\n result = self.get_conditions_rows(table,\n selection=selection)\n\n default = datetime_to_millistamp(datetime.datetime(2017, 1, 1, tzinfo=datetime.timezone.utc))\n try:\n result = result[0][0]\n except IndexError:\n return default\n if result is None:\n return default\n return result","def get_max(self):\n return self._max","def max_time(self):\n return self.time[np.argmax(self.flux)]","def _get_max_t(self):\n\n return max([\n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])","def get_max_end_time(self):\n max_end_time = 1.\n file = h5py.File(self.filename, 'r')\n for idx in range(len(self)):\n label = self.labels[idx]\n timestamps_group = file['/'][self.mode + '_timestamps']\n timestamps_dset = timestamps_group[label]\n end_time = timestamps_dset[-1]\n if end_time > max_end_time: max_end_time = end_time\n file.close()\n return max_end_time","def get_last_match_time():\n\n query = '''SELECT max(reported_at) FROM matches'''\n\n record = db.read(query)\n last_match_time = record[0][0]\n\n return last_match_time","def _get_maximum_value(self):\n if hasattr(self, '_maximum_value'):\n return self._maximum_value\n return None","def last_time(self) -> datetime:\n return self.activities[-1].timestamp","def max_time(self):\n #{{{ function to return time of last sample\n\n if self.maxtime == -1:\n return stock.now()\n\n return self.maxtime","def _get_max_suppress_time(self):\n return self.__max_suppress_time","def max(self):\n return self.get_first()","def max_retire_time(self):\n return self._max_retire_time","def get_mtime(self):\n return max(asset.get_mtime() for asset in self._assets)","def get_last_spot_withdraw_time(self) -> int:\n table = tables.SPOT_WITHDRAW_TABLE\n selection = f\"MAX({table.applyTime})\"\n result = self.get_conditions_rows(table,\n selection=selection)\n default = datetime_to_millistamp(datetime.datetime(2017, 1, 1, tzinfo=datetime.timezone.utc))\n try:\n result = result[0][0]\n except IndexError:\n return default\n if result is None:\n return default\n return result","def last_update(cls):\n\n score = Score.query.with_entities(Score.updated_on).order_by(desc(Score.updated_on)).first()\n if score:\n return score[0]\n else:\n return None","def lasttime(self):\n if hasattr(self, \"_lasttime\"):\n return self._lasttime\n else:\n return None","def get_last_refreshed_on_time():\n last_checked_on = Feed.select().aggregate(fn.Max(Feed.last_checked_on))\n if last_checked_on: \n return datetime_as_epoch(last_checked_on)\n \n # Return a fallback value\n return datetime_as_epoch(datetime.utcnow())","def getLastestTime(self):\n if not self.cache_times:\n return None\n return self.cache_times[-1]","def get_max_delta_id(self):\n result = self.query(sql.get_max_id_from(self.IDCOLNAME, self.delta_table_name))\n # If no events has been replayed, max would return a string 'None'\n # instead of a pythonic None. So we should treat 'None' as 0 here\n if result[0][\"max_id\"] == \"None\":\n return max(0, self.max_id_to_replay_upto_for_good2go)\n elif self.max_id_to_replay_upto_for_good2go != -1:\n return self.max_id_to_replay_upto_for_good2go\n\n return result[0][\"max_id\"]","def max(self):\n return self._max","def max(self):\n return self._max","def last_update(self) -> Optional['outputs.CSIPowerMaxStatusLastUpdate']:\n return pulumi.get(self, \"last_update\")","def last_modified(self) -> str:\n\t\tif not self._closed:\n\t\t\ttimestamp = self.ds.last_modified()\n\t\t\treturn timestamp\n\t\treturn None","def get_last_update_time(self):\n return self.last_update_time","def get_latest_updated_ts(self) -> Optional[int]:\n with self.client.create_session() as session:\n latest_updated_ts_value = session.query(RDSUpdatedTimestamp.latest_timestamp).scalar()\n\n return latest_updated_ts_value","def _get_max_t(self):\n \"\"\"\n if hasattr(self,'k_of_t'):\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n self.k_of_t[-1][0],\n ])\n else:\n return max([ \n self.s_of_t[-1][0],\n self.i_of_t[-1][0],\n self.r_of_t[-1][0],\n ])\n \"\"\"\n return self.t_max","def max(self):\n return self.__max","def last_update(self): # TOFIX model the job and return an object instead of dictionary\n return self._data.get('summary_fields', {}).get('last_update')","def last_update(self):\n return self._last_update","def last_update(self):\n return self._last_update","def max(self):\n return max(self.committed_together, default=0)","def get_last_update(self):\n last_update = os.path.getmtime(self.parent_filepath)\n return last_update","def max_time(self) -> float:\r\n if(len(self.operations_by_name) == 0):\r\n return -1\r\n return max(map(lambda x: x[\"time_step\"], self.operations_by_name.values()))","def get_maxtimestamp(path=''):\n conn = None\n try:\n params = utils.config(path)\n conn = psycopg2.connect(**params)\n cur = conn.cursor()\n cur.execute(\"SELECT max(timestamp) FROM ilm_ilm\")\n print(\"Viimane kanne: \", cur.rowcount)\n\n row = cur.fetchone()\n # d = pytz.timezone('Europe/Tallinn').localize(datetime.now())\n\n # while row is not None:\n # # print(row[0], (d - row[0]).seconds)\n # row = cur.fetchone()\n\n cur.close()\n except (Exception, psycopg2.DatabaseError) as error:\n print(error)\n finally:\n if conn is not None:\n conn.close()\n return row[0]","def get_max(self):\n return self.serie.max()","def time_to_process_last_submission(self) -> int:\n return self.snapshot['time_to_process_last_submission']","def get_last_timestamp(self, symbol):\n if symbol in self.symbol:\n timestamp = self.symbol[symbol][\"timestamp\"]\n return timestamp\n else:\n print(\"Timestamp for symbol {} is not available from {}.\".format(symbol,\n self.__class__.__name__))\n return None","def return_the_maximum(self):\n\n return self.__max_stack[-1]","def last_document_time(self) -> datetime.datetime:\n with self.lock:\n return self._last_document_time","def getOldestTime(self):\n if not self.cache_times:\n return None\n return self.cache_times[0]","def last_event_time(self) -> str:\n return pulumi.get(self, \"last_event_time\")","def dt_last_update(self):\n return self.last_update","def max(self):\n assert self.__stack\n return self.__max_values[-1]","def get_maximum ( self, object ):\n return self.maximum","def last_update_time(self):\n return self._last_update_time","def maxend (self):\n\n maxend = self.list[0][\"period\"].end\n for actor in self.list:\n if maxend < actor[\"period\"].end:\n maxend = actor[\"period\"].end\n return maxend","def get_max_incident_time(new_incidents):\n def incident_to_timestamp(incident):\n incident_time = get_incident_time(incident)\n return datetime.strptime(incident_time, '%Y-%m-%d %H:%M:%S.%f')\n\n incident_with_latest_timestamp = max(new_incidents, key=lambda inc: incident_to_timestamp(inc))\n return get_incident_time(incident_with_latest_timestamp)","def last_job(self): # TOFIX model the job and return an object instead of dictionary\n return self._data.get('summary_fields', {}).get('last_job')","def get_max(self):\n\t\tif self.right:\n\t\t\treturn self.right.get_max()\n\t\treturn self.value","def get_max_value(self):\n max_value = max(self.values)\n return max_value","def max(self):\n return max(self)","def max_current(self):\n return self._max_current","def end_timestamp(self):\n return ms_from_dt(self.range().end())","def last_job_run(self):\n try:\n date_ = parse(self._data.get('last_job_run'))\n except (ValueError, TypeError):\n date_ = None\n return date_","def get_last_update(self):\n facility_data = self.get_raw_facilities_data()\n if facility_data is None:\n return None\n else:\n return datetime.strptime(facility_data['lastUpdate'], \"%Y-%m-%dT%H:%M:%SZ\")","def latestValue(self):\n if len(self.values) > 0:\n return self.values[-1]\n else:\n return 0","def find_max(self):\n\n if self.right:\n return self.right.find_max()\n\n return self.data","def get_last_save(self) -> Optional[int]:\n return self._bin_iter.get_last_save()","def last_modified_at(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified_at\")","def last_modified_at(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified_at\")","def last_modified_at(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified_at\")","def last_modified_at(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified_at\")","def last_modified_at(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified_at\")","def last_modified_at(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified_at\")","def max_root_time(self):\n if self.num_samples == 0:\n raise ValueError(\n \"max_root_time is not defined in a tree sequence with 0 samples\"\n )\n ret = max(self.nodes_time[u] for u in self.samples())\n if self.num_edges > 0:\n # Edges are guaranteed to be listed in parent-time order, so we can get the\n # last one to get the oldest root\n edge = self.edge(self.num_edges - 1)\n # However, we can have situations where there is a sample older than a\n # 'proper' root\n ret = max(ret, self.nodes_time[edge.parent])\n return ret","def get_last_updated_at(self):\n return self.last_updated","def last_optime(self):\n return self._last_optime","def find_max(self):\n if self.right:\n return self.right.find_max()\n return self.data","def get_last_spot_dividend_time(self) -> int:\n table = tables.SPOT_DIVIDEND_TABLE\n selection = f\"MAX({table.divTime})\"\n result = self.get_conditions_rows(table,\n selection=selection)\n\n default = datetime_to_millistamp(datetime.datetime(2017, 1, 1, tzinfo=datetime.timezone.utc))\n try:\n result = result[0][0]\n except IndexError:\n return default\n if result is None:\n return default\n return result","def get_highest_id(self):\n\n return self.mint.get_highest_id()","def get_last_updated(self):\n try:\n return min(p.get_last_updated() for p in self.providers.values())\n except ValueError:\n return 0","def last_update(self, value):\n if self._last_update != value:\n self._last_update = value\n return self._last_update","def lastdate(self):\n if hasattr(self, \"_lastdate\"):\n return self._lastdate\n else:\n return None","def maximum(self):\n return self.properties.get('maximum')","def last_modified(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified\")","def last_modified(self) -> Optional[str]:\n return pulumi.get(self, \"last_modified\")","def _get_last_meas_time(self):\n\n #if flag for whole data regeneration is set\n if self._process_type == 'full_gen':\n return datetime.datetime(1900, 1, 1, 0, 0, 0)\n \n \n res = self._db.Query(\"\"\"SELECT last_measurement_time\n FROM last_dashboard_element_segment_value\n WHERE\n element_id = %s\n AND segment_value_id = %s\n \"\"\",(self._id, self._segment_value_id))\n if not res:\n return datetime.datetime(1900, 1, 1, 0, 0, 0)\n item = self._db.record[0]\n if item['last_measurement_time']:\n return item['last_measurement_time']\n return datetime.datetime(1900, 1, 1, 0, 0, 0)","def _extract_last_timestamp(self, feed_entries):\n if feed_entries:\n dates = sorted([entry.publication_date for entry in feed_entries],\n reverse=True)\n return dates[0]\n return None","def latest(self):\n return self.series.tail(1)[0]","def last_updated_time(self) -> str:\n return pulumi.get(self, \"last_updated_time\")","def lastEventTime(self):\n return self._lastEventTime","def last_count_update_time(self):\n return self.__last_count_update_time","def get_last_version(self):\n version = self.get_current_version()\n\n # read the recent file list\n if version is None:\n version = self.get_version_from_recent_files()\n\n return version","def last_updated(self):\n return self._last_updated","def _get_latest_end(self, valid_list):\n\n return max([item.coords[\"time\"].values[-1] for item in valid_list])"],"string":"[\n \"def max_time(self):\\n return self._ll_tree_sequence.get_max_time()\",\n \"def last_timestamp(self):\\n return self._last_timestamp\",\n \"def last_timestamp(self):\\n LOGGER.debug('Getting last_timestamp as: %s', self._last_timestamp)\\n return self._last_timestamp\",\n \"def max(self):\\n\\n return time_stat(self, stat=\\\"max\\\")\",\n \"def max_time(self):\\n return self._max_time\",\n \"def get_last_timestamp(self):\\n return self._frame_timestamp\",\n \"def get_max_update_dt():\\r\\n from .utils import connect_to_pg\\r\\n conn = connect_to_pg()\\r\\n query = \\\"select max(updated_at) from scf.issues\\\"\\r\\n res = conn.execute(query)\\r\\n max_dt = res.fetchone()[0]\\r\\n print(max_dt)\\r\\n return max_dt\",\n \"def last_updated(self):\\n try:\\n return max(self.station_usage, key=lambda x: x.last_update).dt_last_update\\n except ValueError:\\n return datetime.fromtimestamp(0)\",\n \"def _get_maximum(self):\\n return self._maximum\",\n \"def get_last_time(self):\\n \\n return self._last\",\n \"def maxtime(conn):\\n c = conn.cursor()\\n r = c.execute(\\\"SELECT max(time) as max_time FROM event WHERE bin_id not null\\\").fetchall()\\n last_time = r[0]['max_time']\\n return last_time\",\n \"def max_time(self) -> str:\\n return self._max_time\",\n \"def get_end_time(self):\\n return max([m.get_end_time() for m in self._mappers])\",\n \"def get_max(self):\\n return self.max[-1]\",\n \"def get_last_entry_time():\\r\\n try:\\r\\n last_entry_time = list(mongo_coll_tweets.find().sort(\\r\\n [(\\\"_id\\\", -1)]).limit(1))[0][\\\"_id\\\"].generation_time\\r\\n except:\\r\\n last_entry_time = 0\\r\\n\\r\\n return last_entry_time\",\n \"def get_last_spot_deposit_time(self) -> int:\\n table = tables.SPOT_DEPOSIT_TABLE\\n selection = f\\\"MAX({table.insertTime})\\\"\\n result = self.get_conditions_rows(table,\\n selection=selection)\\n\\n default = datetime_to_millistamp(datetime.datetime(2017, 1, 1, tzinfo=datetime.timezone.utc))\\n try:\\n result = result[0][0]\\n except IndexError:\\n return default\\n if result is None:\\n return default\\n return result\",\n \"def get_max(self):\\n return self._max\",\n \"def max_time(self):\\n return self.time[np.argmax(self.flux)]\",\n \"def _get_max_t(self):\\n\\n return max([\\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\",\n \"def get_max_end_time(self):\\n max_end_time = 1.\\n file = h5py.File(self.filename, 'r')\\n for idx in range(len(self)):\\n label = self.labels[idx]\\n timestamps_group = file['/'][self.mode + '_timestamps']\\n timestamps_dset = timestamps_group[label]\\n end_time = timestamps_dset[-1]\\n if end_time > max_end_time: max_end_time = end_time\\n file.close()\\n return max_end_time\",\n \"def get_last_match_time():\\n\\n query = '''SELECT max(reported_at) FROM matches'''\\n\\n record = db.read(query)\\n last_match_time = record[0][0]\\n\\n return last_match_time\",\n \"def _get_maximum_value(self):\\n if hasattr(self, '_maximum_value'):\\n return self._maximum_value\\n return None\",\n \"def last_time(self) -> datetime:\\n return self.activities[-1].timestamp\",\n \"def max_time(self):\\n #{{{ function to return time of last sample\\n\\n if self.maxtime == -1:\\n return stock.now()\\n\\n return self.maxtime\",\n \"def _get_max_suppress_time(self):\\n return self.__max_suppress_time\",\n \"def max(self):\\n return self.get_first()\",\n \"def max_retire_time(self):\\n return self._max_retire_time\",\n \"def get_mtime(self):\\n return max(asset.get_mtime() for asset in self._assets)\",\n \"def get_last_spot_withdraw_time(self) -> int:\\n table = tables.SPOT_WITHDRAW_TABLE\\n selection = f\\\"MAX({table.applyTime})\\\"\\n result = self.get_conditions_rows(table,\\n selection=selection)\\n default = datetime_to_millistamp(datetime.datetime(2017, 1, 1, tzinfo=datetime.timezone.utc))\\n try:\\n result = result[0][0]\\n except IndexError:\\n return default\\n if result is None:\\n return default\\n return result\",\n \"def last_update(cls):\\n\\n score = Score.query.with_entities(Score.updated_on).order_by(desc(Score.updated_on)).first()\\n if score:\\n return score[0]\\n else:\\n return None\",\n \"def lasttime(self):\\n if hasattr(self, \\\"_lasttime\\\"):\\n return self._lasttime\\n else:\\n return None\",\n \"def get_last_refreshed_on_time():\\n last_checked_on = Feed.select().aggregate(fn.Max(Feed.last_checked_on))\\n if last_checked_on: \\n return datetime_as_epoch(last_checked_on)\\n \\n # Return a fallback value\\n return datetime_as_epoch(datetime.utcnow())\",\n \"def getLastestTime(self):\\n if not self.cache_times:\\n return None\\n return self.cache_times[-1]\",\n \"def get_max_delta_id(self):\\n result = self.query(sql.get_max_id_from(self.IDCOLNAME, self.delta_table_name))\\n # If no events has been replayed, max would return a string 'None'\\n # instead of a pythonic None. So we should treat 'None' as 0 here\\n if result[0][\\\"max_id\\\"] == \\\"None\\\":\\n return max(0, self.max_id_to_replay_upto_for_good2go)\\n elif self.max_id_to_replay_upto_for_good2go != -1:\\n return self.max_id_to_replay_upto_for_good2go\\n\\n return result[0][\\\"max_id\\\"]\",\n \"def max(self):\\n return self._max\",\n \"def max(self):\\n return self._max\",\n \"def last_update(self) -> Optional['outputs.CSIPowerMaxStatusLastUpdate']:\\n return pulumi.get(self, \\\"last_update\\\")\",\n \"def last_modified(self) -> str:\\n\\t\\tif not self._closed:\\n\\t\\t\\ttimestamp = self.ds.last_modified()\\n\\t\\t\\treturn timestamp\\n\\t\\treturn None\",\n \"def get_last_update_time(self):\\n return self.last_update_time\",\n \"def get_latest_updated_ts(self) -> Optional[int]:\\n with self.client.create_session() as session:\\n latest_updated_ts_value = session.query(RDSUpdatedTimestamp.latest_timestamp).scalar()\\n\\n return latest_updated_ts_value\",\n \"def _get_max_t(self):\\n \\\"\\\"\\\"\\n if hasattr(self,'k_of_t'):\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n self.k_of_t[-1][0],\\n ])\\n else:\\n return max([ \\n self.s_of_t[-1][0],\\n self.i_of_t[-1][0],\\n self.r_of_t[-1][0],\\n ])\\n \\\"\\\"\\\"\\n return self.t_max\",\n \"def max(self):\\n return self.__max\",\n \"def last_update(self): # TOFIX model the job and return an object instead of dictionary\\n return self._data.get('summary_fields', {}).get('last_update')\",\n \"def last_update(self):\\n return self._last_update\",\n \"def last_update(self):\\n return self._last_update\",\n \"def max(self):\\n return max(self.committed_together, default=0)\",\n \"def get_last_update(self):\\n last_update = os.path.getmtime(self.parent_filepath)\\n return last_update\",\n \"def max_time(self) -> float:\\r\\n if(len(self.operations_by_name) == 0):\\r\\n return -1\\r\\n return max(map(lambda x: x[\\\"time_step\\\"], self.operations_by_name.values()))\",\n \"def get_maxtimestamp(path=''):\\n conn = None\\n try:\\n params = utils.config(path)\\n conn = psycopg2.connect(**params)\\n cur = conn.cursor()\\n cur.execute(\\\"SELECT max(timestamp) FROM ilm_ilm\\\")\\n print(\\\"Viimane kanne: \\\", cur.rowcount)\\n\\n row = cur.fetchone()\\n # d = pytz.timezone('Europe/Tallinn').localize(datetime.now())\\n\\n # while row is not None:\\n # # print(row[0], (d - row[0]).seconds)\\n # row = cur.fetchone()\\n\\n cur.close()\\n except (Exception, psycopg2.DatabaseError) as error:\\n print(error)\\n finally:\\n if conn is not None:\\n conn.close()\\n return row[0]\",\n \"def get_max(self):\\n return self.serie.max()\",\n \"def time_to_process_last_submission(self) -> int:\\n return self.snapshot['time_to_process_last_submission']\",\n \"def get_last_timestamp(self, symbol):\\n if symbol in self.symbol:\\n timestamp = self.symbol[symbol][\\\"timestamp\\\"]\\n return timestamp\\n else:\\n print(\\\"Timestamp for symbol {} is not available from {}.\\\".format(symbol,\\n self.__class__.__name__))\\n return None\",\n \"def return_the_maximum(self):\\n\\n return self.__max_stack[-1]\",\n \"def last_document_time(self) -> datetime.datetime:\\n with self.lock:\\n return self._last_document_time\",\n \"def getOldestTime(self):\\n if not self.cache_times:\\n return None\\n return self.cache_times[0]\",\n \"def last_event_time(self) -> str:\\n return pulumi.get(self, \\\"last_event_time\\\")\",\n \"def dt_last_update(self):\\n return self.last_update\",\n \"def max(self):\\n assert self.__stack\\n return self.__max_values[-1]\",\n \"def get_maximum ( self, object ):\\n return self.maximum\",\n \"def last_update_time(self):\\n return self._last_update_time\",\n \"def maxend (self):\\n\\n maxend = self.list[0][\\\"period\\\"].end\\n for actor in self.list:\\n if maxend < actor[\\\"period\\\"].end:\\n maxend = actor[\\\"period\\\"].end\\n return maxend\",\n \"def get_max_incident_time(new_incidents):\\n def incident_to_timestamp(incident):\\n incident_time = get_incident_time(incident)\\n return datetime.strptime(incident_time, '%Y-%m-%d %H:%M:%S.%f')\\n\\n incident_with_latest_timestamp = max(new_incidents, key=lambda inc: incident_to_timestamp(inc))\\n return get_incident_time(incident_with_latest_timestamp)\",\n \"def last_job(self): # TOFIX model the job and return an object instead of dictionary\\n return self._data.get('summary_fields', {}).get('last_job')\",\n \"def get_max(self):\\n\\t\\tif self.right:\\n\\t\\t\\treturn self.right.get_max()\\n\\t\\treturn self.value\",\n \"def get_max_value(self):\\n max_value = max(self.values)\\n return max_value\",\n \"def max(self):\\n return max(self)\",\n \"def max_current(self):\\n return self._max_current\",\n \"def end_timestamp(self):\\n return ms_from_dt(self.range().end())\",\n \"def last_job_run(self):\\n try:\\n date_ = parse(self._data.get('last_job_run'))\\n except (ValueError, TypeError):\\n date_ = None\\n return date_\",\n \"def get_last_update(self):\\n facility_data = self.get_raw_facilities_data()\\n if facility_data is None:\\n return None\\n else:\\n return datetime.strptime(facility_data['lastUpdate'], \\\"%Y-%m-%dT%H:%M:%SZ\\\")\",\n \"def latestValue(self):\\n if len(self.values) > 0:\\n return self.values[-1]\\n else:\\n return 0\",\n \"def find_max(self):\\n\\n if self.right:\\n return self.right.find_max()\\n\\n return self.data\",\n \"def get_last_save(self) -> Optional[int]:\\n return self._bin_iter.get_last_save()\",\n \"def last_modified_at(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified_at\\\")\",\n \"def last_modified_at(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified_at\\\")\",\n \"def last_modified_at(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified_at\\\")\",\n \"def last_modified_at(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified_at\\\")\",\n \"def last_modified_at(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified_at\\\")\",\n \"def last_modified_at(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified_at\\\")\",\n \"def max_root_time(self):\\n if self.num_samples == 0:\\n raise ValueError(\\n \\\"max_root_time is not defined in a tree sequence with 0 samples\\\"\\n )\\n ret = max(self.nodes_time[u] for u in self.samples())\\n if self.num_edges > 0:\\n # Edges are guaranteed to be listed in parent-time order, so we can get the\\n # last one to get the oldest root\\n edge = self.edge(self.num_edges - 1)\\n # However, we can have situations where there is a sample older than a\\n # 'proper' root\\n ret = max(ret, self.nodes_time[edge.parent])\\n return ret\",\n \"def get_last_updated_at(self):\\n return self.last_updated\",\n \"def last_optime(self):\\n return self._last_optime\",\n \"def find_max(self):\\n if self.right:\\n return self.right.find_max()\\n return self.data\",\n \"def get_last_spot_dividend_time(self) -> int:\\n table = tables.SPOT_DIVIDEND_TABLE\\n selection = f\\\"MAX({table.divTime})\\\"\\n result = self.get_conditions_rows(table,\\n selection=selection)\\n\\n default = datetime_to_millistamp(datetime.datetime(2017, 1, 1, tzinfo=datetime.timezone.utc))\\n try:\\n result = result[0][0]\\n except IndexError:\\n return default\\n if result is None:\\n return default\\n return result\",\n \"def get_highest_id(self):\\n\\n return self.mint.get_highest_id()\",\n \"def get_last_updated(self):\\n try:\\n return min(p.get_last_updated() for p in self.providers.values())\\n except ValueError:\\n return 0\",\n \"def last_update(self, value):\\n if self._last_update != value:\\n self._last_update = value\\n return self._last_update\",\n \"def lastdate(self):\\n if hasattr(self, \\\"_lastdate\\\"):\\n return self._lastdate\\n else:\\n return None\",\n \"def maximum(self):\\n return self.properties.get('maximum')\",\n \"def last_modified(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified\\\")\",\n \"def last_modified(self) -> Optional[str]:\\n return pulumi.get(self, \\\"last_modified\\\")\",\n \"def _get_last_meas_time(self):\\n\\n #if flag for whole data regeneration is set\\n if self._process_type == 'full_gen':\\n return datetime.datetime(1900, 1, 1, 0, 0, 0)\\n \\n \\n res = self._db.Query(\\\"\\\"\\\"SELECT last_measurement_time\\n FROM last_dashboard_element_segment_value\\n WHERE\\n element_id = %s\\n AND segment_value_id = %s\\n \\\"\\\"\\\",(self._id, self._segment_value_id))\\n if not res:\\n return datetime.datetime(1900, 1, 1, 0, 0, 0)\\n item = self._db.record[0]\\n if item['last_measurement_time']:\\n return item['last_measurement_time']\\n return datetime.datetime(1900, 1, 1, 0, 0, 0)\",\n \"def _extract_last_timestamp(self, feed_entries):\\n if feed_entries:\\n dates = sorted([entry.publication_date for entry in feed_entries],\\n reverse=True)\\n return dates[0]\\n return None\",\n \"def latest(self):\\n return self.series.tail(1)[0]\",\n \"def last_updated_time(self) -> str:\\n return pulumi.get(self, \\\"last_updated_time\\\")\",\n \"def lastEventTime(self):\\n return self._lastEventTime\",\n \"def last_count_update_time(self):\\n return self.__last_count_update_time\",\n \"def get_last_version(self):\\n version = self.get_current_version()\\n\\n # read the recent file list\\n if version is None:\\n version = self.get_version_from_recent_files()\\n\\n return version\",\n \"def last_updated(self):\\n return self._last_updated\",\n \"def _get_latest_end(self, valid_list):\\n\\n return max([item.coords[\\\"time\\\"].values[-1] for item in valid_list])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7324069","0.72471076","0.7213113","0.71249187","0.70386344","0.69946057","0.69175625","0.67901427","0.67749435","0.6734356","0.6730179","0.6711431","0.6706463","0.66920155","0.66324604","0.6624491","0.66190374","0.6587741","0.65800637","0.6567245","0.65296376","0.6513948","0.6487736","0.64721525","0.64643896","0.6460458","0.64447975","0.642519","0.64045125","0.63976586","0.6390174","0.63899064","0.63777137","0.6375512","0.63659626","0.63659626","0.6364246","0.63537824","0.6348762","0.6319069","0.63176745","0.6315131","0.6307518","0.63037115","0.63037115","0.6275266","0.62629634","0.6245584","0.6224619","0.6214283","0.618252","0.61814934","0.6179641","0.6165853","0.6147169","0.6144181","0.6143801","0.6142256","0.6141362","0.61364836","0.6134461","0.613146","0.6131277","0.61300933","0.6127434","0.6123476","0.61231655","0.6121914","0.6117812","0.61128074","0.61054075","0.6104382","0.61010575","0.6095503","0.6095503","0.6095503","0.6095503","0.6095503","0.6095503","0.60837007","0.6081113","0.60729975","0.6063817","0.60595554","0.6058718","0.6058509","0.605826","0.60534286","0.60447073","0.60442096","0.60442096","0.60346824","0.60301405","0.6022812","0.6012077","0.60109204","0.6007204","0.5999685","0.59951854","0.5986287"],"string":"[\n \"0.7324069\",\n \"0.72471076\",\n \"0.7213113\",\n \"0.71249187\",\n \"0.70386344\",\n \"0.69946057\",\n \"0.69175625\",\n \"0.67901427\",\n \"0.67749435\",\n \"0.6734356\",\n \"0.6730179\",\n \"0.6711431\",\n \"0.6706463\",\n \"0.66920155\",\n \"0.66324604\",\n \"0.6624491\",\n \"0.66190374\",\n \"0.6587741\",\n \"0.65800637\",\n \"0.6567245\",\n \"0.65296376\",\n \"0.6513948\",\n \"0.6487736\",\n \"0.64721525\",\n \"0.64643896\",\n \"0.6460458\",\n \"0.64447975\",\n \"0.642519\",\n \"0.64045125\",\n \"0.63976586\",\n \"0.6390174\",\n \"0.63899064\",\n \"0.63777137\",\n \"0.6375512\",\n \"0.63659626\",\n \"0.63659626\",\n \"0.6364246\",\n \"0.63537824\",\n \"0.6348762\",\n \"0.6319069\",\n \"0.63176745\",\n \"0.6315131\",\n \"0.6307518\",\n \"0.63037115\",\n \"0.63037115\",\n \"0.6275266\",\n \"0.62629634\",\n \"0.6245584\",\n \"0.6224619\",\n \"0.6214283\",\n \"0.618252\",\n \"0.61814934\",\n \"0.6179641\",\n \"0.6165853\",\n \"0.6147169\",\n \"0.6144181\",\n \"0.6143801\",\n \"0.6142256\",\n \"0.6141362\",\n \"0.61364836\",\n \"0.6134461\",\n \"0.613146\",\n \"0.6131277\",\n \"0.61300933\",\n \"0.6127434\",\n \"0.6123476\",\n \"0.61231655\",\n \"0.6121914\",\n \"0.6117812\",\n \"0.61128074\",\n \"0.61054075\",\n \"0.6104382\",\n \"0.61010575\",\n \"0.6095503\",\n \"0.6095503\",\n \"0.6095503\",\n \"0.6095503\",\n \"0.6095503\",\n \"0.6095503\",\n \"0.60837007\",\n \"0.6081113\",\n \"0.60729975\",\n \"0.6063817\",\n \"0.60595554\",\n \"0.6058718\",\n \"0.6058509\",\n \"0.605826\",\n \"0.60534286\",\n \"0.60447073\",\n \"0.60442096\",\n \"0.60442096\",\n \"0.60346824\",\n \"0.60301405\",\n \"0.6022812\",\n \"0.6012077\",\n \"0.60109204\",\n \"0.6007204\",\n \"0.5999685\",\n \"0.59951854\",\n \"0.5986287\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75948834"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":6499,"cells":{"query":{"kind":"string","value":"Sets the theta range of the wind rose plot."},"document":{"kind":"string","value":"def set_thetarng(self, trng=(0., 360.), subplot_index=(0,)):\n if self.axes is not None:\n self.axes[subplot_index].set_thetamin(trng[0])\n self.axes[subplot_index].set_thetamax(trng[1])\n self.trng = trng\n else:\n raise RuntimeError((\"Axes must be initialized before\" +\n \" changing limits!\"))\n print(self.trng)"},"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 ChangeWindAngle(self,theta):\n self.problem.ChangeWindAngle(theta)","def set_range(self, **rangekwargs):\n\n if 'xrange' in rangekwargs.keys(): \n xrange = rangekwargs['xrange']\n else: \n xrange = [-50.0, 50.0] # (default)\n\n if 'yrange' in rangekwargs.keys(): \n yrange = rangekwargs['yrange']\n else: \n yrange = [0.0, 1.25 * self.hist_max]\n\n self.sub.set_xlim(xrange) \n self.sub.set_ylim(yrange) \n\n self.sub.set_xlabel(r\"$\\mathtt{d_{LOS}}$ (Mpc/h)\", fontsize=20)\n\n return None","def theta(self, theta):\n\n self._theta = theta","def set_omega_range(self, omega_range=(0, 0, 1)):\n self.omegase = np.arange(*omega_range, dtype=float)\n self.qptanalyzer.omegase = self.omegase","def set(self, x: float, y: float, theta: float):\n self.x = float(x)\n self.y = float(y)\n self.theta = float(theta)","def _set_weights(self, theta):\n self.rnn.theta.set_value(theta)","def theta(self, theta):\n self.kernel.theta = theta","def set_visualization_range(self, start: int, end: int):\n self.__range = (start, end)","def setRange(self, x_range, y_range):\n self._visualiser._plt.setRange(xRange=x_range, yRange=y_range)","def setSlope(self, slope):\n self.angle = math.atan(slope)","def set_ypos(self, deg):\n if deg < -10:\n deg = -10\n elif deg > 10:\n deg = 10\n deg += 10\n self.kit.servo[8].angle = deg","def setRange(self, x_range, y_range):\n pass","def move_theta(self, theta0=None, dth=[0.1, 0.1], deltaE=[None, None]):\n if (theta0 is None):\n if (not self.rc.theta0):\n raise NameError('move_theta(): set theta0 first!')\n else:\n theta0 = self.rc.theta0\n if not self.rc.d:\n raise NameError('move_theta(): set crystal d-spacing first!')\n if not self.rc.Rm:\n raise NameError('move_theta(): set Rowland circle radius first')\n\n self.rc.set_theta0(theta0)\n d = self.rc.d\n ene0 = self.rc.get_ene()\n # adjust source energy to new theta0\n self.oe1.PHOT_CENT = ene0\n if (deltaE[0] is None):\n self.src.PH1 = bragg_ev(d, theta0+abs(dth[1]))\n else:\n self.src.PH1 = ene0 - abs(deltaE[0]) \n if (deltaE[1] is None):\n self.src.PH2 = bragg_ev(d, theta0-abs(dth[0]))\n else:\n self.src.PH2 = ene0 + abs(deltaE[1])\n \n # adjust source divergence to new theta0 (assumig flat)\n _hlp = abs(self.oe1.RLEN1) # half-length pos\n _hln = abs(self.oe1.RLEN2) # half-length neg\n _hwp = abs(self.oe1.RWIDX1) # half-width pos\n _hwn = abs(self.oe1.RWIDX2) # half-width neg\n _rth0 = self.rc.rtheta0\n _pcm = self.rc.p # cm\n # _vdiv_pos = math.atan( (_hlp * math.sin(_rth0)) / (_pcm + _hlp * math.cos(_rth0) ) )\n # _vdiv_neg = math.atan( (_hln * math.sin(_rth0)) / (_pcm - _hln * math.cos(_rth0) ) )\n # _hdiv_pos = math.atan( (_hwp / _pcm) )\n # _hdiv_neg = math.atan( (_hwn / _pcm) )\n _vdiv_pos = (_hlp * math.sin(_rth0)) / (_pcm + _hlp * math.cos(_rth0) )\n _vdiv_neg = (_hln * math.sin(_rth0)) / (_pcm - _hln * math.cos(_rth0) )\n _hdiv_pos = (_hwp / _pcm)\n _hdiv_neg = (_hwn / _pcm)\n self.src.VDIV1 = _vdiv_pos * 1.1 # empirical!\n self.src.VDIV2 = _vdiv_neg * 1.1 # empirical!\n self.src.HDIV1 = _hdiv_pos * 1.1 # empirical!\n self.src.HDIV2 = _hdiv_neg * 1.1 # empirical!\n\n # adjust analyser to new theta0\n self.oe1.set_frame_of_reference(self.rc.p, self.rc.q, 90.-theta0)\n\n if self.rc.showInfos:\n print(' --- theta movement infos --- ')\n print('OE1: PHOT_CENT = {0}'.format(self.oe1.PHOT_CENT )) \n print('SRC: PH1 = {0}'.format(self.src.PH1 )) \n print('SRC: PH2 = {0}'.format(self.src.PH2 )) \n print('SRC: VDIV1 = {0}'.format(self.src.VDIV1 )) \n print('SRC: VDIV2 = {0}'.format(self.src.VDIV2 )) \n print('SRC: HDIV1 = {0}'.format(self.src.HDIV1 )) \n print('SRC: HDIV2 = {0}'.format(self.src.HDIV2 )) \n print('OE1: T_SOURCE = {0}'.format(self.oe1.T_SOURCE )) \n print('OE1: T_IMAGE = {0}'.format(self.oe1.T_IMAGE )) \n print('OE1: T_INCIDENCE = {0}'.format(self.oe1.T_INCIDENCE )) \n print('OE1: T_REFLECTION = {0}'.format(self.oe1.T_REFLECTION))","def set_angle(self, value):\n if not -90 <= value <= 90:\n raise ValueError('Servo angle must be between -90 and 90 degrees')\n self.duty_cycle = ...","def restrict_theta(theta):\n tnew = theta + np.pi\n tnew += -2.0*np.pi*np.floor(tnew/(2.0*np.pi))\n tnew -= np.pi\n return tnew","def set_rrng(self, rrng, subplot_index=(0,)):\n if self.axes is not None:\n self.axes[subplot_index].set_rmin(rrng[0])\n self.axes[subplot_index].set_rmax(rrng[1])\n self.rrng = rrng\n else:\n raise RuntimeError((\"Axes must be initialized before\" +\n \" changing limits!\"))","def setAngle(self,angle = 2.5):\n pass","def setRange(self, x_range, y_range):\n self._pipe.send(\"range,%f,%f,%f,%f\" % (x_range + y_range))","def randomized_theta(self):\n theta_bounds = self.theta\n theta_random = [random_from_bound(b) for b in theta_bounds]\n self.theta = theta_random","def setOrdinate(self, ordinate):\n if abs(self.angle) == math.pi / 2:\n raise ValueError(\"Impossible to set an ordinate because the line is parallel to the y axis. \")\n self.point.y += ordinate","def from_theta(self, theta=10.):\n self.eta = theta","def set_xpos(self, deg):\n if deg < 0:\n deg = 0\n if deg > 90:\n deg = 90\n deg = deg*2\n self.kit.servo[7].angle = deg","def set_radius(self, radius):\n self.__begin.set_radius(radius)\n self.__end.set_radius(radius)","def setR(self, radius):\n self.radius = radius","def set_phi_theta_r(phi, theta, r=1):\n return np.array([sin(theta) * cos(phi),\n sin(theta) * sin(phi),\n cos(theta)]) * r","def theta_start(self, ndim=2):\n return 10","def set_range(self, value):\n self.gauge.SetRange(value)","def set_angle(self, ang):\n if ang < 0:\n ang = 0\n elif ang > 180:\n ang = 180\n dutyCycle = 5 + (ang*5/180)\n self.servoPort.ChangeDutyCycle(dutyCycle)","def set_gyro_range(self, gyro_range):\n\t\t# First change it to 0x00 to make sure we write the correct value later\n\t\tself.bus.write_byte_data(self.address, self.GYRO_CONFIG, 0x00)\n\n\t\t# Write the new range to the ACCEL_CONFIG register\n\t\tself.bus.write_byte_data(self.address, self.GYRO_CONFIG, gyro_range)","def set_wheel(self, wheel):\n self.wheel_turn = clamp(wheel, -1, 1)","def set_angle(self, angle):\n new_angle = angle\n\n # Declaring conversion constants\n angle_min = 0\n angle_max = 180\n angle_range = angle_max - angle_min\n dc_range = self._dc_max - self._dc_min\n\n # Enforcing angle range\n if new_angle > angle_max:\n new_angle = angle_max\n elif new_angle < angle_min:\n new_angle = angle_min\n\n # Scaling input angle to an appropriate duty cycle\n duty_cycle = ((dc_range / angle_range) * (new_angle - angle_min)) + self._dc_min\n\n self._servo_pwm.changeDutyCycle(duty_cycle)","def set_gyro_range(self, gyro_range):\n # First change it to 0x00 to make sure we write the correct value later\n self.bus.write_byte_data(self.address, self.GYRO_CONFIG, 0x00)\n\n # Write the new range to the ACCEL_CONFIG register\n self.bus.write_byte_data(self.address, self.GYRO_CONFIG, gyro_range)","def set_phi(self,phi):\n\t\tr=self.r\n\t\tself.x = np.cos(np.deg2rad(phi))*r\n\t\tself.y = np.sin(np.deg2rad(phi))*r","def azimuth_servo_set_min_max(self, min: int, max: int):\n self.azimuth_servo.set_min_position(min)\n self.azimuth_servo.set_max_position(max)","def wheel_angle(self, angle):\n self.angle = angle","def update_resistance_region(self):\n self.linear_region.setRegion(\n self.resistance_graph.getViewBox().viewRange()[0])","def update_pressure_region(self):\n self.linear_region.setRegion(\n self.pressure_plot_graph.getViewBox().viewRange()[0])","def set_wrist(self, angle):\n return self.set_servo_angle(protocol.SERVO_HAND, angle)","def update_plots_using_region(self):\n self.frequency_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.resistance_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.temperature_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.pressure_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)\n self.humidity_plot_graph.setXRange(\n *self.linear_region.getRegion(), padding=0)","def move(self, theta, phi):\n print('Writing the theta angle: {}'.format(str(theta)))\n self.servo.write(theta)\n #print(\"Serial Port: \" + str(self.servo.read()))\n print('Writing the theta angle: {}'.format(str(phi)))\n self.servo.write(phi)\n #print(\"Serial Port: \" + str(self.servo.read()))","def set_angle(self, angle=0.0):\n self.angle = angle","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 set_gyro_range(self, gyro_range):\r\n # First change it to 0x00 to make sure we write the correct value later\r\n self.bus.write_byte_data(self.deviceaddress, self.gyro_config, 0x00)\r\n\r\n # Write the new range to the ACCEL_CONFIG register\r\n self.bus.write_byte_data(self.deviceaddress, self.gyro_config, gyro_range)","def setRange(self, range):\n\t\tself.range = range\n\t\tself.slider.setMinimum(0.0)\n\t\tself.slider.setMaximum(100.0)\n\t\tself.spinbox.setRange(self.range[0], self.range[1])\n\n\t\tdiff = self.range[1] - self.range[0]\n\t\tif diff <= 1:\n\t\t\tself.spinbox.setSingleStep(0.01)","def setAngle(self, value):\n n, a = Vector.polar(self.components)\n self.components = Vector.cartesian([n, value])","def set_angle(self, req_angle):\n self._current_angle = req_angle\n req_angle_pulse = (self._pulse_max - self._pulse_min) / (self._angle_max - self._angle_min) * (\n req_angle - self._angle_max) + self._pulse_max\n self.pwm.set_pwm(SERVO_CHANEL, 0, int(round(req_angle_pulse)))","def SetYAxisRange(self, lower, upper):\n self.Y_AXIS_RANGE = (lower, upper)","def setAngle(self, angle):\n self.vector.angle = angle","def set_y(self, y):\n self.scene.set_y_loc(y)\n self.redraw()","def set_elevation(self, theta: \"float\") -> \"void\":\n return _beamforming_swig.phasedarray_set_elevation(self, theta)","def setAxisPageOrigin(x,y):\n dislin.axsorg(x,y)","def set_yaw_angles(self, yaw_angles):\n if isinstance(yaw_angles, float) or isinstance(yaw_angles, int):\n yaw_angles = [yaw_angles] * len(self.turbines)\n\n for yaw_angle, turbine in zip(yaw_angles, self.turbines):\n turbine.yaw_angle = yaw_angle","def setHistogramRange(self, mn, mx, padding=0.1):\n self.vb.enableAutoRange(self.vb.YAxis, False)\n if self.orientation == 'horizontal':\n self.vb.setXRange(mn, mx, padding)\n elif self.orientation == 'vertical':\n self.vb.setYrange(mn, mx, padding)\n # mn -= d*padding\n # mx += d*padding\n # self.range = [mn,mx]\n # self.updateRange()\n # self.vb.setMouseEnabled(False, True)\n # self.region.setBounds([mn,mx])","def update_zoom_plot(self):\n self.plot_zoom.setXRange(*self.linear_region.getRegion(), padding=0)","def elevation_servo_set_min_max(self, min: int, max: int):\n self.elevation_servo.set_min_position(min)\n self.elevation_servo.set_max_position(max)","def set_elevation(self, theta: \"float\") -> \"void\":\n return _beamforming_swig.phasedarray_sptr_set_elevation(self, theta)","def theta_plot(self, classified_lines, line_width=3.0):\n for regions, labels in classified_lines:\n for region, label in zip(regions, labels):\n start, end = region\n\n rho = start[0]\n assert np.isclose(rho, end[0])\n\n start_theta = np.degrees(start[1])\n end_theta = np.degrees(end[1])\n\n arc = patches.Arc((0, 0), 2*rho, 2*rho,\n theta1=start_theta, theta2=end_theta,\n color=self.color(int(label)),\n linewidth=line_width)\n plt.gca().add_patch(arc)","def setPlotRotation(ang, x,y):\n dislin.trfrot(ang,x,y)","def set_ly(self):\r\n self._ly = self.dy * self.ny - self.oy","def set_azimuth(self):\n self.azimuth = self.Calculations.convert_to_azimuth( self.declination, self.right_ascension, self.Latitude, self.LHA)\n if self.azimuth < 0:\n self.azimuth = self.azimuth + 360.0\n return self.azimuth\n else:\n pass\n return self.azimuth\n print('azimuth set to', self.azimuth)","def with_params(self, theta):\n self.params = theta\n return self","def set_plot_yrange(wavelengths, fluxes, avoid_regions=None, wl_range=None):\n\n # Default the wavelength range to be the entire spectrum if not specified.\n if wl_range is None:\n wl_range = [numpy.nanmin(wavelengths), numpy.nanmax(wavelengths)]\n\n # This list will keep track of which fluxes to retain when defining the\n # y-axis plot range. Setting the value to 1 means keep this flux for\n # consideration.\n keep_indices = numpy.asarray([1] * len(wavelengths))\n\n # Set any fluxes to 0 (don't keep) if they fall within an Avoid Region.\n if avoid_regions is not None:\n for i, region in enumerate(avoid_regions):\n if i == 0:\n # If this is the first Avoid Region, then we need to check if\n # the wavelengths are within the specified bounds supplied\n # through the `wl_range` parameter, in addition to checking if\n # they are within the Avoid Region itself.\n reject_indices = [i for i in range(len(wavelengths)) if (\n wavelengths[i] >= region.minwl and\n wavelengths[i] <= region.maxwl or\n wavelengths[i] < wl_range[0] or\n wavelengths[i] > wl_range[1])]\n else:\n # Don't need to worry about checking wavelengths within bounds\n # after the first Avoid Region is examined.\n reject_indices = [i for i in range(len(wavelengths)) if (\n wavelengths[i] >= region.minwl and\n wavelengths[i] <= region.maxwl)]\n # Set indices that we don't want to keep to 0. Note that if\n # reject_indices is an empty list then nothing will change.\n keep_indices[reject_indices] = 0\n\n # After all indices have been set to keep or reject, pull out just the\n # fluxes that should be kept.\n keep_fluxes = numpy.asarray([f for ii, f in enumerate(fluxes) if (\n keep_indices[ii] == 1 and numpy.isfinite(fluxes[ii]))])\n\n # Don't just take the pure min and max, since large outliers can affect\n # the calculation. Instead, take the 1th and 99th percentile fluxes within\n # the region to calculate the `min` and `max` fluxes.\n min_flux = numpy.percentile(keep_fluxes, 1.)\n max_flux = numpy.percentile(keep_fluxes, 99.)\n\n # Determine a y-buffer based on the difference between the max. and min.\n # fluxes.\n ybuffer = 0.3 * (max_flux-min_flux)\n\n # Make sure the min. and max. fluxes aren't identical (both 0., or both\n # the same exact value. If so, just return the min. and max. value nudged\n # by 1.0.\n if min_flux != max_flux:\n if min_flux - ybuffer > 0.:\n return [min_flux-ybuffer, max_flux+ybuffer]\n else:\n # We don't want the y-axis range to be TOO far negative, so limit\n # it to be close to the lowest data point. \"\"\"\n return [1.1*min_flux, max_flux+ybuffer]\n else:\n return [min_flux-1., max_flux+1.]","def setAngle(self,a):\n self.angle = a\n if self.drawn == True:\n self.draw()","def setAngleLimit(angle_limit):\n return RoboCaller().call(\"setAngleLimit\", \"void\", angle_limit)","def setAngle(self, angle):\n self._angle = (angle + math.pi / 2) % math.pi - math.pi / 2\n # self._angle = angle % (2*math.pi)","def update_temperature_region(self):\n self.linear_region.setRegion(\n self.temperature_plot_graph.getViewBox().viewRange()[0])","def set_rowland_radius(self, Rm, isJohansson=False):\n self.oe1.F_EXT = 1\n self.oe1.FMIRR = 1\n if isJohansson:\n self.oe1.set_johansson(Rm*2.)\n else:\n self.oe1.F_JOHANSSON = 0\n self.oe1.set_radius(Rm*2.)","def set_radius(self, radius):\n self._radius = radius\n self._reset_slot_bounds()","def radio_range(self, value: int):\n self._radio_range = value","def set_colormap_range(self):\n cmin = self.settingsWidget.ui.colormap_min\n cmax = self.settingsWidget.ui.colormap_max\n region = self.plot.getHistogramWidget().region\n\n if(self.sender() == region):\n cmin.setText(str(region.getRegion()[0]))\n cmax.setText(str(region.getRegion()[1]))\n return\n\n # Sometimes the values in the lineEdits are\n # not proper floats so we get ValueErrors\n try:\n # If necessary swap min and max\n if(float(cmin.text()) > float(cmax.text())):\n _tmp = cmin.text()\n cmin.setText(cmax.text())\n cmax.setText(_tmp)\n\n region = [float(cmin.text()), float(cmax.text())]\n self.plot.getHistogramWidget().region.setRegion(region)\n except ValueError:\n return","def set_slope(self, slope: float) -> None:\r\n self.slope = slope","def set_wheel_speed(self, om_l, om_r):\n self.om_left = om_l\n self.om_right = om_r","def change_angle(self, new_angle):\r\n self.angle = new_angle","def set_y(self, y: float):\n self.y = y","def set_radius(self, rmirr):\n self.F_EXT = 1\n self.RMIRR = rmirr","def hogg_lim_and_label():\n plt.xlim(-20., 1020.)\n plt.xlabel(\"time (d)\")\n plt.ylim(-20., 20.)\n plt.ylabel(\"radial velocity (m\\,s$^{-1}$)\")\n return None","def theta_deg(self):\n return self.theta * 180 / np.pi","def azimuth_servo_set_position(self, position: int):\n return self.azimuth_servo.set_position(position)","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 set_range(self, axis: int, range: Sequence[Union[int, float]]):\n if axis < 0:\n axis += self.ndim\n if axis < 0:\n raise ValueError(\n f'axis is negative, expected positive, got {axis}'\n )\n if self.range[axis] != range:\n self._range[axis] = range\n self.events.range(axis=axis)","def angle(self, angle):\n self._angle = angle\n self.x_rate = self._rate * cos(self._angle)\n self.y_rate = self._rate * sin(self._angle)","def setRobotDirection(self, direction):\n self.direction = direction","def setRobotDirection(self, direction):\n self.direction = direction","def set_range(self, full_range, abs_range=None, suppress_feedback=False):\n self._enabled = full_range[0] != full_range[1]\n if not self._enabled:\n full_range = (\n full_range[0] - 1, full_range[0])\n self._suppress_feedback = suppress_feedback\n super(MarkerProperty, self).set_range(full_range, abs_range=abs_range)","def radians(self):\n self._setDegreesPerAU(2*math.pi)","def set_density_params(self, theta, scale=None):\n self.density.loc = self.mean(theta)\n if scale is not None:\n self.density.scale = scale","def radar_range(self) -> Union[int, float]:\n return self.proto.radar_range","def radius(self, radius: float):\n\n self._radius = radius","def setdirection(self, *args, **kwargs):\n return _coordsys.coordsys_setdirection(self, *args, **kwargs)","def setColorBarRange(start=1,end=254):\n dislin.colran(start,end)","def set_lims(self):\n xx_min, xx_max = self.set_period_limits()\n y_min = self.tf.rho.min()\n y_min = max(y_min, 1e-20)\n y_max = self.tf.rho.max()\n y_max = max(y_max, 1e-20)\n\n yy_min = 10 ** (np.floor(np.log10(y_min)))\n if (np.log10(y_min) - np.log10(yy_min)) < 0.15:\n yy_min = 10 ** (np.log10(yy_min) - 0.3)\n\n yy_max = 10 ** (np.ceil(np.log10(y_max)))\n if (np.log10(yy_max) - np.log10(y_max)) < 0.15:\n yy_max = 10 ** (np.log10(yy_max) + 0.3)\n\n if abs(yy_max - yy_min) > 1:\n lims = [xx_min, xx_max, yy_min, yy_max, 0, 90]\n else:\n lims = [xx_min, xx_max, 0.01, 1e4, 0, 90]\n\n orient = 0.0\n return lims, orient","def initialize_plotter(width, height, min_x, max_x, min_y, max_y):\n global x_begin, x_end, x_increment\n turtle.delay(0)\n x_begin, x_end = min_x, max_x\n turtle.setup(width=width, height=height)\n turtle.screensize(width, height)\n turtle.setworldcoordinates(min_x, min_y, max_x, max_y)\n x_increment = (max_x - min_x)/width\n turtle.hideturtle()\n turtle.pencolor('black')\n turtle.penup()\n turtle.setposition(min_x, 0)\n turtle.setheading(0)\n turtle.pendown()\n turtle.forward(max_x - min_x)\n turtle.penup()\n turtle.setposition(0, min_y)\n turtle.setheading(90)\n turtle.pendown()\n turtle.forward(max_y - min_y)","def move(self, dt):\n w_px = self.meter_to_cart(self.vw)\n # delta_theta = delta_s/r\n self.theta += self.vw*dt/self.get_radial_distance_from(self.host_star)\n self.rect.center = self.polar_to_cartesian(self.r, self.theta)","def coordY(r, theta, useradians = True):\r\n if not useradians :\r\n #convert theta to radians\r\n theta = theta / 180 * math.pi\r\n y = r * math.sin(theta)\r\n return y","def set_radius(self, radius, unit='km'):\n self.radius = radius\n self.unit = unit","def set_grating_va(self, g, wl=None):\n try:\n self.set_grating(g)\n # By default the Shamrock library keeps the same wavelength\n if wl is not None:\n self.set_wavelength(wl)\n except Exception:\n print(\"Failed to change grating to %d\", g)","def set_display_trange(self, trang: float) -> None:\n self.write(':timebase:range {:.4g}'.format(trang))","def setArticulateAngle(self, angle):\n self.articulatePID.setSetpoint(angle)","def __init__(self, x=0.0, y=0.0, theta=0.0, w=1.0):\n self.w = w\n self.theta = theta\n self.x = x\n self.y = y","def setYUnits(self, units): \n self.__y_units__ = units"],"string":"[\n \"def ChangeWindAngle(self,theta):\\n self.problem.ChangeWindAngle(theta)\",\n \"def set_range(self, **rangekwargs):\\n\\n if 'xrange' in rangekwargs.keys(): \\n xrange = rangekwargs['xrange']\\n else: \\n xrange = [-50.0, 50.0] # (default)\\n\\n if 'yrange' in rangekwargs.keys(): \\n yrange = rangekwargs['yrange']\\n else: \\n yrange = [0.0, 1.25 * self.hist_max]\\n\\n self.sub.set_xlim(xrange) \\n self.sub.set_ylim(yrange) \\n\\n self.sub.set_xlabel(r\\\"$\\\\mathtt{d_{LOS}}$ (Mpc/h)\\\", fontsize=20)\\n\\n return None\",\n \"def theta(self, theta):\\n\\n self._theta = theta\",\n \"def set_omega_range(self, omega_range=(0, 0, 1)):\\n self.omegase = np.arange(*omega_range, dtype=float)\\n self.qptanalyzer.omegase = self.omegase\",\n \"def set(self, x: float, y: float, theta: float):\\n self.x = float(x)\\n self.y = float(y)\\n self.theta = float(theta)\",\n \"def _set_weights(self, theta):\\n self.rnn.theta.set_value(theta)\",\n \"def theta(self, theta):\\n self.kernel.theta = theta\",\n \"def set_visualization_range(self, start: int, end: int):\\n self.__range = (start, end)\",\n \"def setRange(self, x_range, y_range):\\n self._visualiser._plt.setRange(xRange=x_range, yRange=y_range)\",\n \"def setSlope(self, slope):\\n self.angle = math.atan(slope)\",\n \"def set_ypos(self, deg):\\n if deg < -10:\\n deg = -10\\n elif deg > 10:\\n deg = 10\\n deg += 10\\n self.kit.servo[8].angle = deg\",\n \"def setRange(self, x_range, y_range):\\n pass\",\n \"def move_theta(self, theta0=None, dth=[0.1, 0.1], deltaE=[None, None]):\\n if (theta0 is None):\\n if (not self.rc.theta0):\\n raise NameError('move_theta(): set theta0 first!')\\n else:\\n theta0 = self.rc.theta0\\n if not self.rc.d:\\n raise NameError('move_theta(): set crystal d-spacing first!')\\n if not self.rc.Rm:\\n raise NameError('move_theta(): set Rowland circle radius first')\\n\\n self.rc.set_theta0(theta0)\\n d = self.rc.d\\n ene0 = self.rc.get_ene()\\n # adjust source energy to new theta0\\n self.oe1.PHOT_CENT = ene0\\n if (deltaE[0] is None):\\n self.src.PH1 = bragg_ev(d, theta0+abs(dth[1]))\\n else:\\n self.src.PH1 = ene0 - abs(deltaE[0]) \\n if (deltaE[1] is None):\\n self.src.PH2 = bragg_ev(d, theta0-abs(dth[0]))\\n else:\\n self.src.PH2 = ene0 + abs(deltaE[1])\\n \\n # adjust source divergence to new theta0 (assumig flat)\\n _hlp = abs(self.oe1.RLEN1) # half-length pos\\n _hln = abs(self.oe1.RLEN2) # half-length neg\\n _hwp = abs(self.oe1.RWIDX1) # half-width pos\\n _hwn = abs(self.oe1.RWIDX2) # half-width neg\\n _rth0 = self.rc.rtheta0\\n _pcm = self.rc.p # cm\\n # _vdiv_pos = math.atan( (_hlp * math.sin(_rth0)) / (_pcm + _hlp * math.cos(_rth0) ) )\\n # _vdiv_neg = math.atan( (_hln * math.sin(_rth0)) / (_pcm - _hln * math.cos(_rth0) ) )\\n # _hdiv_pos = math.atan( (_hwp / _pcm) )\\n # _hdiv_neg = math.atan( (_hwn / _pcm) )\\n _vdiv_pos = (_hlp * math.sin(_rth0)) / (_pcm + _hlp * math.cos(_rth0) )\\n _vdiv_neg = (_hln * math.sin(_rth0)) / (_pcm - _hln * math.cos(_rth0) )\\n _hdiv_pos = (_hwp / _pcm)\\n _hdiv_neg = (_hwn / _pcm)\\n self.src.VDIV1 = _vdiv_pos * 1.1 # empirical!\\n self.src.VDIV2 = _vdiv_neg * 1.1 # empirical!\\n self.src.HDIV1 = _hdiv_pos * 1.1 # empirical!\\n self.src.HDIV2 = _hdiv_neg * 1.1 # empirical!\\n\\n # adjust analyser to new theta0\\n self.oe1.set_frame_of_reference(self.rc.p, self.rc.q, 90.-theta0)\\n\\n if self.rc.showInfos:\\n print(' --- theta movement infos --- ')\\n print('OE1: PHOT_CENT = {0}'.format(self.oe1.PHOT_CENT )) \\n print('SRC: PH1 = {0}'.format(self.src.PH1 )) \\n print('SRC: PH2 = {0}'.format(self.src.PH2 )) \\n print('SRC: VDIV1 = {0}'.format(self.src.VDIV1 )) \\n print('SRC: VDIV2 = {0}'.format(self.src.VDIV2 )) \\n print('SRC: HDIV1 = {0}'.format(self.src.HDIV1 )) \\n print('SRC: HDIV2 = {0}'.format(self.src.HDIV2 )) \\n print('OE1: T_SOURCE = {0}'.format(self.oe1.T_SOURCE )) \\n print('OE1: T_IMAGE = {0}'.format(self.oe1.T_IMAGE )) \\n print('OE1: T_INCIDENCE = {0}'.format(self.oe1.T_INCIDENCE )) \\n print('OE1: T_REFLECTION = {0}'.format(self.oe1.T_REFLECTION))\",\n \"def set_angle(self, value):\\n if not -90 <= value <= 90:\\n raise ValueError('Servo angle must be between -90 and 90 degrees')\\n self.duty_cycle = ...\",\n \"def restrict_theta(theta):\\n tnew = theta + np.pi\\n tnew += -2.0*np.pi*np.floor(tnew/(2.0*np.pi))\\n tnew -= np.pi\\n return tnew\",\n \"def set_rrng(self, rrng, subplot_index=(0,)):\\n if self.axes is not None:\\n self.axes[subplot_index].set_rmin(rrng[0])\\n self.axes[subplot_index].set_rmax(rrng[1])\\n self.rrng = rrng\\n else:\\n raise RuntimeError((\\\"Axes must be initialized before\\\" +\\n \\\" changing limits!\\\"))\",\n \"def setAngle(self,angle = 2.5):\\n pass\",\n \"def setRange(self, x_range, y_range):\\n self._pipe.send(\\\"range,%f,%f,%f,%f\\\" % (x_range + y_range))\",\n \"def randomized_theta(self):\\n theta_bounds = self.theta\\n theta_random = [random_from_bound(b) for b in theta_bounds]\\n self.theta = theta_random\",\n \"def setOrdinate(self, ordinate):\\n if abs(self.angle) == math.pi / 2:\\n raise ValueError(\\\"Impossible to set an ordinate because the line is parallel to the y axis. \\\")\\n self.point.y += ordinate\",\n \"def from_theta(self, theta=10.):\\n self.eta = theta\",\n \"def set_xpos(self, deg):\\n if deg < 0:\\n deg = 0\\n if deg > 90:\\n deg = 90\\n deg = deg*2\\n self.kit.servo[7].angle = deg\",\n \"def set_radius(self, radius):\\n self.__begin.set_radius(radius)\\n self.__end.set_radius(radius)\",\n \"def setR(self, radius):\\n self.radius = radius\",\n \"def set_phi_theta_r(phi, theta, r=1):\\n return np.array([sin(theta) * cos(phi),\\n sin(theta) * sin(phi),\\n cos(theta)]) * r\",\n \"def theta_start(self, ndim=2):\\n return 10\",\n \"def set_range(self, value):\\n self.gauge.SetRange(value)\",\n \"def set_angle(self, ang):\\n if ang < 0:\\n ang = 0\\n elif ang > 180:\\n ang = 180\\n dutyCycle = 5 + (ang*5/180)\\n self.servoPort.ChangeDutyCycle(dutyCycle)\",\n \"def set_gyro_range(self, gyro_range):\\n\\t\\t# First change it to 0x00 to make sure we write the correct value later\\n\\t\\tself.bus.write_byte_data(self.address, self.GYRO_CONFIG, 0x00)\\n\\n\\t\\t# Write the new range to the ACCEL_CONFIG register\\n\\t\\tself.bus.write_byte_data(self.address, self.GYRO_CONFIG, gyro_range)\",\n \"def set_wheel(self, wheel):\\n self.wheel_turn = clamp(wheel, -1, 1)\",\n \"def set_angle(self, angle):\\n new_angle = angle\\n\\n # Declaring conversion constants\\n angle_min = 0\\n angle_max = 180\\n angle_range = angle_max - angle_min\\n dc_range = self._dc_max - self._dc_min\\n\\n # Enforcing angle range\\n if new_angle > angle_max:\\n new_angle = angle_max\\n elif new_angle < angle_min:\\n new_angle = angle_min\\n\\n # Scaling input angle to an appropriate duty cycle\\n duty_cycle = ((dc_range / angle_range) * (new_angle - angle_min)) + self._dc_min\\n\\n self._servo_pwm.changeDutyCycle(duty_cycle)\",\n \"def set_gyro_range(self, gyro_range):\\n # First change it to 0x00 to make sure we write the correct value later\\n self.bus.write_byte_data(self.address, self.GYRO_CONFIG, 0x00)\\n\\n # Write the new range to the ACCEL_CONFIG register\\n self.bus.write_byte_data(self.address, self.GYRO_CONFIG, gyro_range)\",\n \"def set_phi(self,phi):\\n\\t\\tr=self.r\\n\\t\\tself.x = np.cos(np.deg2rad(phi))*r\\n\\t\\tself.y = np.sin(np.deg2rad(phi))*r\",\n \"def azimuth_servo_set_min_max(self, min: int, max: int):\\n self.azimuth_servo.set_min_position(min)\\n self.azimuth_servo.set_max_position(max)\",\n \"def wheel_angle(self, angle):\\n self.angle = angle\",\n \"def update_resistance_region(self):\\n self.linear_region.setRegion(\\n self.resistance_graph.getViewBox().viewRange()[0])\",\n \"def update_pressure_region(self):\\n self.linear_region.setRegion(\\n self.pressure_plot_graph.getViewBox().viewRange()[0])\",\n \"def set_wrist(self, angle):\\n return self.set_servo_angle(protocol.SERVO_HAND, angle)\",\n \"def update_plots_using_region(self):\\n self.frequency_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.resistance_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.temperature_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.pressure_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\\n self.humidity_plot_graph.setXRange(\\n *self.linear_region.getRegion(), padding=0)\",\n \"def move(self, theta, phi):\\n print('Writing the theta angle: {}'.format(str(theta)))\\n self.servo.write(theta)\\n #print(\\\"Serial Port: \\\" + str(self.servo.read()))\\n print('Writing the theta angle: {}'.format(str(phi)))\\n self.servo.write(phi)\\n #print(\\\"Serial Port: \\\" + str(self.servo.read()))\",\n \"def set_angle(self, angle=0.0):\\n self.angle = angle\",\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 set_gyro_range(self, gyro_range):\\r\\n # First change it to 0x00 to make sure we write the correct value later\\r\\n self.bus.write_byte_data(self.deviceaddress, self.gyro_config, 0x00)\\r\\n\\r\\n # Write the new range to the ACCEL_CONFIG register\\r\\n self.bus.write_byte_data(self.deviceaddress, self.gyro_config, gyro_range)\",\n \"def setRange(self, range):\\n\\t\\tself.range = range\\n\\t\\tself.slider.setMinimum(0.0)\\n\\t\\tself.slider.setMaximum(100.0)\\n\\t\\tself.spinbox.setRange(self.range[0], self.range[1])\\n\\n\\t\\tdiff = self.range[1] - self.range[0]\\n\\t\\tif diff <= 1:\\n\\t\\t\\tself.spinbox.setSingleStep(0.01)\",\n \"def setAngle(self, value):\\n n, a = Vector.polar(self.components)\\n self.components = Vector.cartesian([n, value])\",\n \"def set_angle(self, req_angle):\\n self._current_angle = req_angle\\n req_angle_pulse = (self._pulse_max - self._pulse_min) / (self._angle_max - self._angle_min) * (\\n req_angle - self._angle_max) + self._pulse_max\\n self.pwm.set_pwm(SERVO_CHANEL, 0, int(round(req_angle_pulse)))\",\n \"def SetYAxisRange(self, lower, upper):\\n self.Y_AXIS_RANGE = (lower, upper)\",\n \"def setAngle(self, angle):\\n self.vector.angle = angle\",\n \"def set_y(self, y):\\n self.scene.set_y_loc(y)\\n self.redraw()\",\n \"def set_elevation(self, theta: \\\"float\\\") -> \\\"void\\\":\\n return _beamforming_swig.phasedarray_set_elevation(self, theta)\",\n \"def setAxisPageOrigin(x,y):\\n dislin.axsorg(x,y)\",\n \"def set_yaw_angles(self, yaw_angles):\\n if isinstance(yaw_angles, float) or isinstance(yaw_angles, int):\\n yaw_angles = [yaw_angles] * len(self.turbines)\\n\\n for yaw_angle, turbine in zip(yaw_angles, self.turbines):\\n turbine.yaw_angle = yaw_angle\",\n \"def setHistogramRange(self, mn, mx, padding=0.1):\\n self.vb.enableAutoRange(self.vb.YAxis, False)\\n if self.orientation == 'horizontal':\\n self.vb.setXRange(mn, mx, padding)\\n elif self.orientation == 'vertical':\\n self.vb.setYrange(mn, mx, padding)\\n # mn -= d*padding\\n # mx += d*padding\\n # self.range = [mn,mx]\\n # self.updateRange()\\n # self.vb.setMouseEnabled(False, True)\\n # self.region.setBounds([mn,mx])\",\n \"def update_zoom_plot(self):\\n self.plot_zoom.setXRange(*self.linear_region.getRegion(), padding=0)\",\n \"def elevation_servo_set_min_max(self, min: int, max: int):\\n self.elevation_servo.set_min_position(min)\\n self.elevation_servo.set_max_position(max)\",\n \"def set_elevation(self, theta: \\\"float\\\") -> \\\"void\\\":\\n return _beamforming_swig.phasedarray_sptr_set_elevation(self, theta)\",\n \"def theta_plot(self, classified_lines, line_width=3.0):\\n for regions, labels in classified_lines:\\n for region, label in zip(regions, labels):\\n start, end = region\\n\\n rho = start[0]\\n assert np.isclose(rho, end[0])\\n\\n start_theta = np.degrees(start[1])\\n end_theta = np.degrees(end[1])\\n\\n arc = patches.Arc((0, 0), 2*rho, 2*rho,\\n theta1=start_theta, theta2=end_theta,\\n color=self.color(int(label)),\\n linewidth=line_width)\\n plt.gca().add_patch(arc)\",\n \"def setPlotRotation(ang, x,y):\\n dislin.trfrot(ang,x,y)\",\n \"def set_ly(self):\\r\\n self._ly = self.dy * self.ny - self.oy\",\n \"def set_azimuth(self):\\n self.azimuth = self.Calculations.convert_to_azimuth( self.declination, self.right_ascension, self.Latitude, self.LHA)\\n if self.azimuth < 0:\\n self.azimuth = self.azimuth + 360.0\\n return self.azimuth\\n else:\\n pass\\n return self.azimuth\\n print('azimuth set to', self.azimuth)\",\n \"def with_params(self, theta):\\n self.params = theta\\n return self\",\n \"def set_plot_yrange(wavelengths, fluxes, avoid_regions=None, wl_range=None):\\n\\n # Default the wavelength range to be the entire spectrum if not specified.\\n if wl_range is None:\\n wl_range = [numpy.nanmin(wavelengths), numpy.nanmax(wavelengths)]\\n\\n # This list will keep track of which fluxes to retain when defining the\\n # y-axis plot range. Setting the value to 1 means keep this flux for\\n # consideration.\\n keep_indices = numpy.asarray([1] * len(wavelengths))\\n\\n # Set any fluxes to 0 (don't keep) if they fall within an Avoid Region.\\n if avoid_regions is not None:\\n for i, region in enumerate(avoid_regions):\\n if i == 0:\\n # If this is the first Avoid Region, then we need to check if\\n # the wavelengths are within the specified bounds supplied\\n # through the `wl_range` parameter, in addition to checking if\\n # they are within the Avoid Region itself.\\n reject_indices = [i for i in range(len(wavelengths)) if (\\n wavelengths[i] >= region.minwl and\\n wavelengths[i] <= region.maxwl or\\n wavelengths[i] < wl_range[0] or\\n wavelengths[i] > wl_range[1])]\\n else:\\n # Don't need to worry about checking wavelengths within bounds\\n # after the first Avoid Region is examined.\\n reject_indices = [i for i in range(len(wavelengths)) if (\\n wavelengths[i] >= region.minwl and\\n wavelengths[i] <= region.maxwl)]\\n # Set indices that we don't want to keep to 0. Note that if\\n # reject_indices is an empty list then nothing will change.\\n keep_indices[reject_indices] = 0\\n\\n # After all indices have been set to keep or reject, pull out just the\\n # fluxes that should be kept.\\n keep_fluxes = numpy.asarray([f for ii, f in enumerate(fluxes) if (\\n keep_indices[ii] == 1 and numpy.isfinite(fluxes[ii]))])\\n\\n # Don't just take the pure min and max, since large outliers can affect\\n # the calculation. Instead, take the 1th and 99th percentile fluxes within\\n # the region to calculate the `min` and `max` fluxes.\\n min_flux = numpy.percentile(keep_fluxes, 1.)\\n max_flux = numpy.percentile(keep_fluxes, 99.)\\n\\n # Determine a y-buffer based on the difference between the max. and min.\\n # fluxes.\\n ybuffer = 0.3 * (max_flux-min_flux)\\n\\n # Make sure the min. and max. fluxes aren't identical (both 0., or both\\n # the same exact value. If so, just return the min. and max. value nudged\\n # by 1.0.\\n if min_flux != max_flux:\\n if min_flux - ybuffer > 0.:\\n return [min_flux-ybuffer, max_flux+ybuffer]\\n else:\\n # We don't want the y-axis range to be TOO far negative, so limit\\n # it to be close to the lowest data point. \\\"\\\"\\\"\\n return [1.1*min_flux, max_flux+ybuffer]\\n else:\\n return [min_flux-1., max_flux+1.]\",\n \"def setAngle(self,a):\\n self.angle = a\\n if self.drawn == True:\\n self.draw()\",\n \"def setAngleLimit(angle_limit):\\n return RoboCaller().call(\\\"setAngleLimit\\\", \\\"void\\\", angle_limit)\",\n \"def setAngle(self, angle):\\n self._angle = (angle + math.pi / 2) % math.pi - math.pi / 2\\n # self._angle = angle % (2*math.pi)\",\n \"def update_temperature_region(self):\\n self.linear_region.setRegion(\\n self.temperature_plot_graph.getViewBox().viewRange()[0])\",\n \"def set_rowland_radius(self, Rm, isJohansson=False):\\n self.oe1.F_EXT = 1\\n self.oe1.FMIRR = 1\\n if isJohansson:\\n self.oe1.set_johansson(Rm*2.)\\n else:\\n self.oe1.F_JOHANSSON = 0\\n self.oe1.set_radius(Rm*2.)\",\n \"def set_radius(self, radius):\\n self._radius = radius\\n self._reset_slot_bounds()\",\n \"def radio_range(self, value: int):\\n self._radio_range = value\",\n \"def set_colormap_range(self):\\n cmin = self.settingsWidget.ui.colormap_min\\n cmax = self.settingsWidget.ui.colormap_max\\n region = self.plot.getHistogramWidget().region\\n\\n if(self.sender() == region):\\n cmin.setText(str(region.getRegion()[0]))\\n cmax.setText(str(region.getRegion()[1]))\\n return\\n\\n # Sometimes the values in the lineEdits are\\n # not proper floats so we get ValueErrors\\n try:\\n # If necessary swap min and max\\n if(float(cmin.text()) > float(cmax.text())):\\n _tmp = cmin.text()\\n cmin.setText(cmax.text())\\n cmax.setText(_tmp)\\n\\n region = [float(cmin.text()), float(cmax.text())]\\n self.plot.getHistogramWidget().region.setRegion(region)\\n except ValueError:\\n return\",\n \"def set_slope(self, slope: float) -> None:\\r\\n self.slope = slope\",\n \"def set_wheel_speed(self, om_l, om_r):\\n self.om_left = om_l\\n self.om_right = om_r\",\n \"def change_angle(self, new_angle):\\r\\n self.angle = new_angle\",\n \"def set_y(self, y: float):\\n self.y = y\",\n \"def set_radius(self, rmirr):\\n self.F_EXT = 1\\n self.RMIRR = rmirr\",\n \"def hogg_lim_and_label():\\n plt.xlim(-20., 1020.)\\n plt.xlabel(\\\"time (d)\\\")\\n plt.ylim(-20., 20.)\\n plt.ylabel(\\\"radial velocity (m\\\\,s$^{-1}$)\\\")\\n return None\",\n \"def theta_deg(self):\\n return self.theta * 180 / np.pi\",\n \"def azimuth_servo_set_position(self, position: int):\\n return self.azimuth_servo.set_position(position)\",\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 set_range(self, axis: int, range: Sequence[Union[int, float]]):\\n if axis < 0:\\n axis += self.ndim\\n if axis < 0:\\n raise ValueError(\\n f'axis is negative, expected positive, got {axis}'\\n )\\n if self.range[axis] != range:\\n self._range[axis] = range\\n self.events.range(axis=axis)\",\n \"def angle(self, angle):\\n self._angle = angle\\n self.x_rate = self._rate * cos(self._angle)\\n self.y_rate = self._rate * sin(self._angle)\",\n \"def setRobotDirection(self, direction):\\n self.direction = direction\",\n \"def setRobotDirection(self, direction):\\n self.direction = direction\",\n \"def set_range(self, full_range, abs_range=None, suppress_feedback=False):\\n self._enabled = full_range[0] != full_range[1]\\n if not self._enabled:\\n full_range = (\\n full_range[0] - 1, full_range[0])\\n self._suppress_feedback = suppress_feedback\\n super(MarkerProperty, self).set_range(full_range, abs_range=abs_range)\",\n \"def radians(self):\\n self._setDegreesPerAU(2*math.pi)\",\n \"def set_density_params(self, theta, scale=None):\\n self.density.loc = self.mean(theta)\\n if scale is not None:\\n self.density.scale = scale\",\n \"def radar_range(self) -> Union[int, float]:\\n return self.proto.radar_range\",\n \"def radius(self, radius: float):\\n\\n self._radius = radius\",\n \"def setdirection(self, *args, **kwargs):\\n return _coordsys.coordsys_setdirection(self, *args, **kwargs)\",\n \"def setColorBarRange(start=1,end=254):\\n dislin.colran(start,end)\",\n \"def set_lims(self):\\n xx_min, xx_max = self.set_period_limits()\\n y_min = self.tf.rho.min()\\n y_min = max(y_min, 1e-20)\\n y_max = self.tf.rho.max()\\n y_max = max(y_max, 1e-20)\\n\\n yy_min = 10 ** (np.floor(np.log10(y_min)))\\n if (np.log10(y_min) - np.log10(yy_min)) < 0.15:\\n yy_min = 10 ** (np.log10(yy_min) - 0.3)\\n\\n yy_max = 10 ** (np.ceil(np.log10(y_max)))\\n if (np.log10(yy_max) - np.log10(y_max)) < 0.15:\\n yy_max = 10 ** (np.log10(yy_max) + 0.3)\\n\\n if abs(yy_max - yy_min) > 1:\\n lims = [xx_min, xx_max, yy_min, yy_max, 0, 90]\\n else:\\n lims = [xx_min, xx_max, 0.01, 1e4, 0, 90]\\n\\n orient = 0.0\\n return lims, orient\",\n \"def initialize_plotter(width, height, min_x, max_x, min_y, max_y):\\n global x_begin, x_end, x_increment\\n turtle.delay(0)\\n x_begin, x_end = min_x, max_x\\n turtle.setup(width=width, height=height)\\n turtle.screensize(width, height)\\n turtle.setworldcoordinates(min_x, min_y, max_x, max_y)\\n x_increment = (max_x - min_x)/width\\n turtle.hideturtle()\\n turtle.pencolor('black')\\n turtle.penup()\\n turtle.setposition(min_x, 0)\\n turtle.setheading(0)\\n turtle.pendown()\\n turtle.forward(max_x - min_x)\\n turtle.penup()\\n turtle.setposition(0, min_y)\\n turtle.setheading(90)\\n turtle.pendown()\\n turtle.forward(max_y - min_y)\",\n \"def move(self, dt):\\n w_px = self.meter_to_cart(self.vw)\\n # delta_theta = delta_s/r\\n self.theta += self.vw*dt/self.get_radial_distance_from(self.host_star)\\n self.rect.center = self.polar_to_cartesian(self.r, self.theta)\",\n \"def coordY(r, theta, useradians = True):\\r\\n if not useradians :\\r\\n #convert theta to radians\\r\\n theta = theta / 180 * math.pi\\r\\n y = r * math.sin(theta)\\r\\n return y\",\n \"def set_radius(self, radius, unit='km'):\\n self.radius = radius\\n self.unit = unit\",\n \"def set_grating_va(self, g, wl=None):\\n try:\\n self.set_grating(g)\\n # By default the Shamrock library keeps the same wavelength\\n if wl is not None:\\n self.set_wavelength(wl)\\n except Exception:\\n print(\\\"Failed to change grating to %d\\\", g)\",\n \"def set_display_trange(self, trang: float) -> None:\\n self.write(':timebase:range {:.4g}'.format(trang))\",\n \"def setArticulateAngle(self, angle):\\n self.articulatePID.setSetpoint(angle)\",\n \"def __init__(self, x=0.0, y=0.0, theta=0.0, w=1.0):\\n self.w = w\\n self.theta = theta\\n self.x = x\\n self.y = y\",\n \"def setYUnits(self, units): \\n self.__y_units__ = units\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6535932","0.5930254","0.58945006","0.58641726","0.5827496","0.57677525","0.56842303","0.5623213","0.5555848","0.55475396","0.5508905","0.5496923","0.5430605","0.53862256","0.5381699","0.5343665","0.53284","0.5323077","0.5322511","0.5319038","0.53141254","0.52779865","0.5235834","0.51935357","0.5157133","0.5156333","0.5124294","0.5120784","0.50972927","0.5061364","0.5054741","0.50528014","0.5031351","0.5017597","0.5015693","0.50122184","0.5011763","0.50104886","0.49885362","0.4980297","0.49660173","0.49638492","0.49512205","0.49402186","0.493481","0.49249586","0.4918204","0.4916349","0.4915388","0.4915094","0.49031845","0.4901272","0.48993593","0.48936957","0.48933485","0.48914284","0.4873929","0.48645043","0.48483714","0.48395717","0.4838853","0.48348877","0.48230106","0.4821338","0.48203042","0.4819452","0.48121652","0.48050076","0.48022687","0.479455","0.47810215","0.4777363","0.47652322","0.47646627","0.47602174","0.47538564","0.47317418","0.47284147","0.47267354","0.47253174","0.47206178","0.4712421","0.4712421","0.4708692","0.47009543","0.4697259","0.46968943","0.46963558","0.4689715","0.46822375","0.4679076","0.4673931","0.4672098","0.4670396","0.4670306","0.46681717","0.46645346","0.46630967","0.46567324","0.46501192"],"string":"[\n \"0.6535932\",\n \"0.5930254\",\n \"0.58945006\",\n \"0.58641726\",\n \"0.5827496\",\n \"0.57677525\",\n \"0.56842303\",\n \"0.5623213\",\n \"0.5555848\",\n \"0.55475396\",\n \"0.5508905\",\n \"0.5496923\",\n \"0.5430605\",\n \"0.53862256\",\n \"0.5381699\",\n \"0.5343665\",\n \"0.53284\",\n \"0.5323077\",\n \"0.5322511\",\n \"0.5319038\",\n \"0.53141254\",\n \"0.52779865\",\n \"0.5235834\",\n \"0.51935357\",\n \"0.5157133\",\n \"0.5156333\",\n \"0.5124294\",\n \"0.5120784\",\n \"0.50972927\",\n \"0.5061364\",\n \"0.5054741\",\n \"0.50528014\",\n \"0.5031351\",\n \"0.5017597\",\n \"0.5015693\",\n \"0.50122184\",\n \"0.5011763\",\n \"0.50104886\",\n \"0.49885362\",\n \"0.4980297\",\n \"0.49660173\",\n \"0.49638492\",\n \"0.49512205\",\n \"0.49402186\",\n \"0.493481\",\n \"0.49249586\",\n \"0.4918204\",\n \"0.4916349\",\n \"0.4915388\",\n \"0.4915094\",\n \"0.49031845\",\n \"0.4901272\",\n \"0.48993593\",\n \"0.48936957\",\n \"0.48933485\",\n \"0.48914284\",\n \"0.4873929\",\n \"0.48645043\",\n \"0.48483714\",\n \"0.48395717\",\n \"0.4838853\",\n \"0.48348877\",\n \"0.48230106\",\n \"0.4821338\",\n \"0.48203042\",\n \"0.4819452\",\n \"0.48121652\",\n \"0.48050076\",\n \"0.48022687\",\n \"0.479455\",\n \"0.47810215\",\n \"0.4777363\",\n \"0.47652322\",\n \"0.47646627\",\n \"0.47602174\",\n \"0.47538564\",\n \"0.47317418\",\n \"0.47284147\",\n \"0.47267354\",\n \"0.47253174\",\n \"0.47206178\",\n \"0.4712421\",\n \"0.4712421\",\n \"0.4708692\",\n \"0.47009543\",\n \"0.4697259\",\n \"0.46968943\",\n \"0.46963558\",\n \"0.4689715\",\n \"0.46822375\",\n \"0.4679076\",\n \"0.4673931\",\n \"0.4672098\",\n \"0.4670396\",\n \"0.4670306\",\n \"0.46681717\",\n \"0.46645346\",\n \"0.46630967\",\n \"0.46567324\",\n \"0.46501192\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.4911351"},"document_rank":{"kind":"string","value":"50"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":64,"numItemsPerPage":100,"numTotalItems":140256,"offset":6400,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNmFlNWFmZGU5YjYwZTdiMTIyZmRmMTNlIl0sImlhdCI6MTc5NDA4NzUxOSwianRpIjoiNTdmNTE0MTItZGEyMS00Nzc0LWJkYzgtYWI4NmQxMDRlN2ZlIiwic3ViIjoiL2RhdGFzZXRzL2hhcnZleXoxL2Nvcm5zdGFjay1weXRob24zIiwiZXhwIjoxNzk0MDkxMTE5LCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.ygE9KMrMLoWOv6w1j3cktVt5lK40j9yJw5nYWVTVPa9mvxCHeBxHpidKbXAp6t3bU67xLiaZni6v6JGbIaOPCA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":140256,"numBytesParquet":1753816410}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 10 2k | document stringlengths 20 51.2k | metadata dict | negatives listlengths 0 101 | negative_scores listlengths 0 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Calculate the ionization fraction, in equilibrium, for all ions of the element. Calculate the population fractions for every ion of this element as a function of temperature, assuming ionization equilibrium. This returns a matrix with dimensions ``(n,Z+1)``, where ``n`` corresponds to the temperature dimension and ``Z+... | def equilibrium_ionization(self):
# Solve system of equations using singular value decomposition
_, _, V = np.linalg.svd(self._rate_matrix.value)
# Select columns of V with smallest eigenvalues (returned in descending order)
# NOTE: must take the absolute value as the SVD solution is onl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate(self, temperature):\n self.Temperature = np.array(temperature, 'float64')\n if self.Temperature.size == 1:\n print(' temperature must be an array')\n return\n ionList = []\n chIons = []\n z = self.Z\n for stage in range(1, z+2):\n ... | [
"0.55999285",
"0.5488472",
"0.5296714",
"0.50601256",
"0.5011484",
"0.4979466",
"0.48647112",
"0.48613384",
"0.48146105",
"0.4788765",
"0.47775778",
"0.475389",
"0.47358677",
"0.47119826",
"0.47119826",
"0.4689794",
"0.46835712",
"0.46832117",
"0.4669735",
"0.4662512",
"0.465... | 0.67447615 | 0 |
Initializing name, color and age attributes | def __init__(self, name, color, age):
self.name = name
self.color = color
self.age = age
self.breed = "something" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, name, color):\n self.name = name\n self.color = color",
"def __init__(self, name, race, sex, age):\n self.Race = race\n self.Sex = sex\n self.Age = age\n self.Name = name",
"def __init__(self, name, age):\n\t\tself.name = name\n\t\tself.age = age",
"def __... | [
"0.7229465",
"0.714791",
"0.7094137",
"0.7094137",
"0.7094137",
"0.7010226",
"0.7001638",
"0.69976294",
"0.69976294",
"0.69976294",
"0.69976294",
"0.69844526",
"0.69432414",
"0.6920252",
"0.6920252",
"0.6920252",
"0.6920252",
"0.6920252",
"0.6920252",
"0.6920252",
"0.6920252"... | 0.76693255 | 0 |
Initializing restaurat_name and cuisine_type attributes | def __init__(self, restaurant_name, cuisine_type):
self.restaurant_name = restaurant_name
self.cuisine_type = cuisine_type
self.number_served = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, restaurant_name, cuisine_type):\r\n\t\tself.restaurant_name = restaurant_name\r\n\t\tself.cuisine_type = cuisine_type",
"def __init__(self, restaurant_name, cuisine_type):\n\t\tself.restaurant_name = restaurant_name.title()\n\t\tself.cuisine_type = cuisine_type",
"def __init__(self, restaura... | [
"0.8389735",
"0.8383585",
"0.8328781",
"0.82111484",
"0.82111484",
"0.82111484",
"0.8124199",
"0.8124199",
"0.8077414",
"0.8044229",
"0.80015045",
"0.7825798",
"0.7825798",
"0.78211445",
"0.78179175",
"0.78085977",
"0.76126933",
"0.72067785",
"0.7148248",
"0.7136754",
"0.7136... | 0.7834019 | 12 |
Initializing first_name and last_name attributes | def __init__(self, first_name, last_name):
self.first_name = first_name
self.last_name = last_name
self.email = "abc"
self.age = 20 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, first_name, last_name):\r\n self.first_name = first_name\r\n self.last_name = last_name",
"def __init__(self, first_name, last_name):\r\n\r\n self.first_name = first_name\r\n self.last_name = last_name",
"def __init__(self, first_name: str, last_name: str):\n ... | [
"0.7961424",
"0.79049575",
"0.78520286",
"0.7568153",
"0.73494816",
"0.72775275",
"0.7264979",
"0.7236755",
"0.7119964",
"0.70897245",
"0.70897245",
"0.70897245",
"0.70897245",
"0.70897245",
"0.70897245",
"0.70897245",
"0.70897245",
"0.7085531",
"0.69607544",
"0.6951678",
"0.... | 0.72440577 | 7 |
Turn a json database file into a dicitonary | def json2dict(data):
sub_all = data.get("values")
keys = data.get("fields")
dic_all = []
for sub in sub_all:
x = dict(zip(keys, sub))
if not x['datastring'] is None:
x['datastring'] = json.loads(x.get('datastring'))
dic_all.append(x)
return dic_all | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_from_json(path_to_db):\r\n with open(path_to_db, 'r') as fproc:\r\n data_ = json.load(fproc)\r\n \r\n return data_",
"def read_db(self):\n with open(self.filename, 'r') as database:\n data = json.load(database)\n self.data = data",
"def parse_database(d... | [
"0.74750674",
"0.7113321",
"0.7090973",
"0.68696135",
"0.6744415",
"0.67084914",
"0.66681075",
"0.6646405",
"0.6600848",
"0.65745395",
"0.6572555",
"0.655719",
"0.65471816",
"0.65214896",
"0.64806795",
"0.64779276",
"0.6433419",
"0.6399373",
"0.639519",
"0.63337386",
"0.63187... | 0.0 | -1 |
Generates a list of full paths corresponding to the files in a given source directory. | def compile_files(root):
files = [os.path.join(root, f) for f in os.listdir(root) if not f.startswith(".")]
return files | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_source_files(self):\n return [\n path.as_posix()\n for path in _Path(self.src_dir).rglob(\"*\")\n if not path.is_dir()\n ] + [\n (path / \"CMakeLists.txt\").as_posix()\n for path in _PurePath(self.src_dir).parents\n ]",
"def get_... | [
"0.72855586",
"0.7235734",
"0.7105525",
"0.7096677",
"0.7070382",
"0.7066401",
"0.6954114",
"0.69186455",
"0.686106",
"0.6853044",
"0.6829583",
"0.6822751",
"0.67811435",
"0.6775402",
"0.6696862",
"0.66400325",
"0.6605563",
"0.65650314",
"0.6562673",
"0.6506892",
"0.64855105"... | 0.6337624 | 32 |
Gets the filename sans extension from a file path. | def file_name(path):
return os.path.basename(path).split('.')[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file_name_with_ext(path: str) -> str:\n return os.path.basename(path)",
"def getfilename(path):\r\n return path.split('\\\\').pop().split('/').pop().rsplit('.', 1)[0]",
"def get_file_name(path: str) -> str:\n return os.path.splitext(os.path.basename(path))[0]",
"def get_filename(path):\n ... | [
"0.87634933",
"0.8712568",
"0.8711577",
"0.8615625",
"0.85573363",
"0.85461634",
"0.85347843",
"0.84573877",
"0.8419906",
"0.837513",
"0.82898366",
"0.8236268",
"0.8124858",
"0.8120405",
"0.8083538",
"0.803336",
"0.79259366",
"0.790618",
"0.78862053",
"0.78698707",
"0.7816423... | 0.8509036 | 7 |
Convenience function to return basename. | def base_name(path):
return os.path.basename(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def basename(path):\r\n return split(path)[1]",
"def basename(self):\n return self._getbyspec(\"basename\")[0]",
"def basename(path: str) -> str:\n pass",
"def basename(path):\n\n return path.rpartition(\"/\")[2]",
"def basename(self):\n return get_basename(self.filename)",
"def base... | [
"0.834663",
"0.83431476",
"0.833451",
"0.8248663",
"0.8191109",
"0.8124439",
"0.80235136",
"0.79853994",
"0.7927616",
"0.7927259",
"0.7925511",
"0.79180783",
"0.79175466",
"0.7858909",
"0.785414",
"0.78424525",
"0.7744179",
"0.7741232",
"0.7652428",
"0.76208675",
"0.75588536"... | 0.7424492 | 23 |
Opens a new database connection if there is none yet for the current application context. | def get_db(self):
if not hasattr(g, 'sqlite_db'):
g.sqlite_db = self.connect_db()
return g.sqlite_db | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db_open():\n if not hasattr(g, 'sqlite_db'):\n g.sqlite_db = db_connect()\n return g.sqlite_db",
"def open_database(self):\n if self._conn is None:\n self._conn = sqlite3.connect(self._db_path)",
"def open_db(db_name: str = DB_NAME) -> DBConnection:\n return sqlite3.connec... | [
"0.7737739",
"0.75827533",
"0.7317395",
"0.7169041",
"0.702287",
"0.6966418",
"0.69545615",
"0.6949175",
"0.689662",
"0.6843248",
"0.68287647",
"0.6818979",
"0.6806134",
"0.6795601",
"0.676938",
"0.6762347",
"0.67520237",
"0.67473835",
"0.67323875",
"0.66999775",
"0.6688061",... | 0.0 | -1 |
Checks if offer book is updated | def is_updated(self):
return self.timestamp > 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self, book_info, destroy):\n self.connect()\n is_issue = len(book_info) == 2\n\n bid = book_info[0].get()\n if is_issue:\n issue_to = book_info[1].get()\n\n if is_issue:\n extract_bid = f\"select bid from {self.book_table}\"\n else:\n ... | [
"0.66868323",
"0.6317889",
"0.63150305",
"0.62709373",
"0.62313783",
"0.61310667",
"0.6013151",
"0.6004659",
"0.59815544",
"0.59777766",
"0.5953053",
"0.5926266",
"0.59201884",
"0.5893749",
"0.58760464",
"0.5870145",
"0.58474725",
"0.581722",
"0.5815231",
"0.58059347",
"0.578... | 0.6063135 | 6 |
Get brightness of image in RGB format | def estimate_brightness(self):
intensity = self._get_intensity()
self.avg_standard_lum = np.sum(intensity) / (self.img_height * self.img_width)
return self.avg_standard_lum | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_image_brightness(image_path):\n # Convert the Image to greyscale\n img = Image.open(image_path).convert('L')\n # Get the average pixel brightness\n stat = ImageStat.Stat(img)\n return stat.rms[0]",
"def brightness(rgb):\n # return (min(rgb) + max(rgb)) / 2\n return rgb_to_hls(rgb)[1]... | [
"0.8224858",
"0.82156515",
"0.80518216",
"0.78450835",
"0.7830698",
"0.7777487",
"0.77578187",
"0.7643308",
"0.7539643",
"0.75163233",
"0.74390584",
"0.7405258",
"0.7369598",
"0.73672646",
"0.7332657",
"0.73181295",
"0.71981156",
"0.71961015",
"0.71961015",
"0.71961015",
"0.7... | 0.737651 | 12 |
Reads Excel sheet into panda DataFrame | def get_dataframe(path, sheet, header_row, data_row_start, data_row_end):
skip_footer_nrows = get_skip_footer_length(path, sheet, header_row, data_row_end, verbose = SHOW_MESSAGES)
# read data from sheet
df = pd.read_excel(path, sheet, index_col=0, header=header_row-1, na_values=NA_LIST... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_excel_df(path_datafile):\n\treturn pd.read_excel(path_datafile, sheet_name=None)",
"def readxl(df, file_name):\r\n print( 'reading the excel file') \r\n df = pd.read_excel(file_name, sheet_name = 'Sheet1')\r\n df.columns = [x.strip('/s+').lower().replace(' ','_').replace('.','_') for x in df.co... | [
"0.7615827",
"0.7544734",
"0.7537967",
"0.7383408",
"0.73060113",
"0.7235353",
"0.7133055",
"0.70751494",
"0.69122845",
"0.6886774",
"0.68643445",
"0.6854895",
"0.68512046",
"0.6796116",
"0.67596865",
"0.67408925",
"0.67245686",
"0.66885316",
"0.6684376",
"0.6677183",
"0.6668... | 0.68317246 | 13 |
Takes a dataset string and return that data in a dataframe! | def get_dfs(dataset):
test_slice = False
if 'test_' in dataset:
dataset = dataset.replace('test_', '')
test_slice = True
ratings_path = BUILTIN_DATASETS[dataset].path
print('Path to ratings file is: {}'.format(ratings_path))
if not os.path.isfile(ratings_path):
download_built... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_dataset() -> pd.DataFrame:\n\n data = load_iris(as_frame=True)\n\n dataset = data.frame\n dataset.rename(\n columns=lambda colname: colname.strip(' (cm)').replace(' ', '_'),\n inplace=True\n )\n\n return dataset",
"def get_df(data):\n df = pd.read_csv(\n data,\n ... | [
"0.685447",
"0.6847989",
"0.67455137",
"0.6680286",
"0.66781944",
"0.6504736",
"0.6503377",
"0.6491308",
"0.64856774",
"0.6466069",
"0.64520776",
"0.64179295",
"0.64059526",
"0.63421535",
"0.63157284",
"0.62972033",
"0.6282964",
"0.62732446",
"0.626843",
"0.6258372",
"0.62007... | 0.0 | -1 |
This class is always instantiated with a DataHandler class instance. This instance should have the pipeline run, with extra columns included that identify the candidate sensors. | def __init__(self, data_handler_obj):
self.data_handler = data_handler_obj
self.sensor_keys = np.array(list(self.data_handler.extra_matrices.keys()))
if len(self.sensor_keys) == 0:
print("Please add sensor columns to DataHandler pipeline.")
return
self.coverage_sc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_pipeline(self):\n pipe_distance = make_pipeline(DistanceTransformer(), RobustScaler())\n pipe_time = make_pipeline(TimeFeaturesEncoder(time_column='pickup_datetime'), OneHotEncoder(handle_unknown='ignore'))\n dist_cols = ['pickup_latitude', 'pickup_longitude', 'dropoff_latitude', 'drop... | [
"0.5981283",
"0.5748262",
"0.5745058",
"0.5740179",
"0.573706",
"0.5722975",
"0.56946933",
"0.5666524",
"0.56656593",
"0.5637534",
"0.56011313",
"0.5574644",
"0.5571768",
"0.55624294",
"0.55260295",
"0.5505294",
"0.5492911",
"0.54925513",
"0.5490077",
"0.5489706",
"0.54857033... | 0.7206935 | 0 |
Sets the name of this UpdateInboxOptions. | def name(self, name):
self._name = name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_name(self, name):\n self.options['name'] = name",
"def set_name(self, name):\n self.settings[\"name\"] = name",
"def set_name(self, name):\n self.name = name # overwrite the existing name with the input name",
"def set_name(self, name):\n self.name = name # overwrite the... | [
"0.70393825",
"0.64819753",
"0.64318216",
"0.64318216",
"0.6332718",
"0.6325758",
"0.6325758",
"0.62993973",
"0.62860096",
"0.62860096",
"0.62860096",
"0.62860096",
"0.62860096",
"0.6271976",
"0.6239054",
"0.6220303",
"0.6220303",
"0.6220303",
"0.6220303",
"0.62160844",
"0.61... | 0.0 | -1 |
Sets the tags of this UpdateInboxOptions. | def tags(self, tags):
self._tags = tags | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tags(self, tags):\n self._tags = tags",
"def tags(self, tags):\n self._tags = tags",
"def tags(self, tags):\n self._tags = tags",
"def set_tags(self, tags):\n for task in self._tasks:\n task.set_tags(tags)\n\n return self",
"def tags(self, tags: List[Tag]):... | [
"0.6343181",
"0.6343181",
"0.6343181",
"0.6208632",
"0.6134204",
"0.6123332",
"0.5888338",
"0.56895727",
"0.56456083",
"0.5643491",
"0.5628214",
"0.55469376",
"0.54833806",
"0.54451567",
"0.5267078",
"0.5214299",
"0.51585424",
"0.5012797",
"0.5010836",
"0.49723527",
"0.496777... | 0.63935703 | 9 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, UpdateInboxOptions):
return False
return self.to_dict() == other.to_dict() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.8088132",
"0.8088132",
"0.8054589",
"0.7982687",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
if not isinstance(other, UpdateInboxOptions):
return True
return self.to_dict() != other.to_dict() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.8455985",
"0.83913255",
"0.81440157",
"0.8140831",
"0.8132328",
"0.80937284",
"0.809181",
"0.809181",
"0.809181",
"0.808509",
"0.808509",
"0.8076134",
"0.8076134",
"0.8065528",
"0.80422795",
"0.80422795",
"0.80422795",
"0.80422795",
"0.80422795",
"0.80422795",
"0.80422795"... | 0.0 | -1 |
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('Enter desired city (new york city, chicago, washington): ').lower()
if city in... | {
"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.667135",
"0.65355784",
"0.6459417",
"0.6372491",
"0.6349019",
"0.63104576",
"0.62870693",
"0.6259983",
"0.62297434",
"0.62112975",
"0.62049454",
"0.6181796",
"0.6170252",
"0.6170224",
"0.6159359",
"0.61588275",
"0.6153817",
"0.61454034",
"0.61345667",
"0.61054",
"0.6103349... | 0.5910564 | 42 |
Loads data for the specified city and filters by month and day if applicable. | def load_data(city, month, day):
print('\nLoading Data...\n')
path = os.getcwd().replace('\\', '/') + '/'
dir_path = os.path.dirname(os.path.realpath(__file__)).replace('\\', '/') + '/'
try:
df = pd.read_csv(dir_path + CITY_DATA.get(city))
except FileNotFoundError as e:
sys.exit('E... | {
"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.8045821",
"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.788921... | 0.7343438 | 99 |
Displays statistics on the most frequent times of travel. | def time_stats(df, month, day):
print('\nCalculating Time Stats...\n')
# display the most common month
mode_month = df['month'].mode()[0]
print('(Pre-filter) the most common month is {}'.format(months[mode_month-1]))
# display the most common day of week
mode_day = df['day_of_week'].mode()[0]... | {
"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.80247396",
"0.80233026",
"0.7915788",
"0.78266186",
"0.7822246",
"0.78143597",
"0.77659196",
"0.7740343",
"0.773628",
"0.77344066",
"0.76867086",
"0.7668633",
"0.7651731",
"0.7644636",
"0.76399267",
"0.76367253",
"0.7625196",
"0.7623158",
"0.7612803",
"0.76002145",
"0.7583... | 0.0 | -1 |
Displays statistics on the most popular stations and trip. | def station_stats(df):
print('\nCalculating Station Stats...\n')
# display most commonly used start station
mode_start_station = df['Start Station'].mode()[0]
print('the most common start station is {}'.format(mode_start_station))
# display most commonly used end station
mode_end_station ... | {
"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.7815675",
"0.7662213",
"0.7553417",
"0.74914914",
"0.74748665",
"0.7446617",
"0.7428588",
"0.74237514",
"0.74177027",
"0.7400495",
"0.7387161",
"0.7385634",
"0.73647535",
"0.735934",
"0.73566747",
"0.73548365",
"0.7351854",
"0.7351274",
"0.735057",
"0.73421645",
"0.7340198... | 0.6791951 | 97 |
Displays statistics on the total and average trip duration. | def trip_duration_stats(df):
print('\nCalculating Duration Stats...\n')
# display total travel time
total_time = df['Trip Duration'].sum()
hours, rem = divmod(total_time, 3600)
minutes, seconds = divmod(rem, 60)
print('The total travel time was {:02.0f}:{:02.0f}:{:05.2f}'.format(hours, minutes... | {
"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.8141812",
"0.8024182",
"0.80032814",
"0.7948688",
"0.79363805",
"0.79301584",
"0.7925556",
"0.79139745",
"0.79132074",
"0.79069036",
"0.79044855",
"0.7899693",
"0.78905743",
"0.7888294",
"0.78858185",
"0.7883996",
"0.78832155",
"0.7881429",
"0.7872763",
"0.78675747",
"0.78... | 0.7718519 | 64 |
Add add two values as unsigned 8bit values. | def _uint8_add(self, a, b):
return ((a & 0xFF) + (b & 0xFF)) & 0xFF | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add(a, b):\n\n # Todo: What if numbers have bigger length than 8\n a = _I2B(a, fixed_length=8)\n b = _I2B(b, fixed_length=8)\n return _B2I([i ^ j for i, j in zip(a, b)])",
"def add_binary(a, b):\n return bin(a + b)[2:]",
"def add64(a,b):\n return(np.add(a, b, dtype=np.uint64))",
"def a... | [
"0.7118355",
"0.6863869",
"0.6765149",
"0.665138",
"0.66207707",
"0.64209676",
"0.63915664",
"0.63376117",
"0.62058306",
"0.6175232",
"0.60576916",
"0.603546",
"0.6032429",
"0.59999746",
"0.5897095",
"0.5881542",
"0.5862601",
"0.5828295",
"0.58184725",
"0.5767223",
"0.5704461... | 0.8304557 | 0 |
Add headers to prevent caching. | def add_headers(r):
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_header(req):\n req.headers[\"Cache-Control\"] = \"no-cache\"\n return req",
"def add_header(response):\n\n # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control\n response.cache_control.no_store = True\n return response",
"def add_header(response):\n\n # ht... | [
"0.84266937",
"0.841703",
"0.841703",
"0.8395993",
"0.83906054",
"0.8382698",
"0.83295184",
"0.83173895",
"0.8296773",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
"0.8296285",
... | 0.8201493 | 34 |
Quaternary Phase Shift Keying (QPSK) signal. | def anaqpsk(n_points, n_comp=None, f0=0.25):
if n_comp is None:
n_comp = round(n_points / 5.0)
if (f0 < 0) or (f0 > 0.5):
raise TypeError("f0 must be between 0 and 0.5")
m = int(np.ceil(n_points / n_comp))
jumps = np.floor(4 * np.random.rand(m))
jumps[jumps == 4] = 3
pm0 = (np.pi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def p(self, q0, phase=DEF_PHASE, ctrl=None):\n self.__add_quantum_gate(kind=PHASE_SHIFT, qid=[q0], phase=phase, ctrl=ctrl)\n return self",
"def pitch_gen(freq: float, duration: float, signal: np.array, sample_freq: int, alpha=0.99, ref_length=50):\n total_sample_number = int(sample_freq * durati... | [
"0.5408042",
"0.53112704",
"0.5284314",
"0.5255777",
"0.5245763",
"0.52398986",
"0.5203375",
"0.515996",
"0.5156246",
"0.5156018",
"0.5143576",
"0.5109748",
"0.5084516",
"0.5084516",
"0.49888036",
"0.49568644",
"0.4943298",
"0.4911667",
"0.4909686",
"0.4904744",
"0.4900166",
... | 0.0 | -1 |
Constructor for Hand objects. Optionally takes a card or list of cards. | def __init__(self, cards = []):
self.cards=cards | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, cards_on_table=None, cards=[], hands_list=[]):\n self.cards = cards\n self.cards_on_table = cards_on_table\n self.hands_list = hands_list",
"def add_card(self, card):\n #Determines if there are more than one.\n if isinstance(card,list):\n for eleme... | [
"0.8086171",
"0.71335506",
"0.7127037",
"0.6982965",
"0.6802928",
"0.65441805",
"0.6543608",
"0.6504932",
"0.6497756",
"0.6464802",
"0.64384717",
"0.63839906",
"0.63518137",
"0.63354486",
"0.63304275",
"0.63034296",
"0.6294396",
"0.6281515",
"0.6276011",
"0.6274122",
"0.62712... | 0.70107305 | 3 |
Test case for connect_post_namespaced_status_webhooks_with_path | def test_connect_post_namespaced_status_webhooks_with_path(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_connect_post_namespaced_status_webhooks(self):\n pass",
"def connect_post_namespaced_status_webhooks_1(self, namespace, name, path2, **kwargs):\n\n all_params = ['namespace', 'name', 'path2', 'path']\n all_params.append('callback')\n\n params = locals()\n for key, val ... | [
"0.81542915",
"0.72567916",
"0.70768386",
"0.6168528",
"0.56414336",
"0.55579436",
"0.5390352",
"0.5262062",
"0.5236467",
"0.5224782",
"0.51910794",
"0.5176027",
"0.51725316",
"0.5153039",
"0.5123162",
"0.50873536",
"0.50747126",
"0.5051635",
"0.5045923",
"0.5044757",
"0.5032... | 0.94886124 | 0 |
Test case for create_egress_network_policy_for_all_namespaces | def test_create_egress_network_policy_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_egress_network_policy(self):\n pass",
"def test_list_egress_network_policy_for_all_namespaces(self):\n pass",
"def test_list_namespaced_egress_network_policy(self):\n pass",
"def test_replace_namespaced_egress_network_policy(self):\n pass",
"def test_p... | [
"0.8664481",
"0.8521904",
"0.8020849",
"0.7897353",
"0.7703624",
"0.7572405",
"0.74850076",
"0.72024673",
"0.6883535",
"0.66519046",
"0.62801635",
"0.62497866",
"0.60414034",
"0.60309887",
"0.5821768",
"0.5754535",
"0.57487166",
"0.5718347",
"0.5717843",
"0.5671705",
"0.56091... | 0.95230854 | 0 |
Test case for create_image_stream_for_all_namespaces | def test_create_image_stream_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_image_stream_tag_for_all_namespaces(self):\n pass",
"def test_create_image_stream_mapping_for_all_namespaces(self):\n pass",
"def test_create_namespaced_image_stream(self):\n pass",
"def test_create_image_stream_import_for_all_namespaces(self):\n pass",
"def test... | [
"0.9088928",
"0.89130735",
"0.889287",
"0.8872689",
"0.8536201",
"0.84663653",
"0.8451075",
"0.8336805",
"0.8129746",
"0.81173295",
"0.8034135",
"0.7941872",
"0.77382636",
"0.76966006",
"0.76674956",
"0.74966055",
"0.7485253",
"0.7450198",
"0.7190685",
"0.71756494",
"0.713151... | 0.96039075 | 0 |
Test case for create_image_stream_import_for_all_namespaces | def test_create_image_stream_import_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_image_stream_import(self):\n pass",
"def test_create_image_stream_for_all_namespaces(self):\n pass",
"def test_create_image_stream_mapping_for_all_namespaces(self):\n pass",
"def test_create_image_stream_tag_for_all_namespaces(self):\n pass",
"def test... | [
"0.8958092",
"0.886222",
"0.835668",
"0.8331445",
"0.8163908",
"0.7932511",
"0.7851598",
"0.78005266",
"0.7746258",
"0.7556122",
"0.7476707",
"0.73902404",
"0.7253503",
"0.72491485",
"0.7233775",
"0.7157064",
"0.6953136",
"0.68886954",
"0.68099636",
"0.6708648",
"0.6689925",
... | 0.95803815 | 0 |
Test case for create_namespaced_build_request_instantiate | def test_create_namespaced_build_request_instantiate(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_deployment_request_instantiate(self):\n pass",
"def test_create_namespaced_build_request_clone(self):\n pass",
"def create_namespaced_build_request_instantiate(self, body, namespace, name, **kwargs):\n\n all_params = ['body', 'namespace', 'name', 'pretty']\n ... | [
"0.8502078",
"0.83170307",
"0.76645523",
"0.74378824",
"0.67364556",
"0.66046137",
"0.65032786",
"0.6417477",
"0.63983643",
"0.63728017",
"0.6030284",
"0.6030111",
"0.6029587",
"0.60130584",
"0.59885395",
"0.59660023",
"0.58713955",
"0.5854541",
"0.5824336",
"0.58161306",
"0.... | 0.94818825 | 0 |
Test case for create_namespaced_deployment_config | def test_create_namespaced_deployment_config(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_generate_namespaced_deployment_config(self):\n pass",
"def test_create_deployment_config_for_all_namespaces(self):\n pass",
"def test_create_namespaced_deployment_config_rollback(self):\n pass",
"def test_replace_namespaced_deployment_config(self):\n pass",
"def test_pa... | [
"0.90208375",
"0.8209942",
"0.8146177",
"0.80212843",
"0.7990842",
"0.793712",
"0.7865985",
"0.77581066",
"0.7747018",
"0.7700346",
"0.7516933",
"0.73865527",
"0.7349639",
"0.7249784",
"0.71158814",
"0.7051148",
"0.7023652",
"0.68583107",
"0.6829023",
"0.6737736",
"0.6664528"... | 0.9388213 | 0 |
Test case for create_namespaced_deployment_request_instantiate | def test_create_namespaced_deployment_request_instantiate(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_build_request_instantiate(self):\n pass",
"def test_create_namespaced_build_request_clone(self):\n pass",
"def test_create_namespaced_deployment_config(self):\n pass",
"def create_namespaced_build_request_instantiate(self, body, namespace, name, **kwargs):\n\n ... | [
"0.848718",
"0.72598684",
"0.6961696",
"0.6730869",
"0.65543026",
"0.65338725",
"0.63395345",
"0.6294449",
"0.6169637",
"0.6159322",
"0.60053974",
"0.5977857",
"0.5956605",
"0.59537166",
"0.5938256",
"0.59331006",
"0.58611876",
"0.58389896",
"0.58209556",
"0.5806656",
"0.5758... | 0.9507465 | 0 |
Test case for create_namespaced_image_stream_import | def test_create_namespaced_image_stream_import(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_image_stream(self):\n pass",
"def test_create_image_stream_import_for_all_namespaces(self):\n pass",
"def test_create_namespaced_image_stream_tag(self):\n pass",
"def test_create_namespaced_image_stream_mapping(self):\n pass",
"def test_read_namespaced... | [
"0.914461",
"0.8810778",
"0.8651879",
"0.8548657",
"0.8406771",
"0.84033275",
"0.8376729",
"0.8086984",
"0.8073045",
"0.805253",
"0.79443",
"0.77436376",
"0.773594",
"0.7619955",
"0.7598826",
"0.7590755",
"0.7555989",
"0.7538121",
"0.73467183",
"0.7318656",
"0.7120735",
"0.... | 0.96332693 | 0 |
Test case for create_namespaced_image_stream_mapping | def test_create_namespaced_image_stream_mapping(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_image_stream_mapping_for_all_namespaces(self):\n pass",
"def test_create_namespaced_image_stream(self):\n pass",
"def test_create_namespaced_image_stream_import(self):\n pass",
"def test_create_namespaced_image_stream_tag(self):\n pass",
"def test_create_image_st... | [
"0.89398944",
"0.8848656",
"0.8484017",
"0.84818804",
"0.8191045",
"0.80822265",
"0.7962002",
"0.7901439",
"0.78981113",
"0.779059",
"0.771194",
"0.7656804",
"0.76329035",
"0.75881535",
"0.7520886",
"0.74736154",
"0.7459581",
"0.735906",
"0.7176009",
"0.7122044",
"0.6997119",... | 0.9681065 | 0 |
Test case for create_namespaced_local_resource_access_review | def test_create_namespaced_local_resource_access_review(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_resource_access_review(self):\n pass",
"def test_create_local_resource_access_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_local_subject_access_review(self):\n pass",
"def test_create_resource_access_review_for_all_namespaces(self):\n ... | [
"0.86689955",
"0.8598542",
"0.7941337",
"0.7766395",
"0.7418849",
"0.730348",
"0.6976435",
"0.6538376",
"0.6496826",
"0.64750427",
"0.6311006",
"0.61978716",
"0.60786754",
"0.6051682",
"0.5989073",
"0.5942939",
"0.5938958",
"0.5880371",
"0.5880273",
"0.58254516",
"0.57635087"... | 0.940623 | 0 |
Test case for create_namespaced_local_subject_access_review | def test_create_namespaced_local_subject_access_review(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_subject_access_review(self):\n pass",
"def test_create_local_subject_access_review_for_all_namespaces(self):\n pass",
"def test_create_subject_access_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_local_resource_access_review(self):\n ... | [
"0.88866955",
"0.8753824",
"0.8224597",
"0.7894797",
"0.77134854",
"0.7585319",
"0.75217044",
"0.72628343",
"0.7259053",
"0.72015387",
"0.7122134",
"0.6877161",
"0.6840564",
"0.68367285",
"0.6818058",
"0.6802144",
"0.66375524",
"0.65448123",
"0.65413296",
"0.6315185",
"0.6178... | 0.94674575 | 0 |
Test case for create_namespaced_pod_security_policy_review | def test_create_namespaced_pod_security_policy_review(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_pod_security_policy_subject_review(self):\n pass",
"def test_create_namespaced_pod_security_policy_self_subject_review(self):\n pass",
"def test_create_pod_security_policy_review_for_all_namespaces(self):\n pass",
"def test_create_pod_security_policy_subject_re... | [
"0.91099143",
"0.87703824",
"0.87325585",
"0.8281268",
"0.81559813",
"0.78384876",
"0.6911392",
"0.6884812",
"0.6676987",
"0.6674108",
"0.66300714",
"0.6588382",
"0.65482754",
"0.64584625",
"0.6453993",
"0.64402235",
"0.6327952",
"0.6307666",
"0.63071185",
"0.62481487",
"0.61... | 0.95652115 | 0 |
Test case for create_namespaced_pod_security_policy_self_subject_review | def test_create_namespaced_pod_security_policy_self_subject_review(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_pod_security_policy_subject_review(self):\n pass",
"def test_create_pod_security_policy_self_subject_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_pod_security_policy_review(self):\n pass",
"def test_create_pod_security_policy_subject_re... | [
"0.91454023",
"0.89536476",
"0.8558195",
"0.84508944",
"0.7929238",
"0.7433228",
"0.7082314",
"0.69961935",
"0.68619114",
"0.67855215",
"0.6334922",
"0.62115645",
"0.6157037",
"0.60863394",
"0.60768753",
"0.58363783",
"0.58181775",
"0.5789456",
"0.578296",
"0.5721847",
"0.569... | 0.9542857 | 0 |
Test case for create_namespaced_pod_security_policy_subject_review | def test_create_namespaced_pod_security_policy_subject_review(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_pod_security_policy_self_subject_review(self):\n pass",
"def test_create_pod_security_policy_subject_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_pod_security_policy_review(self):\n pass",
"def test_create_pod_security_policy_self_subje... | [
"0.907722",
"0.8850439",
"0.88305086",
"0.8541379",
"0.8246502",
"0.7641548",
"0.73712593",
"0.7152709",
"0.71513295",
"0.6908093",
"0.66712636",
"0.6374191",
"0.6345974",
"0.6310135",
"0.6178523",
"0.6142125",
"0.61253786",
"0.6121054",
"0.5968019",
"0.5910762",
"0.5841365",... | 0.9521095 | 0 |
Test case for create_namespaced_policy | def test_create_namespaced_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_policy_binding(self):\n pass",
"def test_create_policy_for_all_namespaces(self):\n pass",
"def test_create_namespaced_pod_security_policy_review(self):\n pass",
"def test_replace_namespaced_policy(self):\n pass",
"def test_create_namespaced_pod_securit... | [
"0.8328139",
"0.83136094",
"0.7929725",
"0.7657052",
"0.75435853",
"0.74992865",
"0.7413273",
"0.7398919",
"0.73692733",
"0.73265564",
"0.7284671",
"0.7074059",
"0.68835217",
"0.6880968",
"0.6851964",
"0.6808157",
"0.67670083",
"0.67465657",
"0.6724354",
"0.66848195",
"0.6639... | 0.9380289 | 0 |
Test case for create_namespaced_policy_binding | def test_create_namespaced_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_policy(self):\n pass",
"def test_create_policy_binding_for_all_namespaces(self):\n pass",
"def test_replace_namespaced_policy_binding(self):\n pass",
"def test_patch_namespaced_policy_binding(self):\n pass",
"def test_read_namespaced_policy_binding(sel... | [
"0.84590375",
"0.8220456",
"0.8165595",
"0.78607124",
"0.78552896",
"0.76295924",
"0.7627882",
"0.7422",
"0.7364754",
"0.7327115",
"0.73057556",
"0.72808963",
"0.7274273",
"0.6991942",
"0.68144697",
"0.6777888",
"0.67765397",
"0.6713866",
"0.670911",
"0.6675343",
"0.6605467",... | 0.94703835 | 0 |
Test case for create_namespaced_resource_access_review | def test_create_namespaced_resource_access_review(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_resource_access_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_local_resource_access_review(self):\n pass",
"def test_create_namespaced_subject_access_review(self):\n pass",
"def test_create_local_resource_access_review_for_all_namespaces(self):\n ... | [
"0.84853894",
"0.8388937",
"0.7883514",
"0.77488244",
"0.749628",
"0.74303234",
"0.7335768",
"0.6819785",
"0.6791199",
"0.66249764",
"0.65099764",
"0.64683306",
"0.64654547",
"0.64338446",
"0.6429376",
"0.6367493",
"0.6316877",
"0.626278",
"0.61675453",
"0.6113542",
"0.610345... | 0.9307612 | 0 |
Test case for create_namespaced_route | def test_create_namespaced_route(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_route_for_all_namespaces(self):\n pass",
"def test_replace_namespaced_route(self):\n pass",
"def test_patch_namespaced_route(self):\n pass",
"def test_read_namespaced_route(self):\n pass",
"def test_list_namespaced_route(self):\n pass",
"def create_names... | [
"0.83822095",
"0.79478455",
"0.77725613",
"0.7664274",
"0.7533141",
"0.7413956",
"0.7236707",
"0.7198782",
"0.687994",
"0.6793015",
"0.67491585",
"0.67317766",
"0.6596346",
"0.65922016",
"0.6580498",
"0.6486518",
"0.6480092",
"0.64339334",
"0.6400338",
"0.6358479",
"0.6214070... | 0.9503767 | 0 |
Test case for create_o_auth_client_authorization | def test_create_o_auth_client_authorization(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_o_auth_client(self):\n pass",
"def test_replace_o_auth_client_authorization(self):\n pass",
"def test_read_o_auth_client_authorization(self):\n pass",
"def test_list_o_auth_client_authorization(self):\n pass",
"def test_patch_o_auth_client_authorization(self):\n ... | [
"0.86155874",
"0.7900972",
"0.7896313",
"0.7753028",
"0.7589106",
"0.7485101",
"0.74720734",
"0.7339221",
"0.7294155",
"0.72583526",
"0.7211064",
"0.7198834",
"0.70936495",
"0.698751",
"0.6973961",
"0.6940471",
"0.68962914",
"0.6894741",
"0.67974263",
"0.6749787",
"0.6719089"... | 0.928411 | 0 |
Test case for create_pod_security_policy_self_subject_review_for_all_namespaces | def test_create_pod_security_policy_self_subject_review_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_pod_security_policy_subject_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_pod_security_policy_self_subject_review(self):\n pass",
"def test_create_pod_security_policy_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_pod_securit... | [
"0.93095344",
"0.8983847",
"0.87683463",
"0.8758628",
"0.81381744",
"0.76423675",
"0.75585026",
"0.74677485",
"0.7313108",
"0.7245934",
"0.7128543",
"0.7116196",
"0.7099344",
"0.70359945",
"0.66174614",
"0.6549184",
"0.6200282",
"0.58766776",
"0.5834126",
"0.5710886",
"0.5675... | 0.95557183 | 0 |
Test case for create_pod_security_policy_subject_review_for_all_namespaces | def test_create_pod_security_policy_subject_review_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_pod_security_policy_self_subject_review_for_all_namespaces(self):\n pass",
"def test_create_pod_security_policy_review_for_all_namespaces(self):\n pass",
"def test_create_namespaced_pod_security_policy_subject_review(self):\n pass",
"def test_create_namespaced_pod_securit... | [
"0.9089189",
"0.89108753",
"0.8864628",
"0.838307",
"0.81015927",
"0.7931425",
"0.7709151",
"0.76478916",
"0.7458033",
"0.7396261",
"0.7382406",
"0.7150249",
"0.69822335",
"0.69345266",
"0.67130363",
"0.6456883",
"0.6415125",
"0.61829835",
"0.586133",
"0.5840685",
"0.57517153... | 0.95695823 | 0 |
Test case for create_role_binding_for_all_namespaces | def test_create_role_binding_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_role_binding_restriction_for_all_namespaces(self):\n pass",
"def test_create_namespaced_role_binding(self):\n pass",
"def test_create_role_for_all_namespaces(self):\n pass",
"def test_list_role_binding_for_all_namespaces(self):\n pass",
"def test_create_namespace... | [
"0.9103006",
"0.86585265",
"0.8459771",
"0.8394788",
"0.8377843",
"0.7971442",
"0.79192793",
"0.76226646",
"0.7601138",
"0.7563945",
"0.75596726",
"0.75144124",
"0.75134003",
"0.75008684",
"0.7347723",
"0.73392165",
"0.73251927",
"0.73176664",
"0.6978599",
"0.69578975",
"0.68... | 0.9585177 | 0 |
Test case for create_role_binding_restriction_for_all_namespaces | def test_create_role_binding_restriction_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_role_binding_restriction(self):\n pass",
"def test_create_role_binding_for_all_namespaces(self):\n pass",
"def test_list_role_binding_restriction_for_all_namespaces(self):\n pass",
"def test_list_namespaced_role_binding_restriction(self):\n pass",
"def... | [
"0.8878432",
"0.88176525",
"0.85561717",
"0.8195311",
"0.8186807",
"0.80923605",
"0.8036668",
"0.7987786",
"0.79452336",
"0.79143465",
"0.7488097",
"0.74283165",
"0.7307162",
"0.7285516",
"0.728321",
"0.7227291",
"0.71210515",
"0.6999721",
"0.6681523",
"0.6649977",
"0.654205"... | 0.9557484 | 0 |
Test case for create_route_for_all_namespaces | def test_create_route_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_namespaced_route(self):\n pass",
"def test_list_route_for_all_namespaces(self):\n pass",
"def test_list_namespaced_route(self):\n pass",
"def test_read_namespaced_route(self):\n pass",
"def test_create_role_for_all_namespaces(self):\n pass",
"def test_re... | [
"0.82805735",
"0.81944215",
"0.74122554",
"0.7057854",
"0.70103717",
"0.70007586",
"0.6872161",
"0.6863963",
"0.6791686",
"0.67706263",
"0.6641386",
"0.65658057",
"0.6387995",
"0.6343293",
"0.633438",
"0.62537646",
"0.6234159",
"0.62249416",
"0.6157473",
"0.6134032",
"0.60712... | 0.9544573 | 0 |
Test case for delete_collection_namespaced_build_config | def test_delete_collection_namespaced_build_config(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_namespaced_build_config(self):\n pass",
"def test_delete_collection_namespaced_deployment_config(self):\n pass",
"def test_delete_collection_namespaced_build(self):\n pass",
"def test_delete_namespaced_build(self):\n pass",
"def test_delete_collection_net_namespa... | [
"0.87105393",
"0.85826904",
"0.83276486",
"0.7966111",
"0.7784211",
"0.77130747",
"0.73661524",
"0.7247685",
"0.7096329",
"0.6976883",
"0.6967644",
"0.6918478",
"0.6889459",
"0.6879883",
"0.686037",
"0.6849961",
"0.6762526",
"0.66430926",
"0.655027",
"0.650822",
"0.64469624",... | 0.9338268 | 0 |
Test case for delete_collection_namespaced_policy | def test_delete_collection_namespaced_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_namespaced_policy_binding(self):\n pass",
"def test_delete_namespaced_policy(self):\n pass",
"def test_delete_collection_net_namespace(self):\n pass",
"def test_delete_collection_cluster_policy_binding(self):\n pass",
"def test_delete_collection_namesp... | [
"0.9186656",
"0.8532096",
"0.83839655",
"0.8102736",
"0.8065399",
"0.80626464",
"0.79287684",
"0.7919427",
"0.7889485",
"0.7801394",
"0.7703894",
"0.7695669",
"0.7449543",
"0.7335111",
"0.73327845",
"0.7319061",
"0.7224661",
"0.71204746",
"0.7097772",
"0.70312816",
"0.6989023... | 0.9541902 | 0 |
Test case for delete_collection_namespaced_policy_binding | def test_delete_collection_namespaced_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_namespaced_policy(self):\n pass",
"def test_delete_namespaced_policy_binding(self):\n pass",
"def test_delete_collection_cluster_policy_binding(self):\n pass",
"def test_delete_collection_namespaced_role_binding_restriction(self):\n pass",
"def test_de... | [
"0.9096359",
"0.8651254",
"0.8483308",
"0.8321003",
"0.8188139",
"0.7967268",
"0.7750436",
"0.76248956",
"0.7564997",
"0.74818724",
"0.7477099",
"0.73974264",
"0.7372265",
"0.73352516",
"0.72043705",
"0.7163871",
"0.7083335",
"0.7028835",
"0.7010488",
"0.7003391",
"0.6842556"... | 0.96229213 | 0 |
Test case for delete_collection_namespaced_route | def test_delete_collection_namespaced_route(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_namespaced_template(self):\n pass",
"def test_delete_namespaced_route(self):\n pass",
"def test_delete_collection(self):\n pass",
"def test_delete_collection_namespaced_policy(self):\n pass",
"def test_delete_collection_net_namespace(self):\n pa... | [
"0.8727557",
"0.8353086",
"0.8244764",
"0.82009155",
"0.8133968",
"0.8009254",
"0.7839451",
"0.77908754",
"0.7596726",
"0.7594186",
"0.74399334",
"0.7427433",
"0.7370278",
"0.73658866",
"0.733113",
"0.7236678",
"0.7141253",
"0.7120295",
"0.70706666",
"0.7062712",
"0.6913768",... | 0.95453006 | 0 |
Test case for delete_collection_o_auth_access_token | def test_delete_collection_o_auth_access_token(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_o_auth_authorize_token(self):\n pass",
"def test_delete_o_auth_access_token(self):\n pass",
"def test_delete_collection_o_auth_client_authorization(self):\n pass",
"def test_delete_collection_o_auth_client(self):\n pass",
"def test_delete_o_auth_author... | [
"0.89253896",
"0.8636085",
"0.8290429",
"0.81794876",
"0.80667055",
"0.76929116",
"0.7413754",
"0.734917",
"0.7304953",
"0.7159078",
"0.69740564",
"0.6895119",
"0.68829507",
"0.6818793",
"0.6794616",
"0.6776235",
"0.6754919",
"0.67193395",
"0.66921204",
"0.66710985",
"0.66434... | 0.95910263 | 0 |
Test case for delete_collection_o_auth_authorize_token | def test_delete_collection_o_auth_authorize_token(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_o_auth_authorize_token(self):\n pass",
"def test_delete_collection_o_auth_access_token(self):\n pass",
"def test_delete_collection_o_auth_client_authorization(self):\n pass",
"def test_delete_collection_o_auth_client(self):\n pass",
"def test_delete_o_auth_access... | [
"0.8859185",
"0.8828697",
"0.8117271",
"0.78548217",
"0.7763415",
"0.75740874",
"0.7214835",
"0.71455806",
"0.709899",
"0.70989406",
"0.7025451",
"0.70223886",
"0.6963349",
"0.68641454",
"0.6823119",
"0.67010117",
"0.66327524",
"0.65997624",
"0.65668803",
"0.65296376",
"0.649... | 0.95486134 | 0 |
Test case for delete_collection_o_auth_client | def test_delete_collection_o_auth_client(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_o_auth_client_authorization(self):\n pass",
"def test_delete_collection_o_auth_access_token(self):\n pass",
"def test_delete_collection(self):\n pass",
"def test_delete_o_auth_client(self):\n pass",
"def test_delete_o_auth_client_authorization(self):\n... | [
"0.9397677",
"0.8381249",
"0.83508503",
"0.8337235",
"0.8296779",
"0.8289998",
"0.8262201",
"0.8246754",
"0.7866164",
"0.7713604",
"0.7619595",
"0.7544593",
"0.7507639",
"0.7455466",
"0.7437973",
"0.73492235",
"0.72750443",
"0.727301",
"0.7243627",
"0.7223031",
"0.7205993",
... | 0.95537156 | 0 |
Test case for delete_collection_o_auth_client_authorization | def test_delete_collection_o_auth_client_authorization(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_o_auth_client(self):\n pass",
"def test_delete_o_auth_client_authorization(self):\n pass",
"def test_delete_collection_o_auth_authorize_token(self):\n pass",
"def test_delete_collection_o_auth_access_token(self):\n pass",
"def test_delete_o_auth_client... | [
"0.91921526",
"0.8697684",
"0.84969616",
"0.84150016",
"0.8145708",
"0.79783195",
"0.79061884",
"0.7863596",
"0.7667531",
"0.7384615",
"0.7384567",
"0.7371626",
"0.73430425",
"0.7265672",
"0.72469646",
"0.7238444",
"0.72179717",
"0.7190505",
"0.71038395",
"0.70913166",
"0.708... | 0.95005333 | 0 |
Test case for delete_namespaced_build_config | def test_delete_namespaced_build_config(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_namespaced_deployment_config(self):\n pass",
"def test_delete_namespaced_build(self):\n pass",
"def test_delete_collection_namespaced_build_config(self):\n pass",
"def test_replace_namespaced_build_config(self):\n pass",
"def test_patch_namespaced_build_config(se... | [
"0.8195701",
"0.8189324",
"0.77454793",
"0.7740929",
"0.77189547",
"0.7417156",
"0.7170956",
"0.71046394",
"0.7075535",
"0.6940931",
"0.68273073",
"0.6794706",
"0.6782108",
"0.67404294",
"0.66740054",
"0.6655758",
"0.66125274",
"0.6522335",
"0.65139556",
"0.65067875",
"0.6492... | 0.93705595 | 0 |
Test case for delete_namespaced_deployment_config | def test_delete_namespaced_deployment_config(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_namespaced_deployment_config(self):\n pass",
"def test_delete_namespaced_build_config(self):\n pass",
"def test_delete_deployment(self):\n pass",
"def test_delete_deployment_run(self):\n pass",
"def test_create_namespaced_deployment_config(self):\n ... | [
"0.8467466",
"0.79632676",
"0.7785367",
"0.757743",
"0.7543459",
"0.7534816",
"0.75088304",
"0.74550503",
"0.74096775",
"0.7394573",
"0.7235857",
"0.7165363",
"0.71062076",
"0.7095277",
"0.7013173",
"0.70034444",
"0.6999992",
"0.6992311",
"0.6853656",
"0.6845557",
"0.6845524"... | 0.94896835 | 0 |
Test case for delete_namespaced_policy | def test_delete_namespaced_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_namespaced_policy_binding(self):\n pass",
"def test_delete_collection_namespaced_policy(self):\n pass",
"def test_delete_collection_namespaced_policy_binding(self):\n pass",
"def test_delete_namespaced_egress_network_policy(self):\n pass",
"def test_delete_cluste... | [
"0.86845714",
"0.81856424",
"0.8048289",
"0.7597352",
"0.7567181",
"0.75044644",
"0.7346029",
"0.7280841",
"0.72685",
"0.7166225",
"0.69848776",
"0.6980555",
"0.6964739",
"0.6961379",
"0.69580686",
"0.6938444",
"0.6905987",
"0.6901475",
"0.68757176",
"0.6866323",
"0.68449724"... | 0.9467844 | 0 |
Test case for delete_namespaced_policy_binding | def test_delete_namespaced_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_namespaced_policy(self):\n pass",
"def test_delete_collection_namespaced_policy_binding(self):\n pass",
"def test_delete_cluster_policy_binding(self):\n pass",
"def test_delete_namespaced_role_binding_restriction(self):\n pass",
"def test_delete_namespaced_role_b... | [
"0.8768048",
"0.86476654",
"0.8012261",
"0.7836465",
"0.77335984",
"0.76803833",
"0.7663977",
"0.7607579",
"0.74020493",
"0.73987067",
"0.7191712",
"0.71706426",
"0.7153931",
"0.7119036",
"0.70290214",
"0.7027777",
"0.6841527",
"0.6837148",
"0.67969894",
"0.678719",
"0.674439... | 0.956074 | 0 |
Test case for delete_net_namespace | def test_delete_net_namespace(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_net_namespace(self):\n pass",
"def test_create_net_namespace(self):\n pass",
"def delete_namespace(node, namespace):\n cmd_timeout = 5\n cmd = f\"ip netns delete {namespace}\"\n (ret_code, _, delete_errmsg) = \\\n exec_cmd(node, cmd, time... | [
"0.81892765",
"0.76615024",
"0.76211727",
"0.7544154",
"0.72948986",
"0.725785",
"0.72547966",
"0.7164626",
"0.71542585",
"0.7076664",
"0.7026319",
"0.699504",
"0.69330263",
"0.6878476",
"0.6857322",
"0.68284273",
"0.6797996",
"0.67731583",
"0.6734245",
"0.67237914",
"0.66201... | 0.95552844 | 0 |
Test case for delete_o_auth_access_token | def test_delete_o_auth_access_token(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_o_auth_authorize_token(self):\n pass",
"def test_delete_collection_o_auth_access_token(self):\n pass",
"def test_delete_o_auth_client_authorization(self):\n pass",
"def test_delete_device_token(self):\n pass",
"def test_logout_user_with_valid_access_token(auth_cl... | [
"0.85573065",
"0.84796643",
"0.78098685",
"0.77319765",
"0.7672638",
"0.7588378",
"0.75559103",
"0.74990535",
"0.744162",
"0.7290663",
"0.72702837",
"0.70992625",
"0.70200664",
"0.6973432",
"0.6945754",
"0.6909124",
"0.6898041",
"0.6889971",
"0.6871122",
"0.6831075",
"0.68269... | 0.95635015 | 0 |
Test case for delete_o_auth_authorize_token | def test_delete_o_auth_authorize_token(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_collection_o_auth_authorize_token(self):\n pass",
"def test_delete_o_auth_access_token(self):\n pass",
"def test_delete_collection_o_auth_access_token(self):\n pass",
"def test_replace_o_auth_authorize_token(self):\n pass",
"def test_delete_o_auth_client_authoriz... | [
"0.86089015",
"0.85262555",
"0.7883491",
"0.77940357",
"0.7739321",
"0.769095",
"0.75507444",
"0.7534566",
"0.7525784",
"0.7408195",
"0.7166869",
"0.69772434",
"0.69080204",
"0.6850849",
"0.6847625",
"0.6844308",
"0.681687",
"0.68147534",
"0.676576",
"0.6696316",
"0.6686662",... | 0.9544021 | 0 |
Test case for delete_o_auth_client | def test_delete_o_auth_client(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_o_auth_client_authorization(self):\n pass",
"def test_delete_client(self):\n pass",
"def test_delete_collection_o_auth_client(self):\n pass",
"def test_delete_collection_o_auth_client_authorization(self):\n pass",
"def test_client_delete(self, mock_input, mock_pa... | [
"0.9192536",
"0.84898233",
"0.8323787",
"0.81361234",
"0.79230696",
"0.7683435",
"0.7633186",
"0.7595747",
"0.7469516",
"0.7450155",
"0.74401855",
"0.7384784",
"0.73717535",
"0.72981673",
"0.72896826",
"0.7280532",
"0.7256604",
"0.72355497",
"0.7220867",
"0.7215264",
"0.72047... | 0.94725233 | 0 |
Test case for delete_o_auth_client_authorization | def test_delete_o_auth_client_authorization(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_delete_o_auth_client(self):\n pass",
"def test_delete_collection_o_auth_client_authorization(self):\n pass",
"def test_delete_collection_o_auth_client(self):\n pass",
"def test_delete_o_auth_authorize_token(self):\n pass",
"def test_delete_client(self):\n pass",
... | [
"0.89451355",
"0.8528184",
"0.8171714",
"0.79294217",
"0.7889846",
"0.7778269",
"0.77771443",
"0.7761332",
"0.76907605",
"0.75471497",
"0.7525022",
"0.75006074",
"0.7414036",
"0.73720086",
"0.734159",
"0.72225785",
"0.7208678",
"0.7170468",
"0.7167096",
"0.71196204",
"0.71155... | 0.94621915 | 0 |
Test case for list_cluster_policy_binding | def test_list_cluster_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_read_cluster_policy_binding(self):\n pass",
"def test_list_cluster_policy(self):\n pass",
"def test_create_cluster_policy_binding(self):\n pass",
"def test_replace_cluster_policy_binding(self):\n pass",
"def test_get_hyperflex_cluster_network_policy_list(self):\n ... | [
"0.8153618",
"0.81450325",
"0.81119305",
"0.76308465",
"0.7562472",
"0.74894035",
"0.74805164",
"0.7470103",
"0.7423919",
"0.7297185",
"0.70267755",
"0.6935628",
"0.6775499",
"0.67512023",
"0.67224973",
"0.66257054",
"0.65236205",
"0.63718724",
"0.6361835",
"0.6349497",
"0.63... | 0.9420438 | 0 |
Test case for list_deployment_config_for_all_namespaces | def test_list_deployment_config_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_namespaced_deployment_config(self):\n pass",
"def test_create_deployment_config_for_all_namespaces(self):\n pass",
"def test_list_build_config_for_all_namespaces(self):\n pass",
"def test_read_namespaced_deployment_config(self):\n pass",
"def test_read_namespaced_d... | [
"0.8668477",
"0.8299942",
"0.82171994",
"0.749131",
"0.74072593",
"0.7384879",
"0.7056545",
"0.6994429",
"0.6850863",
"0.68157536",
"0.67718214",
"0.67692804",
"0.6719976",
"0.66842586",
"0.66662884",
"0.6643524",
"0.6637423",
"0.6521334",
"0.6507041",
"0.6419748",
"0.6418546... | 0.95935655 | 0 |
Test case for list_egress_network_policy_for_all_namespaces | def test_list_egress_network_policy_for_all_namespaces(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_namespaced_egress_network_policy(self):\n pass",
"def test_create_egress_network_policy_for_all_namespaces(self):\n pass",
"def test_read_namespaced_egress_network_policy(self):\n pass",
"def test_replace_namespaced_egress_network_policy(self):\n pass",
"def test_l... | [
"0.86914474",
"0.85695183",
"0.7528057",
"0.7213123",
"0.720596",
"0.7200696",
"0.6925456",
"0.686231",
"0.6672125",
"0.6556107",
"0.6291253",
"0.62272704",
"0.6104726",
"0.5914677",
"0.5911128",
"0.58700126",
"0.561069",
"0.5579711",
"0.5570148",
"0.55536854",
"0.54001933",
... | 0.9531447 | 0 |
Test case for list_namespaced_deployment_config | def test_list_namespaced_deployment_config(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_deployment_config_for_all_namespaces(self):\n pass",
"def test_read_namespaced_deployment_config(self):\n pass",
"def test_read_namespaced_deployment_config_status(self):\n pass",
"def test_generate_namespaced_deployment_config(self):\n pass",
"def test_list_namesp... | [
"0.8757961",
"0.8139894",
"0.791674",
"0.77280277",
"0.7694728",
"0.76167876",
"0.7598496",
"0.74982977",
"0.73754996",
"0.72179824",
"0.7180601",
"0.7107146",
"0.7105298",
"0.70936775",
"0.7046267",
"0.7045492",
"0.6736859",
"0.6517339",
"0.6429069",
"0.63816506",
"0.6360290... | 0.9377877 | 0 |
Test case for list_namespaced_egress_network_policy | def test_list_namespaced_egress_network_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_egress_network_policy_for_all_namespaces(self):\n pass",
"def test_read_namespaced_egress_network_policy(self):\n pass",
"def test_create_namespaced_egress_network_policy(self):\n pass",
"def test_replace_namespaced_egress_network_policy(self):\n pass",
"def test_c... | [
"0.87709725",
"0.8352935",
"0.8254193",
"0.8102907",
"0.80815834",
"0.796664",
"0.78044933",
"0.7487731",
"0.6074534",
"0.6018102",
"0.5671351",
"0.56184626",
"0.538118",
"0.5368046",
"0.53219557",
"0.5314506",
"0.52301663",
"0.5228623",
"0.5172541",
"0.51564616",
"0.51069677... | 0.9459662 | 0 |
Test case for list_namespaced_policy | def test_list_namespaced_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_policy_for_all_namespaces(self):\n pass",
"def test_list_namespaced_policy_binding(self):\n pass",
"def test_list_policy_binding_for_all_namespaces(self):\n pass",
"def test_read_namespaced_policy(self):\n pass",
"def test_create_policy_for_all_namespaces(self):\n ... | [
"0.8714546",
"0.8519107",
"0.7799171",
"0.77709657",
"0.74619913",
"0.7447385",
"0.72899675",
"0.7188281",
"0.6904148",
"0.6819399",
"0.67727774",
"0.6753038",
"0.6689875",
"0.66180557",
"0.6586477",
"0.65495753",
"0.65252596",
"0.65222955",
"0.65029645",
"0.64977235",
"0.649... | 0.93448126 | 0 |
Test case for list_namespaced_policy_binding | def test_list_namespaced_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_policy_binding_for_all_namespaces(self):\n pass",
"def test_list_namespaced_policy(self):\n pass",
"def test_read_namespaced_policy_binding(self):\n pass",
"def test_list_policy_for_all_namespaces(self):\n pass",
"def test_create_namespaced_policy_binding(self):\n ... | [
"0.8693679",
"0.8506472",
"0.8046588",
"0.7872489",
"0.7741329",
"0.76264966",
"0.7436308",
"0.73124427",
"0.7288537",
"0.7212066",
"0.7184775",
"0.70604086",
"0.7052414",
"0.70006096",
"0.69394535",
"0.69184786",
"0.68374836",
"0.6828275",
"0.6596421",
"0.6584391",
"0.655416... | 0.9467579 | 0 |
Test case for list_namespaced_template | def test_list_namespaced_template(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_template_for_all_namespaces(self):\n pass",
"def test_list_namespaced_build(self):\n pass",
"def test_list_namespaced_route(self):\n pass",
"def test_list_build_for_all_namespaces(self):\n pass",
"def test_list_namespaced_policy(self):\n pass",
"def test_c... | [
"0.86385757",
"0.7613358",
"0.74557674",
"0.73476434",
"0.72069955",
"0.71854657",
"0.71840733",
"0.71166986",
"0.7041801",
"0.68955433",
"0.6814159",
"0.67707205",
"0.6684124",
"0.6629291",
"0.662589",
"0.6516339",
"0.64642787",
"0.6453726",
"0.64402306",
"0.6411679",
"0.639... | 0.925227 | 0 |
Test case for list_o_auth_client_authorization | def test_list_o_auth_client_authorization(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_o_auth_client(self):\n pass",
"def test_read_o_auth_client_authorization(self):\n pass",
"def test_create_o_auth_client_authorization(self):\n pass",
"def test_csc_authorization_request_list_authlist_user(self):\n # Arrange:\n self.client.credentials(\n ... | [
"0.84907115",
"0.8119086",
"0.774851",
"0.7666535",
"0.74267125",
"0.7422302",
"0.7416622",
"0.73179334",
"0.7204115",
"0.7187676",
"0.7106088",
"0.7071051",
"0.7061799",
"0.70490015",
"0.7004367",
"0.69607735",
"0.69402236",
"0.6927734",
"0.6913884",
"0.67222506",
"0.6588893... | 0.9285005 | 0 |
Test case for patch_namespaced_deployment_config | def test_patch_namespaced_deployment_config(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_patch_namespaced_deployment_config_status(self):\n pass",
"def test_replace_namespaced_deployment_config(self):\n pass",
"def test_replace_namespaced_deployment_config_status(self):\n pass",
"def test_create_namespaced_deployment_config(self):\n pass",
"def test_generat... | [
"0.89417493",
"0.8687218",
"0.84036833",
"0.8056383",
"0.800111",
"0.78820187",
"0.78417903",
"0.76886016",
"0.7557737",
"0.7325799",
"0.7324299",
"0.729642",
"0.72839797",
"0.7277201",
"0.7093646",
"0.69340783",
"0.6879229",
"0.6847127",
"0.6841002",
"0.66998994",
"0.6617728... | 0.94663924 | 0 |
Test case for patch_namespaced_deployment_config_status | def test_patch_namespaced_deployment_config_status(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_replace_namespaced_deployment_config_status(self):\n pass",
"def test_patch_namespaced_deployment_config(self):\n pass",
"def test_read_namespaced_deployment_config_status(self):\n pass",
"def test_replace_namespaced_deployment_config(self):\n pass",
"def test_delete_na... | [
"0.87573683",
"0.8087603",
"0.80385566",
"0.71677035",
"0.6913377",
"0.6845573",
"0.6833631",
"0.6786732",
"0.6727495",
"0.66783524",
"0.66314936",
"0.66163325",
"0.65606797",
"0.65432113",
"0.6488937",
"0.6454958",
"0.6333678",
"0.6304584",
"0.61649704",
"0.59923255",
"0.588... | 0.94525826 | 0 |
Test case for patch_namespaced_route | def test_patch_namespaced_route(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_replace_namespaced_route(self):\n pass",
"def test_patch_namespaced_route_status(self):\n pass",
"def test_replace_namespaced_route_status(self):\n pass",
"def test_create_namespaced_route(self):\n pass",
"def patch_namespaced_route(self, body, namespace, name, **kwargs... | [
"0.8746831",
"0.86130023",
"0.817499",
"0.79485244",
"0.7504642",
"0.7429558",
"0.7296179",
"0.7190777",
"0.7173144",
"0.70406395",
"0.68885046",
"0.669036",
"0.6682487",
"0.66246015",
"0.6617786",
"0.65799654",
"0.6501204",
"0.64597315",
"0.6423692",
"0.6422788",
"0.63146365... | 0.9516455 | 0 |
Test case for patch_namespaced_route_status | def test_patch_namespaced_route_status(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_replace_namespaced_route_status(self):\n pass",
"def test_patch_namespaced_route(self):\n pass",
"def test_read_namespaced_route_status(self):\n pass",
"def replace_namespaced_route_status(self, body, namespace, name, **kwargs):\n\n all_params = ['body', 'namespace', 'nam... | [
"0.8806604",
"0.7780327",
"0.776012",
"0.7176817",
"0.69782203",
"0.68567294",
"0.6421145",
"0.6286344",
"0.61480236",
"0.61139196",
"0.6076105",
"0.60570097",
"0.6036684",
"0.5983171",
"0.59340554",
"0.58357316",
"0.57945913",
"0.5792366",
"0.5778844",
"0.5761386",
"0.574990... | 0.947145 | 0 |
Test case for patch_namespaced_template | def test_patch_namespaced_template(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_replace_namespaced_template(self):\n pass",
"def test_create_namespaced_processed_template(self):\n pass",
"def test_create_namespaced_template(self):\n pass",
"def patch_namespaced_template(self, body, namespace, name, **kwargs):\n\n all_params = ['body', 'namespace', 'n... | [
"0.84549844",
"0.7730883",
"0.76431817",
"0.7200317",
"0.7199513",
"0.7076575",
"0.70486087",
"0.69105726",
"0.69055986",
"0.6872885",
"0.6844818",
"0.66965157",
"0.65777063",
"0.65466386",
"0.64915144",
"0.6486524",
"0.6472401",
"0.63795507",
"0.6359112",
"0.6353963",
"0.634... | 0.941435 | 0 |
Test case for read_host_subnet | def test_read_host_subnet(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_host_subnet(self):\n pass",
"def test_create_host_subnet(self):\n pass",
"def test_replace_host_subnet(self):\n pass",
"def test_patch_host_subnet(self):\n pass",
"def test_get_subnet(self):\n self.assertEqual(\n type(self.the_client.get_subnet(su... | [
"0.83215505",
"0.7765226",
"0.72865564",
"0.7264329",
"0.72325575",
"0.7102943",
"0.70725733",
"0.6744679",
"0.67405957",
"0.668331",
"0.6677014",
"0.6595161",
"0.6460783",
"0.6399852",
"0.63536865",
"0.6345168",
"0.63303334",
"0.6282562",
"0.62656736",
"0.62243706",
"0.62087... | 0.93999827 | 0 |
Test case for read_namespaced_egress_network_policy | def test_read_namespaced_egress_network_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_namespaced_egress_network_policy(self):\n pass",
"def test_create_namespaced_egress_network_policy(self):\n pass",
"def test_replace_namespaced_egress_network_policy(self):\n pass",
"def test_delete_namespaced_egress_network_policy(self):\n pass",
"def test_patch_n... | [
"0.8479502",
"0.8312286",
"0.81959933",
"0.8013687",
"0.788059",
"0.76451063",
"0.75786984",
"0.72267693",
"0.61946094",
"0.58136886",
"0.5657824",
"0.5631801",
"0.55770653",
"0.54549116",
"0.544993",
"0.5342152",
"0.52906483",
"0.5254874",
"0.5254677",
"0.51699495",
"0.51293... | 0.93721026 | 0 |
Test case for read_namespaced_policy | def test_read_namespaced_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_read_namespaced_policy_binding(self):\n pass",
"def test_list_namespaced_policy(self):\n pass",
"def test_create_namespaced_policy(self):\n pass",
"def test_list_policy_for_all_namespaces(self):\n pass",
"def read_namespaced_policy(self, namespace, name, **kwargs):\n\n ... | [
"0.8458174",
"0.76975876",
"0.7401808",
"0.72310144",
"0.7058736",
"0.6938734",
"0.6930372",
"0.6748759",
"0.6723758",
"0.66725624",
"0.6658754",
"0.66396904",
"0.65331894",
"0.6525058",
"0.65121275",
"0.64953625",
"0.64839894",
"0.6340554",
"0.62573785",
"0.61842465",
"0.616... | 0.93138695 | 0 |
Test case for read_namespaced_policy_binding | def test_read_namespaced_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_read_namespaced_policy(self):\n pass",
"def test_list_namespaced_policy_binding(self):\n pass",
"def test_create_namespaced_policy_binding(self):\n pass",
"def test_read_namespaced_role_binding_restriction(self):\n pass",
"def test_replace_namespaced_policy_binding(self... | [
"0.8554552",
"0.78362435",
"0.7684384",
"0.7354066",
"0.7351557",
"0.72459316",
"0.71397173",
"0.71054673",
"0.708809",
"0.70825005",
"0.7077147",
"0.6974614",
"0.6867441",
"0.67314845",
"0.6658143",
"0.65882885",
"0.65640664",
"0.6513399",
"0.6246242",
"0.61868644",
"0.61835... | 0.94003093 | 0 |
Test case for replace_cluster_policy_binding | def test_replace_cluster_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_patch_cluster_policy_binding(self):\n pass",
"def test_create_cluster_policy_binding(self):\n pass",
"def test_replace_cluster_policy(self):\n pass",
"def test_delete_cluster_policy_binding(self):\n pass",
"def test_replace_cluster_role_binding(self):\n pass",
... | [
"0.8825095",
"0.83823466",
"0.82347655",
"0.79850763",
"0.7864699",
"0.777195",
"0.77688307",
"0.76552796",
"0.74235946",
"0.7259801",
"0.7178297",
"0.7133931",
"0.70231754",
"0.6948916",
"0.6942355",
"0.68618757",
"0.6825636",
"0.6820126",
"0.6692589",
"0.6601875",
"0.657180... | 0.94153637 | 0 |
Test case for replace_namespaced_deployment_config_status | def test_replace_namespaced_deployment_config_status(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_patch_namespaced_deployment_config_status(self):\n pass",
"def test_replace_namespaced_deployment_config(self):\n pass",
"def test_read_namespaced_deployment_config_status(self):\n pass",
"def test_patch_namespaced_deployment_config(self):\n pass",
"def test_delete_name... | [
"0.9077437",
"0.8093075",
"0.8090764",
"0.8012836",
"0.73361146",
"0.72328234",
"0.71699154",
"0.71106404",
"0.7076299",
"0.70643705",
"0.6807396",
"0.67077523",
"0.6545072",
"0.65230423",
"0.64710814",
"0.63409925",
"0.631678",
"0.6310832",
"0.62975526",
"0.62397736",
"0.619... | 0.9422467 | 0 |
Test case for replace_namespaced_egress_network_policy | def test_replace_namespaced_egress_network_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_patch_namespaced_egress_network_policy(self):\n pass",
"def test_create_namespaced_egress_network_policy(self):\n pass",
"def test_delete_namespaced_egress_network_policy(self):\n pass",
"def test_read_namespaced_egress_network_policy(self):\n pass",
"def test_list_name... | [
"0.8956728",
"0.8705721",
"0.84044665",
"0.83021057",
"0.8095901",
"0.7916204",
"0.7399577",
"0.71620125",
"0.6780843",
"0.63877505",
"0.60804576",
"0.60586923",
"0.6015408",
"0.59164834",
"0.5886516",
"0.57567894",
"0.573082",
"0.5694427",
"0.5681005",
"0.5635501",
"0.553573... | 0.94444555 | 0 |
Test case for replace_namespaced_image_stream_tag | def test_replace_namespaced_image_stream_tag(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_patch_namespaced_image_stream_tag(self):\n pass",
"def test_replace_namespaced_image_stream(self):\n pass",
"def test_create_namespaced_image_stream_tag(self):\n pass",
"def test_replace_namespaced_image_stream_status(self):\n pass",
"def test_read_namespaced_image_stre... | [
"0.89403737",
"0.8859994",
"0.84644556",
"0.82173675",
"0.8153144",
"0.8034805",
"0.7964295",
"0.77844036",
"0.77463096",
"0.75652725",
"0.752651",
"0.7346247",
"0.72245437",
"0.72100097",
"0.7205298",
"0.7164246",
"0.71595997",
"0.7025611",
"0.69198143",
"0.6815857",
"0.6800... | 0.94826895 | 0 |
Test case for replace_namespaced_policy | def test_replace_namespaced_policy(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_replace_namespaced_policy_binding(self):\n pass",
"def test_patch_namespaced_policy(self):\n pass",
"def test_patch_namespaced_policy_binding(self):\n pass",
"def test_create_namespaced_policy(self):\n pass",
"def test_delete_namespaced_policy(self):\n pass",
"... | [
"0.85956126",
"0.84932315",
"0.7981715",
"0.7802912",
"0.74888945",
"0.7307528",
"0.70882314",
"0.70839316",
"0.70651513",
"0.7028067",
"0.6999062",
"0.6894913",
"0.6874332",
"0.68268967",
"0.68138945",
"0.6786766",
"0.67765564",
"0.67324567",
"0.6640167",
"0.6599705",
"0.649... | 0.93145555 | 0 |
Test case for replace_namespaced_policy_binding | def test_replace_namespaced_policy_binding(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_replace_namespaced_policy(self):\n pass",
"def test_patch_namespaced_policy_binding(self):\n pass",
"def test_create_namespaced_policy_binding(self):\n pass",
"def test_patch_namespaced_policy(self):\n pass",
"def test_delete_namespaced_policy_binding(self):\n pa... | [
"0.86989194",
"0.8652881",
"0.82459605",
"0.79204464",
"0.7818484",
"0.7640414",
"0.76052934",
"0.74074817",
"0.73223156",
"0.7265056",
"0.71855193",
"0.714238",
"0.71397364",
"0.68988097",
"0.6849962",
"0.68448925",
"0.6768197",
"0.6730452",
"0.67253023",
"0.6724539",
"0.672... | 0.9406181 | 0 |
Parses the camera name from the S3 Object Key | def parse_camera_name_from_object_key(object_key):
first_parts = object_key.split("/")
return first_parts[1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _extract_bucket_key(s3_uri: str)->tuple:\n s3_regex=\"^s3://([a-z0-9.-]+)/(.*)$\"\n search =re.search(s3_regex, s3_uri)\n if search is None:\n raise Error(\"Invalid s3 uri: {}\".format(s3_uri))\n return search.groups()",
"def s3_key(self) -> pulumi.Input[str]:\n return pulumi.get(se... | [
"0.6068487",
"0.60591346",
"0.59437984",
"0.58954835",
"0.5870015",
"0.57224745",
"0.5706212",
"0.5686476",
"0.5675471",
"0.5613313",
"0.5565013",
"0.5521519",
"0.5514461",
"0.54904205",
"0.54869753",
"0.54478157",
"0.5415071",
"0.5412702",
"0.53466153",
"0.532687",
"0.531310... | 0.8231692 | 0 |
Converts a local naive date & time to a UTC Timestamp. | def convert_naive_local_to_utc_timestamp(year, month, day, hour, minutes, seconds):
pacific = pytz.timezone('America/Los_Angeles')
this_date = datetime.datetime(int(year), int(month), int(day), int(hour),
int(minutes), int(seconds))
local_dt = pacific.localize(this_date, is... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def UTCtimestampTolocal(ts, local_tz):\n t_utc = dt.datetime.fromtimestamp(ts,tz=pytz.timezone(\"UTC\"))\n t_local = t_utc.astimezone(local_tz)\n return t_local",
"def utc_timestamp(ts):\n import pandas\n\n ts = pandas.Timestamp(ts)\n if not ts.tzinfo:\n ts = ts.tz_localize(\"UTC\")\n ... | [
"0.72205764",
"0.6983059",
"0.6770738",
"0.677013",
"0.6730794",
"0.67281",
"0.6722522",
"0.67161834",
"0.6703183",
"0.66836935",
"0.65544444",
"0.6550889",
"0.6534934",
"0.6487955",
"0.6462393",
"0.64471936",
"0.64004195",
"0.63812923",
"0.6343139",
"0.6335491",
"0.63339645"... | 0.76103634 | 0 |
Calculate the gravitational delay The implementation is described in IERS Conventions [1]_, section 11.1, in particular equation (11.9). | def vlbi_grav_delay(dset):
eph = apriori.get("ephemerides", time=dset.time)
grav_delay = np.zeros(dset.num_obs)
# List of celestial bodies. Major moons are also recommended, like Titan, Ganymedes, ...
bodies = [
"mercury barycenter",
"venus barycenter",
"earth",
"moon",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_gravitation(self):\n with PhysicsEngineHarness('tests/massive-objects.json') as physics_engine:\n # In this case, the first entity is very massive and the second\n # entity should gravitate towards the first entity.\n t0 = 1\n t1 = 2\n initial ... | [
"0.68207735",
"0.6423103",
"0.6103835",
"0.60187733",
"0.59844357",
"0.59758383",
"0.59610367",
"0.5958875",
"0.5919561",
"0.5867162",
"0.5851209",
"0.58429337",
"0.5788291",
"0.5788291",
"0.5756704",
"0.5749892",
"0.5749892",
"0.5729351",
"0.57071257",
"0.56512266",
"0.56450... | 0.71809274 | 0 |
out = dense( shape=shape, init=None, paramset=None) | def dense(x, outdim, initializer=tf.glorot_uniform, bias=False, name=None):
if x.ndim == 4:
x = x.flat2d()
assert x.ndim == 2
outshape = not isinstance(outdim, int)
if outshape:
dim = [-1] + list(outdim)
outdim = np.prod(outdim)
shape = [x.dims[-1], outdim]
W = tf.get_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dense(in_layer):\n return Dense(neurons,\n kernel_initializer=initializer())(in_layer)",
"def init_dense(self, layer):\n pass",
"def dense(name, x, w=None, output_dim=128, initializer=tf.contrib.layers.xavier_initializer(), l2_strength=0.0,\n bias=... | [
"0.7653407",
"0.6918959",
"0.6870725",
"0.6866443",
"0.67675555",
"0.6675576",
"0.6606242",
"0.6437295",
"0.636316",
"0.6265649",
"0.62594026",
"0.6241238",
"0.62202615",
"0.61882836",
"0.6177038",
"0.61097765",
"0.61029375",
"0.6090636",
"0.6085418",
"0.6082854",
"0.6075049"... | 0.6904602 | 2 |
leaky_relu see also pleaky | def leaky(x, slope=0.01, name=None):
return tf.maximum(x, x*slope, name=name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_leaky_relu(g, op, block):\n\n alpha = op.attr(\"alpha\")\n x = g.get_node(op.input(\"X\")[0])\n out = _op.nn.leaky_relu(x, alpha=alpha)\n g.add_node(op.output(\"Out\")[0], out)",
"def leaky_rel(x, alpha=0.1):\r\n return tf.nn.leaky_relu(x, alpha=alpha)",
"def leaky_relu(self, x, name... | [
"0.77571315",
"0.7699009",
"0.7633883",
"0.75718963",
"0.74843746",
"0.7368186",
"0.73186827",
"0.7298966",
"0.7279396",
"0.7277081",
"0.72377855",
"0.7230744",
"0.7227955",
"0.7192606",
"0.71790683",
"0.7178993",
"0.7163494",
"0.6911991",
"0.6824623",
"0.6707451",
"0.6517727... | 0.0 | -1 |
Compute softmax values for each sets of scores in x. | def __softmax2(self, x):
e_x = np.exp(x - np.max(x))
return e_x / e_x.sum() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def softmax(self, scores):\n\n\n # for each sample, for each class ,caclulate\n # np.exp(scores) : still (n_samples, n_classes)\n\n # axis = 1\n # a00, a01, a02 as a sinlge one to perfrom np_sum\n # which is the same sample \n # sum_exp : still (n_samples, 1)\n\n # ... | [
"0.7796294",
"0.7760558",
"0.7759004",
"0.77567077",
"0.76577055",
"0.76577055",
"0.76577055",
"0.76577055",
"0.7585655",
"0.743143",
"0.7407772",
"0.73941606",
"0.7358175",
"0.73174125",
"0.72689486",
"0.72623265",
"0.72614294",
"0.7256868",
"0.723019",
"0.7214918",
"0.72017... | 0.0 | -1 |
Gets the max timestamp that was set during the latest merge. | def get_max_ingest_timestamp(self):
get_last_max_ts_config = bigquery.QueryJobConfig()
get_last_max_ts_config.use_legacy_sql = False
get_last_max_timestamp_query = self.bq_client.query(
query='SELECT max(ingestTimestamp) as max_ingest_timestamp '
'FROM `{0:s}.{1:s}.{2:s}`... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_time(self):\n return self._ll_tree_sequence.get_max_time()",
"def last_timestamp(self):\n return self._last_timestamp",
"def last_timestamp(self):\n LOGGER.debug('Getting last_timestamp as: %s', self._last_timestamp)\n return self._last_timestamp",
"def max(self):\n\n r... | [
"0.7324069",
"0.72471076",
"0.7213113",
"0.71249187",
"0.70386344",
"0.69946057",
"0.69175625",
"0.67901427",
"0.67749435",
"0.6734356",
"0.6730179",
"0.6711431",
"0.6706463",
"0.66920155",
"0.66324604",
"0.6624491",
"0.66190374",
"0.6587741",
"0.65800637",
"0.6567245",
"0.65... | 0.75948834 | 0 |
Sets the theta range of the wind rose plot. | def set_thetarng(self, trng=(0., 360.), subplot_index=(0,)):
if self.axes is not None:
self.axes[subplot_index].set_thetamin(trng[0])
self.axes[subplot_index].set_thetamax(trng[1])
self.trng = trng
else:
raise RuntimeError(("Axes must be initialized before... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ChangeWindAngle(self,theta):\n self.problem.ChangeWindAngle(theta)",
"def set_range(self, **rangekwargs):\n\n if 'xrange' in rangekwargs.keys(): \n xrange = rangekwargs['xrange']\n else: \n xrange = [-50.0, 50.0] # (default)\n\n if 'yrange' in rangekwargs.key... | [
"0.6535932",
"0.5930254",
"0.58945006",
"0.58641726",
"0.5827496",
"0.57677525",
"0.56842303",
"0.5623213",
"0.5555848",
"0.55475396",
"0.5508905",
"0.5496923",
"0.5430605",
"0.53862256",
"0.5381699",
"0.5343665",
"0.53284",
"0.5323077",
"0.5322511",
"0.5319038",
"0.53141254"... | 0.4911351 | 50 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.