= rect.centery, group)\r\n return min(map(lambda sprt: sprt.rect.top, same_centerx_lower_centery), default=RESOLUTION[1])","def test_groups_group_id_get(self):\n pass","def _set_starting_point_metadata(\n self,\n groupby: str = None,\n group: typing.Any = None,\n ) -> None:\n # check that arguments are valid\n if groupby is None or group is None:\n raise ValueError('must supply both groupby and group.')\n\n # set starting points as the designated positions in the \n # position field\n bidx = self.vadata.obs[groupby] == group\n print(f'Found {sum(bidx)} points matching starting criteria.')\n self.starting_points = self.pfield[bidx, :]\n return","def _get_target_group(self):\n return self.__target_group","def _get_target_group(self):\n return self.__target_group","def _get_target_group(self):\n return self.__target_group","def _get_target_group(self):\n return self.__target_group","def _get_target_group(self):\n return self.__target_group","def _get_target_group(self):\n return self.__target_group","def get_gps_data(i):\n info = i._getexif()\n exif_data={}\n lat = np.nan\n lon = np.nan\n alt = np.nan\n for tag, value in info.items():\n decoded = TAGS.get(tag, tag)\n if decoded == \"GPSInfo\":\n gps_data = {}\n for t in value:\n sub_decoded = GPSTAGS.get(t, t)\n gps_data[sub_decoded] = value[t]\n\n lat,lon,alt=latlon_from_gps_data(gps_data)\n\n return lat,lon,alt","def create_lod_groups(lod_dict, name='LOD_grp'):\n geo_lod_list = list()\n cmds.select(clear=True)\n for lod, lod_geo in lod_dict.items():\n for geo in lod_geo:\n if cmds.listRelatives(geo, parent=True):\n cmds.parent(geo, world=True)\n geo_lod_list.append(lod_geo[0])\n\n if geo_lod_list:\n cmds.select(geo_lod_list)\n cmds.LevelOfDetailGroup()\n lod_grp = cmds.rename(cmds.ls(selection=True)[0], name)\n for lod, lod_geo in lod_dict.items():\n if len(lod_geo) > 1:\n lod_parent = cmds.listRelatives(lod_geo[0], parent=True)\n if lod_parent:\n cmds.parent(lod_geo[1:], lod_parent[0])\n return lod_grp","def get_group(self, predictions):\n top_n = helpers.get_top_n(predictions, 1, threshold=0.05)\n\n if top_n:\n top = top_n[0]\n if prediction_index_in_set(top[0], self.dogs):\n return \"Dog\", top[1]\n elif prediction_index_in_set(top[0], self.cats):\n return \"Cat\", top[1]\n\n return None","def _parse_groupped_data(self):\n for i, val in enumerate(self.values.keys()):\n xy = self.values[val]\n self._set_and_get(\"x_\", val, xy[:, 0])\n self._set_and_get(\"y_\", val, xy[:, 1])","def geo_proximity_locations(self) -> Optional[Sequence['outputs.GetTrafficPolicyDocumentRuleGeoProximityLocationResult']]:\n return pulumi.get(self, \"geo_proximity_locations\")","def test_groups_get(self):\n pass","def test_groups_get(self):\n pass","def customer_group_get_related(group_id):\n db_conn = DB_Conn()\n db = db_conn.db_connect()\n\n query = \"\"\"\n SELECT \n `group_id`,\n `group_name`,\n `description`,\n `timestamp`,\n `created_by`,\n `creation_time`,\n `is_deleted`,\n `updated_by`,\n `role_id`,\n `is_default`,\n `is_customer`,\n `company_name`,\n `company_address`,\n `company_telephone`,\n `company_fax`,\n `company_website`,\n `company_sales_contact`,\n `company_purchase_contact`,\n `company_business`,\n `company_business_type`,\n `company_sales_email`,\n `company_purchase_email`,\n `company_reg_number`,\n `company_vat_number` \n FROM `groups` \n WHERE `groups`.`company_name` = (\n SELECT `asshole`.`company_name` \n FROM \n (\n SELECT * \n FROM `groups` \n WHERE `group_id` = \"%s\"\n ) AS `asshole`\n )\n \"\"\" %(group_id)\n \n group_details = None\n cursor = db.cursor()\n\n if cursor.execute(query) != 0:\n group_details = cursor.fetchall()\n\n cursor.close()\n db.close()\n\n return group_details","def __get_gps_location(self):\n\n pos = {'alt_ft': None, 'error': False, 'lat': None, 'lon': None, 'lock': False}\n\n gpsd.connect(host=self.__gpsd_host, port=self.__gpsd_port)\n\n try:\n packet = gpsd.get_current()\n if packet.mode >= 2:\n pos['lock'] = True\n pos['lat'] = packet.lat\n pos['lon'] = packet.lon\n if packet.mode >= 3:\n pos['alt_ft'] = packet.alt\n except UserWarning:\n pos['error'] = True\n pos['lock'] = False\n\n return pos","def get_all_locations(self):","def test_RNA_position_placement(self):\n \n \n tool = pybedtools.create_interval_from_list(\"chr1 50 60 ENSMUSG1_1_83;ENSMUSG1_6_83 0 + 60 60\".split())\n location_dict = {\"ENSMUSG1\" : {\"strand\" : \"+\", \"regions\" : [(0,100),\n ] \n }\n }\n \n self.assertEqual(RNA_position(tool, location_dict), (.60, .60))\n \n tool = pybedtools.create_interval_from_list(\"chr1 50 60 ENSMUSG1_1_83;ENSMUSG1_6_83 0 - 60 60\".split())\n location_dict = {\"ENSMUSG1\" : {\"strand\" : \"-\", \"regions\" : [(0,100),\n ] \n }\n }\n \n #individual_fraction, total_fraction\n self.assertEqual(RNA_position(tool, location_dict), (.4, .4))","def get_group_details(self, group_id):\n url = self.groups_url + \"/\" + group_id\n return requests.get(url, headers=self.headers)","def getRC(self, group):\n\n if self.arrangement is None:\n raise ValueError(\"specifying a group requires an arrangment dictionary\")\n # look for the group label in the arrangement dicts\n for c, colname in enumerate(self.arrangement.keys()):\n if group in self.arrangement[colname]:\n # print ('column name, column: ', colname, self.arrangement[colname])\n # print ('group: ', group)\n r = self.arrangement[colname].index(\n group\n ) # get the row position this way\n return self.axarr[r, c]\n print(\"Group {:s} not in the arrangement\".format(group))\n return None\n\n # sizer = {'A': {'pos': [0.08, 0.22, 0.50, 0.4]}, 'B1': {'pos': [0.40, 0.25, 0.60, 0.3]}, 'B2': {'pos': [0.40, 0.25, 0.5, 0.1]},\n # 'C1': {'pos': [0.72, 0.25, 0.60, 0.3]}, 'C2': {'pos': [0.72, 0.25, 0.5, 0.1]},\n # 'D': {'pos': [0.08, 0.25, 0.1, 0.3]}, 'E': {'pos': [0.40, 0.25, 0.1, 0.3]}, 'F': {'pos': [0.72, 0.25, 0.1, 0.3]},\n # }","def get_placement(nodes_list, sf_list):\n placement = defaultdict(list)\n for node in nodes_list:\n placement[node] = sf_list\n return placement","def groups(self):\n\n\t\tprint \"completed minimization\"\n\t\tcopy(self.rootdir+'counterions-minimized.gro',self.rootdir+'system.gro')\n\t\tcopy(self.rootdir+'counterions.top',self.rootdir+'system.top')\n\t\tif self.simscale == 'aamd': grouptype = 'standard'\n\t\tif self.simscale == 'cgmd': grouptype = 'cgmd_water'\n\t\tself.grouping(grouptype=grouptype)"],"string":"[\n \"def proximity_placement_group_id(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"proximity_placement_group_id\\\")\",\n \"def get_proximity_placement_group(include_colocation_status: Optional[str] = None,\\n proximity_placement_group_name: Optional[str] = None,\\n resource_group_name: Optional[str] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetProximityPlacementGroupResult:\\n __args__ = dict()\\n __args__['includeColocationStatus'] = include_colocation_status\\n __args__['proximityPlacementGroupName'] = proximity_placement_group_name\\n __args__['resourceGroupName'] = resource_group_name\\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\\n __ret__ = pulumi.runtime.invoke('azure-native:compute/v20230301:getProximityPlacementGroup', __args__, opts=opts, typ=GetProximityPlacementGroupResult).value\\n\\n return AwaitableGetProximityPlacementGroupResult(\\n availability_sets=pulumi.get(__ret__, 'availability_sets'),\\n colocation_status=pulumi.get(__ret__, 'colocation_status'),\\n id=pulumi.get(__ret__, 'id'),\\n intent=pulumi.get(__ret__, 'intent'),\\n location=pulumi.get(__ret__, 'location'),\\n name=pulumi.get(__ret__, 'name'),\\n proximity_placement_group_type=pulumi.get(__ret__, 'proximity_placement_group_type'),\\n tags=pulumi.get(__ret__, 'tags'),\\n type=pulumi.get(__ret__, 'type'),\\n virtual_machine_scale_sets=pulumi.get(__ret__, 'virtual_machine_scale_sets'),\\n virtual_machines=pulumi.get(__ret__, 'virtual_machines'),\\n zones=pulumi.get(__ret__, 'zones'))\",\n \"def get(self, group_id=None):\\n utils.check_group_id_in_req(group_id)\\n #group_id = int(group_id)\\n _check_group_exists(group_id)\\n (process_id, ip_addr) = GID_COORD_DICT[group_id]\\n response = {constants.COORD_PID_KEY: process_id,\\n constants.COORD_IP_KEY: ip_addr}\\n return response\",\n \"def CreateLocationByProximityQuery(self):\\n self.CenterPoint = self.randomGenerator.CreateRandomLattitudeLongitude()\\n self.SearchDistanceMiles = self.randomGenerator.CreateRandomNumber(self.minDistanceMiles,self.maxDistanceMiles)\\n self.SearchDistanceMeters = GeoConversion.ConvertMilesToMeters(self.SearchDistanceMiles)\\n QueryParameterDic = {}\\n QueryParameterDic['SearchType'] ='LocationByProximity'\\n QueryParameterDic['MaxResults'] = self.maxSearchResults\\n QueryParameterDic['MaxDistanceMeters'] = GeoConversion.ConvertMilesToMeters(self.SearchDistanceMiles)\\n QueryParameterDic['CenterPt'] = self.CenterPoint\\n QueryParameterDic['HasShopsOnly'] = 'True'\\n QueryParameterDic['FilterByTrueDistance'] = 'True'\\n\\n # Get a list of GpGridCells to search\\n gpSearch = GpSearch()\\n gpSearch.MaxSearchCellCount = self.MaxSearchCellCount\\n centerGpPoint = GpPoint(self.CenterPoint[0],self.CenterPoint[1])\\n gpSearch.ComputeSearchListForMetersProximity(centerGpPoint,self.SearchDistanceMeters)\\n self.FinalSearchResolution = gpSearch.FinalSearchResolution\\n self.SearchGpGridCells = gpSearch.SearchCellList\\n\\n QueryParameterDic['SearchGridCells'] = self.SearchGpGridCells\\n return QueryParameterDic\",\n \"async def position_info(request):\\n return web.json_response({\\n 'positions': {\\n 'change_pipette': {\\n 'target': 'mount',\\n 'left': (300, 40, 30),\\n 'right': (95, 40, 30)\\n },\\n 'attach_tip': {\\n 'target': 'pipette',\\n 'point': (200, 90, 150)\\n }\\n }\\n })\",\n \"def parse_detail(self, response):\\n self.lat = response.xpath(\\\"//meta[@name='geo.position']/@content\\\").get().split(\\\";\\\")[1]\\n self.lon = response.xpath(\\\"//meta[@name='geo.position']/@content\\\").get().split(\\\";\\\")[0]\",\n \"def get_position(self, position):\",\n \"def pid_gid(p):\\n return (p['iOrder'], p['iGroup'])\",\n \"def intent(self) -> Optional['outputs.ProximityPlacementGroupPropertiesResponseIntent']:\\n return pulumi.get(self, \\\"intent\\\")\",\n \"def test_get_group(self):\\n pass\",\n \"def getSearchSpaceCoords(self):\",\n \"def get_terrapos_position():\\n dset = parsers.parse_key(\\\"terrapos_output_position\\\").as_dataset()\\n dset.add_time(\\\"time\\\", val=dset.gpsweek, val2=dset.gpssec, scale=\\\"gps\\\", fmt=\\\"gps_ws\\\")\\n dset.add_position(\\\"site_pos\\\", time=\\\"time\\\", itrs=_get_site_pos(dset))\\n\\n return dset\",\n \"def print_item(group):\\n print(\\\"\\\\tName: {}\\\".format(group.name))\\n print(\\\"\\\\tId: {}\\\".format(group.id))\\n if hasattr(group, 'location'):\\n print(\\\"\\\\tLocation: {}\\\".format(group.location))\\n print_properties(getattr(group, 'properties', None))\",\n \"def get_place_city_by_group_id(self, num1:int, num2:int):\\n try:\\n self.cursor.execute(\\\"with tab1 as ( \\\" \\n\\t \\\"select fest_id from group_list\\\"\\n\\t f\\\" where group_id between {num1} and {num2} ), \\\"\\n \\\"tab2 as (select place_id from festivals\\\"\\n\\t \\\" where id in (select fest_id from tab1))\\\"\\n \\\" select places.* from places, tab2 where id=tab2.place_id\\\")\\n self.connection.commit()\\n result = self.cursor.fetchall()\\n return result\\n except(Exception, psycopg2.Error) as error:\\n self.connect.rollback()\\n print(\\\"error\\\", error)\",\n \"def distance_group(record):\\n perm_dist = int((record[\\\"Perm_km\\\"]).strip(\\\" km\\\").strip(\\\"K\\\"))\\n next_bigger = \\\"up\\\"\\n for distance in [1200, 1000, 600, 400, 300, 200, 100]:\\n if perm_dist >= distance:\\n return distance, next_bigger\\n next_bigger = distance - 1\\n return distance, next_bigger\",\n \"def get_pd_info():\\n pd_info = browser.find_element_by_class_name(\\\"pd_info\\\")\\n h1 = pd_info.find_element_by_class_name(\\\"biggest_hed\\\").get_property(\\\"innerHTML\\\")\\n second_label = pd_info.find_element_by_class_name(\\\"second_label\\\").get_property(\\n \\\"innerHTML\\\"\\n )\\n patrol_area = (\\n pd_info.find_element_by_class_name(\\\"town_description\\\")\\n .find_element_by_class_name(\\\"left\\\")\\n .find_element_by_class_name(\\\"town_label\\\")\\n .get_property(\\\"innerHTML\\\")\\n )\\n\\n return (h1, second_label, patrol_area)\",\n \"def get_group(self, address):\\n return self.groups[address]\",\n \"def search_for_molgroup_by_coords(coords, target):\\n\\n x = coords[0]\\n y = coords[1]\\n z = coords[2]\\n\\n limit_list = []\\n\\n for coord in x, y, z:\\n lower, upper = get_coord_limits(coord)\\n limit_list.append([lower, upper])\\n\\n search = MolGroup.objects.filter(target_id__title=target, x_com__gte=limit_list[0][0], x_com__lte=limit_list[0][1],\\n y_com__gte=limit_list[1][0], y_com__lte=limit_list[1][1],\\n z_com__gte=limit_list[2][0],\\n z_com__lte=limit_list[2][1])\\n\\n if len(search) == 1:\\n mol_group = search[0]\\n else:\\n return None\\n\\n return mol_group\",\n \"def map(self):\\n return self.map_digis(self.group)\",\n \"def __getitem__(self, index):\\n group = self.groups[index]\\n return self.get_x_y(group)\",\n \"def get_gps_details(img):\\n gpsinfo = {}\\n exif = {TAGS[k]: v for k, v in img._getexif().items() if k in TAGS}\\n for item in exif['GPSInfo'].keys():\\n name = GPSTAGS.get(item, item)\\n gpsinfo[name] = exif['GPSInfo'][item]\\n return gpsinfo\",\n \"def basicGetPointsGeodesic(self):\\n\\n # more geodesic, distance=2 (complicated because random)\\n data = numpy.array([[0, 1, 1, 1, 2, 2, 2, 0],\\n [0, 1, 1, 1, 2, 2, 2, 0],\\n [0, 1, 1, 1, 2, 2, 2, 0]])\\n labels = Labels(data=data)\\n result = labels.getPoints(ids=[1], mode='geodesic', distance=2, \\n connectivity=1)\\n result = result.tolist()\\n if len(result) == 5:\\n desired = [[0, 1], [0, 3], [1, 2], [2, 1], [2, 3]]\\n elif len(result) == 4:\\n desired = [[0, 2], [1, 1], [1, 3], [2, 2]]\\n elif len(result) == 3:\\n if [1, 2] in result:\\n if [0, 1] in result:\\n desired = [[0, 1], [1, 2], [2, 3]] \\n elif [0, 3] in result:\\n desired = [[0, 3], [1, 2], [2, 1]]\\n elif [0, 1] in result:\\n if [0, 3] in result:\\n desired = [[0, 1], [0, 3], [2, 2]]\\n elif [2, 1] in result:\\n desired = [[0, 1], [2, 1], [1, 3]]\\n else:\\n desired = [[0, 1], [1, 3], [2, 2]]\\n elif [2, 3] in result:\\n if [0, 3] in result:\\n desired = [[0, 3], [1, 1], [2, 3]]\\n elif [2, 1] in result:\\n desired = [[0, 2], [2, 1], [2, 3]]\\n else:\\n desired = [[2, 3], [1, 1], [0, 2]] \\n elif [0, 3] in result:\\n desired = [[0, 3], [1, 1], [2, 2]]\\n elif [2, 1] in result:\\n desired = [[2, 1], [1, 3], [0, 2]]\\n for des in desired:\\n np_test.assert_equal(des in result, True)\\n for res in result:\\n np_test.assert_equal(res in desired, True)\\n\\n # mode geodesic, distance=3, inset\\n labels = Labels(data=data[1:3, 2:8])\\n labels.setInset([slice(1, 3), slice(2, 8)])\\n result = labels.getPoints(ids=[2], mode='geodesic', distance=3, \\n connectivity=1)\\n result = result.tolist()\\n if len(result) == 1:\\n np_test.assert_equal(result[0][1], 5)\\n elif len(result) == 2:\\n desired = []\\n if [1, 4] in result:\\n desired = [[1, 4], [2, 6]]\\n elif [2, 4] in result:\\n desired = [[2, 4], [1, 6]]\\n for des in desired: \\n np_test.assert_equal(des in result, True)\\n for res in result:\\n np_test.assert_equal(res in desired, True)\",\n \"def GetGps(data):\\n\\n lat_dms = data['GPS GPSLatitude'].values\\n long_dms = data['GPS GPSLongitude'].values\\n latitude = DmsToDecimal(lat_dms[0].num, lat_dms[0].den,\\n lat_dms[1].num, lat_dms[1].den,\\n lat_dms[2].num, lat_dms[2].den)\\n longitude = DmsToDecimal(long_dms[0].num, long_dms[0].den,\\n long_dms[1].num, long_dms[1].den,\\n long_dms[2].num, long_dms[2].den)\\n if data['GPS GPSLatitudeRef'].printable == 'S': latitude *= -1\\n if data['GPS GPSLongitudeRef'].printable == 'W': longitude *= -1\\n altitude = None\\n direction = None\\n\\n try:\\n alt = data['GPS GPSAltitude'].values[0]\\n altitude = alt.num/alt.den\\n if data['GPS GPSAltitudeRef'] == 1: altitude *= -1\\n\\n except KeyError:\\n altitude = 0\\n \\n try:\\n direction = data['GPS GPSImgDirection'].values[0]\\n direction = float(direction.num/direction.den)\\n\\n except KeyError:\\n direction = 0\\n \\n return latitude, longitude, altitude, direction\",\n \"def __get_addr_grp(self, objtype, address=None):\\n if address is not None:\\n return self.get(\\\"/%s/entry[@name='%s']\\\"%(objtype, address))\\n else:\\n return self.get(\\\"/%s/entry\\\"%objtype)\",\n \"def get_pingroups(self):\\n return self.groups[:]\",\n \"def select_point_from_group(group, pts):\\n\\n p_in_group = []\\n\\n for i in range(len(group)):\\n p_in_group.append(pts[group[i]])\\n \\n return p_in_group\",\n \"def select_point_from_group(group, pts):\\n\\n p_in_group = []\\n\\n for i in range(len(group)):\\n p_in_group.append(pts[group[i]])\\n \\n return p_in_group\",\n \"def get_profile_data(self, transceiver, placement):\",\n \"def get_info(self):\\r\\n return np.array([self.ypos, self.xpos, self.radius, self.count_sum, self.bg_galaxy, self.no_count])\",\n \"def get(self):\\n # TODO: Cannot just return the dict, because it will not include the labels/keys in the response\\n return GID_COORD_DICT\",\n \"def getTargetPositions(rg):\\n targetPositions = OrderedDict()\\n for r in rg.robotDict.values():\\n x, y, z = r.metFiberPos\\n targetPositions[r.id] = [x, y]\\n return targetPositions\",\n \"def placement_group(template, name):\\n p = PlacementGroup(name, template=template)\\n p.Strategy = 'cluster'\\n return p\",\n \"def get_address_group(addressgroup=None, vsys=\\\"1\\\"):\\n query = {\\n \\\"type\\\": \\\"config\\\",\\n \\\"action\\\": \\\"get\\\",\\n \\\"xpath\\\": (\\n \\\"/config/devices/entry[@name='localhost.localdomain']/vsys/entry[@name='vsys{}']/\\\"\\n \\\"address-group/entry[@name='{}']\\\".format(vsys, addressgroup)\\n ),\\n }\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def groups(self):\\n #return self.get('{}/groups'.format(ApiVersion.A1.value))\\n return self.get('{}/groups'.format(ApiVersion.CM1.value))\",\n \"def _get_group(self, x, y, traversed):\\n loc = self[x, y]\\n\\n # Get surrounding locations which have the same color and whose\\n # coordinates have not already been traversed\\n locations = [\\n (p, (a, b))\\n for p, (a, b) in self._get_surrounding(x, y)\\n if p is loc and (a, b) not in traversed\\n ]\\n\\n # Add current coordinates to traversed coordinates\\n traversed.add((x, y))\\n\\n # Find coordinates of similar neighbors\\n if locations:\\n return traversed.union(*[\\n self._get_group(a, b, traversed)\\n for _, (a, b) in locations\\n ])\\n else:\\n return traversed\",\n \"def get_group_atoms(self, group_name):\\r\\n return self.groups[group_name].getAtoms()\",\n \"def locator(pcap_obj,kml_file):\\r\\n ip_list = []\\r\\n for ts, buf in pcap_obj:\\r\\n eth = dpkt.ethernet.Ethernet(buf)\\r\\n ip = eth.data\\r\\n try: # extract all unique IPs\\r\\n src_ip = str(socket.inet_ntoa(ip.src))\\r\\n dst_ip = str(socket.inet_ntoa(ip.dst))\\r\\n if src_ip in ip_list:\\r\\n pass\\r\\n else:\\r\\n ip_list.append(src_ip)\\r\\n if dst_ip in ip_list:\\r\\n pass\\r\\n else:\\r\\n ip_list.append(dst_ip)\\r\\n except AttributeError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n reader = geoip2.database.Reader('GeoLite2-City_20190129.mmdb') # reading from db(can be redacted)\\r\\n except FileNotFoundError:\\r\\n print(f'[!]DB file not in current directory or with a different file name')\\r\\n sys.exit(1)\\r\\n area = []\\r\\n longitude = []\\r\\n latitude = []\\r\\n ips = []\\r\\n for ip_addr in ip_list:\\r\\n try:\\r\\n rec = reader.city(ip_addr) # reading IP\\r\\n country = rec.country.iso_code # assigning country and city\\r\\n city = rec.city.name\\r\\n if city is None and country is None:\\r\\n area.append('Unknown')\\r\\n elif city is None:\\r\\n area.append(f'Unknown city:{country}') # looking for unknown country\\r\\n elif country is None:\\r\\n area.append(f'Unknown country:{city}') # looking for unknown city\\r\\n else:\\r\\n area.append(f'{city} {country}')\\r\\n\\r\\n longitude.append(rec.location.longitude)\\r\\n latitude.append(rec.location.latitude)\\r\\n ips.append(ip_addr)\\r\\n except geoip2.errors.AddressNotFoundError:\\r\\n pass\\r\\n\\r\\n try:\\r\\n kml = simplekml.Kml()\\r\\n final_path = str(os.getcwd() + os.sep + kml_file) # defining full canonical path\\r\\n for i in range(0, len(ips)):\\r\\n kml.newpoint(name=(area[i]),\\r\\n coords=[(longitude[i], latitude[i])],\\r\\n description=f'[+] Location = {area[i]}\\\\n IP: {ips[i]}')\\r\\n kml.save(final_path)\\r\\n print(f\\\"[+] Writing IP locations to {kml_file}\\\") # writing data to a KML file\\r\\n print(f\\\"[+] Opening Google Earth with:{kml_file}\\\\n\\\") # reading file with google earth\\r\\n try:\\r\\n os.startfile(final_path)\\r\\n except OSError:\\r\\n print(f'[!] Warning: Google Earth must be installed to open the kml')\\r\\n except FileNotFoundError:\\r\\n pass\",\n \"def extractCoords(self):\\n if not self.rank:\\n logging.info('Extracting atomic poitions')\\n\\n # Extract coordinates from liggghts\\n self.lmp.command('variable x atom x')\\n x = Rxn.lmp.extract_variable(\\\"x\\\", \\\"group1\\\", 1)\\n\\n self.lmp.command('variable y atom y')\\n y = Rxn.lmp.extract_variable(\\\"y\\\", \\\"group1\\\", 1)\\n\\n self.lmp.command('variable z atom z')\\n z = Rxn.lmp.extract_variable(\\\"z\\\", \\\"group1\\\", 1)\\n\\n coords = np.zeros((self.lmp.get_natoms(),3))\\n\\n for i in range(self.lmp.get_natoms()):\\n coords[i,:] = x[i], y[i], z[i]\\n\\n self.lmp.command('variable x delete')\\n self.lmp.command('variable y delete')\\n self.lmp.command('variable z delete')\\n\\n return coords\",\n \"def _get_site_pos(dset):\\n # TODO hjegei: Workaround -> better would it be if Position object can handle LLH as input format!!!\\n x, y, z = gnss.llh2xyz(np.deg2rad(dset.lat), np.deg2rad(dset.lon), dset.height)\\n return np.stack((x, y, z), axis=1)\",\n \"def get_nearbyPTMs(self,ID,pos, window):\\n mods = self.get_PTMs(ID)\\n modsInWin = []\\n if mods == -1:\\n return -1\\n elif len(mods)==0:\\n return []\\n else:\\n for m in mods:\\n site = int(m[0])\\n if site >= pos-window and site <= pos+window:\\n modsInWin.append(m)\\n\\n return modsInWin\",\n \"def getpos(self):\\n return self.pos.cartesianas()\",\n \"def groupId(self):\\n\\t\\treturn \\\"dem_processing\\\"\",\n \"def parse_grism_associations(exposure_groups, \\n best_direct=DIRECT_ORDER,\\n get_max_overlap=True):\\n N = len(exposure_groups)\\n \\n grism_groups = []\\n for i in range(N):\\n f_i = exposure_groups[i]['product'].split('-')[-1]\\n root_i = exposure_groups[i]['product'].split('-'+f_i)[0]\\n \\n if f_i.startswith('g'):\\n group = OrderedDict(grism=exposure_groups[i], \\n direct=None)\\n else:\\n continue\\n \\n fp_i = exposure_groups[i]['footprint']\\n olap_i = 0.\\n d_i = f_i\\n \\n #print('\\\\nx\\\\n')\\n d_idx = 10\\n for j in range(N):\\n f_j = exposure_groups[j]['product'].split('-')[-1]\\n if f_j.startswith('g'):\\n continue\\n \\n fp_j = exposure_groups[j]['footprint']\\n olap = fp_i.intersection(fp_j)\\n root_j = exposure_groups[j]['product'].split('-'+f_j)[0]\\n\\n #print(root_j, root_i, root_j == root_i)\\n if (root_j == root_i):\\n # if (group['direct'] is not None):\\n # pass\\n # if (group['direct']['product'].startswith(root_i)) & (d_i.upper() == best_direct[f_i.upper()]):\\n # continue\\n \\n if best_direct[f_i.upper()].index(f_j.upper()) < d_idx:\\n d_idx = best_direct[f_i.upper()].index(f_j.upper())\\n group['direct'] = exposure_groups[j]\\n olap_i = olap.area\\n d_i = f_j\\n #print(0,group['grism']['product'], group['direct']['product'])\\n # continue\\n \\n #print(exposure_groups[i]['product'], exposure_groups[j]['product'], olap.area*3600.)\\n \\n # #print(exposure_groups[j]['product'], olap_i, olap.area)\\n # if olap.area > 0:\\n # if group['direct'] is None:\\n # group['direct'] = exposure_groups[j]\\n # olap_i = olap.area\\n # d_i = f_j\\n # #print(1,group['grism']['product'], group['direct']['product'])\\n # else:\\n # #if (f_j.upper() == best_direct[f_i.upper()]):\\n # if get_max_overlap:\\n # if olap.area < olap_i:\\n # continue\\n # \\n # if d_i.upper() == best_direct[f_i.upper()]:\\n # continue\\n # \\n # group['direct'] = exposure_groups[j]\\n # #print(exposure_groups[j]['product'])\\n # olap_i = olap.area\\n # d_i = f_j\\n # #print(2,group['grism']['product'], group['direct']['product'])\\n \\n grism_groups.append(group)\\n \\n return grism_groups\",\n \"def post(self):\\n if not request.is_json:\\n parser = reqparse.RequestParser()\\n parser.add_argument(constants.PID_KEY, help='Process id')\\n parser.add_argument(constants.GID_KEY, help='Group id')\\n data = parser.parse_args()\\n else:\\n data = request.json\\n process_id = data[constants.PID_KEY]\\n group_id = data[constants.GID_KEY]\\n utils.check_process_id_in_req(process_id)\\n utils.check_group_id_in_req(group_id)\\n _check_group_does_not_exist(group_id)\\n GID_COORD_DICT[group_id] = (process_id, request.remote_addr)\\n response = {constants.COORD_PID_KEY: GID_COORD_DICT[group_id][0],\\n constants.COORD_IP_KEY: GID_COORD_DICT[group_id][1]}\\n return response\",\n \"def getSolventGroupFromGenion( tprfile ):\\n\\n startdir = os.getcwd()\\n tempdir = tempfile.mkdtemp() #Temporary directory\\n shutil.copy( tprfile, os.path.join( tempdir, 'tmp.tpr') ) \\n os.chdir(tempdir)\\n genion_out = commands.getoutput('echo q | genion -s tmp.tpr -np 1')\\n genion_lines = genion_out.split('\\\\n')\\n groupstr = None\\n for line in genion_lines:\\n if line[0:5] == 'Group':\\n fields = line.replace(')',' ').replace('(',' ').split()\\n if fields[2].strip() == 'SOL':\\n groupstr = fields[1]\\n break\\n if groupstr == None:\\n print genion_lines\\n raise RuntimeError('Error in getting solvent group from genion on tpr file %s (working directory %s); no solvent group found.' % (tprfile, os.getcwd()) )\\n \\n\\n shutil.rmtree(tempdir)\\n os.chdir(startdir)\\n return int(groupstr)\",\n \"def best_coords(self):\\n lat, lon = None, None\\n for term in self.terms:\\n # print(term)\\n # print(term['weight'])\\n geo = term.get(\\\"geo\\\")\\n if geo:\\n osm = geo['osm']\\n gm = geo['gm']\\n geo_data = None\\n if osm:\\n geo_data = osm\\n elif gm:\\n geo_data = gm\\n if geo_data:\\n g = geo_data[0]\\n lat, lon = g['latitude'], g['longitude']\\n break\\n return lat, lon, self.region\",\n \"def sgi(self):\\n from cctbx import sgtbx\\n if self.space_group == '':\\n sg = self.space_groups[self.centring]\\n else:\\n sg = self.space_group\\n return sgtbx.space_group_info(sg)\",\n \"def get_group(self):\\n\\t\\treturn self.variables.get('group')\",\n \"def getPosition(self, request, context): \\n \\n # The latitude and longitude are relative to the WGS84 coordinate system. \\n # The altitude is relative to mean sea-level (MSL)\\n globalLocation = str(self.vehicle.location.global_frame)\\n \\n # LocationGlobalRelative:lat=0.0,lon=0.0,alt=6.6\\n # Altitude relative to the home location. The lat and long values for this and the above\\n # variable will be the same.\\n relativeLocation = str(self.vehicle.location.global_relative_frame)\\n \\n latitude, longitude, altGPS, altHome = None, None, None, None\\n \\n match = re.search(r\\\"lat=(.*),lon=(.*),alt=(.*)$\\\", globalLocation)\\n if match:\\n latitude = match.group(1)\\n longitude = match.group(2)\\n altGPS = match.group(3)\\n \\n match = re.search(r\\\"lat=(.*),lon=(.*),alt=(.*)$\\\", relativeLocation)\\n if match:\\n altHome = match.group(3)\\n\\t\\t\\t\\n return droneconnect_pb2.Position(lat = float(latitude),\\n lon = float(longitude),\\n gpsAltitude = float(altGPS),\\n relativeAltitude = float(altHome))\",\n \"def GetDetailPlacementView(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def placement(self):\\n return self.container['placement']\",\n \"def get_free_standins(group):\",\n \"async def list_placement_groups(self, *, option: ListApiOptions) -> ListApiResponse:\\n try:\\n reply = await self._client.get_all_placement_group_info(\\n timeout=option.timeout\\n )\\n except DataSourceUnavailable:\\n raise DataSourceUnavailable(GCS_QUERY_FAILURE_WARNING)\\n\\n result = []\\n for message in reply.placement_group_table_data:\\n data = protobuf_message_to_dict(\\n message=message,\\n fields_to_decode=[\\\"placement_group_id\\\", \\\"creator_job_id\\\", \\\"node_id\\\"],\\n )\\n result.append(data)\\n num_after_truncation = len(result)\\n\\n result = self._filter(\\n result, option.filters, PlacementGroupState, option.detail\\n )\\n num_filtered = len(result)\\n # Sort to make the output deterministic.\\n result.sort(key=lambda entry: entry[\\\"placement_group_id\\\"])\\n return ListApiResponse(\\n result=list(islice(result, option.limit)),\\n total=reply.total,\\n num_after_truncation=num_after_truncation,\\n num_filtered=num_filtered,\\n )\",\n \"def get_proximity_db_detail(self, context, id):\\n zone_obj = self.dns_manager.get_proximity_db_detail(context, id)\\n return zone_obj\",\n \"def net_xy(street):\\r\\n\\r\\n # api-endpoint\\r\\n URL = \\\"https://ags.govmap.gov.il/Search/FreeSearch\\\"\\r\\n # headers\\r\\n headers = {\\\"Content-Type\\\": \\\"application/json\\\", \\\"charset\\\": \\\"utf-8\\\"}\\r\\n # location given here\\r\\n try:\\r\\n p = \\\"{\\\\\\\"keyword\\\\\\\": \\\\\\\"\\\" + street + \\\"\\\\\\\",\\\\\\\"LstResult\\\\\\\": null}\\\"\\r\\n PARAMS = p.encode(\\\"utf-8\\\")\\r\\n\\r\\n # sending get request and saving the response as response object\\r\\n r = requests.post(url=URL, data=PARAMS, headers=headers)\\r\\n\\r\\n # extracting data in json format\\r\\n data = r.json()\\r\\n\\r\\n # extracting latitude, longitude and formatted address\\r\\n # of the first matching location\\r\\n\\r\\n X = data['data']['Result'][0]['X']\\r\\n Y = data['data']['Result'][0]['Y']\\r\\n except Exception as e:\\r\\n print(e)\\r\\n # print('exception ddamammnnnnn')\\r\\n print(street)\\r\\n return 0,0\\r\\n return X,Y\",\n \"def DOM_positions(omkeys, omgeo):\\n x_list = []\\n y_list = []\\n z_list = []\\n r_list = []\\n for omkey in omkeys:\\n x_list.append(omgeo[omkey].position.x)\\n y_list.append(omgeo[omkey].position.y)\\n z_list.append(omgeo[omkey].position.z)\\n r_list.append(np.sqrt(omgeo[omkey].position.x**2 + omgeo[omkey].position.y**2))\\n returndict = {\\\"x\\\":x_list,\\\"y\\\":y_list,\\\"z\\\":z_list, \\\"r\\\":r_list}\\n return returndict\",\n \"def test_nearest_pandevice_from_device_group_in_pano_dg_fw_ao_chain(self):\\n ret_val = self.device_group.nearest_pandevice()\\n\\n self.assertEqual(self.panorama, ret_val)\",\n \"def getGroup(self):\\n\\t\\treturn self.Group\",\n \"def comm_group(self):\\n return self._gcomm\",\n \"def get_group(self, group, intg):\\n return self.data[intg, group, :, :]\",\n \"def galaxy_positions():\\n hdulist1 = pf.open(source+'/kids_data/KiDS_DR3.1_G9_ugri_shear.fits')\\n '''\\n hdulist2 = pf.open('../kids_data/KiDS_DR3.1_G12_ugri_shear.fits')\\n hdulist3 = pf.open('../kids_data/KiDS_DR3.1_G15_ugri_shear.fits')\\n hdulist4 = pf.open('../kids_data/KiDS_DR3.1_G23_ugri_shear.fits')\\n hdulist5 = pf.open('../kids_data/KiDS_DR3.1_GS_ugri_shear.fits')\\n '''\\n ra = hdulist1[1].data['RAJ2000'][:sample]\\n dec = hdulist1[1].data['DECJ2000'][:sample]\\n global maxra\\n maxra = max(ra)\\n global minra\\n minra = min(ra)\\n global maxdec\\n maxdec = max(dec)\\n global mindec\\n mindec = min(dec)\\n global bsize\\n bsize = abs(max(maxra, maxdec) - min(mindec, minra))\\n coords = np.column_stack([ra, dec])\\n global SIZE\\n SIZE = len(coords)\\n print(maxra, maxdec, minra, mindec, SIZE)\\n ctree = cKDTree(coords)\\n return ctree\",\n \"def utility_groom(self, utility_name=\\\"ALL\\\", location=None, ttl=g_config.TTL_MAX):\\n # TODO: The best approach here is to trigger the outage groom at the center of the last alarm.\\n # trigger_time = arrow.get(\\\"2015-01-09T19:42:33.689-0400\\\").timestamp*1000\\n trigger_date = arrow.utcnow().to('US/Eastern').format('YYYY-MM-DDTHH:mm:ss.SSSZ')\\n trigger_time = arrow.get(trigger_date).timestamp*1000\\n if location is None:\\n ttl = g_config.TTL_RANDOM_GROOM\\n if utility_name in self.utility_region.keys():\\n r = random.random()\\n this_lat = r * (self.utility_region[utility_name]['max_latitude'] -\\n self.utility_region[utility_name]['min_latitude']) + \\\\\\n self.utility_region[utility_name]['min_latitude']\\n r = random.random()\\n this_lon = r * (self.utility_region[utility_name]['max_longitude'] -\\n self.utility_region[utility_name]['min_longitude']) + \\\\\\n self.utility_region[utility_name]['min_longitude']\\n this_payload = self.build_groom_payload(trigger_date, utility_name, trigger_time, this_lat, this_lon, ttl)\\n self.my_local_logger.info(\\\"SEEDED %s\\\" % this_payload)\\n if this_payload is not None:\\n self.queue_to_publish(this_payload)\\n else:\\n for company in self.utility_region.keys():\\n r = random.random()\\n this_lat = r * (self.utility_region[company]['max_latitude'] -\\n self.utility_region[company]['min_latitude']) + \\\\\\n self.utility_region[company]['min_latitude']\\n r = random.random()\\n this_lon = r * (self.utility_region[company]['max_longitude'] -\\n self.utility_region[company]['min_longitude']) + \\\\\\n self.utility_region[company]['min_longitude']\\n this_payload = self.build_groom_payload(trigger_date, company, trigger_time, this_lat, this_lon, ttl)\\n self.my_local_logger.info(\\\"SEEDED %s\\\" % this_payload)\\n if this_payload is not None:\\n self.queue_to_publish(this_payload)\\n else:\\n if utility_name in self.utility_region.keys():\\n this_lat = location[\\\"lat\\\"]\\n this_lon = location[\\\"lon\\\"]\\n this_payload = self.build_groom_payload(trigger_date, utility_name, trigger_time, this_lat, this_lon,\\n ttl)\\n self.my_local_logger.info(\\\"SEEDED %s\\\" % this_payload)\\n if this_payload is not None:\\n self.queue_to_publish(this_payload)\\n else:\\n for company in self.utility_region.keys():\\n this_lat = location[\\\"lat\\\"]\\n this_lon = location[\\\"lon\\\"]\\n this_payload = self.build_groom_payload(trigger_date, company, trigger_time, this_lat, this_lon,\\n ttl)\\n self.my_local_logger.info(\\\"SEEDED %s\\\" % this_payload)\\n if this_payload is not None:\\n self.queue_to_publish(this_payload)\",\n \"def build_group(\\n location_group: str,\\n location_class: Type[Location] = Location,\\n) -> Dict[str, Location]:\\n groups = {}\\n for shape in get_shapes(location_group):\\n\\n assert shape[\\\"type\\\"] == \\\"Feature\\\"\\n\\n name = shape[\\\"properties\\\"].get(\\\"ADMIN\\\", location_group)\\n\\n location = location_class(name)\\n\\n location.alpha3code = shape[\\\"properties\\\"].get(\\\"ADM0_A3\\\")\\n\\n if location_group == \\\"country\\\":\\n location.parent = shape[\\\"properties\\\"][\\\"CONTINENT\\\"]\\n location.level = 2\\n\\n elif location_group == \\\"city\\\":\\n location.parent = shape[\\\"properties\\\"][\\\"ADM0NAME\\\"]\\n location.level = 3\\n\\n if shape[\\\"geometry\\\"][\\\"type\\\"] in (\\\"LineString\\\", \\\"Polygon\\\"):\\n\\n coordinates = numpy.array(shape[\\\"geometry\\\"][\\\"coordinates\\\"])\\n location.border_x.append(coordinates.T[0])\\n location.border_y.append(coordinates.T[1])\\n location.border_hull_x.append(None)\\n location.border_hull_y.append(None)\\n\\n elif shape[\\\"geometry\\\"][\\\"type\\\"] in (\\\"MultiPolygon\\\",):\\n for coordinates in shape[\\\"geometry\\\"][\\\"coordinates\\\"]:\\n border = numpy.array(coordinates[0])\\n location.border_x.append(border.T[0])\\n location.border_y.append(border.T[1])\\n\\n if len(coordinates) == 2:\\n hull = numpy.array(coordinates[1])\\n location.border_hull_x.append(hull.T[0])\\n location.border_hull_y.append(hull.T[1])\\n else:\\n location.border_hull_x.append(None)\\n location.border_hull_y.append(None)\\n\\n location.shape = shape\\n groups[name] = location\\n\\n return groups\",\n \"def gps_data():\\n gpsd = gps(mode=WATCH_ENABLE|WATCH_NEWSTYLE)\\n lat = 0\\n lon = 0\\n satellites = 0\\n tpv = False\\n sky = False\\n while True:\\n nx = gpsd.next()\\n if nx['class'] == 'TPV':\\n lat = getattr(nx, 'lat', 0)\\n lon = getattr(nx, 'lon', 0)\\n tpv = True\\n elif nx['class'] == 'SKY':\\n satellites = len(nx['satellites'])\\n sky = True\\n if sky and tpv:\\n return satellites, lat, lon\",\n \"def params_groups(request):\\n return np.array([-0.2, -0.1])\",\n \"def find_best_group(mdl_array, lpx, tcost_bar, contract_size, max_group_pos=20, exclude_gp=None, clip_maxpos=True, best_pos=None, best_shp=0):\\n ndays, n = lpx.shape\\n mcnt = len(mdl_array)\\n best_gp = None\\n if best_pos is None:\\n best_pos = np.zeros((ndays,n))\\n\\n best_shp0 = best_shp\\n for m, mdl_dict in enumerate(mdl_array):\\n pick_array = mdl_dict['pick']\\n for p, pick in enumerate(pick_array):\\n if exclude_gp is not None and (m,p) in exclude_gp:\\n continue\\n (k0,k1) = pick[0]\\n pos0 = best_pos.copy()\\n pos0[:,k0:k1+1]+=mdl_dict['pos_scale'][:,k0:k1+1]\\n pos00, pnl0, shp0 = pnl_from_pos_tcost(lpx, np.r_[pos0.flatten(),0], tcost_bar, max_group_pos, contract_size, clip_maxpos=clip_maxpos)\\n\\n # recover the original k0k1 position. i.e. from model_dict['pos_scale']\\n pos0-=best_pos\\n if shp0>best_shp0:\\n print(' best shp update - ', m, p, '(%d,%d) shp:%f pnl:%f'%(k0,k1,shp0,np.sum(pnl0)))\\n best_shp0 = shp0\\n best_gp0 = (m,p)\\n best_pos0 = pos0.copy()\\n best_pnl = pnl0.copy()\\n dshp = best_shp0-best_shp\\n if dshp == 0:\\n print('Nothing beats the given, fold')\\n return None, None, None, None\\n\\n print('PICK: ', best_gp0, best_shp0, np.sum(best_pnl))\\n return best_gp0, best_pos0, best_pnl, best_shp0\",\n \"def test_groups_group_ref_get(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"def print_item(group):\\n print(\\\"\\\\tName: {}\\\".format(group.name))\\n print(\\\"\\\\tId: {}\\\".format(group.id))\\n print(\\\"\\\\tLocation: {}\\\".format(group.location))\\n print(\\\"\\\\tTags: {}\\\".format(group.tags))\\n if hasattr(group, 'properties'):\\n print_properties(group.properties)\",\n \"def print_item(group):\\n print(\\\"\\\\tName: {}\\\".format(group.name))\\n print(\\\"\\\\tId: {}\\\".format(group.id))\\n print(\\\"\\\\tLocation: {}\\\".format(group.location))\\n print(\\\"\\\\tTags: {}\\\".format(group.tags))\\n if hasattr(group, 'status'):\\n print(\\\"\\\\tStatus: {}\\\".format(group.status))\\n if hasattr(group, 'state'): # Site\\n print(\\\"\\\\tStatus: {}\\\".format(group.state))\\n if hasattr(group, 'properties'):\\n print_properties(group.properties)\\n print(\\\"\\\\n\\\\n\\\")\",\n \"def proximity(self) -> 'outputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximity':\\n return pulumi.get(self, \\\"proximity\\\")\",\n \"def find_gpas(s):\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def get_gtf_region_position_info(region_gtf_pr):\\n ## Check if region has no features\\n if region_gtf_pr.empty:\\n return dict()\\n\\n gene_info_dict = dict()\\n for name, group in region_gtf_pr.df.groupby(\\\"transcript_id\\\"):\\n for row in group.itertuples():\\n\\n ## Add Transcript Info\\n if row.Feature == \\\"transcript\\\":\\n\\n if row.gene_id not in gene_info_dict:\\n gene_info_dict[row.gene_id] = dict()\\n if row.transcript_id not in gene_info_dict[row.gene_id]:\\n gene_info_dict[row.gene_id][row.transcript_id] = {\\\"exons\\\": []}\\n\\n gene_info_dict[row.gene_id][row.transcript_id][\\\"chrom\\\"] = row.Chromosome\\n gene_info_dict[row.gene_id][row.transcript_id][\\\"start\\\"] = row.Start\\n gene_info_dict[row.gene_id][row.transcript_id][\\\"end\\\"] = row.End\\n gene_info_dict[row.gene_id][row.transcript_id][\\n \\\"gene_symbol\\\"\\n ] = row.gene_name\\n gene_info_dict[row.gene_id][row.transcript_id][\\n \\\"biotype\\\"\\n ] = row.gene_type\\n gene_info_dict[row.gene_id][row.transcript_id][\\\"strand\\\"] = row.Strand\\n\\n ## Add exon feature info\\n elif row.Feature == \\\"exon\\\":\\n\\n if row.gene_id not in gene_info_dict:\\n gene_info_dict[row.gene_id] = dict()\\n if row.transcript_id not in gene_info_dict[row.gene_id]:\\n gene_info_dict[row.gene_id][row.transcript_id] = {\\\"exons\\\": []}\\n\\n gene_info_dict[row.gene_id][row.transcript_id][\\\"exons\\\"].append(\\n {\\\"start\\\": row.Start, \\\"end\\\": row.End, \\\"exon_number\\\": row.exon_number}\\n )\\n\\n return gene_info_dict\",\n \"def ground_contact_geoms(self):\\n raise NotImplementedError\",\n \"def get_lat_lng(self):\\n self.input_api = '%20'.join(self.parsed_question)\\n self.input_api = ' '.join(self.parsed_question)\\n self.google_api_url = 'https://maps.googleapis.com/maps/api/place/findplacefromtext/json?input={}&inputtype=textquery&fields=geometry,name,place_id&types=point_of_interest&key={}'.format (self.input_api, api_key) \\n self.r = requests.get(url=self.google_api_url)\\n self.data = self.r.json()\\n self.name = self.data['candidates'][0]['name']\\n self.place_id = self.data['candidates'][0]['place_id']\\n self.lat = self.data['candidates'][0]['geometry']['location']['lat']\\n self.lng = self.data['candidates'][0]['geometry']['location']['lng']\\n print(self.lat, self.lng, self.place_id)\\n return (self.lat, self.lng, self.place_id)\",\n \"def group_top(group: pygame.sprite.Group, rect: pygame.Rect):\\r\\n same_centerx_lower_centery = filter(lambda sprt: sprt.rect.centerx == rect.centerx\\r\\n and sprt.rect.centery >= rect.centery, group)\\r\\n return min(map(lambda sprt: sprt.rect.top, same_centerx_lower_centery), default=RESOLUTION[1])\",\n \"def test_groups_group_id_get(self):\\n pass\",\n \"def _set_starting_point_metadata(\\n self,\\n groupby: str = None,\\n group: typing.Any = None,\\n ) -> None:\\n # check that arguments are valid\\n if groupby is None or group is None:\\n raise ValueError('must supply both groupby and group.')\\n\\n # set starting points as the designated positions in the \\n # position field\\n bidx = self.vadata.obs[groupby] == group\\n print(f'Found {sum(bidx)} points matching starting criteria.')\\n self.starting_points = self.pfield[bidx, :]\\n return\",\n \"def _get_target_group(self):\\n return self.__target_group\",\n \"def _get_target_group(self):\\n return self.__target_group\",\n \"def _get_target_group(self):\\n return self.__target_group\",\n \"def _get_target_group(self):\\n return self.__target_group\",\n \"def _get_target_group(self):\\n return self.__target_group\",\n \"def _get_target_group(self):\\n return self.__target_group\",\n \"def get_gps_data(i):\\n info = i._getexif()\\n exif_data={}\\n lat = np.nan\\n lon = np.nan\\n alt = np.nan\\n for tag, value in info.items():\\n decoded = TAGS.get(tag, tag)\\n if decoded == \\\"GPSInfo\\\":\\n gps_data = {}\\n for t in value:\\n sub_decoded = GPSTAGS.get(t, t)\\n gps_data[sub_decoded] = value[t]\\n\\n lat,lon,alt=latlon_from_gps_data(gps_data)\\n\\n return lat,lon,alt\",\n \"def create_lod_groups(lod_dict, name='LOD_grp'):\\n geo_lod_list = list()\\n cmds.select(clear=True)\\n for lod, lod_geo in lod_dict.items():\\n for geo in lod_geo:\\n if cmds.listRelatives(geo, parent=True):\\n cmds.parent(geo, world=True)\\n geo_lod_list.append(lod_geo[0])\\n\\n if geo_lod_list:\\n cmds.select(geo_lod_list)\\n cmds.LevelOfDetailGroup()\\n lod_grp = cmds.rename(cmds.ls(selection=True)[0], name)\\n for lod, lod_geo in lod_dict.items():\\n if len(lod_geo) > 1:\\n lod_parent = cmds.listRelatives(lod_geo[0], parent=True)\\n if lod_parent:\\n cmds.parent(lod_geo[1:], lod_parent[0])\\n return lod_grp\",\n \"def get_group(self, predictions):\\n top_n = helpers.get_top_n(predictions, 1, threshold=0.05)\\n\\n if top_n:\\n top = top_n[0]\\n if prediction_index_in_set(top[0], self.dogs):\\n return \\\"Dog\\\", top[1]\\n elif prediction_index_in_set(top[0], self.cats):\\n return \\\"Cat\\\", top[1]\\n\\n return None\",\n \"def _parse_groupped_data(self):\\n for i, val in enumerate(self.values.keys()):\\n xy = self.values[val]\\n self._set_and_get(\\\"x_\\\", val, xy[:, 0])\\n self._set_and_get(\\\"y_\\\", val, xy[:, 1])\",\n \"def geo_proximity_locations(self) -> Optional[Sequence['outputs.GetTrafficPolicyDocumentRuleGeoProximityLocationResult']]:\\n return pulumi.get(self, \\\"geo_proximity_locations\\\")\",\n \"def test_groups_get(self):\\n pass\",\n \"def test_groups_get(self):\\n pass\",\n \"def customer_group_get_related(group_id):\\n db_conn = DB_Conn()\\n db = db_conn.db_connect()\\n\\n query = \\\"\\\"\\\"\\n SELECT \\n `group_id`,\\n `group_name`,\\n `description`,\\n `timestamp`,\\n `created_by`,\\n `creation_time`,\\n `is_deleted`,\\n `updated_by`,\\n `role_id`,\\n `is_default`,\\n `is_customer`,\\n `company_name`,\\n `company_address`,\\n `company_telephone`,\\n `company_fax`,\\n `company_website`,\\n `company_sales_contact`,\\n `company_purchase_contact`,\\n `company_business`,\\n `company_business_type`,\\n `company_sales_email`,\\n `company_purchase_email`,\\n `company_reg_number`,\\n `company_vat_number` \\n FROM `groups` \\n WHERE `groups`.`company_name` = (\\n SELECT `asshole`.`company_name` \\n FROM \\n (\\n SELECT * \\n FROM `groups` \\n WHERE `group_id` = \\\"%s\\\"\\n ) AS `asshole`\\n )\\n \\\"\\\"\\\" %(group_id)\\n \\n group_details = None\\n cursor = db.cursor()\\n\\n if cursor.execute(query) != 0:\\n group_details = cursor.fetchall()\\n\\n cursor.close()\\n db.close()\\n\\n return group_details\",\n \"def __get_gps_location(self):\\n\\n pos = {'alt_ft': None, 'error': False, 'lat': None, 'lon': None, 'lock': False}\\n\\n gpsd.connect(host=self.__gpsd_host, port=self.__gpsd_port)\\n\\n try:\\n packet = gpsd.get_current()\\n if packet.mode >= 2:\\n pos['lock'] = True\\n pos['lat'] = packet.lat\\n pos['lon'] = packet.lon\\n if packet.mode >= 3:\\n pos['alt_ft'] = packet.alt\\n except UserWarning:\\n pos['error'] = True\\n pos['lock'] = False\\n\\n return pos\",\n \"def get_all_locations(self):\",\n \"def test_RNA_position_placement(self):\\n \\n \\n tool = pybedtools.create_interval_from_list(\\\"chr1 50 60 ENSMUSG1_1_83;ENSMUSG1_6_83 0 + 60 60\\\".split())\\n location_dict = {\\\"ENSMUSG1\\\" : {\\\"strand\\\" : \\\"+\\\", \\\"regions\\\" : [(0,100),\\n ] \\n }\\n }\\n \\n self.assertEqual(RNA_position(tool, location_dict), (.60, .60))\\n \\n tool = pybedtools.create_interval_from_list(\\\"chr1 50 60 ENSMUSG1_1_83;ENSMUSG1_6_83 0 - 60 60\\\".split())\\n location_dict = {\\\"ENSMUSG1\\\" : {\\\"strand\\\" : \\\"-\\\", \\\"regions\\\" : [(0,100),\\n ] \\n }\\n }\\n \\n #individual_fraction, total_fraction\\n self.assertEqual(RNA_position(tool, location_dict), (.4, .4))\",\n \"def get_group_details(self, group_id):\\n url = self.groups_url + \\\"/\\\" + group_id\\n return requests.get(url, headers=self.headers)\",\n \"def getRC(self, group):\\n\\n if self.arrangement is None:\\n raise ValueError(\\\"specifying a group requires an arrangment dictionary\\\")\\n # look for the group label in the arrangement dicts\\n for c, colname in enumerate(self.arrangement.keys()):\\n if group in self.arrangement[colname]:\\n # print ('column name, column: ', colname, self.arrangement[colname])\\n # print ('group: ', group)\\n r = self.arrangement[colname].index(\\n group\\n ) # get the row position this way\\n return self.axarr[r, c]\\n print(\\\"Group {:s} not in the arrangement\\\".format(group))\\n return None\\n\\n # sizer = {'A': {'pos': [0.08, 0.22, 0.50, 0.4]}, 'B1': {'pos': [0.40, 0.25, 0.60, 0.3]}, 'B2': {'pos': [0.40, 0.25, 0.5, 0.1]},\\n # 'C1': {'pos': [0.72, 0.25, 0.60, 0.3]}, 'C2': {'pos': [0.72, 0.25, 0.5, 0.1]},\\n # 'D': {'pos': [0.08, 0.25, 0.1, 0.3]}, 'E': {'pos': [0.40, 0.25, 0.1, 0.3]}, 'F': {'pos': [0.72, 0.25, 0.1, 0.3]},\\n # }\",\n \"def get_placement(nodes_list, sf_list):\\n placement = defaultdict(list)\\n for node in nodes_list:\\n placement[node] = sf_list\\n return placement\",\n \"def groups(self):\\n\\n\\t\\tprint \\\"completed minimization\\\"\\n\\t\\tcopy(self.rootdir+'counterions-minimized.gro',self.rootdir+'system.gro')\\n\\t\\tcopy(self.rootdir+'counterions.top',self.rootdir+'system.top')\\n\\t\\tif self.simscale == 'aamd': grouptype = 'standard'\\n\\t\\tif self.simscale == 'cgmd': grouptype = 'cgmd_water'\\n\\t\\tself.grouping(grouptype=grouptype)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6448816","0.6372465","0.59885687","0.5547061","0.52896416","0.5240235","0.5159709","0.514106","0.50733167","0.50714","0.50509393","0.50364816","0.50350046","0.5000382","0.49950966","0.49934098","0.49427128","0.49386653","0.49252462","0.4914164","0.4912549","0.49009758","0.48957592","0.4894618","0.48820248","0.48803782","0.48803782","0.48778826","0.4875818","0.4865901","0.48572546","0.484659","0.484085","0.48387724","0.48335645","0.48298144","0.48285562","0.48283088","0.4827579","0.4819901","0.48111948","0.48111764","0.48106876","0.48083904","0.4796747","0.4789696","0.47858107","0.4773103","0.47554016","0.47456378","0.4733673","0.4722031","0.47016746","0.4696211","0.46944925","0.46878043","0.46826693","0.4679179","0.46783265","0.4670967","0.46692327","0.46683648","0.4666696","0.466608","0.46654683","0.46621922","0.46611565","0.4660262","0.4660262","0.46591234","0.46558097","0.46454918","0.46450713","0.46441996","0.46437624","0.46436352","0.4642014","0.46381027","0.46354127","0.46353877","0.46353877","0.46353877","0.46353877","0.46353877","0.46353877","0.46344516","0.46338028","0.4629411","0.46288678","0.46275485","0.46252552","0.46252552","0.46172398","0.46154287","0.46134025","0.4612801","0.46039","0.4602165","0.4600663","0.45893675"],"string":"[\n \"0.6448816\",\n \"0.6372465\",\n \"0.59885687\",\n \"0.5547061\",\n \"0.52896416\",\n \"0.5240235\",\n \"0.5159709\",\n \"0.514106\",\n \"0.50733167\",\n \"0.50714\",\n \"0.50509393\",\n \"0.50364816\",\n \"0.50350046\",\n \"0.5000382\",\n \"0.49950966\",\n \"0.49934098\",\n \"0.49427128\",\n \"0.49386653\",\n \"0.49252462\",\n \"0.4914164\",\n \"0.4912549\",\n \"0.49009758\",\n \"0.48957592\",\n \"0.4894618\",\n \"0.48820248\",\n \"0.48803782\",\n \"0.48803782\",\n \"0.48778826\",\n \"0.4875818\",\n \"0.4865901\",\n \"0.48572546\",\n \"0.484659\",\n \"0.484085\",\n \"0.48387724\",\n \"0.48335645\",\n \"0.48298144\",\n \"0.48285562\",\n \"0.48283088\",\n \"0.4827579\",\n \"0.4819901\",\n \"0.48111948\",\n \"0.48111764\",\n \"0.48106876\",\n \"0.48083904\",\n \"0.4796747\",\n \"0.4789696\",\n \"0.47858107\",\n \"0.4773103\",\n \"0.47554016\",\n \"0.47456378\",\n \"0.4733673\",\n \"0.4722031\",\n \"0.47016746\",\n \"0.4696211\",\n \"0.46944925\",\n \"0.46878043\",\n \"0.46826693\",\n \"0.4679179\",\n \"0.46783265\",\n \"0.4670967\",\n \"0.46692327\",\n \"0.46683648\",\n \"0.4666696\",\n \"0.466608\",\n \"0.46654683\",\n \"0.46621922\",\n \"0.46611565\",\n \"0.4660262\",\n \"0.4660262\",\n \"0.46591234\",\n \"0.46558097\",\n \"0.46454918\",\n \"0.46450713\",\n \"0.46441996\",\n \"0.46437624\",\n \"0.46436352\",\n \"0.4642014\",\n \"0.46381027\",\n \"0.46354127\",\n \"0.46353877\",\n \"0.46353877\",\n \"0.46353877\",\n \"0.46353877\",\n \"0.46353877\",\n \"0.46353877\",\n \"0.46344516\",\n \"0.46338028\",\n \"0.4629411\",\n \"0.46288678\",\n \"0.46275485\",\n \"0.46252552\",\n \"0.46252552\",\n \"0.46172398\",\n \"0.46154287\",\n \"0.46134025\",\n \"0.4612801\",\n \"0.46039\",\n \"0.4602165\",\n \"0.4600663\",\n \"0.45893675\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71223414"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76196,"cells":{"query":{"kind":"string","value":"This function constructs VGG_CNN_F and is based on"},"document":{"kind":"string","value":"def VGG_CNN_F(arch_mode='full', weights='imagenet',\n input_shape=(224, 224, 3), pooling=None, classes=1000):\n\n if not (weights in {'imagenet', None} or os.path.exists(weights)):\n raise ValueError('The `weights` argument should be either '\n '`None` (random initialization), `imagenet` '\n '(pre-training on ImageNet), '\n 'or the path to the weights file to be loaded.')\n\n if weights == 'imagenet' and arch_mode == 'full' and classes != 1000:\n raise ValueError('If using `weights` as imagenet with `arch_mode`'\n ' as `full`, `classes` should be 1000')\n\n img_input = Input(shape=input_shape)\n x = Conv2D(64, (11, 11), strides=(4, 4), activation='relu', name='conv1')(img_input) # conv1\n x = LRN(n=5, alpha=0.0005, beta=0.75, k=2, name='norm1')(x) # norm1\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same', name='pool1')(x) # pool1\n\n x = ZeroPadding2D(padding=(2, 2))(x)\n x = Conv2D(256, (5, 5), strides=(1, 1), activation='relu', name='conv2')(x) # conv2\n x = LRN(n=5, alpha=0.0005, beta=0.75, k=2, name='norm2')(x) # norm2\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool2')(x) # pool2\n\n x = ZeroPadding2D(padding=(1, 1))(x)\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv3')(x) # conv3\n\n x = ZeroPadding2D(padding=(1, 1))(x)\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv4')(x) # conv4\n\n x = ZeroPadding2D(padding=(1, 1))(x)\n x = Conv2D(256, (3, 3), strides=(1, 1), activation='relu', name='conv5')(x) # conv5\n x = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), name='pool5')(x) # pool5\n\n if arch_mode == 'notop':\n if pooling == 'avg':\n x = GlobalAveragePooling2D()(x)\n elif pooling == 'max':\n x = GlobalMaxPooling2D()(x)\n else:\n x = Flatten()(x)\n x = Dense(4096, activation='relu', name='fc6')(x) # fc6\n x = Dropout(0.5)(x) # drop6\n x = Dense(4096, activation='relu', name='fc7')(x) # fc7\n x = Dropout(0.5)(x) # drop7\n\n if arch_mode == 'full':\n x = Dense(classes, name='fc8')(x) # fc8\n x = Activation('softmax', name='prob')(x) # prob\n elif arch_mode != 'rmlast':\n raise ValueError('arch_mode: {} is not supported.'.format(arch_mode))\n\n inputs = img_input\n\n # Create model.\n model = Model(inputs, x, name='vgg_cnn_f')\n\n # load weights\n if weights == 'imagenet':\n if arch_mode == 'full':\n weights_path = 'init_weights/vgg_cnn_f.h5'\n elif arch_mode == 'rmlast':\n weights_path = 'init_weights/vgg_cnn_f_rmlast.h5'\n elif arch_mode == 'notop':\n weights_path = 'init_weights/vgg_cnn_f_notop.h5'\n model.load_weights(weights_path)\n\n if K.backend() == 'theano':\n raise NotImplemented('Support for loading imagenet weights with '\n 'theano backend is not implemented yet!')\n\n if K.image_data_format() == 'channels_first':\n raise NotImplemented('Support for loading imagenet weights with '\n 'channels_first image data format is not implemented yet!')\n elif weights is not None:\n model.load_weights(weights)\n return model"},"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 build_vgg16(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_1_feats = convolution(imgs, 3, 3, 64, 1, 1, 'conv1_1')\n conv1_1_feats = nonlinear(conv1_1_feats, 'relu')\n conv1_2_feats = convolution(conv1_1_feats, 3, 3, 64, 1, 1, 'conv1_2')\n conv1_2_feats = nonlinear(conv1_2_feats, 'relu')\n pool1_feats = max_pool(conv1_2_feats, 2, 2, 2, 2, 'pool1')\n\n conv2_1_feats = convolution(pool1_feats, 3, 3, 128, 1, 1, 'conv2_1')\n conv2_1_feats = nonlinear(conv2_1_feats, 'relu')\n conv2_2_feats = convolution(conv2_1_feats, 3, 3, 128, 1, 1, 'conv2_2')\n conv2_2_feats = nonlinear(conv2_2_feats, 'relu')\n pool2_feats = max_pool(conv2_2_feats, 2, 2, 2, 2, 'pool2')\n\n conv3_1_feats = convolution(pool2_feats, 3, 3, 256, 1, 1, 'conv3_1')\n conv3_1_feats = nonlinear(conv3_1_feats, 'relu')\n conv3_2_feats = convolution(conv3_1_feats, 3, 3, 256, 1, 1, 'conv3_2')\n conv3_2_feats = nonlinear(conv3_2_feats, 'relu')\n conv3_3_feats = convolution(conv3_2_feats, 3, 3, 256, 1, 1, 'conv3_3')\n conv3_3_feats = nonlinear(conv3_3_feats, 'relu')\n pool3_feats = max_pool(conv3_3_feats, 2, 2, 2, 2, 'pool3')\n\n conv4_1_feats = convolution(pool3_feats, 3, 3, 512, 1, 1, 'conv4_1')\n conv4_1_feats = nonlinear(conv4_1_feats, 'relu')\n conv4_2_feats = convolution(conv4_1_feats, 3, 3, 512, 1, 1, 'conv4_2')\n conv4_2_feats = nonlinear(conv4_2_feats, 'relu')\n conv4_3_feats = convolution(conv4_2_feats, 3, 3, 512, 1, 1, 'conv4_3')\n conv4_3_feats = nonlinear(conv4_3_feats, 'relu')\n pool4_feats = max_pool(conv4_3_feats, 2, 2, 2, 2, 'pool4')\n\n conv5_1_feats = convolution(pool4_feats, 3, 3, 512, 1, 1, 'conv5_1')\n conv5_1_feats = nonlinear(conv5_1_feats, 'relu')\n conv5_2_feats = convolution(conv5_1_feats, 3, 3, 512, 1, 1, 'conv5_2')\n conv5_2_feats = nonlinear(conv5_2_feats, 'relu')\n conv5_3_feats = convolution(conv5_2_feats, 3, 3, 512, 1, 1, 'conv5_3')\n conv5_3_feats = nonlinear(conv5_3_feats, 'relu')\n\n conv5_3_feats_flat = tf.reshape(conv5_3_feats, [self.batch_size, 196, 512])\n self.conv_feats = conv5_3_feats_flat\n self.conv_feat_shape = [196, 512]\n self.num_ctx = 196 \n self.dim_ctx = 512\n\n self.imgs = imgs\n self.is_train = is_train","def build_cnn_vgg16(num_classes):\n\n inputs = tf.keras.layers.Input(\n shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS)\n )\n\n x = inputs\n x = tf.keras.applications.vgg16.preprocess_input(x)\n vgg16 = tf.keras.applications.VGG16(\n input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS),\n weights=\"imagenet\",\n include_top=False\n )\n\n vgg16.trainable = False\n x = vgg16(x, training=False)\n\n x = tf.keras.layers.GlobalAveragePooling2D()(x)\n x = tf.keras.layers.Dense(\n units=num_classes,\n activation=tf.keras.activations.softmax\n )(x)\n\n outputs = x\n\n model = tf.keras.Model(\n inputs=inputs,\n outputs=outputs\n )\n\n return model","def vgg_fcn(images,\n num_classes=FLAGS.num_classes,\n is_training=True,\n dropout_keep_prob=0.5,\n spatial_squeeze=False, #True,\n scope='vgg_16',\n fc_conv_padding='VALID'):\n with tf.variable_scope(scope, 'vgg_16', [images]) as sc:\n end_points_collection = sc.name + '_end_points'\n with slim.arg_scope([slim.conv2d, slim.conv2d_transpose, slim.fully_connected, slim.max_pool2d], outputs_collections=end_points_collection):\n conv1 = slim.repeat(images, 2, slim.conv2d, 64, [3, 3], scope='conv1')\n pool1 = slim.max_pool2d(conv1, [2, 2], scope='pool1')\n conv2 = slim.repeat(pool1, 2, slim.conv2d, 128, [3, 3], scope='conv2')\n pool2 = slim.max_pool2d(conv2, [2, 2], scope='pool2')\n conv3 = slim.repeat(pool2, 3, slim.conv2d, 256, [3, 3], scope='conv3')\n pool3 = slim.max_pool2d(conv3, [2, 2], scope='pool3')\n conv4 = slim.repeat(pool3, 3, slim.conv2d, 512, [3, 3], scope='conv4')\n pool4 = slim.max_pool2d(conv4, [2, 2], scope='pool4')\n conv5 = slim.repeat(pool4, 3, slim.conv2d, 512, [3, 3], scope='conv5')\n pool5 = slim.max_pool2d(conv5, [2, 2], scope='pool5')\n fc6 = slim.conv2d(pool5, 4096, [7, 7], stride=1, scope='fc6')\n drop6 = slim.dropout(fc6, dropout_keep_prob, is_training=is_training, scope='dropout6')\n fc7 = slim.conv2d(drop6, 4096, [1, 1], scope='fc7')\n drop7 = slim.dropout(fc7, dropout_keep_prob, is_training=is_training, scope='dropout7')\n fc8 = slim.conv2d(drop7, num_classes, [1, 1], activation_fn=None, normalizer_fn=None, scope='fc8')\n #end_points = slim.utils.convert_collection_to_dict(end_points_collection)\n\n if spatial_squeeze:\n fc8 = tf.squeeze(fc8, [1, 2], name='fc8/squeezed')\n msk_shape = images.shape\n # it is intialized as bilinar interpolation(calculation predfined)\n score_fr = slim.conv2d(fc7, num_classes, [1, 1], scope='score_fr')\n tf.logging.info(\"score_fr size: %s\"% tf.shape(score_fr))\n fc32s = slim.conv2d_transpose(inputs=score_fr, num_outputs=num_classes, kernel_size=[64, 64], stride=32, scope='fc32s')\n tf.logging.info(\"fc32s: %s\" % tf.shape(fc32s))\n\n #fc32s = tf.image.crop_to_bounding_box(fc32s, 19, 19, msk_shape[1], msk_shape[2])\n \n upscore2 = slim.conv2d_transpose(inputs=score_fr, num_outputs=num_classes, kernel_size=[4, 4], stride=2, scope='upscore2')\n\n deconv_shape1 = upscore2.get_shape() \n score_pool4 = slim.conv2d(pool4, num_classes, [1, 1], stride=1, scope='score_pool4')\n\n #score_pool4 = tf.image.crop_to_bounding_box(score_pool4, 5, 5, deconv_shape1[1], deconv_shape1[2])\n \n fuse_pool4 = tf.add(upscore2, score_pool4)\n\n fc16s = slim.conv2d_transpose(inputs=fuse_pool4, num_outputs=num_classes, kernel_size=[32, 32], stride=16, scope='fc16s')\n\n tf.logging.info(\"fc16s size: %s\" % tf.shape(fc16s))\n #fc16s = tf.image.crop_to_bounding_box(fc16s, 27, 27, msk_shape[1], msk_shape[2])\n \n upscore_pool4 = slim.conv2d_transpose(inputs=fuse_pool4, num_outputs=num_classes, kernel_size=[4, 4], stride=2, scope='upscore_pool4')\n\n upscore_pool3 = slim.conv2d(pool3, num_classes, [1, 1], stride=1, scope='upscore_pool3')\n deconv_shape2 = upscore_pool4.get_shape()\n #upscore_pool3 = tf.image.crop_to_bounding_box(upscore_pool3, 9, 9, deconv_shape2[1], deconv_shape[2])\n fuse_pool3 = tf.add(upscore_pool4, upscore_pool3)\n\n fc8s = slim.conv2d_transpose(inputs=fuse_pool3, num_outputs=num_classes, kernel_size=[16, 16], stride=8, scope='fc8s')\n tf.logging.info(\"fc8s size: %s\" % tf.shape(fc8s))\n #fc8s = tf.image.crop_to_bounding_box(fc8s, 31, 31, msk_shape[1], msk_shape[2])\n\n\n annotation_pred = tf.argmax(fc8s, dimension=3, name=\"prediction\")\n end_points = slim.utils.convert_collection_to_dict(end_points_collection)\n\n tf.get_variable_scope().reuse_variables()\n\n return tf.expand_dims(annotation_pred, dim=3), fc8s, end_points","def build_model(self):\n \n start_time = time.time()\n print(\"build model started\")\n # label\n self.FA = tf.placeholder(dtype=tf.int32, shape=[None])\n self.ges = tf.placeholder(dtype=tf.int32, shape=[None])\n self.obj = tf.placeholder(dtype=tf.int32, shape=[None])\n \n self.images = tf.placeholder(dtype=tf.float32, shape=[None, height, width, 3])\n batch_size = tf.shape(self.images)[0]\n rgb_scaled = self.images * 255.0\n\n # Convert RGB to BGR\n VGG_MEAN = [103.939, 116.779, 123.68]\n red, green, blue = tf.split(axis=3, num_or_size_splits=3, value=rgb_scaled)\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\n bgr = tf.concat(axis=3, values=[\n blue - VGG_MEAN[0],\n green - VGG_MEAN[1],\n red - VGG_MEAN[2],\n ])\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\n \n with tf.variable_scope(\"vgg19\"):\n self.conv1_1 = self.conv_layer(bgr, \"conv1_1\")\n self.conv1_2 = self.conv_layer(self.conv1_1, \"conv1_2\")\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\n\n self.conv2_1 = self.conv_layer(self.pool1, \"conv2_1\")\n self.conv2_2 = self.conv_layer(self.conv2_1, \"conv2_2\")\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\n\n self.conv3_1 = self.conv_layer(self.pool2, \"conv3_1\")\n self.conv3_2 = self.conv_layer(self.conv3_1, \"conv3_2\")\n self.conv3_3 = self.conv_layer(self.conv3_2, \"conv3_3\")\n self.conv3_4 = self.conv_layer(self.conv3_3, \"conv3_4\")\n self.pool3 = self.max_pool(self.conv3_4, 'pool3')\n\n self.conv4_1 = self.conv_layer(self.pool3, \"conv4_1\")\n self.conv4_2 = self.conv_layer(self.conv4_1, \"conv4_2\")\n self.conv4_3 = self.conv_layer(self.conv4_2, \"conv4_3\")\n self.conv4_4 = self.conv_layer(self.conv4_3, \"conv4_4\")\n self.pool4 = self.max_pool(self.conv4_4, 'pool4')\n\n self.conv5_1 = self.conv_layer(self.pool4, \"conv5_1\")\n self.conv5_2 = self.conv_layer(self.conv5_1, \"conv5_2\")\n self.conv5_3 = self.conv_layer(self.conv5_2, \"conv5_3\")\n self.conv5_4 = self.conv_layer(self.conv5_3, \"conv5_4\")\n self.pool5 = self.max_pool(self.conv5_4, 'pool5')\n\n \n shape = self.pool5.get_shape()\n size = 1\n for dim in shape[1:]:\n size *= dim.value\n \n # dense\n with tf.variable_scope('dense') as scope:\n # Move everything into depth so we can perform a single matrix multiply.\n reshape = tf.reshape(self.pool5, [-1, size])\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[size, 192]))\n biases = tf.get_variable('biases', [192], initializer=tf.constant_initializer(0.1))\n dense = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)\n\n\n # linear layer(WX + b),\n with tf.variable_scope('softmax_linear_FA') as scope:\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 2]))\n biases = tf.get_variable('biases', [2], initializer=tf.constant_initializer(0.1))\n softmax_linear_FA = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\n self.output_FA = tf.nn.softmax(softmax_linear_FA)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.FA, logits=softmax_linear_FA, name='cross_entropy')\n cross_entropy_mean_FA = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\n\n with tf.variable_scope('softmax_linear_ges') as scope:\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 13]))\n biases = tf.get_variable('biases', [13], initializer=tf.constant_initializer(0.1))\n softmax_linear_ges = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\n self.output_ges = tf.nn.softmax(softmax_linear_ges)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.ges, logits=softmax_linear_ges, name='cross_entropy')\n cross_entropy_mean_ges = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\n\n with tf.variable_scope('softmax_linear_obj') as scope:\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 24]))\n biases = tf.get_variable('biases', [24], initializer=tf.constant_initializer(0.1))\n softmax_linear_obj = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\n self.output_obj = tf.nn.softmax(softmax_linear_obj)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.obj, logits=softmax_linear_obj, name='cross_entropy')\n cross_entropy_mean_obj = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\n\n self.loss = cross_entropy_mean_FA + cross_entropy_mean_ges + cross_entropy_mean_obj\n self.lr = tf.placeholder(tf.float32, [])\n self.global_step = tf.Variable(0, name=\"global_step\", trainable=False)\n optimizer = tf.train.AdamOptimizer(self.lr)\n grads_and_vars = optimizer.compute_gradients(self.loss)\n self.train_op = optimizer.apply_gradients(grads_and_vars, global_step=self.global_step)\n self.data_dict = None\n print((\"build model finished: %ds\" % (time.time() - start_time)))","def build_vgg():\n input_shape = (256, 256, 3)\n\n vgg = keras.applications.VGG19(include_top = False , input_shape = input_shape , weights=\"imagenet\")\n features = vgg.get_layer(index = 9).output\n\n model = keras.Model(inputs=[vgg.inputs], outputs=[features])\n return model","def vgg_16(input_shape=(224, 224, 3), output_shape=1000):\n model = Sequential()\n \n # layer 1 ~ 2 (filter: 64)\n model.add(Input(shape=input_shape))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(64, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(64, (3, 3), activation='relu'))\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\n # output size: 112 x 112 x 64\n \n # layer 3 ~ 4 (filter: 128)\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(128, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(128, (3, 3), activation='relu'))\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\n # output size: 56 x 56 x 128\n \n # layer 5 ~ 7 (filter: 256)\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(256, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(256, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(256, (3, 3), activation='relu'))\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\n # output size: 28 x 28 x 256\n \n # layer 8 ~ 10 (filter: 512)\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(512, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(512, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(512, (3, 3), activation='relu'))\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\n # output size: 14 x 14 x 512\n \n # layer 11 ~ 13 (filter: 512)\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(512, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(512, (3, 3), activation='relu'))\n model.add(ZeroPadding2D((1, 1)))\n model.add(Conv2D(512, (3, 3), activation='relu'))\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\n # output size: 7 x 7 x 512\n \n # layer 14 ~ 16 (Fully Connected)\n model.add(Flatten())\n # flatten: 7 x 7 x 512 = 25,088\n model.add(Dense(4096, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(4096, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(output_shape, activation='softmax'))\n # categorized by output shape\n \n return model","def build(self):\n\n # bgr_ = bgr*255.0\n bgr_= self.X\n start_time = time.time()\n print(\"build model started\")\n\n # blue ,green, red = tf.split(axis=3, num_or_size_splits=3, value= bgr)\n red ,green, blue, = tf.split(axis=3, num_or_size_splits=3, value= bgr_)\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\n bgr = tf.concat(axis=3, values=[\n # blue - VGG_MEAN[0],\n # green - VGG_MEAN[1],\n # red - VGG_MEAN[2],\n\n red - VGG_MEAN[0],\n green - VGG_MEAN[1],\n blue - VGG_MEAN[2],\n ])\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\n\n\n\n print(bgr.shape)\n\n self.conv1_1 = self.conv_layer(bgr, \"conv1_1\")\n self.conv1_2 = self.conv_layer(self.conv1_1, \"conv1_2\")\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\n\n self.conv2_1 = self.conv_layer(self.pool1, \"conv2_1\")\n self.conv2_2 = self.conv_layer(self.conv2_1, \"conv2_2\")\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\n\n\n\n\n self.conv3_1 = self.conv_layer(self.pool2, \"conv3_1\")\n self.conv3_2 = self.conv_layer(self.conv3_1, \"conv3_2\")\n self.conv3_3 = self.conv_layer(self.conv3_2, \"conv3_3\")\n self.pool3 = self.max_pool(self.conv3_3, 'pool3')\n\n self.conv4_1 = self.conv_layer(self.pool3, \"conv4_1\")\n self.conv4_2 = self.conv_layer(self.conv4_1, \"conv4_2\")\n self.conv4_3 = self.conv_layer(self.conv4_2, \"conv4_3\")\n self.pool4 = self.max_pool(self.conv4_3, 'pool4')\n\n\n\n\n\n self.conv5_1 = self.conv_layer(self.pool4, \"conv5_1\")\n self.conv5_2 = self.conv_layer(self.conv5_1, \"conv5_2\")\n self.conv5_3 = self.conv_layer(self.conv5_2, \"conv5_3\")\n self.pool5 = self.max_pool(self.conv5_3, 'pool5')\n\n self.fc6 = self.fc_layer(self.pool5, \"fc6\")\n assert self.fc6.get_shape().as_list()[1:] == [4096]\n self.relu6 = tf.nn.relu(self.fc6)\n\n self.fc7 = self.fc_layer(self.relu6, \"fc7\")\n self.relu7 = tf.nn.relu(self.fc7)\n\n self.fc8 = self.fc_layer(self.relu7, \"fc8\")\n\n # self.fc9 = self.fc_layer(self.fc8,'fc9')\n # self.relu9 = tf.nn.relu(self.fc9)\n\n\n\n\n relu8 = tf.nn.relu(self.fc8)\n fc9 = self.fc_layer(relu8, 'fc9')\n print((\"build model finished: %ds\" % (time.time() - start_time)))\n return fc9\n\n # self.prob = tf.nn.softmax(self.fc8, name=\"prob\")","def _build_preprocessor(self, crop_size=[224,224]):\n self.image_ph = tf.placeholder(tf.float32)\n self.cropbox_ph = tf.placeholder(tf.float32, shape=[4]) #y1,x1,y2,x2\n img = self.image_ph - self.VGG_MEAN\n batch_img = tf.image.crop_and_resize(\n tf.expand_dims(img, 0),\n tf.expand_dims(self.cropbox_ph, 0),\n [0], crop_size)\n self.image_after_crop = tf.cast(tf.squeeze(batch_img) + self.VGG_MEAN, tf.uint8)\n vgg_graph_def = tf.GraphDef()\n with open(FLAGS.vgg_model_frozen, \"rb\") as f:\n vgg_graph_def.ParseFromString(f.read())\n features = tf.import_graph_def(\n vgg_graph_def, input_map={'inputs': batch_img},\n return_elements=[FLAGS.feature_layer])[0]\n features_dim = features.get_shape().as_list()\n features_dim[1] = features_dim[2] = 8\n features, num_features = extract_features(features)\n self.features_dim = features_dim\n #logging.debug('features_dim', features_dim)\n self.num_features = num_features\n self.features = tf.reshape(features, [num_features, features_dim[3]])","def build_vgg(self, weights=\"imagenet\"): \n \n # Input image to extract features from\n img = Input(shape=(self.img_rows, self.img_cols, 3))\n\n # Mean center and rescale by variance as in PyTorch\n processed = Lambda(lambda x: (x-self.mean) / self.std)(img)\n \n # If inference only, just return empty model \n if self.inference_only:\n model = Model(inputs=img, outputs=[img for _ in range(len(self.vgg_layers))])\n model.trainable = False\n model.compile(loss='mse', optimizer='adam')\n return model\n \n # Get the vgg network from Keras applications\n if weights in ['imagenet', None]:\n vgg = VGG16(weights=weights, include_top=False)\n else:\n vgg = VGG16(weights=None, include_top=False)\n vgg.load_weights(weights, by_name=True)\n\n # Output the first three pooling layers\n vgg.outputs = [vgg.layers[i].output for i in self.vgg_layers] \n \n # Create model and compile\n model = Model(inputs=img, outputs=vgg(processed))\n model.trainable = False\n model.compile(loss='mse', optimizer='adam')\n\n return model","def __init__(self, input_shape=(3, 244, 244), include_classifier=True,\n **kwargs):\n self._name = \"VGG16\"\n self._weightsUrl = {\n 'th': 'https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg16_weights_th_dim_ordering_th_kernels.h5',\n 'tf': 'https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg16_weights_tf_dim_ordering_tf_kernels.h5'\n }\n\n # If using the Tensor Flow backend we have to transform input shape\n if K.image_dim_ordering() == \"tf\":\n input_shape = (input_shape[1], input_shape[2], input_shape[0])\n\n self._inLayer = Input(shape=input_shape)\n\n self._net = Convolution2D(64, 3, 3, activation='relu',\n border_mode='same',\n name='block1_conv1')(self._inLayer)\n self._net = Convolution2D(64, 3, 3, activation='relu',\n border_mode='same',\n name='block1_conv2')(self._net)\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\n name='block1_pool')(self._net)\n\n self._net = Convolution2D(128, 3, 3, activation='relu',\n border_mode='same',\n name='block2_conv1')(self._net)\n self._net = Convolution2D(128, 3, 3, activation='relu',\n border_mode='same',\n name='block2_conv2')(self._net)\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\n name='block2_pool')(self._net)\n\n self._net = Convolution2D(256, 3, 3, activation='relu',\n border_mode='same',\n name='block3_conv1')(self._net)\n self._net = Convolution2D(256, 3, 3, activation='relu',\n border_mode='same',\n name='block3_conv2')(self._net)\n self._net = Convolution2D(256, 3, 3, activation='relu',\n border_mode='same',\n name='block3_conv3')(self._net)\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\n name='block3_pool')(self._net)\n\n self._net = Convolution2D(512, 3, 3, activation='relu',\n border_mode='same',\n name='block4_conv1')(self._net)\n self._net = Convolution2D(512, 3, 3, activation='relu',\n border_mode='same',\n name='block4_conv2')(self._net)\n self._net = Convolution2D(512, 3, 3, activation='relu',\n border_mode='same',\n name='block4_conv3')(self._net)\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\n name='block4_pool')(self._net)\n\n self._net = Convolution2D(512, 3, 3, activation='relu',\n border_mode='same',\n name='block5_conv1')(self._net)\n self._net = Convolution2D(512, 3, 3, activation='relu',\n border_mode='same',\n name='block5_conv2')(self._net)\n self._net = Convolution2D(512, 3, 3, activation='relu',\n border_mode='same',\n name='block5_conv3')(self._net)\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\n name='block5_pool')(self._net)\n\n # Classification block\n if include_classifier:\n self._net = Flatten(name='flatten')(self._net)\n self._net = Dense(4096, activation='relu', name='fc1')(self._net)\n self._net = Dense(4096, activation='relu', name='fc2')(self._net)\n self._net = Dense(1000, activation='softmax',\n name='predictions')(self._net)\n\n # Create the model\n self._model = Model(self._inLayer, self._net)\n super(VGG16, self).__init__(**kwargs)","def VGGWithCustomLayers(nb_classes, input_shape, fc_size):\n # setup model\n base_model = VGGFace(include_top=False, input_tensor=Input(shape=input_shape))\n x = base_model.output\n x = GlobalAveragePooling2D()(x)\n x = Dense(fc_size, activation='relu')(x) # new FC layer, random init\n x = Dense(fc_size * 2, activation='relu')(x) # new FC layer, random init\n x = Dense(fc_size * 4, activation='relu')(x) # new FC layer, random init\n predictions = Dense(nb_classes, activation='softmax')(x) # new softmax layer\n model = Model(outputs=predictions, inputs=base_model.input)\n return model, base_model","def __init__(self, num_classes):\n super(VGG16, self).__init__()\n self.vgg16_feature_extractor = VGG16FeatureExtraction(weights_update=True)\n self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)\n self.classifier = VGG16Classfier()\n self.fc3 = _fc(in_channels=4096, out_channels=num_classes)","def build_vgg16_notop(image_dimensions, pooling, size_final_dense, num_classes, trainable=False, weights='imagenet'):\n\n vgg16_base = VGG16(weights=weights\n , include_top=False # Ignore the final dense layers, we'll train our own\n , input_shape=image_dimensions\n , pooling=pooling)\n vgg16_base.trainable=trainable\n\n image_input = Input(shape=image_dimensions)\n\n x = vgg16_base(image_input)\n x = Flatten()(x)\n x = Dense(size_final_dense,activation='relu')(x)\n out = Dense(num_classes,activation='softmax')(x) # Task is classification\n\n model = Model(image_input, out)\n return(model)","def build_vgg(self):\n vgg = VGG19(weights=\"imagenet\")\n # Set outputs to outputs of last conv. layer in block 3\n # See architecture at: https://github.com/keras-team/keras/blob/master/keras/applications/vgg19.py\n vgg.outputs = [vgg.layers[9].output]\n\n img = Input(shape=self.hr_shape)\n\n # Extract image features\n img_features = vgg(img)\n\n return Model(img, img_features)","def build(self, input_image, num_class):\n x = build_resnet(101)\n # add classifier\n x = Conv2D(num_class, (1, 1), kernel_initializer='he_normal', activation='linear', padding='valid', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x)","def VGGFace(input_shape=(224, 224, 3), n_classes=10, include_top=True):\n # Create the Tensor\n input = Input(shape=input_shape)\n\n # Block 1\n # 1st Convolutional Layer\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv1')(input)\n x = Activation('relu', name='block1_relu1')(x)\n\n # 2nd Convolutional Layer\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv2')(x)\n x = Activation('relu', name='block1_relu2')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block1_pool')(x)\n\n # Block 2\n # 3rd Convolutional Layer\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv1')(x)\n x = Activation('relu', name='block2_relu1')(x)\n\n # 4th Convolutional Layer\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv2')(x)\n x = Activation('relu', name='block2_relu2')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block2_pool')(x)\n\n # Block 3\n # 5th Convolutional Layer\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv1')(x)\n x = Activation('relu', name='block3_relu1')(x)\n\n # 6th Convolutional Layer\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv2')(x)\n x = Activation('relu', name='block3_relu2')(x)\n\n # 7th Convolutional Layer\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv3')(x)\n x = Activation('relu', name='block3_relu3')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block3_pool')(x)\n\n # Block 4\n # 8th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv1')(x)\n x = Activation('relu', name='block4_relu1')(x)\n\n # 9th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv2')(x)\n x = Activation('relu', name='block4_relu2')(x)\n\n # 10th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv3')(x)\n x = Activation('relu', name='block4_relu3')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block4_pool')(x)\n\n # Block 5\n # 11th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv1')(x)\n x = Activation('relu', name='block5_relu1')(x)\n\n # 12th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv2')(x)\n x = Activation('relu', name='block5_relu2')(x)\n\n # 13th Convolutional Layer\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv3')(x)\n x = Activation('relu', name='block5_relu3')(x)\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block5_pool')(x)\n\n # Block 6\n # 14th Convulation Layer\n x = Conv2D(4096, (7, 7), strides=(1, 1), name='fc1_conv1')(x)\n x = Activation('relu', name='fc1_relu1')(x)\n x = Dropout(0.5)(x)\n\n # 15th Convulation Layer\n x = Conv2D(4096, (1, 1), strides=(1, 1), name='fc2_conv1')(x)\n x = Activation('relu', name='fc2_relu2')(x)\n x = Dropout(0.5, name='fc2_dropout')(x)\n\n # 16th Convulation Layer\n x = Conv2D(2622, (1, 1), strides=(1, 1), name='fc3_conv1')(x)\n x = Flatten(name='fc3_flatten')(x)\n\n if include_top:\n # Output Layer\n x = Activation('softmax', name='predictions_softmax')(x)\n\n # Create model\n model = keras.models.Model(input, x, name='vggface')\n return model","def __init__(self, dropout_rate, num_classes, include_top, layer):\r\n super(VGG16_Rand, self).__init__()\r\n print(\"CIFAR VGG16_Rand is used\")\r\n self.dropout_rate = dropout_rate\r\n self.num_classes = num_classes\r\n self.include_top = include_top\r\n self.layer = layer\r\n self.bias = True\r\n\r\n # Define the building blocks\r\n if layer <= 11:\r\n self.conv11 = CONV_3x3rand(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 12:\r\n self.conv12 = nn.Sequential(CONV_3x3rand(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 21:\r\n self.conv21 = CONV_3x3rand(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 22:\r\n self.conv22 = nn.Sequential(CONV_3x3rand(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 31:\r\n self.conv31 = CONV_3x3rand(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 32:\r\n self.conv32 = CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 33:\r\n self.conv33 = nn.Sequential(CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 41:\r\n self.conv41 = CONV_3x3rand(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 42:\r\n self.conv42 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 43:\r\n self.conv43 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n if layer <= 51:\r\n self.conv51 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 52:\r\n self.conv52 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n else:\r\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\r\n\r\n if layer <= 53:\r\n self.conv53 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n self.avgpool = nn.AdaptiveAvgPool2d(1)\r\n self.fc = nn.Sequential(nn.Linear(512, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, num_classes))\r\n\r\n # Initialize the weights\r\n for m in self.modules():\r\n if isinstance(m, nn.Conv2d):\r\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\r\n elif isinstance(m, nn.BatchNorm2d):\r\n # raise Exception('You are using a model without BN!!!')\r\n nn.init.constant_(m.weight, 1)\r\n nn.init.constant_(m.bias, 0)","def vgg_16(inputs,\n num_classes=1000,\n is_training=True,\n dropout_keep_prob=0.5,\n spatial_squeeze=True,\n scope='vgg_16',\n fc_conv_padding='VALID',\n global_pool=False):\n with tf.variable_scope(scope, 'vgg_16', [inputs]) as sc:\n end_points_collection = sc.original_name_scope + '_end_points'\n # Collect outputs for conv2d, fully_connected and max_pool2d.\n with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],\n outputs_collections=end_points_collection):\n net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')\n net = slim.max_pool2d(net, [2, 2], scope='pool1')\n net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')\n net = slim.max_pool2d(net, [2, 2], scope='pool2')\n net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')\n net = slim.max_pool2d(net, [2, 2], scope='pool3')\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')\n net = slim.max_pool2d(net, [2, 2], scope='pool4')\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')\n net = slim.max_pool2d(net, [2, 2], scope='pool5')\n\n # if num_classes == 0:\n # return net\n\n # Use conv2d instead of fully_connected layers.\n net = slim.conv2d(net, 4096, [7, 7], padding=fc_conv_padding, scope='fc6')\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\n scope='dropout6')\n net = slim.conv2d(net, 4096, [1, 1], scope='fc7')\n # Convert end_points_collection into a end_point dict.\n end_points = slim.utils.convert_collection_to_dict(end_points_collection)\n if global_pool:\n net = tf.reduce_mean(net, [1, 2], keep_dims=True, name='global_pool')\n end_points['global_pool'] = net\n if num_classes:\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\n scope='dropout7')\n net = slim.conv2d(net, num_classes, [1, 1],\n activation_fn=None,\n normalizer_fn=None,\n scope='fc8')\n if spatial_squeeze:\n net = tf.squeeze(net, [1, 2], name='fc8/squeezed')\n end_points[sc.name + '/fc8'] = net\n return net, end_points","def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\n dtype=np.float32):\n self.params = {}\n self.reg = reg\n self.dtype = dtype\n \n ############################################################################\n # TODO: Initialize weights and biases for the three-layer convolutional #\n # network. Weights should be initialized from a Gaussian with standard #\n # deviation equal to weight_scale; biases should be initialized to zero. #\n # All weights and biases should be stored in the dictionary self.params. #\n ############################################################################\n \n # Store weights and biases for the convolutional layer using the keys 'W1' and 'b1'; \n C, H, W = input_dim\n filter_sizes = (filter_size, filter_size)\n self.params['W1'] = np.random.normal(0, weight_scale, [num_filters, C, filter_sizes[0], filter_sizes[1]])\n self.params['b1'] = np.zeros((num_filters, ))\n\n # use keys 'W2' and 'b2' for the weights and biases of the hidden affine layer;\n # In this case, ConvLayer doesn't reduce the spatial size of the input, (N, C, H, W) -> Conv -> (N, F, H, W)\n # To satisfy this constraint, (W + 2 * pad - filter_size) / stride + 1 = W need to hold, which led to pad = (F - S) / 2 where S == 1\n # (N, C, H, W) -> Conv -> (N, F, H, W) -> Pooling -> (N, F, H/2, W/2)\n # In a FC_NN, FCL weights (input_dim, hidden_dim) where every img is flatten into a 1D array of length D = F * H/2 * W/2.\n self.params['W2'] = np.random.normal(0, weight_scale, [num_filters * (H / 2) * (W / 2), hidden_dim])\n self.params['b2'] = np.zeros((hidden_dim, ))\n\n # And the keys 'W3' and 'b3' for the weights and biases of the output affine layer. \n self.params['W3'] = np.random.normal(0, weight_scale, [hidden_dim, num_classes])\n self.params['b3'] = np.zeros((num_classes, ))\n\n \n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n for k, v in self.params.iteritems():\n self.params[k] = v.astype(dtype)","def __init__(self, img_rows=400, img_cols=400, vgg_weights=\"imagenet\", inference_only=False, net_name='default', gpus=1, vgg_device=None):\n \n # Settings\n self.img_rows = img_rows\n self.img_cols = img_cols\n self.img_overlap = 30\n self.inference_only = inference_only\n self.net_name = net_name\n self.gpus = gpus\n self.vgg_device = vgg_device\n\n # Scaling for VGG input\n self.mean = [0.485, 0.456, 0.406]\n self.std = [0.229, 0.224, 0.225]\n \n #get PowerSpect_CMB\n reader = np.zeros((2507,))\n fp = open('./data/COM_PowerSpect_CMB-base-plikHM-TTTEEE-lowl-lowE-lensing-minimum-theory_R3.01.txt')\n \n for i,line in enumerate(fp):\n if i >= 1:\n reader[i-1] = line.split()[1]\n \n fp.close() \n readers = np.log(reader)\n self.cl = K.constant(readers)\n # Assertions\n assert self.img_rows >= 256, 'Height must be >256 pixels'\n assert self.img_cols >= 256, 'Width must be >256 pixels'\n\n # Set current epoch\n self.current_epoch = 0\n \n # VGG layers to extract features from (first maxpooling layers, see pp. 7 of paper)\n self.vgg_layers = [3, 6, 10]\n\n # Instantiate the vgg network\n if self.vgg_device:\n with tf.device(self.vgg_device):\n self.vgg = self.build_vgg(vgg_weights)\n else:\n self.vgg = self.build_vgg(vgg_weights)\n \n # Create UNet-like model\n if self.gpus <= 1:\n self.model, inputs_mask= self.build_pconv_unet()\n self.compile_pconv_unet(self.model, inputs_mask) \n else:\n with tf.device(\"/cpu:0\"):\n self.model, inputs_mask = self.build_pconv_unet()\n self.model = multi_gpu_model(self.model, gpus=self.gpus)\n self.compile_pconv_unet(self.model, inputs_mask)","def build_vgg(self):\n # Get the vgg network. Extract features from Block 5, last convolution.\n vgg = tf.keras.applications.VGG19(weights=\"imagenet\", input_shape=self.hr_shape, include_top=False)\n vgg.trainable = False\n for layer in vgg.layers:\n layer.trainable = False\n\n # Create model and compile\n model = tf.keras.models.Model(inputs=vgg.input, outputs=vgg.get_layer(\"block5_conv4\").output)\n\n return model","def __init__(self, dropout_rate, num_classes, include_top, layer):\r\n super(VGG16_Shuffle, self).__init__()\r\n print(\"CIFAR VGG16_Shuffle is used\")\r\n self.dropout_rate = dropout_rate\r\n self.num_classes = num_classes\r\n self.include_top = include_top\r\n self.layer = layer\r\n\r\n # Define the building blocks\r\n if layer == 11:\r\n self.conv11 = CONV_3x3shuffle(3, 64, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 12:\r\n self.conv12 = nn.Sequential(CONV_3x3shuffle(64, 64, kernelsize=3, stride=1, padding=1),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=False),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n # self.conv12 = CONV_3x3(64, 64, kernelsize=3, stride=2, padding=1, bias=False)\r\n\r\n if layer == 21:\r\n self.conv21 = CONV_3x3shuffle(64, 128, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 22:\r\n self.conv22 = nn.Sequential(CONV_3x3shuffle(128, 128, kernelsize=3, stride=1, padding=1),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=False),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n # self.conv22 = CONV_3x3(128, 128, kernelsize=3, stride=2, padding=1, bias=False)\r\n\r\n if layer == 31:\r\n self.conv31 = CONV_3x3shuffle(128, 256, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 32:\r\n self.conv32 = CONV_3x3shuffle(256, 256, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 33:\r\n self.conv33 = nn.Sequential(CONV_3x3shuffle(256, 256, kernelsize=3, stride=1, padding=1),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=False),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n # self.conv33 = CONV_3x3(256, 256, kernelsize=3, stride=2, padding=1, bias=False)\r\n\r\n if layer == 41:\r\n self.conv41 = CONV_3x3shuffle(256, 512, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 42:\r\n self.conv42 = CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 43:\r\n self.conv43 = nn.Sequential(CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n # self.conv43 = CONV_3x3(512, 512, kernelsize=3, stride=2, padding=1, bias=False)\r\n\r\n if layer == 51:\r\n self.conv51 = CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 52:\r\n self.conv52 = CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1)\r\n else:\r\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False)\r\n\r\n if layer == 53:\r\n self.conv53 = nn.Sequential(CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n else:\r\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False),\r\n nn.MaxPool2d(kernel_size=2, stride=2))\r\n\r\n self.avgpool = nn.AdaptiveAvgPool2d(1)\r\n self.fc = nn.Sequential(nn.Linear(512, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, 4096),\r\n nn.ReLU(True),\r\n nn.Linear(4096, num_classes))\r\n\r\n # Initialize the weights\r\n for m in self.modules():\r\n if isinstance(m, nn.Conv2d):\r\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\r\n elif isinstance(m, nn.BatchNorm2d):\r\n # raise Exception('You are using a model without BN!!!')\r\n nn.init.constant_(m.weight, 1)\r\n nn.init.constant_(m.bias, 0)","def vgg_16(inputs,\n num_classes=1000,\n is_training=True,\n dropout_keep_prob=0.5,\n spatial_squeeze=True,\n scope='vgg_16'):\n with tf.name_scope(scope, 'vgg_16', [inputs]) as sc:\n end_points_collection = sc + '_end_points'\n # Collect outputs for conv2d, fully_connected and max_pool2d.\n with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],\n outputs_collections=end_points_collection):\n net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')\n net = slim.max_pool2d(net, [2, 2], scope='pool1')\n net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')\n net = slim.max_pool2d(net, [2, 2], scope='pool2')\n net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')\n net = slim.max_pool2d(net, [2, 2], scope='pool3')\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')\n net = slim.max_pool2d(net, [2, 2], scope='pool4')\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')\n net = slim.max_pool2d(net, [2, 2], scope='pool5')\n # Use conv2d instead of fully_connected layers.\n net = slim.conv2d(net, 4096, [3, 3], padding='VALID', scope='fc6')\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\n scope='dropout6')\n net = slim.conv2d(net, 4096, [1, 1], scope='fc7')\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\n scope='dropout7')\n net = slim.conv2d(net, num_classes, [1, 1],\n activation_fn=None,\n normalizer_fn=None,\n scope='fc8')\n # Convert end_points_collection into a end_point dict.\n end_points = slim.utils.convert_collection_to_dict(end_points_collection)\n if spatial_squeeze:\n net = tf.squeeze(net, [1, 2], name='fc8/squeezed')\n end_points[sc + '/fc8'] = net\n return net, end_points","def instantiate_VGG_model(img_input_shape):\r\n # Load the VGG model\r\n vgg_conv = VGG16(weights='imagenet', include_top=False, input_shape=img_input_shape)\r\n \r\n # Freeze the layers except the last 4 layers\r\n for layer in vgg_conv.layers[:-4]:\r\n layer.trainable = False\r\n \r\n # Create the model\r\n model = models.Sequential()\r\n model.add(vgg_conv)\r\n \r\n # Add new layers\r\n model.add(layers.Flatten())\r\n model.add(layers.Dense(256, activation='relu'))\r\n model.add(layers.Dropout(0.25))\r\n model.add(layers.Dense(nb_class, activation='softmax'))\r\n \r\n model.compile(loss='categorical_crossentropy',\r\n optimizer=optimizers.RMSprop(lr=1e-4),\r\n metrics=['acc'])\r\n return model","def build_finetuned_model(args, input_shape, fc_size):\n # setup model\n vgg, base_vgg = VGGWithCustomLayers(args.nb_classes, input_shape, fc_size)\n # setup layers to be trained or not\n setup_trainable_layers(vgg, args.layers_to_freeze)\n # compiling the model\n vgg.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy'])\n\n return vg","def VGGModel(input_shape):\n \n\n X_input = Input(input_shape)\n \n # Creating a Neural Network (VGG-16)\n\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(X_input)\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(X)\n\n # Block 2\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(X)\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(X)\n\n # Block 3\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(X)\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(X)\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(X)\n\n # Block 4\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(X)\n\n # Block 5\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(X)\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(X)\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(X)\n \n X = Flatten()(X)\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc')(X)\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc2')(X)\n X = Dense(2048, activation='relu', kernel_initializer = 'he_normal', name='fc3')(X)\n X = Dense(1024, activation='relu', kernel_initializer = 'he_normal', name='fc4')(X)\n X = Dense(512, activation='relu', kernel_initializer = 'he_normal', name='fc5')(X)\n X = Dense(256, activation='relu', kernel_initializer = 'he_normal', name='fc6')(X)\n X = Dense(2, activation='linear', name='regression')(X)\n model = Model(inputs=X_input, outputs = X, name='HappyModel')\n print(model.summary())\n \n return model","def create_cnn(num_half_rows, num_half_columns, num_channels):\n\n error_checking.assert_is_integer(num_half_rows)\n error_checking.assert_is_integer(num_half_columns)\n error_checking.assert_is_integer(num_channels)\n\n error_checking.assert_is_greater(num_half_rows, 0)\n error_checking.assert_is_greater(num_half_columns, 0)\n error_checking.assert_is_greater(num_channels, 0)\n\n regularizer_object = keras.regularizers.l1_l2(l1=L1_WEIGHT, l2=L2_WEIGHT)\n\n num_grid_rows = 2 * num_half_rows + 1\n num_grid_columns = 2 * num_half_columns + 1\n input_layer_object = keras.layers.Input(\n shape=(num_grid_rows, num_grid_columns, num_channels)\n )\n\n current_num_filters = None\n current_layer_object = None\n\n # Add convolutional layers.\n for _ in range(NUM_CONV_LAYER_SETS):\n for _ in range(NUM_CONV_LAYERS_PER_SET):\n\n if current_num_filters is None:\n current_num_filters = (\n num_channels * NUM_CHANNELS_TO_FIRST_NUM_FILTERS)\n this_input_layer_object = input_layer_object\n\n else:\n current_num_filters *= 2\n this_input_layer_object = current_layer_object\n\n current_layer_object = keras.layers.Conv2D(\n filters=current_num_filters,\n kernel_size=(NUM_CONV_FILTER_ROWS, NUM_CONV_FILTER_COLUMNS),\n strides=(1, 1), padding='valid', data_format='channels_last',\n dilation_rate=(1, 1), activation=None, use_bias=True,\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\n kernel_regularizer=regularizer_object\n )(this_input_layer_object)\n\n current_layer_object = keras.layers.LeakyReLU(\n alpha=SLOPE_FOR_RELU\n )(current_layer_object)\n\n if CONV_LAYER_DROPOUT_FRACTION is not None:\n current_layer_object = keras.layers.Dropout(\n rate=CONV_LAYER_DROPOUT_FRACTION\n )(current_layer_object)\n\n if USE_BATCH_NORMALIZATION:\n current_layer_object = keras.layers.BatchNormalization(\n axis=-1, center=True, scale=True\n )(current_layer_object)\n\n current_layer_object = keras.layers.MaxPooling2D(\n pool_size=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\n strides=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\n padding='valid', data_format='channels_last'\n )(current_layer_object)\n\n these_dimensions = numpy.array(\n current_layer_object.get_shape().as_list()[1:], dtype=int)\n num_features = numpy.prod(these_dimensions)\n\n current_layer_object = keras.layers.Flatten()(current_layer_object)\n\n # Add intermediate dense layers.\n _, num_outputs_by_dense_layer = (\n architecture_utils.get_dense_layer_dimensions(\n num_input_units=num_features, num_classes=NUM_CLASSES,\n num_dense_layers=NUM_DENSE_LAYERS)\n )\n\n for k in range(NUM_DENSE_LAYERS - 1):\n current_layer_object = keras.layers.Dense(\n num_outputs_by_dense_layer[k], activation=None, use_bias=True,\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\n kernel_regularizer=regularizer_object\n )(current_layer_object)\n\n current_layer_object = keras.layers.LeakyReLU(\n alpha=SLOPE_FOR_RELU\n )(current_layer_object)\n\n if DENSE_LAYER_DROPOUT_FRACTION is not None:\n current_layer_object = keras.layers.Dropout(\n rate=DENSE_LAYER_DROPOUT_FRACTION\n )(current_layer_object)\n\n if USE_BATCH_NORMALIZATION:\n current_layer_object = keras.layers.BatchNormalization(\n axis=-1, center=True, scale=True\n )(current_layer_object)\n\n # Add output layer (also dense).\n current_layer_object = keras.layers.Dense(\n NUM_CLASSES, activation=None, use_bias=True,\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\n kernel_regularizer=regularizer_object\n )(current_layer_object)\n\n current_layer_object = keras.layers.Activation(\n 'softmax'\n )(current_layer_object)\n\n if DENSE_LAYER_DROPOUT_FRACTION is not None and NUM_DENSE_LAYERS == 1:\n current_layer_object = keras.layers.Dropout(\n rate=DENSE_LAYER_DROPOUT_FRACTION\n )(current_layer_object)\n\n # Put the whole thing together and compile.\n cnn_model_object = keras.models.Model(\n inputs=input_layer_object, outputs=current_layer_object)\n cnn_model_object.compile(\n loss=keras.losses.categorical_crossentropy,\n optimizer=keras.optimizers.Adam(),\n metrics=LIST_OF_METRIC_FUNCTIONS)\n\n cnn_model_object.summary()\n return cnn_model_object","def __init__(self):\n torch.nn.Module.__init__(self)\n ######################### Convolution and pooling layers of VGG-16.\n self.features = torchvision.models.vgg16(pretrained=True).features # fine tune?\n self.features = torch.nn.Sequential(*list(self.features.children())\n [:-22]) # Remove pool2 and rest, lack of computational resource\n # No grad for convVGG\n # for param in self.features.parameters():\n # param.requires_grad = False\n\n #################### Channel Grouping Net\n # self.fc1_ = torch.nn.Linear(128, 128*16)#lack of resource\n # self.fc2_ = torch.nn.Linear(128, 128*16)\n # self.fc3_ = torch.nn.Linear(128, 128*16)\n #\n # torch.nn.init.kaiming_normal_(self.fc1_.weight.data, nonlinearity='relu')\n # if self.fc1_.bias is not None:\n # torch.nn.init.constant_(self.fc1_.bias.data, val=0) # fc层的bias进行constant初始化\n # torch.nn.init.kaiming_normal_(self.fc2_.weight.data, nonlinearity='relu')\n # if self.fc2_.bias is not None:\n # torch.nn.init.constant_(self.fc2_.bias.data, val=0) # fc层的bias进行constant初始化\n # torch.nn.init.kaiming_normal_(self.fc3_.weight.data, nonlinearity='relu')\n # if self.fc3_.bias is not None:\n # torch.nn.init.constant_(self.fc3_.bias.data, val=0) # fc层的bias进行constant初始化\n\n self.fc1 = torch.nn.Linear(128*28*28, 128)\n self.fc2 = torch.nn.Linear(128*28*28, 128)\n self.fc3 = torch.nn.Linear(128*28*28, 128)\n\n\n torch.nn.init.kaiming_normal_(self.fc1.weight.data, nonlinearity='relu')\n if self.fc1.bias is not None:\n torch.nn.init.constant_(self.fc1.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.fc2.weight.data, nonlinearity='relu')\n if self.fc2.bias is not None:\n torch.nn.init.constant_(self.fc2.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.fc3.weight.data, nonlinearity='relu')\n if self.fc3.bias is not None:\n torch.nn.init.constant_(self.fc3.bias.data, val=0) # fc层的bias进行constant初始化\n\n self.layerNorm=nn.LayerNorm([224,224])\n\n # global grad for hook\n self.image_reconstruction = None\n self.register_hooks()\n self.GradWeight=1e-1\n\n # ################### STN input N*3*448*448\n # self.localization = [\n # nn.Sequential(\n # nn.MaxPool2d(4,stride=4),#112\n # nn.ReLU(True),\n #\n # nn.Conv2d(3, 32, kernel_size=5,stride=1,padding=2), # 112\n # nn.MaxPool2d(2, stride=2), # 56\n # nn.ReLU(True),\n #\n # nn.Conv2d(32, 48, kernel_size=3,stride=1,padding=1),\n # nn.MaxPool2d(2, stride=2), # 56/2=28\n # nn.ReLU(True),\n #\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 28/2=14\n # nn.ReLU(True) #output 64*14*14\n # ).cuda(),\n # nn.Sequential(\n # nn.MaxPool2d(4, stride=4), # 112\n # nn.ReLU(True),\n #\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\n # nn.MaxPool2d(2, stride=2), # 56\n # nn.ReLU(True),\n #\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 56/2=28\n # nn.ReLU(True),\n #\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 28/2=14\n # nn.ReLU(True) # output 64*14*14\n # ).cuda(),\n # nn.Sequential(\n # nn.MaxPool2d(4, stride=4), # 112\n # nn.ReLU(True),\n #\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\n # nn.MaxPool2d(2, stride=2), # 56\n # nn.ReLU(True),\n #\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 56/2=28\n # nn.ReLU(True),\n #\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\n # nn.MaxPool2d(2, stride=2), # 28/2=14\n # nn.ReLU(True) # output 64*14*14\n # ).cuda()\n # ]\n # # Regressor for the 3 * 2 affine matrix\n # self.fc_loc = [\n # nn.Sequential(\n # nn.Linear(64 * 14 * 14, 32),\n # nn.ReLU(True),\n # nn.Linear(32, 3 * 2)\n # ).cuda(),\n # nn.Sequential(\n # nn.Linear(64 * 14 * 14, 32),\n # nn.ReLU(True),\n # nn.Linear(32, 3 * 2)\n # ).cuda(),\n # nn.Sequential(\n # nn.Linear(64 * 14 * 14, 32),\n # nn.ReLU(True),\n # nn.Linear(32, 3 * 2)\n # ).cuda()\n # ]\n # # Initialize the weights/bias with identity transformation\n # for fc_locx in self.fc_loc:\n # fc_locx[2].weight.data.zero_()\n # fc_locx[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\n\n ########################Bilinear CNN output 256 channels\n self.bcnnConv_1=torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\n [:-1]) # Remove pool3 and rest.\n self.bcnnConv_2 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\n [:-1]) # Remove pool3 and rest.\n self.bcnnConv_3 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\n [:-1]) # Remove pool3 and rest.\n #BCNN Linear classifier.\n self.bfc1 = torch.nn.Linear(512*512, 200)\n self.bfc2 = torch.nn.Linear(512*512, 200)\n self.bfc3 = torch.nn.Linear(512*512, 200)\n torch.nn.init.kaiming_normal_(self.bfc1.weight.data) # 何凯明初始化\n if self.bfc1.bias is not None:\n torch.nn.init.constant_(self.bfc1.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.bfc2.weight.data) # 何凯明初始化\n if self.bfc2.bias is not None:\n torch.nn.init.constant_(self.bfc2.bias.data, val=0) # fc层的bias进行constant初始化\n torch.nn.init.kaiming_normal_(self.bfc3.weight.data) # 何凯明初始化\n if self.bfc3.bias is not None:\n torch.nn.init.constant_(self.bfc3.bias.data, val=0) # fc层的bias进行constant初始化\n\n # self.CBP1 = CompactBilinearPooling(512, 512, 50000)\n # self.CBP2 = CompactBilinearPooling(512, 512, 50000)\n # self.CBP3 = CompactBilinearPooling(512, 512, 50000)","def create_vggvox(embedding_dims, name=\"vggvox\"):\n model = tf.keras.Sequential(name=name)\n model.add(tf.keras.layers.Conv2D(96, (7,7), strides=(2,2), padding=\"valid\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\"{name}_conv1\"))\n model.add(tf.keras.layers.BatchNormalization())\n model.add(tf.keras.layers.ReLU())\n model.add(tf.keras.layers.MaxPooling2D((3,3), strides=(2,2), name=\"mpool1\"))\n model.add(tf.keras.layers.Conv2D(256, (5,5), strides=(2,2), padding=\"valid\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\"{name}_conv2\"))\n model.add(tf.keras.layers.BatchNormalization())\n model.add(tf.keras.layers.ReLU())\n model.add(tf.keras.layers.MaxPooling2D((3,3), strides=(2,2), name=\"mpool2\"))\n model.add(tf.keras.layers.Conv2D(384, (3,3), strides=(1,1), padding=\"same\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\"{name}_conv3\"))\n model.add(tf.keras.layers.BatchNormalization())\n model.add(tf.keras.layers.ReLU())\n model.add(tf.keras.layers.Conv2D(256, (3,3), strides=(1,1), padding=\"same\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\"{name}_conv4\"))\n model.add(tf.keras.layers.BatchNormalization())\n model.add(tf.keras.layers.ReLU())\n model.add(tf.keras.layers.Conv2D(256, (3,3), strides=(1,1), padding=\"same\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\"{name}_conv5\"))\n model.add(tf.keras.layers.BatchNormalization())\n model.add(tf.keras.layers.ReLU())\n model.add(tf.keras.layers.MaxPooling2D((5,3), strides=(3,2), name=f\"{name}_mpool5\"))\n model.add(tf.keras.layers.Conv2D(4096, (9,1), strides=1, kernel_regularizer=tf.keras.regularizers.L2(5e-4), padding=\"valid\", name=f\"{name}_fc6\"))\n model.add(tf.keras.layers.BatchNormalization())\n model.add(tf.keras.layers.ReLU())\n model.add(tf.keras.layers.Lambda(lambda x: tf.math.reduce_mean(x, axis=[1,2], name=f\"{name}_apool6\")))\n model.add(tf.keras.layers.Flatten())\n model.add(tf.keras.layers.Dense(embedding_dims, kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\"{name}_embeddings\"))\n model.add(tf.keras.layers.BatchNormalization())\n model.add(tf.keras.layers.ReLU())\n return model","def _build_model(self):\n fc0_std = 0.2 # std of random initialization for fc0 matrix\n fc0_shape = [4, 4, 1024] # shape of the fc0 reshaped output (for batch size = 1)\n fc0_size = fc0_shape[0] * fc0_shape[1] * fc0_shape[2] # size of the fc0 output\n\n # if input is not a variable connecting the discriminator to another network (ex, generator output),\n # initialize a placeholder\n if self._input_data is None:\n # placeholder for input data\n self._input_data = tf.placeholder(tf.float32, [None, self.input_size], name=self.nid + \"_input\")\n\n # project and reshape the input array - basically an fc layer doing matrix multiplication and bias addition\n with tf.variable_scope(self.nid+\"_fc0\"):\n W = tf.get_variable(\"W\", shape=[self.input_size, fc0_size], dtype=tf.float32,\n initializer=tf.random_normal_initializer(stddev=fc0_std))\n b = tf.get_variable(\"b\", shape=[fc0_size], dtype=tf.float32,\n initializer=tf.random_normal_initializer(stddev=fc0_std))\n fc0_output = tf.reshape(tf.nn.bias_add(tf.matmul(self._input_data, W), b), [-1] + fc0_shape)\n\n fsconv_input = fc0_output # initial fsconv input is the output of the fc layer\n\n # filter's first 2 dimensions, the rest two are auto computed\n filter_shape = [5, 5]\n # generate output shapes for each fsconv layer\n output_shapes = [[int(2 ** x), int(2 ** x), int(fc0_shape[2] * 4 / (2 ** x))]\n for x in range(3, 10) if int(2**x) <= np.min(self.output_size[:2])]\n # set the last output shape to be 3-channeled (or as required by the model)\n output_shapes[-1][2] = self.output_size[2]\n\n fsconv_shapes = [fc0_output.get_shape().as_list()]\n\n batch_size = tf.shape(fsconv_input)[0] # workaround since conv2d_transpose explicitly needs batch size\n\n # create the intermediate fsconv layers\n for output_shape in output_shapes:\n with tf.variable_scope(self.nid+\"_fsconv-{}x{}\".format(output_shape[0], output_shape[1])):\n W_shape = filter_shape+[output_shape[2]]+[fsconv_input.get_shape().as_list()[-1]]\n W = tf.get_variable(\"W\", initializer=tf.truncated_normal(W_shape, stddev=0.1))\n b = tf.get_variable(\"b\", shape=output_shape[-1:], initializer=tf.constant_initializer(0.0))\n # fractionally-strided convolution network\n # conv2d_transpose does not accept variable batch sizes and batch size needs to be explicitly specified\n # a workaround is to compute it during run-time and pass it with the output_shape\n # https://github.com/tensorflow/tensorflow/issues/833\n fsconv = tf.nn.conv2d_transpose(fsconv_input, W,\n output_shape=[batch_size]+output_shape, strides=[1, 2, 2, 1])\n fsconv = tf.nn.bias_add(fsconv, b)\n fsconv = tf.nn.relu(fsconv) # apply relu layer\n # store the shape for verbose\n fsconv_shapes.append(fsconv.get_shape().as_list())\n fsconv_input = fsconv\n\n if self._verbose:\n print(\"FSConv layer output shapes - {}\".format(fsconv_shapes))\n\n self._model = fsconv","def __init__(self, nfeat, nhid, nclass, dropout, alpha):\n super(GCN, self).__init__()\n self.dropout = dropout\n\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\n \n self.add_module('conv1', self.conv1)\n\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)","def vgg_bsd(args, x, train_phase):\n # Sure layers weight & bias\n nf = int(args.n_filters)\n nf2 = int((args.filter_gain)*nf)\n nf3 = int((args.filter_gain**2)*nf)\n nf4 = int((args.filter_gain**3)*nf)\n bs = args.batch_size\n fs = args.filter_size\n nch = args.n_channels\n tp = train_phase\n\n fm = {}\n # Convolutional Layers\n with tf.name_scope('stage1') as scope:\n cv1 = linear(x, nf, fs, name='1_1')\n cv1 = tf.nn.relu(cv1, name='1_1')\n\n cv2 = linear(cv1, nf, fs, name='1_2')\n cv2 = Zbn(cv2, tp, name='bn1')\n cv2 = tf.nn.relu(cv2)\n fm[1] = linear(cv2, 1, 1, name='fm1')\n\n with tf.name_scope('stage2') as scope:\n cv3 = tf.nn.max_pool(cv2, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\n cv3 = linear(cv3, nf2, fs, name='2_1')\n cv3 = tf.nn.relu(cv3, name='2_1')\n\n cv4 = linear(cv3, nf2, fs, name='2_2')\n cv4 = Zbn(cv4, train_phase, name='bn2')\n cv4 = tf.nn.relu(cv4)\n fm[2] = linear(cv4, 1, 1, name='fm2')\n\n with tf.name_scope('stage3') as scope:\n cv5 = tf.nn.max_pool(cv4, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\n cv5 = linear(cv5, nf3, fs, name='3_1')\n cv5 = tf.nn.relu(cv5, name='3_1')\n\n cv6 = linear(cv5, nf3, fs, name='3_2')\n cv6 = Zbn(cv6, train_phase, name='bn3')\n cv6 = tf.nn.relu(cv6)\n fm[3] = linear(cv6, 1, 1, name='fm3')\n\n with tf.name_scope('stage4') as scope:\n cv7 = tf.nn.max_pool(cv6, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\n cv7 = linear(cv7, nf4, fs, name='4_1')\n cv7 = tf.nn.relu(cv7, name='4_1')\n\n cv8 = linear(cv7, nf4, fs, name='4_2')\n cv8 = Zbn(cv8, train_phase, name='bn4')\n cv8 = tf.nn.relu(cv8)\n fm[4] = linear(cv8, 1, 1, name='fm4')\n\n with tf.name_scope('stage5') as scope:\n cv9 = tf.nn.max_pool(cv8, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\n cv9 = linear(cv9, nf4, fs, name='5_1')\n cv9 = tf.nn.relu(cv9, name='5_1')\n\n cv10 = linear(cv9, nf4, fs, name='5_2')\n cv10 = Zbn(cv10, train_phase, name='bn5')\n cv10 = tf.nn.relu(cv10)\n fm[5] = linear(cv10, 1, 1, name='fm5')\n\n fms = {}\n side_preds = []\n xsh = tf.shape(x)\n with tf.name_scope('fusion') as scope:\n for key in fm.keys():\n fms[key] = tf.image.resize_images(fm[key], tf.stack([xsh[1], xsh[2]]))\n side_preds.append(fms[key])\n side_preds = tf.concat(axis=3, values=side_preds)\n\n fms['fuse'] = linear(side_preds, 1, 1, bias_init=0.01, name='fuse')\n return fms","def Vgg19_simple_api(input, reuse, nchannels, rgb=False):\n VGG_MEAN = [103.939, 116.779, 123.68]\n with tf.variable_scope(\"VGG19\", reuse=reuse) as vs:\n start_time = time.time()\n print(\"build model started\")\n\n if rgb == True:\n rgb_scaled = input * 255.0\n # Convert RGB to BGR\n if tf.__version__ <= '0.11':\n red, green, blue = tf.split(3, 3, rgb_scaled)\n else: # TF 1.0\n # print(rgb_scaled)\n red, green, blue = tf.split(rgb_scaled, 3, 3)\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\n if tf.__version__ <= '0.11':\n bgr = tf.concat(3, [\n blue - VGG_MEAN[0],\n green - VGG_MEAN[1],\n red - VGG_MEAN[2],\n ])\n else:\n bgr = tf.concat(\n [\n blue - VGG_MEAN[0],\n green - VGG_MEAN[1],\n red - VGG_MEAN[2],\n ], axis=3)\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\n\n \"\"\" input layer \"\"\"\n net_in = InputLayer(bgr, name='input')\n\n else:\n assert input.get_shape().as_list()[1:] == [224, 224, nchannels]\n net_in = InputLayer(input, name = 'input')\n\n\n \"\"\" conv1 \"\"\"\n network = Conv2d(net_in, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv1_1')\n network = Conv2d(network, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv1_2')\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool1')\n \"\"\" conv2 \"\"\"\n network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv2_1')\n network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv2_2')\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool2')\n \"\"\" conv3 \"\"\"\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_1')\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_2')\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_3')\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_4')\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool3')\n \"\"\" conv4 \"\"\"\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_1')\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_2')\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_3')\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_4')\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool4') # (batch_size, 14, 14, 512)\n conv = network\n \"\"\" conv5 \"\"\"\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_1')\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_2')\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_3')\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_4')\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool5') # (batch_size, 7, 7, 512)\n \"\"\" fc 6~8 \"\"\"\n network = FlattenLayer(network, name='flatten')\n network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc6')\n network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc7')\n network = DenseLayer(network, n_units=1000, act=tf.identity, name='fc8')\n print(\"build model finished: %fs\" % (time.time() - start_time))\n return network, conv","def __init__(self, input_dim=(3, 32, 32), hidden_dims_CNN = ((32, 5, 1, 1), (2, 2, 2)),\n hidden_dims_FC = ((1024), (0.5)), num_classes=10, weight_scale=1e-3, \n reg=0.0, dtype=np.float32):\n self.params = {}\n self.fix_params = {}\n self.reg = reg\n self.dtype = dtype\n \n C_input, H_input, W_input = input_dim\n pre_C = C_input \n pre_H = H_input\n pre_W = W_input\n \n num_CNN = len(hidden_dims_CNN)\n num_FC = len(hidden_dims_FC)\n\n for i in range(0, num_CNN):\n W_name = \"W\" + str(i)\n b_name = \"b\" + str(i)\n conv_param_name = \"conv_param\" + str(i)\n gamma_name = \"gamma\" + str(i)\n beta_name = \"beta\" + str(i)\n bn_param_name = \"bn_param\" + str(i)\n pool_param_name = \"pool_param\" + str(i)\n\n if num_CNN == 1:\n num_filters, filter_size, stride, pad = hidden_dims_CNN[0] # (F, filter_size, stride, pad)\n pool_stride, pool_height, pool_width = hidden_dims_CNN[1] # (pooling_stride, pooling_size)\n else:\n num_filters, filter_size, stride, pad = hidden_dims_CNN[i][0] # (F, filter_size, stride, pad)\n pool_stride, pool_height, pool_width = hidden_dims_CNN[i][1] # (pooling_stride, pooling_size)\n \n if weight_scale == -1:\n self.params[W_name] = np.random.randn(num_filters, pre_C, filter_size, filter_size) / np.sqrt(filter_size * filter_size * pre_C)\n else: \n self.params[W_name] = np.random.randn(num_filters, pre_C, filter_size, filter_size) * weight_scale\n self.params[b_name] = np.zeros(num_filters)\n self.fix_params[conv_param_name] = {'stride': stride, 'pad': pad}\n \n self.params[gamma_name] = np.random.randn(num_filters)\n self.params[beta_name] = np.random.randn(num_filters)\n self.fix_params[bn_param_name] = {'mode': 'train'}\n\n self.fix_params[pool_param_name] = {'pool_height': pool_height, 'pool_width': pool_width, 'stride': pool_stride}\n \n pre_H, pre_W = cnn_out_shape(pre_H, pre_W, filter_size, filter_size, stride, pad)\n pre_C = num_filters \n pre_H, pre_W = pool_out_shape(pre_H, pre_W, pool_height, pool_width, pool_stride)\n\n pre_fc_dim = pre_H * pre_W * pre_C\n\n for i in range(0, num_FC):\n W_name = \"W\" + str(i + num_CNN)\n b_name = \"b\" + str(i + num_CNN)\n gamma_name = \"gamma\" + str(i + num_CNN)\n beta_name = \"beta\" + str(i + num_CNN)\n bn_param_name = \"bn_param\" + str(i + num_CNN)\n drop_name = \"drop_ratio\" + str(i + num_CNN)\n \n if num_FC == 1 :\n fc_num = hidden_dims_FC[0]\n drop_ratio = hidden_dims_FC[1]\n else:\n fc_num = hidden_dims_FC[i][0]\n drop_ratio = hidden_dims_FC[i][1]\n\n if weight_scale == -1:\n self.params[W_name] = np.random.randn(pre_fc_dim, fc_num) / np.sqrt(pre_fc_dim)\n else:\n self.params[W_name] = np.random.randn(pre_fc_dim, fc_num) * weight_scale\n self.params[b_name] = np.zeros(fc_num)\n\n self.params[gamma_name] = np.random.randn(fc_num)\n self.params[beta_name] = np.random.randn(fc_num)\n self.fix_params[bn_param_name] = {'mode': 'train'}\n\n self.fix_params[drop_name] = {'mode': 'train', 'p': drop_ratio}\n\n pre_fc_dim = fc_num\n\n total_layer = num_CNN + num_FC\n W_name = \"W\" + str(total_layer)\n b_name = \"b\" + str(total_layer)\n if weight_scale == -1:\n self.params[W_name] = np.random.randn(pre_fc_dim, num_classes) / np.sqrt(pre_fc_dim)\n else:\n self.params[W_name] = np.random.randn(pre_fc_dim, num_classes) * weight_scale\n self.params[b_name] = np.zeros(num_classes)\n\n\n self.num_CNN = num_CNN\n self.num_FC = num_FC\n self.total_layer = num_CNN + num_FC\n\n for k, v in self.params.iteritems():\n self.params[k] = v.astype(dtype)","def vgg16_general(features, labels, mode):\n\n input_layer = tf.reshape(features, [-1, SIZE, SIZE, 3])\n\n # 1st stack of convolutional layers\n conv3_64_0 = tf.layers.conv2d(\n inputs=input_layer,\n filters=64,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv3_64_1 = tf.layers.conv2d(\n inputs=conv3_64_0,\n filters=64,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n maxpool_0 = tf.layers.max_pooling2d(\n inputs=conv3_64_1,\n pool_size=[2, 2],\n strides=2)\n\n # 2nd stack of convolutional layers\n conv3_128_0 = tf.layers.conv2d(\n inputs=maxpool_0,\n filters=128,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv3_128_1 = tf.layers.conv2d(\n inputs=conv3_128_0,\n filters=128,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n maxpool_1 = tf.layers.max_pooling2d(\n inputs=conv3_128_1,\n pool_size=[2, 2],\n strides=2)\n\n # 3rd stack of convolutional layers\n conv3_256_0 = tf.layers.conv2d(\n inputs=maxpool_1,\n filters=256,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv3_256_1 = tf.layers.conv2d(\n inputs=conv3_256_0,\n filters=256,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv1_256_0 = tf.layers.conv2d(\n inputs=conv3_256_1,\n filters=256,\n kernel_size=[1, 1],\n padding=\"same\",\n activation=tf.nn.relu)\n\n maxpool_2 = tf.layers.max_pooling2d(\n inputs=conv1_256_0,\n pool_size=[2, 2],\n strides=2)\n\n # 4th stack of convolutional layers\n conv3_512_0 = tf.layers.conv2d(\n inputs=maxpool_2,\n filters=512,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv3_512_1 = tf.layers.conv2d(\n inputs=conv3_512_0,\n filters=512,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv1_512_0 = tf.layers.conv2d(\n inputs=conv3_512_1,\n filters=512,\n kernel_size=[1, 1],\n padding=\"same\",\n activation=tf.nn.relu)\n\n maxpool_3 = tf.layers.max_pooling2d(\n inputs=conv1_512_0,\n pool_size=[2, 2],\n strides=2)\n\n # 5th stack of convolutional layers\n conv3_512_2 = tf.layers.conv2d(\n inputs=maxpool_3,\n filters=512,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv3_512_3 = tf.layers.conv2d(\n inputs=conv3_512_2,\n filters=512,\n kernel_size=[3, 3],\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv1_512_1 = tf.layers.conv2d(\n inputs=conv3_512_3,\n filters=512,\n kernel_size=[1, 1],\n padding=\"same\",\n activation=tf.nn.relu)\n\n maxpool_4 = tf.layers.max_pooling2d(\n inputs=conv1_512_1,\n pool_size=[2, 2],\n strides=2)\n\n # Flatten tensor for dense layers\n _, new_size, _, new_channels = maxpool_4.shape\n maxpool_4_flat = tf.reshape(maxpool_4, [-1, new_size * new_size * new_channels])\n\n # Dense layers\n fc_4096_0 = tf.layers.dense(\n inputs=maxpool_4_flat,\n units=4096,\n activation=tf.nn.relu)\n\n fc_4096_1 = tf.layers.dense(\n inputs=fc_4096_0,\n units=4096,\n activation=tf.nn.relu)\n\n return fc_4096_1","def build(self, input_shape: tf.Tensor):\n self.conv = tf.keras.layers.Conv2D(\n self.channels, (1, 1), input_shape=input_shape)\n self.bn = tf.keras.layers.BatchNormalization(momentum=self.momentum)","def create_vgg_up_block(filters, in_features, activation, kernel_size=3, batch_norm=False):\n layers = []\n if isinstance(filters, int):\n filters = [filters]\n\n if not isinstance(filters, list):\n raise ValueError(\"Filters has to be a list\")\n\n in_feat = in_features\n\n layers.append(Conv2d_Up(in_features=in_feat, out_features=filters[0], activation=activation, kernel_size=kernel_size, batch_norm=batch_norm))\n in_feat = filters[0]\n\n for n in range(len(filters))[1:]:\n out_feat = filters[n]\n conv = Conv2d_same(in_features=in_feat, out_features=out_feat, activation=activation, kernel_size=kernel_size, batch_norm=batch_norm)\n layers.append(conv)\n in_feat = out_feat\n\n out_feat = filters[-1]\n return layers, out_feat","def cnn_model_fn(features, labels, mode, num_classes=20):\n # Write this function\n # Input Layer\n input_layer = tf.reshape(features[\"x\"], [-1, 256, 256, 3])\n img_num = input_layer.get_shape().as_list()[0]\n input_image_layer = input_layer\n\n '''\n if img_num is not None:\n for img_idx in range(img_num):\n image = input_layer[img_idx,:]\n image = tf.random_crop(value = image, size = [224, 224, 3])\n image = tf.image.flip_left_right(image)\n image = tf.image.resize_image_with_crop_or_pad(image=image,target_height = 224, target_width = 224)\n input_image_layer.append(image)\n\n input_image_layer = tf.convert_to_tensor(input_image_layer, dtype=tf.float32)\n else:\n input_image_layer = input_layer\n print('img_num shape {}: input_layer is {} '.format(img_num, np.shape(input_layer.get_shape().as_list())))\n print(\"img_num is None\")\n '''\n\n # Convolutional Layer #1\n conv1_1 = tf.layers.conv2d(\n inputs=input_image_layer,\n filters=64,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n # pad = 1\n conv1_2 = tf.layers.conv2d(\n inputs=conv1_1,\n filters=64,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n pool1 = tf.layers.max_pooling2d(inputs=conv1_2, pool_size=[2, 2], strides=2)\n\n\n conv2_1 = tf.layers.conv2d(\n inputs=pool1,\n filters=128,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n\n conv2_2 = tf.layers.conv2d(\n inputs= conv2_1,\n filters=128,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n pool2 = tf.layers.max_pooling2d(inputs=conv2_2, pool_size=[2, 2], strides=2)\n\n conv3_1 = tf.layers.conv2d(\n inputs= pool2,\n filters=256,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv3_2 = tf.layers.conv2d(\n inputs= conv3_1,\n filters=256,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv3_3 = tf.layers.conv2d(\n inputs= conv3_2,\n filters=256,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n pool3 = tf.layers.max_pooling2d(inputs=conv3_3, pool_size=[2, 2], strides=2)\n\n\n conv4_1 = tf.layers.conv2d(\n inputs= pool3,\n filters=512,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv4_2 = tf.layers.conv2d(\n inputs= conv4_1,\n filters=512,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv4_3 = tf.layers.conv2d(\n inputs= conv4_2,\n filters=512,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n pool4 = tf.layers.max_pooling2d(inputs=conv4_3, pool_size=[2, 2], strides=2)\n\n conv5_1 = tf.layers.conv2d(\n inputs= pool4,\n filters=512,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv5_2 = tf.layers.conv2d(\n inputs= conv5_1,\n filters=512,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n conv5_3 = tf.layers.conv2d(\n inputs= conv5_2,\n filters=512,\n kernel_size=[3, 3],\n strides=(1, 1),\n padding=\"same\",\n activation=tf.nn.relu)\n\n pool5 = tf.layers.max_pooling2d(inputs=conv5_3, pool_size=[2, 2], strides=2)\n\n # Dense Layer\n pool5_shape = pool5.get_shape()\n pool5_list = pool5_shape.as_list()\n pool5_product = np.int32(pool5_list[1]*pool5_list[2]*pool5_list[3])\n pool5_flat = tf.reshape(pool5, [-1, pool5_product])\n\n dense6 = tf.layers.dense(inputs=pool5_flat, units=4096,activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(mean=0.0,stddev=0.01),bias_initializer=tf.zeros_initializer(),)\n dropout6 = tf.layers.dropout(\n inputs=dense6, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\n\n\n dense7 = tf.layers.dense(inputs=dropout6, units= 4096, activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(mean=0.0,stddev=0.01),\n bias_initializer=tf.zeros_initializer(),)\n dropout7 = tf.layers.dropout(\n inputs=dense7, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\n\n # Logits Layer\n logits = tf.layers.dense(inputs=dropout7, units=20)\n\n\n predictions = {\n # Generate predictions (for PREDICT and EVAL mode)\n \"classes\": tf.argmax(input=logits, axis=1),\n # Add `softmax_tensor` to the graph. It is used for PREDICT and by the\n # `logging_hook`.\n \"probabilities\": tf.nn.sigmoid(logits, name=\"sigmoid_tensor\")\n }\n\n if mode == tf.estimator.ModeKeys.PREDICT:\n return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\n\n\n # Calculate Loss (for both TRAIN and EVAL modes)\n\n loss = tf.identity(tf.losses.sigmoid_cross_entropy(multi_class_labels=labels,logits=logits))\n\n # Configure the Training Op (for TRAIN mode)\n if mode == tf.estimator.ModeKeys.TRAIN:\n grad_input = tf.gradients(loss,input_layer)\n grad_conv1_1 = tf.gradients(loss, conv1_1)\n grad_conv2_1 = tf.gradients(loss, conv2_1)\n grad_conv3_1 = tf.gradients(loss, conv3_1)\n grad_conv4_1 = tf.gradients(loss, conv4_1)\n grad_conv5_1 = tf.gradients(loss, conv5_1)\n grad_dense6 = tf.gradients(loss, dense6)\n grad_dense7 = tf.gradients(loss, dense7)\n\n starter_learning_rate = 0.001\n global_step = tf.train.get_global_step()\n learning_rate = tf.train.exponential_decay(learning_rate= starter_learning_rate, global_step = global_step,\n decay_steps = 100000, decay_rate= 0.5, staircase=True)\n optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)\n train_op = optimizer.minimize(\n loss=loss,\n global_step=tf.train.get_global_step())\n #tf.summary()\n # print(\"Training\")\n tf.summary.scalar(name= 'train_loss', tensor = loss )\n tf.summary.scalar(name= 'learning rate', tensor = learning_rate)\n tf.summary.histogram(name='grad_dense7', values=grad_input)\n tf.summary.histogram(name='grad_conv1_1', values= grad_conv1_1)\n tf.summary.histogram(name='grad_conv2_1', values=grad_conv2_1)\n tf.summary.histogram(name='grad_conv3_1', values=grad_conv3_1)\n tf.summary.histogram(name='grad_conv4_1', values=grad_conv4_1)\n tf.summary.histogram(name='grad_conv5_1', values=grad_conv5_1)\n tf.summary.histogram(name='grad_dense6', values=grad_dense6)\n tf.summary.histogram(name='grad_dense7', values=grad_dense7)\n\n tf.summary.image(name='image', tensor= input_layer)\n\n summary_hook = tf.train.SummarySaverHook(\n 10,\n output_dir='./models/03_VGG_Test0301',\n summary_op=tf.summary.merge_all())\n\n return tf.estimator.EstimatorSpec(\n mode=mode, loss=loss, train_op=train_op, training_hooks = [summary_hook])\n\n # Add evaluation metrics (for EVAL mode)\n eval_metric_ops = {\n \"accuracy\": tf.metrics.accuracy(\n labels=labels, predictions=predictions[\"classes\"])}\n return tf.estimator.EstimatorSpec(\n mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)","def init(self):\n self.reparam_layers = []\n if self.model_type == \"GCN\":\n for i in range(self.num_layers):\n if self.reparam_all_layers is True:\n is_reparam = True\n elif isinstance(self.reparam_all_layers, tuple):\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\n is_reparam = i in reparam_all_layers\n else:\n raise\n if is_reparam:\n self.reparam_layers.append(i)\n setattr(self, \"conv{}\".format(i + 1),\n GCNConv(self.num_features if i == 0 else self.latent_size,\n self.latent_size if i != self.num_layers - 1 else self.num_classes,\n cached=True,\n reparam_mode=self.reparam_mode if is_reparam else None,\n prior_mode=self.prior_mode if is_reparam else None,\n sample_size=self.sample_size,\n bias=True if self.with_relu else False,\n val_use_mean=self.val_use_mean,\n normalize=self.normalize,\n ))\n # self.conv1 = ChebConv(self.num_features, 16, K=2)\n # self.conv2 = ChebConv(16, self.num_features, K=2)\n\n elif self.model_type == \"GAT\":\n latent_size = int(self.latent_size / 2) # Under the default setting, latent_size = 8\n for i in range(self.num_layers):\n if i == 0:\n input_size = self.num_features\n else:\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\n input_size = latent_size * 8 * 2\n else:\n input_size = latent_size * 8\n if self.reparam_all_layers is True:\n is_reparam = True\n elif isinstance(self.reparam_all_layers, tuple):\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\n is_reparam = i in reparam_all_layers\n else:\n raise\n if is_reparam:\n self.reparam_layers.append(i)\n setattr(self, \"conv{}\".format(i + 1), GATConv(\n input_size,\n latent_size if i != self.num_layers - 1 else self.num_classes,\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\n reparam_mode=self.reparam_mode if is_reparam else None,\n prior_mode=self.prior_mode if is_reparam else None,\n val_use_mean=self.val_use_mean,\n struct_dropout_mode=self.struct_dropout_mode,\n sample_size=self.sample_size,\n ))\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\n setattr(self, \"conv{}_1\".format(i + 1), GATConv(\n input_size,\n latent_size if i != self.num_layers - 1 else self.num_classes,\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\n reparam_mode=self.reparam_mode if is_reparam else None,\n prior_mode=self.prior_mode if is_reparam else None,\n val_use_mean=self.val_use_mean,\n struct_dropout_mode=self.struct_dropout_mode,\n sample_size=self.sample_size,\n ))\n # On the Pubmed dataset, use heads=8 in conv2.\n \n else:\n raise Exception(\"Model_type {} is not valid!\".format(self.model_type))\n\n self.reparam_layers = sorted(self.reparam_layers)\n \n if self.model_type == \"GCN\":\n if self.with_relu:\n reg_params = [getattr(self, \"conv{}\".format(i+1)).parameters() for i in range(self.num_layers - 1)]\n self.reg_params = itertools.chain(*reg_params)\n self.non_reg_params = getattr(self, \"conv{}\".format(self.num_layers)).parameters()\n else:\n self.reg_params = OrderedDict()\n self.non_reg_params = self.parameters()\n else:\n self.reg_params = self.parameters()\n self.non_reg_params = OrderedDict()\n self.to(self.device)","def build_vgg(hr_shape):\n \n vgg = VGG19(weights=\"imagenet\")\n # Set outputs to outputs of last conv. layer in block 3\n # See architecture at: https://github.com/keras-team/keras/blob/master/keras/applications/vgg19.py\n vgg.outputs = [vgg.layers[9].output]\n\n img = Input(hr_shape)\n\n # Extract image features\n img_features = vgg(img)\n\n return Model(img, img_features)","def __init__(self, num_classes=200):\n nn.Module.__init__(self)\n # Convolution and pooling layers of VGG-16.\n self.features = vgg16(pretrained=True).features\n self.features_conv5_1 = nn.Sequential(*list(self.features.children())[:-5])\n self.features_conv5_2 = nn.Sequential(*list(self.features.children())[-5:-3])\n self.features_conv5_3 = nn.Sequential(*list(self.features.children())[-3:-1])\n self.bilinear_proj = nn.Sequential(nn.Conv2d(512, 8192, kernel_size=1, bias=False),\n nn.BatchNorm2d(8192),\n nn.ReLU(inplace=True))\n # Linear classifier.\n self.fc = torch.nn.Linear(8192 * 3, num_classes)","def _build(self, generation):\n with tf.variable_scope ('discriminator') as scope:\n \n image_unflatten = unflatten_layer ( self.images )\n gen_unflatten = unflatten_layer ( generation )\n\n # Conv Layer 1 - image\n conv1_out_image, params = conv_2d_layer (\n input = image_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n name = 'conv_1_img',\n visualize = True ) \n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \n \n # Conv Layer 1 - gen\n conv1_out_gen, params = conv_2d_layer (\n input = gen_unflatten,\n neurons = CONV_1_N,\n filter_size = CONV_1_FILT,\n params = params,\n name = 'conv_1_gen',\n visualize = False )\n\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \n process_params(params, name = self.name)\n c1_params = params\n\n\n\n\n\n # Conv Layer 2 - image\n conv2_out_image, params = conv_2d_layer (\n input = lrn1_out_img,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n name = 'conv_2_img' )\n\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \n\n\n # Conv Layer 2 - gen\n conv2_out_gen, params = conv_2d_layer (\n input = lrn1_out_gen,\n neurons = CONV_2_N,\n filter_size = CONV_2_FILT,\n params = params,\n name = 'conv_2_gen' )\n\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \n process_params(params, name = self.name)\n c2_params = params\n\n # Dropout Layer\n flat_gen = flatten_layer(lrn2_out_gen)\n flat_img = flatten_layer(lrn2_out_img)\n\n flat_gen_dropout = dropout_layer ( input = flat_gen,\n prob = self.dropout_prob,\n name = 'dropout_1_gen') \n\n flat_img_dropout = dropout_layer ( input = flat_img,\n prob = self.dropout_prob,\n name = 'dropout_1_img') \n\n\n\n # Dot Product Layer 1 -img\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\n neurons = HIDDEN_1,\n name = 'image_disc_dot_1')\n # Dot Product Layer 1 - gen\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_1')\n\n process_params(params, name = self.name)\n d1_params = params\n \n ##\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_2_gen') \n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\n prob = self.dropout_prob,\n name = 'dropout_2_img')\n\n # Dot Product Layer 2 -img\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\n neurons = HIDDEN_2,\n name = 'image_disc_dot_2')\n # Dot Product Layer 2 - gen\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\n params = params,\n neurons = HIDDEN_2,\n name = 'gen_disc_dot_2')\n process_params(params, name = self.name)\n d2_params = params\n\n ##\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\n prob = self.dropout_prob,\n name = 'dropout_3_gen') \n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\n prob = self.dropout_prob,\n name = 'dropout_3_img')\n\n # Dot Product Layer 1 -img\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\n neurons = 1,\n activation = 'sigmoid',\n name = 'real')\n # Dot Product Layer 1 -gen\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\n params = params,\n neurons = 1,\n activation = 'sigmoid',\n name = 'fake')\n\n process_params(params, name = self.name)\n d3_params = params\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \n\n\n with tf.variable_scope (self.name + '_objectives') as scope: \n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\n 0.5 * tf.reduce_mean ((self.fake)**2)\n tf.summary.scalar('discriminator_obj', discriminator_obj)\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \n\n with tf.variable_scope (self.name + '_probabilites') as scope: \n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\n \n self._cook_optimizer( \n lr = DIS_GAN_LR, \n optimizer = DIS_GAN_OPTIMIZER,\n l1_coeff = DIS_GAN_L1_COEFF,\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)","def __init__(self, embed_size):\n super(ImgAttentionEncoder, self).__init__()\n vggnet_feat = models.vgg19(pretrained=True).features\n modules = list(vggnet_feat.children())[:-2]\n self.cnn = nn.Sequential(*modules)\n self.fc = nn.Sequential(nn.Linear(self.cnn[-3].out_channels, embed_size),\n nn.Tanh()) # feature vector of image","def vgg16(**kwargs):\r\n return VGG16(**kwargs)","def __cnnNetFn(self, input, is_training):\n with tf.variable_scope('CNN'):\n conv1 = tf.layers.conv2d(input, 32, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv1_bn = tf.layers.batch_normalization(conv1)\n conv2 = tf.layers.conv2d(conv1_bn, 32, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv2_bn = tf.layers.batch_normalization(conv2)\n conv2_pool = tf.layers.max_pooling2d(conv2_bn, 2, 2, padding='SAME')\n conv2_drop = tf.layers.dropout(conv2_pool, rate=0.2, training=is_training)\n\n conv3 = tf.layers.conv2d(conv2_drop, 64, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv3_bn = tf.layers.batch_normalization(conv3)\n conv4 = tf.layers.conv2d(conv3_bn, 64, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv4_bn = tf.layers.batch_normalization(conv4)\n conv4_pool = tf.layers.max_pooling2d(conv4_bn, 2, 2, padding='SAME')\n conv4_drop = tf.layers.dropout(conv4_pool, rate=0.3, training=is_training)\n\n conv5 = tf.layers.conv2d(conv4_drop, 128, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv5_bn = tf.layers.batch_normalization(conv5)\n conv6 = tf.layers.conv2d(conv5_bn, 128, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv6_pool = tf.layers.max_pooling2d(conv6, 2, 2, padding='SAME')\n\n csnn_features = tf.stop_gradient(self.__csnn.getTrainOp(input))\n csnn_features = tf.identity(csnn_features)\n if self.__use_csnn:\n joint_features = tf.concat((conv6_pool, csnn_features), axis=3)\n else:\n joint_features = conv6_pool\n\n conv6_bn = tf.layers.batch_normalization(joint_features)\n\n conv7 = tf.layers.conv2d(conv6_bn, 256, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv7_bn = tf.layers.batch_normalization(conv7)\n conv8 = tf.layers.conv2d(conv7_bn, 256, 3, activation=\"elu\", padding='SAME',\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\n conv8_bn = tf.layers.batch_normalization(conv8)\n conv8_pool = tf.layers.max_pooling2d(conv8_bn, 2, 2, padding='SAME')\n conv8_drop = tf.layers.dropout(conv8_pool, rate=0.4, training=is_training)\n\n flat = tf.contrib.layers.flatten(conv8_drop)\n logits = tf.layers.dense(flat, self.__num_classes)\n return logits, csnn_features","def inference(self,image, keep_prob):\n\tNUM_OF_CLASSESS = 51\n\tIMAGE_SIZE = 224\n print(\"setting up vgg initialized conv layers ...\")\n model_data = self.data\n mean = model_data['normalization'][0][0][0]\n mean_pixel = np.mean(mean, axis=(0, 1))\n\n weights = np.squeeze(model_data['layers'])\n\n processed_image = self.process_image(image, mean_pixel)\n\n with tf.variable_scope(\"inference\"):\n image_net = self.vgg_net(weights, processed_image)\n conv_final_layer = image_net[\"conv5_3\"]\n\n pool5 = self.max_pool_2x2(conv_final_layer)\n\n W6 = self.weight_variable([7, 7, 512, 4096], name=\"W6\")\n b6 = self.bias_variable([4096], name=\"b6\")\n conv6 = self.conv2d_basic(pool5, W6, b6)\n relu6 = tf.nn.relu(conv6, name=\"relu6\")\n relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)\n\n W7 = self.weight_variable([1, 1, 4096, 4096], name=\"W7\")\n b7 = self.bias_variable([4096], name=\"b7\")\n conv7 = self.conv2d_basic(relu_dropout6, W7, b7)\n relu7 = tf.nn.relu(conv7, name=\"relu7\")\n relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)\n\n W8 = self.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name=\"W8\")\n b8 = self.bias_variable([NUM_OF_CLASSESS], name=\"b8\")\n conv8 = self.conv2d_basic(relu_dropout7, W8, b8)\n # annotation_pred1 = tf.argmax(conv8, dimension=3, name=\"prediction1\")\n\n # now to upscale to actual image size\n deconv_shape1 = image_net[\"pool4\"].get_shape()\n W_t1 = self.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name=\"W_t1\")\n b_t1 = self.bias_variable([deconv_shape1[3].value], name=\"b_t1\")\n conv_t1 = self.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(image_net[\"pool4\"]))\n fuse_1 = tf.add(conv_t1, image_net[\"pool4\"], name=\"fuse_1\")\n\n deconv_shape2 = image_net[\"pool3\"].get_shape()\n W_t2 = self.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name=\"W_t2\")\n b_t2 = self.bias_variable([deconv_shape2[3].value], name=\"b_t2\")\n conv_t2 = self.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(image_net[\"pool3\"]))\n fuse_2 = tf.add(conv_t2, image_net[\"pool3\"], name=\"fuse_2\")\n\n shape = tf.shape(image)\n deconv_shape3 = tf.pack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])\n W_t3 = self.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name=\"W_t3\")\n b_t3 = self.bias_variable([NUM_OF_CLASSESS], name=\"b_t3\")\n conv_t3 = self.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)\n\n annotation_pred = tf.argmax(conv_t3, dimension=3, name=\"prediction\")\n\n return tf.expand_dims(annotation_pred, dim=3), conv_t3","def __init__(self, in_channels, out_channels, pool=True, last=False, stride=1):\n super(Vggish, self).__init__()\n # The two convolutional layers\n self.conv_1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(3, 3),\n stride=(stride, stride), padding=(1, 1), bias=False)\n self.conv_2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=(3, 3),\n stride=(stride, stride), padding=(1, 1), bias=False)\n\n # Batch normalization\n self.bn_1 = nn.BatchNorm2d(out_channels)\n self.bn_2 = nn.BatchNorm2d(out_channels)\n\n # Flags\n self.last = last\n self.pool = pool\n\n # Setting up the max pooling\n self.max_pool = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2), return_indices=True)\n\n # Weights initialization\n def _weights_init(m):\n if isinstance(m, nn.Conv2d or nn.Linear or nn.GRU or nn.LSTM):\n init.xavier_normal_(m.weight)\n # m.bias.data.zero_()\n elif isinstance(m, nn.BatchNorm2d or nn.BatchNorm1d):\n m.weight.data.fill_(1)\n m.bias.data.zero_()\n\n self.apply(_weights_init)","def __init__(self, filter1x1, ker_size, filters):\n super(reduce, self).__init__()\n self.con1 = layers.Conv2D(\n filter1x1, kernel_size=1, padding=\"same\", activation=\"relu\"\n )\n self.conv = layers.Conv2D(\n filters, kernel_size=ker_size, padding=\"same\", activation=\"relu\"\n )","def _make_conv_level(in_channels, out_channels, num_convs, norm_func,\n stride=1, dilation=1):\n layers = []\n for i in range(num_convs):\n layers.extend([\n nn.Conv2D(in_channels, out_channels, kernel_size=3,\n stride=stride if i == 0 else 1,\n padding=dilation, bias_attr=False, dilation=dilation),\n norm_func(out_channels),\n nn.ReLU()])\n\n in_channels = out_channels\n\n return nn.Sequential(*layers)","def VGG_create(desc=None, isigma=None, img_normalize=None, use_scale_orientation=None, scale_factor=None, dsc_normalize=None): # real signature unknown; restored from __doc__\n pass","def _build_model(self, image_input_source, encoder_input_source, dropout_toggle):\n\t\t# We have to match this output size.\n\t\tbatch, input_height, input_width, input_depth = image_input_source.get_shape().as_list()\n\t\n\t\tfilter_sizes = [64, 64, 64] # Like VGG net, except made by a stupid person.\n\t\n\t\t# Convolutional ops will go here.\n\t\tc0, wc0, bc0 = self._build_conv(image_input_source, [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\n\t\tc1 = self._build_max_pool(c0, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tc2, wc2, bc2 = self._build_conv(self._build_dropout(c1, dropout_toggle), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\n\t\tc3 = self._build_max_pool(c2, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tc4, wc4, bc4 = self._build_conv(self._build_dropout(c3, dropout_toggle), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\n\t\tc5 = self._build_max_pool(c4, [1, 2, 2, 1], [1, 2, 2, 1])\n\t\tconv_output = c5\n\t\n\t\t# Transition to FC layers.\n\t\tpre_flat_shape = conv_output.get_shape().as_list()\n\t\tflatten = tf.reshape(conv_output, [-1, pre_flat_shape[1]*pre_flat_shape[2]*pre_flat_shape[3]])\n\t\n\t\t# Dense connections\n\t\tfc0, wf0, bf0 = self._build_fc(flatten, 512)\n\t\tfc1, wf1, bf1 = self._build_fc(fc0, 512)\n\t\tfc2, wf2, bf2 = self._build_fc(self._build_dropout(fc1, dropout_toggle), self.REPRESENTATION_SIZE)\n\t\tfc_out = fc2\n\t\n\t\t# Output point and our encoder mix-in.\n\t\tmu_output, wmu, bmu = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\n\t\tz_output, wz, bz = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\n\t\tencoded_output = tf.random_normal(mean=mu_output, stddev=z_output, shape=z_output.get_shape()) #tf.nn.softmax(fc_out)\n\t\tencoded_input = self._build_dropout(encoder_input_source + encoded_output, dropout_toggle) # Mix input and enc.\n\t\tencoded_input.set_shape(encoded_output.get_shape()) # Otherwise we can't ascertain the size.\n\t\n\t\t# More dense connections on the offset.\n\t\tdfc2, dwf2, dbf2 = self._build_fc(encoded_input, 512, weight=tf.transpose(wf2), bias=tf.transpose(bf1))\n\t\tdfc1, dwf1, dbf1 = self._build_fc(dfc2, 512, weight=tf.transpose(wf1), bias=tf.transpose(bf0))\n\t\tdfc0, dwf0, dbf0 = self._build_fc(self._build_dropout(dfc1, dropout_toggle), flatten.get_shape().as_list()[-1], weight=tf.transpose(wf0))\n\t\n\t\t# Expand for more convolutional operations.\n\t\tunflatten = tf.reshape(dfc0, [-1, pre_flat_shape[1], pre_flat_shape[2], pre_flat_shape[3]]) #pre_flat_shape)\n\t\n\t\t# More convolutions here.\n\t\tdc5 = self._build_unpool(unflatten, [1, 2, 2, 1])\n\t\tdc4, wdc4, bdc4 = self._build_deconv(self._build_dropout(dc5, dropout_toggle), c3.get_shape().as_list(), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\n\t\tdc3 = self._build_unpool(dc4, [1, 2, 2, 1])\n\t\tdc2, wdc2, bdc2 = self._build_deconv(self._build_dropout(dc3, dropout_toggle), c1.get_shape().as_list(), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\n\t\tdc1 = self._build_unpool(dc2, [1, 2, 2, 1])\n\t\tdc0, wdc0, bdc0 = self._build_deconv(dc1, [batch, input_height, input_width, input_depth], [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\n\t\tdeconv_output = dc0\n\t\n\t\t# Return result + encoder output\n\t\treturn deconv_output, encoded_output","def _make_conv_layers(self):\n conv = nn.Sequential(\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(kernel_size=2, stride=2),\n\n nn.Conv2d(64, 192, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(128, 256, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 256, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(256, 512, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(512, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1), \n nn.LeakyReLU(0.1, inplace=True),\n nn.MaxPool2d(2,2),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n\n nn.Conv2d(1024, 512, 1, padding=1),\n nn.LeakyReLU(0.1, inplace=True),\n nn.Conv2d(512, 1024, 3, padding=1),\n nn.LeakyReLU(0.1, inplace=True)\n )\n return conv","def vgg16_bn(model_dir, tag, num_classes, use_cls, batchnorm=True):\n cfg = [[64, 64, 'M'], [128, 128, 'M'], [256, 256, 256, 'M'], [512, 512, 512, 512, 512, 512], [1024, 'D', 1024, 'D']]\n net = VGG(model_dir, tag, cfg, num_classes, use_cls, batchnorm=batchnorm)\n\n return net","def create_model():\n \n cnn = tf.keras.Sequential()\n \n cnn.add(tf.keras.layers.InputLayer(input_shape=(img_height,img_width,1)))\n \n # Normalization\n cnn.add(tf.keras.layers.BatchNormalization())\n \n # Conv + Maxpooling\n cnn.add(tf.keras.layers.Convolution2D(64, (4, 4), padding='same', activation='relu'))\n cnn.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\n\n # Dropout\n cnn.add(tf.keras.layers.Dropout(0.1))\n \n # Conv + Maxpooling\n cnn.add(tf.keras.layers.Convolution2D(64, (4, 4), activation='relu'))\n cnn.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\n\n # Dropout\n cnn.add(tf.keras.layers.Dropout(0.3))\n\n # Converting 3D feature to 1D feature Vektor\n cnn.add(tf.keras.layers.Flatten())\n\n # Fully Connected Layer\n cnn.add(tf.keras.layers.Dense(256, activation='relu'))\n\n # Dropout\n cnn.add(tf.keras.layers.Dropout(0.5))\n \n # Fully Connected Layer\n cnn.add(tf.keras.layers.Dense(64, activation='relu'))\n \n # Normalization\n cnn.add(tf.keras.layers.BatchNormalization())\n\n cnn.add(tf.keras.layers.Dense(num_classes, activation='softmax'))\n cnn.compile(loss='sparse_categorical_crossentropy', optimizer=tf.compat.v1.train.AdamOptimizer(), metrics=['accuracy'])\n\n return cnn","def vgg_based_model(num_cls, input_shape=(150, 150, 3), weights=None):\n # Create a base model\n base_model = VGG16(include_top=False, weights='imagenet', input_shape=input_shape)\n\n # Add new classifier\n last = base_model.output\n x = Flatten()(last)\n x = Dense(256, activation='relu')(x)\n x = Dropout(0.5)(x)\n predictions = Dense(num_cls, activation='softmax')(x)\n model = Model(input=base_model.input, output=predictions)\n\n if weights:\n model.load_weights(weights)\n\n return model, base_model","def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\n super(ConvGRUCell, self).__init__()\n self.height, self.width = input_size\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\n self.hidden_dim = hidden_dim\n self.bias = bias\n self.dtype = dtype\n\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)\n\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\n out_channels=self.hidden_dim, # for candidate neural memory\n kernel_size=kernel_size,\n padding=self.padding,\n bias=self.bias).type(dtype)","def __init__(self, n_input_channels=3, n_conv_output_channels=16, k=3, s=1, pad=1, p = 0.5):\n super(ModelCNN, self).__init__()\n # 1. Convolutional layers\n # Single image is in shape: 3x96x96 (CxHxW, H==W), RGB images\n self.conv1 = nn.Conv2d(in_channels = n_input_channels, out_channels = n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn1 = nn.BatchNorm2d(n_conv_output_channels)\n self.conv2 = nn.Conv2d(in_channels = n_conv_output_channels, out_channels = 2*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn2 = nn.BatchNorm2d(2*n_conv_output_channels)\n self.conv3 = nn.Conv2d(in_channels = 2*n_conv_output_channels, out_channels = 4*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn3 = nn.BatchNorm2d(4*n_conv_output_channels)\n self.conv4 = nn.Conv2d(in_channels = 4*n_conv_output_channels, out_channels = 8*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\n self.bn4 = nn.BatchNorm2d(8*n_conv_output_channels)\n self.pool = nn.MaxPool2d(kernel_size = k - 1, stride = 2*s, padding = pad - pad)\n \n self.dropout = nn.Dropout(p = p)\n \n # 2. FC layers to final output\n self.fc1 = nn.Linear(in_features = 288*n_conv_output_channels, out_features = 32*n_conv_output_channels)\n self.fc_bn1 = nn.BatchNorm1d(32*n_conv_output_channels)\n self.fc2 = nn.Linear(in_features = 32*n_conv_output_channels, out_features = 16*n_conv_output_channels)\n self.fc_bn2 = nn.BatchNorm1d(16*n_conv_output_channels)\n self.fc3 = nn.Linear(in_features = 16*n_conv_output_channels, out_features = 8*n_conv_output_channels)\n self.fc_bn3 = nn.BatchNorm1d(8*n_conv_output_channels)\n self.fc4 = nn.Linear(in_features = 8*n_conv_output_channels, out_features = 1)","def create_model(input_tensor, mode, hyper_params):\n model = {}\n with tf.variable_scope('vgg16') as scope:\n net = tf.cast(input_tensor[\"image\"], dtype=tf.float32, name=\"input/cast\")\n model[\"image\"] = net\n mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')\n net = net - mean\n model[\"image-normalized\"] = net\n\n net = _create_conv2_block(model, net, filters=64, layer_number=1)\n net = _create_conv2_block(model, net, filters=128, layer_number=2)\n net = _create_conv3_block(model, net, filters=256, layer_number=3)\n net = _create_conv3_block(model, net, filters=512, layer_number=4)\n net = _create_conv3_block(model, net, filters=512, layer_number=5)\n print(net.get_shape())\n\n if not hyper_params.vgg16.encoder_only:\n net = tf.layers.conv2d(inputs=net, filters=4096, kernel_size=(7, 7), strides=(1, 1), name=\"fc1\", activation=tf.nn.relu)\n model[\"vgg16/fc1\"] = net\n net = tf.layers.conv2d(inputs=net, filters=4096, kernel_size=(1, 1), strides=(1, 1), name=\"fc2\", activation=tf.nn.relu)\n model[\"vgg16/fc2\"] = net\n net = tf.layers.conv2d(inputs=net, filters=1000, kernel_size=(1, 1), strides=(1, 1), name=\"logits\", activation=None)\n model[\"logits\"] = net\n net = tf.nn.softmax(net)\n model[\"probs\"] = net\n return model","def create():\n with torch.set_grad_enabled(False):\n model = torch.hub.load(\n \"pytorch/vision:v0.6.0\", \"vgg11\", pretrained=True).eval()\n\n with_cuda = torch.cuda.is_available()\n if with_cuda:\n model.to(\"cuda\")\n else:\n logging.warn(\"Running on CPU, no CUDA detected.\")\n\n def call(features):\n images = features[\"image\"].numpy()\n # Normalize according to the documentation. Note that the pro-processing\n # will already have the range normalized to [0, 1].\n mean = [0.485, 0.456, 0.406]\n std = [0.229, 0.224, 0.225]\n images_normalized = (images - mean) / std\n # Reshape from [batch, h, w, c] -> [batch, c, h, w]\n images_normalized_bchw = np.transpose(\n images_normalized, [0, 3, 1, 2]).astype(np.float32).copy()\n with torch.no_grad():\n images_torch = torch.from_numpy(images_normalized_bchw)\n if with_cuda:\n images_torch = images_torch.to(\"cuda\")\n logits = model(images_torch)\n return torch.nn.functional.softmax(logits, dim=-1).cpu().numpy()\n\n preprocess_config = \"resize_small(256)|central_crop(224)|value_range(0,1)\"\n preprocess_fn = pipeline_builder.get_preprocess_fn(\n preprocess_config, remove_tpu_dtypes=False)\n return call, preprocess_fn","def __init__(self, layers, input_size):\n super(ConvNetMaker, self).__init__()\n self.conv_layers = []\n self.fc_layers = []\n # h, w, d = 32, 32, 3\n h, w, d = input_size, input_size, 3\n previous_layer_filter_count = 3\n previous_layer_size = h * w * d\n num_fc_layers_remained = len([1 for l in layers if l.startswith('FC')])\n for layer in layers:\n if layer.startswith('Conv'):\n filter_count = int(layer[4:])\n self.conv_layers += [\n nn.Conv2d(previous_layer_filter_count,\n filter_count,\n kernel_size=3,\n padding=1),\n nn.BatchNorm2d(filter_count),\n nn.ReLU(inplace=True)\n ]\n\n previous_layer_filter_count = filter_count\n d = filter_count\n previous_layer_size = h * w * d\n elif layer.startswith('MaxPool'):\n self.conv_layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\n h, w = int(h / 2.0), int(w / 2.0)\n previous_layer_size = h * w * d\n elif layer.startswith('FC'):\n num_fc_layers_remained -= 1\n current_layer_size = int(layer[2:])\n if num_fc_layers_remained == 0:\n self.fc_layers += [nn.Linear(previous_layer_size,\n current_layer_size)]\n else:\n self.fc_layers += [nn.Linear(previous_layer_size,\n current_layer_size),\n nn.ReLU(inplace=True)]\n previous_layer_size = current_layer_size\n\n conv_layers = self.conv_layers\n fc_layers = self.fc_layers\n self.conv_layers = nn.Sequential(*conv_layers)\n self.fc_layers = nn.Sequential(*fc_layers)","def __init__(self, in_channels, out_channels):\n super(CNN, self).__init__()\n self.conv1 = nn.Conv1d(in_channels=in_channels, out_channels=out_channels, kernel_size=5, padding=1)","def __init__(self, vgg_net):\n super().__init__()\n # create a conv layer that corresponds to the first linear layer\n linear1 = vgg_net.classifier[0]\n conv = nn.Conv2d(512, 4096, 7, 7)\n\n # copy data into it\n conv.bias.data.copy_(linear1.bias.data)\n conv.weight.data.view(4096, -1).copy_(linear1.weight.data)\n\n # replace the layer in the sequential classifier part\n vgg_net.classifier = nn.Sequential(\n conv, nn.Flatten(1), *vgg_net.classifier[1:]\n )\n\n self.vgg_net = vgg_net","def __init__(self, img_size, multi_layers=False):\n super().__init__()\n\n vgg = VGG16(include_top=False, input_shape=(img_size[0], img_size[1], 3))\n if multi_layers:\n layer_ids = [2, 5, 9, 13, 17]\n layer_outputs = [\n Flatten()(vgg.layers[layer_id].output) for layer_id in layer_ids]\n features = Concatenate(axis=-1)(layer_outputs)\n else:\n layer_ids = [13] # 13 -> conv4_3\n features = [\n Flatten()(vgg.layers[layer_id].output) for layer_id in layer_ids]\n\n self._model = Model(inputs=vgg.input, outputs=features)","def init_encoder(self):\n\n vgg = models.vgg16(pretrained=True)\n\n blocks = [self.layer_1,\n self.layer_2,\n self.layer_3,\n self.layer_4,\n self.layer_5]\n\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\n features = list(vgg.features.children())\n\n vgg_layers = []\n for _layer in features:\n if isinstance(_layer, nn.Conv2d):\n vgg_layers.append(_layer)\n\n merged_layers = []\n for idx, conv_block in enumerate(blocks):\n if idx < 2:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit]\n else:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit,\n conv_block.conv3.cbr_unit]\n for _unit in units:\n for _layer in _unit:\n if isinstance(_layer, nn.Conv2d):\n merged_layers.append(_layer)\n\n assert len(vgg_layers) == len(merged_layers)\n\n for l1, l2 in zip(vgg_layers, merged_layers):\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\n assert l1.weight.size() == l2.weight.size()\n assert l1.bias.size() == l2.bias.size()\n l2.weight.data = l1.weight.data\n l2.bias.data = l1.bias.data","def run_vgg_experiment(args, device):\n validation_ratio, record_train_acc, record_val_acc, record_test_acc = utils.configure_training_mode(args)\n\n train_loader, validation_loader, test_loader = datasets.build_cifar10_loaders(args.batch_size,\n validation_ratio=validation_ratio,\n train_validation_split_seed=0)\n local_loss_list = utils.get_loss(args)\n nonlinearity = utils.get_nonlinearity(args)\n\n optimizer_local, local_opt_arguments_dict, local_scheduler_arguments_dict, \\\n optimizer_final, final_opt_arguments_dict, final_scheduler_arguments_dict = \\\n utils.choose_optimizers_and_parameters(args)\n\n conv_sizes = [128, 256, 256, 512, 512, 512]\n\n if args.vgg_conv_size_multiplier != 1:\n for i in range(len(conv_sizes)):\n conv_sizes[i] = conv_sizes[i] * args.vgg_conv_size_multiplier\n do_pooling = [False, True, False, True, True, True]\n\n if args.divisive_norm_conv:\n divisive_norm_list_conv = [networks.DivisiveNorm(args.divnorm_power, args.grouping_dim, args.grouped_var_delta)\n for i in range(len(conv_sizes))]\n else:\n divisive_norm_list_conv = None\n\n kernel_sizes = [3 for i in range(len(conv_sizes))]\n fc_layers = [1024]\n\n if args.divisive_norm_fc:\n divisive_norm_list_fc = [networks.DivisiveNorm(args.divnorm_power, args.grouping_dim,\n args.grouped_var_delta)\n for i in range(len(fc_layers))]\n else:\n divisive_norm_list_fc = None\n\n alt_feedback_type = None\n if args.feedback_alignment:\n alt_feedback_type = 'feedback_alignment'\n elif args.sign_symmetry:\n alt_feedback_type = 'sign_symmetry'\n\n net = networks.Network(nonlinearity, local_loss_list, optimizer_local,\n torch.optim.lr_scheduler.MultiStepLR, conv_sizes, kernel_sizes,\n do_pooling, fc_layers, 'max', 'CIFAR10', bias=False,\n local_opt_arguments_dict=local_opt_arguments_dict,\n local_scheduler_arguments_dict=local_scheduler_arguments_dict,\n dropout_p=args.dropout_p, batch_norm=args.batch_norm,\n divisive_norm_list_conv=divisive_norm_list_conv, divisive_norm_list_fc=divisive_norm_list_fc,\n spatial_dropout=args.spatial_dropout, alt_feedback_type=alt_feedback_type)\n\n net = net.to(device)\n print(net)\n\n final_loss = nn.CrossEntropyLoss()\n\n if args.backprop:\n final_opt = optimizer_final(net.parameters(), **final_opt_arguments_dict)\n compute_local_loss = False\n update_local_loss = False\n else:\n final_opt = optimizer_final(net.softmax_layer.parameters(), **final_opt_arguments_dict)\n compute_local_loss = True\n update_local_loss = True\n\n final_scheduler = torch.optim.lr_scheduler.MultiStepLR(final_opt, **final_scheduler_arguments_dict)\n\n train_acc, val_acc, test_acc = utils.train_network(\n net, device, final_loss, final_opt, final_scheduler, args.n_epochs, train_loader, validation_loader,\n test_loader, compute_local_loss=compute_local_loss, update_local_loss=update_local_loss,\n record_train_acc=record_train_acc, record_val_acc=record_val_acc, record_test_acc=record_test_acc,\n print_results=True, backprop_batch_manhattan=args.backprop_batch_manhattan)\n\n return train_acc, val_acc, test_acc","def create_cnn(num_features: int = None) -> models.Model:\n nclass = num_features or 5\n inp = Input(shape=(187, 1))\n img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\"valid\")(inp)\n # img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = MaxPool1D(pool_size=2)(img_1)\n img_1 = Dropout(rate=0.1)(img_1)\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = MaxPool1D(pool_size=2)(img_1)\n img_1 = Dropout(rate=0.1)(img_1)\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = MaxPool1D(pool_size=2)(img_1)\n img_1 = Dropout(rate=0.1)(img_1)\n img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n # img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\"valid\")(img_1)\n img_1 = GlobalMaxPool1D()(img_1)\n img_1 = Dropout(rate=0.2)(img_1)\n\n dense_1 = Dense(64, activation=activations.relu, name=\"dense_1\")(img_1)\n dense_1 = Dense(64, activation=activations.relu, name=\"dense_2\")(dense_1)\n dense_1 = Dense(nclass, activation=activations.softmax, name=\"dense_3_mitbih\")(dense_1)\n\n model = models.Model(inputs=inp, outputs=dense_1)\n opt = optimizers.Adam(learning_rate=0.001)\n\n model.compile(optimizer=opt,\n loss=losses.sparse_categorical_crossentropy,\n metrics=['accuracy'])\n model.summary()\n return model","def create_vgg_down_block(filters, in_features, activation, kernel_size=3, strategy='stride', batch_norm=False):\n layers = []\n if isinstance(filters, int):\n filters = [filters]\n\n if not isinstance(filters, list):\n raise ValueError(\"Filters has to be a list\")\n\n in_feat = in_features\n for n in range(len(filters))[:-1]:\n out_feat = filters[n]\n conv = Conv2d_same(in_features=in_feat, out_features=out_feat, activation=activation, kernel_size=kernel_size, batch_norm=batch_norm)\n layers.append(conv)\n in_feat = out_feat\n\n layers.append(Conv2d_Down(in_features=in_feat, out_features=filters[-1], activation=activation, kernel_size=kernel_size, strategy=strategy, batch_norm=batch_norm))\n out_feat = filters[-1]\n return layers, out_feat","def layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out, num_classes, is_training):\n # Build the decode part of FCN-8\n vgg_layer7_n = tf.layers.batch_normalization(vgg_layer7_out,\n name=\"new_vgg_layer7_normalization\",\n training = is_training)\n filters = 4096 if USE_ORIGINAL_NUM_FILTERS else num_classes\n conv_layer_7 = tf.layers.conv2d(vgg_layer7_n, filters, 1, strides=(1, 1),\n padding='same',\n activation=tf.nn.relu,\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\n name='new_conv_layer_7')\n conv_layer_7 = tf.layers.batch_normalization(conv_layer_7,\n name=\"new_conv_layer_7_normalization\",\n training = is_training)\n\n filters = 512 if USE_ORIGINAL_NUM_FILTERS else num_classes\n dconv_layer_7 = tf.layers.conv2d_transpose(conv_layer_7, filters, 4, strides=(2, 2),\n padding='same', activation=tf.nn.relu,\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\n name='new_dconv_layer_7')\n dconv_layer_7 = tf.layers.batch_normalization(dconv_layer_7,\n name=\"new_dconv_layer_7_normalization\",\n training = is_training)\n\n vgg_layer4_n = tf.layers.batch_normalization(vgg_layer4_out,\n name=\"new_vgg_layer4_normalization\",\n training = is_training)\n filters = 512 if USE_ORIGINAL_NUM_FILTERS else num_classes\n conv_layer_4 = tf.layers.conv2d(vgg_layer4_n, filters, 1, strides=(1, 1),\n padding='same',\n activation=tf.nn.relu,\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\n name='new_conv_layer_4')\n conv_layer_4 = tf.layers.batch_normalization(conv_layer_4,\n name=\"new_conv_layer_4_normalization\",\n training = is_training)\n\n skip_layer_4 = tf.add(conv_layer_4, dconv_layer_7, name='new_skip_layer_4')\n\n filters = 256 if USE_ORIGINAL_NUM_FILTERS else num_classes\n dconv_layer_4 = tf.layers.conv2d_transpose(skip_layer_4, filters, 4, strides=(2, 2),\n padding='same',\n activation=tf.nn.relu,\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\n name='new_dconf_layer_4')\n dconv_layer_4 = tf.layers.batch_normalization(dconv_layer_4,\n name=\"new_dconv_layer_4_normalization\",\n training = is_training)\n\n vgg_layer3_n = tf.layers.batch_normalization(vgg_layer3_out,\n name=\"new_vgg_layer3_normalization\",\n training = is_training)\n filters = 256 if USE_ORIGINAL_NUM_FILTERS else num_classes\n conv_layer_3 = tf.layers.conv2d(vgg_layer3_n, filters, 1, strides=(1, 1),\n padding='same',\n activation=tf.nn.relu,\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\n name='new_conv_layer_3')\n conv_layer_3 = tf.layers.batch_normalization(conv_layer_3,\n name=\"new_conv_layer_3_normalization\",\n training = is_training)\n\n skip_layer_3 = tf.add(conv_layer_3, dconv_layer_4, name='new_skip_layer_3')\n\n dconv_layer_3 = tf.layers.conv2d_transpose(skip_layer_3, num_classes, 16, strides=(8, 8),\n padding='same',\n activation=tf.nn.relu,\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\n name='new_dconf_layer_3')\n dconv_layer_3 = tf.layers.batch_normalization(dconv_layer_3,\n name=\"new_dconv_layer_3_normalization\",\n training = is_training)\n\n # Debug info\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(vgg_layer7_out)],\n message='vgg_layer7_out = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [vgg_layer7_out],\n message='vgg_layer7_out = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(dconv_layer_7)],\n message='dconv_layer_7 = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [dconv_layer_7],\n message='dconv_layer_7 = ', summarize = 10, first_n = 3)\n\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(vgg_layer4_out)],\n message='vgg_layer4_out = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [vgg_layer4_out],\n message='vgg_layer4_out = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(dconv_layer_4)],\n message='dconv_layer_4 = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [dconv_layer_4],\n message='dconv_layer_4 = ', summarize = 10, first_n = 3)\n\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(vgg_layer3_out)],\n message='vgg_layer3_out = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [vgg_layer3_out],\n message='vgg_layer3_out = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(dconv_layer_3)],\n message='dconf_layer_3 = ', summarize = 10, first_n = 3)\n dconv_layer_3 = tf.Print(dconv_layer_3, [dconv_layer_3],\n message='dconf_layer_3 = ', summarize = 10, first_n = 3)\n\n return dconv_layer_3","def build_model(\n data_tensor,\n reuse,\n training,\n output_shape,\n data_format='NHWC'):\n if isinstance(output_shape, list):\n output_shape = output_shape[-1]\n elif isinstance(output_shape, dict):\n output_shape = output_shape['output']\n # norm_moments_training = training # Force instance norm\n # normalization_type = 'no_param_batch_norm_original'\n # output_normalization_type = 'batch_norm_original_renorm'\n output_normalization_type = 'instance_norm'\n data_tensor, long_data_format = tf_fun.interpret_data_format(\n data_tensor=data_tensor,\n data_format=data_format)\n\n # Build model\n with tf.variable_scope('vgg', reuse=reuse):\n vgg = vgg16.Vgg16(\n vgg16_npy_path='/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy')\n vgg(rgb=data_tensor, train=training, ff_reuse=reuse)\n\n with tf.variable_scope('fgru', reuse=reuse):\n # Get side weights\n h2_rem = [\n vgg.conv1_2,\n vgg.conv2_2,\n vgg.conv3_3,\n vgg.conv4_3,\n vgg.conv5_3]\n res_act = []\n for idx, h in enumerate(h2_rem):\n res = normalization.apply_normalization(\n activity=h,\n name='output_norm1_%s' % idx,\n normalization_type=output_normalization_type,\n data_format=data_format,\n training=training,\n trainable=training,\n reuse=reuse)\n res_act += [tf.image.resize_bilinear(\n res,\n data_tensor.get_shape().as_list()[1:3],\n align_corners=True)]\n\n activity = tf.layers.conv2d(\n tf.concat(res_act, -1),\n filters=output_shape,\n kernel_size=(1, 1),\n padding='same',\n data_format=long_data_format,\n name='out',\n activation=None,\n trainable=training,\n use_bias=True,\n reuse=reuse)\n\n if long_data_format is 'channels_first':\n activity = tf.transpose(activity, (0, 2, 3, 1))\n extra_activities = {} # idx: v for idx, v in enumerate(hs_0)}\n if activity.dtype != tf.float32:\n activity = tf.cast(activity, tf.float32)\n return activity, extra_activities","def model(self, input_shape=(3, 224, 224), nclasses=3):\n inputs = Input(input_shape)\n\n pad1_1 = ZeroPadding2D(padding=(1, 1))(inputs)\n conv1_1 = Conv2D(64, 3, 3, activation='relu', name='conv1_1')(pad1_1)\n pad1_2 = ZeroPadding2D(padding=(1, 1))(conv1_1)\n conv1_2 = Conv2D(64, 3, 3, activation='relu', name='conv1_2')(pad1_2)\n pool1 = MaxPooling2D((2, 2), strides=(2, 2))(conv1_2)\n\n pad2_1 = ZeroPadding2D((1, 1))(pool1)\n conv2_1 = Conv2D(128, 3, 3, activation='relu', name='conv2_1')(pad2_1)\n pad2_2 = ZeroPadding2D((1, 1))(conv2_1)\n conv2_2 = Conv2D(128, 3, 3, activation='relu', name='conv2_2')(pad2_2)\n pool2 = MaxPooling2D((2, 2), strides=(2, 2))(conv2_2)\n\n pad3_1 = ZeroPadding2D((1, 1))(pool2)\n conv3_1 = Conv2D(256, 3, 3, activation='relu', name='conv3_1')(pad3_1)\n pad3_2 = ZeroPadding2D((1, 1))(conv3_1)\n conv3_2 = Conv2D(256, 3, 3, activation='relu', name='conv3_2')(pad3_2)\n pad3_3 = ZeroPadding2D((1, 1))(conv3_2)\n conv3_3 = Conv2D(256, 3, 3, activation='relu', name='conv3_3')(pad3_3)\n pool3 = MaxPooling2D((2, 2), strides=(2, 2))(conv3_3)\n\n pad4_1 = ZeroPadding2D((1, 1))(pool3)\n conv4_1 = Conv2D(512, 3, 3, activation='relu', name='conv4_1')(pad4_1)\n pad4_2 = ZeroPadding2D((1, 1))(conv4_1)\n conv4_2 = Conv2D(512, 3, 3, activation='relu', name='conv4_2')(pad4_2)\n pad4_3 = ZeroPadding2D((1, 1))(conv4_2)\n conv4_3 = Conv2D(512, 3, 3, activation='relu', name='conv4_3')(pad4_3)\n pool4 = MaxPooling2D((2, 2), strides=(2, 2))(conv4_3)\n\n pad5_1 = ZeroPadding2D((1, 1))(pool4)\n conv5_1 = Conv2D(512, 3, 3, activation='relu', name='conv5_1')(pad5_1)\n pad5_2 = ZeroPadding2D((1, 1))(conv5_1)\n conv5_2 = Conv2D(512, 3, 3, activation='relu', name='conv5_2')(pad5_2)\n pad5_3 = ZeroPadding2D((1, 1))(conv5_2)\n conv5_3 = Conv2D(512, 3, 3, activation='relu', name='conv5_3')(pad5_3)\n pool5 = MaxPooling2D((2, 2), strides=(2, 2))(conv5_3)\n\n # fc5 = base_model.layers[-8].output\n fc6 = Flatten()(pool5)\n fc7_1 = Dense(256, activation='relu', name='fc7_1')(fc6)\n dropout7_1 = Dropout(0.3, name='dropout7_1')(fc7_1)\n fc7_2 = Dense(128, activation='relu', name='fc7_2')(dropout7_1)\n # dropout7_2 = Dropout(0.2, name='dropout7_2')(fc7_2)\n # fc7_3 = Dense(128, activation=\"relu\", name=\"fc7_pre3\")(dropout7_2)\n prediction = Dense(nclasses, activation='softmax')(fc7_2)\n model = Model(inputs, prediction)\n model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n # model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\n return model","def create_tcnn_bottom(vgg_weights_path, conv1_1_weigths):\r\n\t# Create inputs for the 5 frames\r\n\tinput_shape=(224, 224, 3)\r\n\tframe1 = Input(shape=input_shape)\r\n\tframe2 = Input(shape=input_shape)\r\n\tframe3 = Input(shape=input_shape)\r\n\tframe4 = Input(shape=input_shape)\r\n\tframe5 = Input(shape=input_shape)\r\n\t\r\n\t# Convolution for each frame\r\n\tframe1_conv = ZeroPadding2D((1,1))(frame1)\r\n\tframe1_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1a')(frame1_conv)\r\n\r\n\tframe2_conv = ZeroPadding2D((1,1))(frame2)\r\n\tframe2_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1b')(frame2_conv)\r\n\r\n\tframe3_conv = ZeroPadding2D((1,1))(frame3)\r\n\tframe3_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1c')(frame3_conv)\r\n\r\n\tframe4_conv = ZeroPadding2D((1,1))(frame4)\r\n\tframe4_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1d')(frame4_conv)\r\n\r\n\tframe5_conv = ZeroPadding2D((1,1))(frame5)\r\n\tframe5_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1e')(frame5_conv)\r\n\t\r\n\t# Temporal aggregation by averaging\r\n\ttemp_aggr = average([frame1_conv, frame2_conv, frame3_conv, frame4_conv, frame5_conv])\r\n\r\n\t# Then standard VGG-16 architecture\r\n\toutput = ZeroPadding2D((1,1))(temp_aggr)\r\n\toutput = Convolution2D(64, (3, 3), activation='relu', name='conv1_2')(output)\r\n\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\r\n\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(128, (3, 3), activation='relu', name='conv2_1')(output)\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(128, (3, 3), activation='relu', name='conv2_2')(output)\r\n\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\r\n\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(256, (3, 3), activation='relu', name='conv3_1')(output)\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(256, (3, 3), activation='relu', name='conv3_2')(output)\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(256, (3, 3), activation='relu', name='conv3_3')(output)\r\n\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\r\n\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv4_1')(output)\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv4_2')(output)\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv4_3')(output)\r\n\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\r\n\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv5_1')(output)\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv5_2')(output)\r\n\toutput = ZeroPadding2D((1,1))(output)\r\n\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv5_3')(output)\r\n\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\r\n\r\n\tinputs = [frame1, frame2, frame3, frame4, frame5]\r\n\tmodel = Model(inputs=inputs, outputs=output)\r\n\t\r\n\t# load VGG-face weigths\r\n\tmodel.load_weights(vgg_weights_path, by_name=True)\r\n\tfor layer in ['conv1_1a', 'conv1_1b', 'conv1_1c', 'conv1_1d', 'conv1_1e']:\r\n\t\tmodel.get_layer(layer).set_weights(conv1_1_weigths)\r\n\r\n\treturn model","def build_network(self):\n net = self.ccf_data\n\n # Reshape [length] -> [length, 1].\n net = tf.expand_dims(net, -1)\n\n # create summary object\n summary = []\n\n for i in self.hparams.conv_block_filters:\n for _ in range(self.hparams.conv_layers_per_block):\n input_shape = net.shape.as_list()\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\n activation=tf.nn.relu)\n net = conv_op(net)\n summary.append(\"Conv1D-{}-{}. Input shape: {}. Output shape: {}\".format(self.hparams.kernel_size, i, input_shape,\n net.shape.as_list()))\n pool_size = 2\n strides = 2\n max_pool = tf.keras.layers.MaxPool1D(pool_size=pool_size, strides=strides)\n net = max_pool(net)\n summary.append(\"MaxPool1D-{}. Pool Size: {}. Strides: {}\".format(self.hparams.kernel_size, pool_size, strides))\n\n for i in self.hparams.final_conv_num_filters:\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\n activation=tf.nn.relu)\n net = conv_op(net)\n flatten = tf.keras.layers.Flatten()\n net = flatten(net)\n\n for i in self.hparams.dense_num_layers:\n dense = tf.keras.layers.Dense(i, activation=tf.nn.relu)\n net = dense(net)\n\n # output layer\n output = tf.keras.layers.Dense(1)\n net = tf.squeeze(output(net))\n\n self.summary = \"\\n\".join(summary)\n self.predicted_rv = net","def build_cnn(self):\n model = Sequential()\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\n model.add(Flatten())\n model.add(Dense(len(ACTIONS), activation = 'linear'))\n model.compile(loss = 'mse', optimizer = Adam(lr = alpha))\n\n return model","def forward(self, x):\n sources = list()\n loc = list()\n conf = list()\n\n # apply vgg up to conv4_3 relu\n #print('Reached start of vgg')\n for k in self.vgg._modules.keys():\n if int(k) < 23:\n #print('Reached ' + k + ' ', x.size())\n x = self.vgg._modules[k].cuda()(x)\n #print('Reached L2Norm')\n s = self.L2Norm(x)\n sources.append(s)\n\n #print('Reached after L2Norm')\n # apply vgg up to fc7\n for k in self.vgg._modules.keys():\n if int(k) >= 23:\n #print('Reached ' + k + ' ', x.size())\n x = self.vgg._modules[k].cuda()(x)\n sources.append(x)\n #print('Reached end of VGG')\n\n # apply extra layers and cache source layer outputs\n for k, v in enumerate(self.extras):\n x = F.relu(v(x), inplace=True)\n if k % 2 == 1:\n sources.append(x)\n\n # apply multibox head to source layers\n for (x, l, c) in zip(sources, self.loc, self.conf):\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\n\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\n\n if self.phase == \"test\":\n output = self.detect(\n loc.view(loc.size(0), -1, 4), # loc preds\n self.softmax(conf.view(-1, self.num_classes)), # conf preds\n self.priors # default boxes\n )\n else:\n output = (\n loc.view(loc.size(0), -1, 4),\n conf.view(conf.size(0), -1, self.num_classes),\n self.priors\n )\n return output","def model(pretrained=False, **kwargs):\r\n\r\n layers = make_layers(cfg['O'], dilation=dilation['D1'])\r\n cnv = np.cumsum(cnvs['OI']) if kwargs['args'].IN or kwargs['args'].INL else np.cumsum(cnvs['O'])\r\n model = VGG(layers, cnvs=cnv, **kwargs)\r\n if pretrained:\r\n pre2local_keymap = [('features.{}.weight'.format(i), 'conv1_2.{}.weight'.format(i)) for i in range(10)]\r\n pre2local_keymap += [('features.{}.bias'.format(i), 'conv1_2.{}.bias'.format(i)) for i in range(10)]\r\n pre2local_keymap += [('features.{}.weight'.format(i + 10), 'conv3.{}.weight'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.bias'.format(i + 10), 'conv3.{}.bias'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.weight'.format(i + 17), 'conv4.{}.weight'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.bias'.format(i + 17), 'conv4.{}.bias'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.weight'.format(i + 24), 'conv5.{}.weight'.format(i)) for i in range(7)]\r\n pre2local_keymap += [('features.{}.bias'.format(i + 24), 'conv5.{}.bias'.format(i)) for i in range(7)]\r\n pre2local_keymap = dict(pre2local_keymap)\r\n\r\n\r\n model_dict = model.state_dict()\r\n pretrained_file = os.path.join(kwargs['args'].pretrained_model_dir, kwargs['args'].pretrained_model)\r\n if os.path.isfile(pretrained_file):\r\n pretrained_dict = torch.load(pretrained_file)\r\n print('load pretrained model from {}'.format(pretrained_file))\r\n else:\r\n pretrained_dict = model_zoo.load_url(model_urls['vgg16'])\r\n print('load pretrained model from {}'.format(model_urls['vgg16']))\r\n # 0. replace the key\r\n pretrained_dict = {pre2local_keymap[k] if k in pre2local_keymap.keys() else k: v for k, v in\r\n pretrained_dict.items()}\r\n # *. show the loading information\r\n for k in pretrained_dict.keys():\r\n if k not in model_dict:\r\n print('Key {} is removed from vgg16'.format(k))\r\n print(' ')\r\n for k in model_dict.keys():\r\n if k not in pretrained_dict:\r\n print('Key {} is new added for DA Net'.format(k))\r\n # 1. filter out unnecessary keys\r\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\r\n # 2. overwrite entries in the existing state dict\r\n model_dict.update(pretrained_dict)\r\n # 3. load the new state dict\r\n model.load_state_dict(model_dict)\r\n return model","def __init__(self, in_classes=1, channelscale=64):\n super(DetectPatchAndSegm, self).__init__()\n self.unetvgg1 = UNetSimple(in_classes=in_classes, channelscale=64, out_classes=2)#UNetVgg()\n self.unetvgg2 = UNetSimple(in_classes=3, channelscale=128, out_classes=3)#in is 2 patches and original image\n self.sft = nn.Softmax2d()","def __init__(self, count, kernel_size, channels, padding_mode):\n super().__init__()\n self._count = count\n self._kernel_size = kernel_size\n self._channels = channels\n self._padding_mode = padding_mode\n\n if kernel_size % 2 == 0:\n raise ValueError('Kernel size must be an odd number')\n\n self._cnn_layers = []\n\n input_count = count\n self._number_of_layers = 0\n while input_count > 4:\n next_power = self._next_power_of_two(input_count)\n # Padding inputs to the target size 'pad_to' ensures that after applying\n # convolution, the result is another power of two (< next_power).\n pad_to = next_power + kernel_size - 1\n pad_size = (pad_to - input_count) // 2\n # If pad size is odd, pad asymmetrically.\n extra_pad_right = (pad_to - input_count) % 2\n padding = (pad_size, pad_size + extra_pad_right)\n\n self._cnn_layers.append(Pad1D(padding, padding_mode))\n # Use valid to prevent automatic 0 padding.\n self._cnn_layers.append(\n tf.keras.layers.Conv1D(channels, kernel_size, padding='valid'))\n # The output of the CNN is now an exact power of 2, so pooling reduces\n # to the next smaller power of two.\n self._cnn_layers.append(tf.keras.layers.MaxPool1D(pool_size=2))\n input_count = next_power // 2\n self._number_of_layers += 1","def fcn32(vgg16, l2=0):\n\n x = keras.layers.Conv2D(filters=21, kernel_size=(1,1), strides=(1,1), padding='same', activation='linear',\n kernel_initializer=keras.initializers.Zeros(),\n kernel_regularizer=keras.regularizers.L2(l2=l2),\n name='score7')(vgg16.get_layer('drop7').output)\n\n x = keras.layers.Conv2DTranspose(filters=21, kernel_size=(64,64), strides=(32,32),\n padding='same', use_bias=False, activation='softmax',\n kernel_initializer=BilinearInitializer(),\n kernel_regularizer=keras.regularizers.L2(l2=l2),\n name='fcn32')(x)\n\n return keras.Model(vgg16.input, x)","def __init__(self, num_blocks=3, layers_per_block=2, base_num_channels=16,\n upconv=False, fc_layer_sizes=None, upconv_reshape_size=None,\n conditioning_layer_sizes=None, channels_out=3, alpha=0.3,\n conditioning_postprocessing=None,\n final_sigmoid=False, conditioning_type=\"mult_and_add\",\n kernel_initializer_mode=\"fan_in\"):\n\n super(ConditionalConvnet, self).__init__()\n self._num_blocks = num_blocks\n self._layers_per_block = layers_per_block\n self._base_num_channels = base_num_channels\n self._channels_out = channels_out\n self._upconv = upconv\n self._fc_layer_sizes = fc_layer_sizes\n self._upconv_reshape_size = upconv_reshape_size\n self._final_sigmoid = final_sigmoid\n if upconv_reshape_size is not None and ((not upconv) or\n (fc_layer_sizes is None)):\n raise ValueError(\"upconv_reshape_size should be supplied only if \"\n \"upconv=True and fc_layer_sizes is not None.\")\n self._conditioning_layer_sizes = conditioning_layer_sizes\n self._nonlinearity = lambda x: tf.nn.leaky_relu(x, alpha)\n if conditioning_postprocessing is not None:\n self._conditioning_postprocessing = conditioning_postprocessing()\n else:\n self._conditioning_postprocessing = None\n if conditioning_type not in [\"mult_and_add\", \"concat\", \"input\"]:\n raise ValueError(\"Unknown conditioning_type {}\".format(conditioning_type))\n self._conditioning_type = conditioning_type\n scale_factor = 2. / (1. + alpha**2)\n self._kernel_initializer = tf.keras.initializers.VarianceScaling(\n mode=kernel_initializer_mode, scale=scale_factor)","def __init__(self, input_dim, conv_layers, num_labels, batch_size):\n super(CRF, self).__init__()\n\n self.input_dim = input_dim\n self.crf_input_dim = None # Calculated inside init_params() based on Conv layer I/O dims\n self.conv_layers = conv_layers\n self.num_labels = num_labels\n self.batch_size = batch_size\n\t\t#Uncomment below and remove self.use_cuda=False once all tensors are set to run on cuda\n #self.use_cuda = torch.cuda.is_available()\n self.use_cuda=False\n self.conv_objects = torch.nn.ModuleList() # Stores multiple Conv objects\n self.Ks = [] # Stores multiple Conv filters\n self.W = None # CRF parameter (node potential)\n self.T = None # CRF parameter (transition weights between node pairs)\n\n ### Use GPU if available\n if self.use_cuda:\n [m.cuda() for m in self.modules()]","def vgg16_bn(pretrained,**kwargs):\n model = VGG(make_layers(cfg['D'], batch_norm=True), **kwargs)\n if pretrained:\n model_dict = paddle.load('./pre_model/vgg16_bn.paddle')\n model.set_state_dict(model_dict)\n return model","def cnn_model_fn(features):\n print(\"features shape\", features.shape)\n\n input_layer = tf.reshape(features, [-1, 28, 28, 1])\n\n conv1 = tf.layers.conv2d(inputs=input_layer, filters=64, kernel_size=[3, 3], padding=\"same\", activation=tf.nn.relu)\n print(conv1)\n pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2, padding=\"same\")\n print(pool1)\n conv2 = tf.layers.conv2d(inputs=pool1, filters=128, kernel_size=[3, 3], padding=\"same\", activation=tf.nn.relu)\n print(conv2)\n pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2, padding=\"same\")\n print(pool2)\n conv3 = tf.layers.conv2d(inputs=pool2, filters=256, kernel_size=[3, 3], padding=\"same\", activation=tf.nn.relu)\n print(conv3)\n conv4 = tf.layers.conv2d(inputs=conv3, filters=256, kernel_size=[3, 3], padding=\"same\", activation=tf.nn.relu)\n print(conv4)\n pool3 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2, padding=\"same\")\n print(pool3)\n pool3_flat = tf.reshape(pool3, [-1, 4 * 4 * 256])\n print(pool3_flat)\n fc1 = tf.layers.dense(inputs=pool3_flat, units=1024, activation=tf.nn.relu)\n print(fc1)\n fc2 = tf.layers.dense(inputs=fc1, units=1024, activation=tf.nn.relu)\n print(fc2)\n fc2_bn = tf.nn.batch_normalization(x=fc2, mean=0, variance=1, scale=1, offset=0, variance_epsilon=1e-6)\n print(fc2_bn)\n fc3 = tf.layers.dense(inputs=fc2_bn, units=10)\n print(fc3)\n return fc3","def __init__(self, num_gpus):\n\n super(Critic, self).__init__()\n n_in = IMG_CHANNELS\n n_out = 1\n\n feature_map = IMG_SIZE\n kernel_size = 4\n stride = 2\n padding = 1\n bias = False\n\n self.num_gpus = num_gpus\n\n self.network = nn.Sequential(\n # nodes = IMG_CHANNELS * IMG_SIZE * IMG_SIZE\n nn.Conv2d(n_in, feature_map, kernel_size, stride, padding, bias=bias),\n nn.LeakyReLU(0.2, inplace=True),\n\n # nodes = feature_map * 2\n nn.Conv2d(feature_map, feature_map * 2, kernel_size, stride, padding, bias=bias),\n nn.BatchNorm2d(feature_map * 2),\n nn.LeakyReLU(0.2, inplace=True),\n\n # nodes = feature_map * 4\n nn.Conv2d(feature_map * 2, feature_map * 4, kernel_size, stride, padding, bias=bias),\n nn.BatchNorm2d(feature_map * 4),\n nn.LeakyReLU(0.2, inplace=True),\n\n # nodes = feature_map * 8\n nn.Conv2d(feature_map * 4, feature_map * 8, kernel_size, stride, padding, bias=bias),\n nn.BatchNorm2d(feature_map * 8),\n nn.LeakyReLU(0.2, inplace=True),\n\n # nodes = feature_map * 8\n nn.Conv2d(feature_map * 8, n_out, kernel_size, 1, 0, bias=bias),\n # scratched sigmoid activation function\n )","def build_model():\n\n if K.image_data_format() == 'channels_first':\n input_shape = (3, img_width, img_height)\n else:\n input_shape = (img_width, img_height, 3)\n\n model = Sequential()\n model.add(Conv2D(32, (3, 3), input_shape=input_shape))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Conv2D(32, (3, 3)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Conv2D(64, (3, 3)))\n model.add(Activation('relu'))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n\n model.add(Flatten())\n\n # FC layer\n model.add(Dense(64))\n model.add(Activation('relu'))\n model.add(Dropout(0.5))\n model.add(Dense(1))\n model.add(Activation('sigmoid'))\n\n model.compile(loss='binary_crossentropy',\n optimizer='adadelta',\n metrics=['accuracy'])\n\n return model","def __init__(self, n_filters = 64,\n n_kernels = 3,\n n_outputs = 10,\n inp_shape = (28,28),\n residual=True,\n regularizer = None,\n intializer = None,\n use_pool= False,\n use_dropout = False,\n use_batchnorm = False\n ):\n super(CNNModel, self).__init__()\n self.conv_dim = len(inp_shape)-1\n self.n_filters = n_filters\n self.initializer = intializer\n self.n_kernels = n_kernels\n self.projection = 3\n self.n_outputs = n_outputs\n self.num_layers = 1\n self.inp_shape = inp_shape\n self.regularizer = regularizer\n self.use_pool = use_pool\n self.residual = residual\n self.use_dropout = use_dropout\n self.use_batchnorm = use_batchnorm\n\n kernel_initializer = initializers.RandomNormal(mean=0.0, stddev=0.05)\n\n if self.conv_dim == 1:\n self.input_layer = layers.Conv1D(self.n_filters, (self.projection),\n activation = \"linear\",\n input_shape = self.inp_shape,\n name ='cnn_input',\n padding = 'same',\n kernel_regularizer = self.regularizer,\n bias_regularizer = self.regularizer,\n kernel_initializer=kernel_initializer,\n bias_initializer=initializers.get(\"zeros\")\n )\n self.output_layer = layers.Conv1D(self.n_kernels, (self.projection),\n activation=\"linear\",\n input_shape=(None, self.inp_shape[0], self.n_filters),\n name='cnn_output',\n padding = 'same',\n kernel_regularizer=self.regularizer,\n bias_regularizer=self.regularizer,\n kernel_initializer=kernel_initializer,\n bias_initializer=initializers.get(\"zeros\")\n )\n if self.use_pool:\n self.pool = layers.MaxPool1D()\n elif self.conv_dim == 2:\n self.input_layer = layers.Conv2D(self.n_filters, (self.projection,self.projection),\n activation=\"linear\",\n input_shape=self.inp_shape,\n name='cnn_input',\n padding = 'same',\n kernel_regularizer=self.regularizer,\n bias_regularizer=self.regularizer,\n kernel_initializer=kernel_initializer,\n bias_initializer=initializers.get(\"zeros\")\n )\n self.output_layer = layers.Conv2D(self.n_kernels, (self.projection, self.projection),\n activation= \"linear\",\n input_shape=(None, self.inp_shape[0],self.inp_shape[1], self.n_filters),\n name=\"cnn_output\",\n padding = 'same',\n kernel_regularizer=self.regularizer,\n bias_regularizer=self.regularizer,\n kernel_initializer=kernel_initializer,\n bias_initializer=initializers.get(\"zeros\")\n )\n if self.use_pool:\n self.pool = layers.MaxPool2D()\n self.list_cnn = [self.input_layer]\n self.flatten = layers.Flatten()\n\n #compute input shape after flatten for the dense layer\n if not self.use_pool:\n self.class_inp = np.prod(self.inp_shape[:-1])*self.n_kernels\n else:\n self.class_inp = np.prod(self.inp_shape[:-1])*self.n_kernels//(2**self.conv_dim)\n # self.classify = MyDenseLayer(\n # self.n_outputs,shape = (None,self.class_inp),\n # layer_name = 'classify',\n # initializer = \"RandomNormal\")\n self.classify = layers.Dense(units = self.n_outputs,\n activation = 'softmax', use_bias = True,\n input_shape = self.class_inp,\n kernel_initializer = kernel_initializer, bias_initializer=initializers.get(\"zeros\"),\n name = 'classification_layer')","def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\n dtype=np.float32):\n self.params = {}\n self.reg = reg\n self.dtype = dtype\n \n ############################################################################\n # TODO: Initialize weights and biases for the three-layer convolutional #\n # network. Weights should be initialized from a Gaussian with standard #\n # deviation equal to weight_scale; biases should be initialized to zero. #\n # All weights and biases should be stored in the dictionary self.params. #\n # Store weights and biases for the convolutional layer using the keys 'W1' #\n # and 'b1'; use keys 'W2' and 'b2' for the weights and biases of the #\n # hidden affine layer, and keys 'W3' and 'b3' for the weights and biases #\n # of the output affine layer. #\n ############################################################################ \n C, H, W = input_dim;\n\n # Dimensions of data output by convolutional layer\n S = 1; pad = (filter_size - 1) / 2; # Stride and image padding\n hconv = (H - filter_size + 2*pad)/S + 1;\n wconv = (W - filter_size + 2*pad)/S + 1;\n\n # Get dimensions of 2x2 max-pool output\n hmp = hconv / 2;\n wmp = wconv / 2;\n\n # Get dimensions of vector fed into affine layer\n # Convert maxpool output by using np.reshape(v1,(N,-1))\n # Recover by using np.reshape(dv1,v1.shape)\n laff = hmp*wmp*num_filters;\n\n # Determine starting weight and bias matrices\n self.params['W1'] = weight_scale * np.random.randn(num_filters, C, filter_size, filter_size);\n self.params['b1'] = np.zeros(num_filters);\n self.params['W2'] = weight_scale * np.random.randn(laff, hidden_dim);\n self.params['b2'] = np.zeros(hidden_dim);\n self.params['W3'] = weight_scale * np.random.rand(hidden_dim,num_classes);\n self.params['b3'] = np.zeros(num_classes);\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n for k, v in self.params.iteritems():\n self.params[k] = v.astype(dtype)","def __init__(self):\n super(CNN, self).__init__()\n\n self.conv0 = nn.Conv2d(3, 3, kernel_size=5, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv0.weight)\n\n self.conv1 = nn.Conv2d(3, 30, kernel_size=5, stride=2, padding=0)\n self.conv1.weight = nn.Parameter(get_filters())\n\n self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\n\n self.conv2 = nn.Conv2d(30, 16, kernel_size=3, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv2.weight)\n\n self.conv3 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv3.weight)\n\n self.conv4 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv4.weight)\n\n self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\n\n self.conv5 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv5.weight)\n\n self.conv6 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv6.weight)\n\n self.conv7 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv7.weight)\n\n self.conv8 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\n nn.init.xavier_uniform_(self.conv8.weight)\n\n self.fc = nn.Linear(16 * 5 * 5, 2)\n\n self.drop1 = nn.Dropout(p=0.5) # used only for the NC dataset","def get_network(x):\n n_classes = 5\n batch_size = x.get_shape().as_list()[0]\n channels = x.get_shape().as_list()[3]\n\n # Model Helpers --------------------------------------------------------\n\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#conv2d\n def conv2d(img, w, b):\n \n x = tf.nn.conv2d(img, w, strides=[1, 1, 1, 1], padding='VALID')\n z = tf.nn.bias_add(x, b)\n return tf.nn.relu(z)\n\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#max_pool\n def max_pool(img, k):\n ks = [1, k, k, 1]\n return tf.nn.max_pool(img, ksize=ks, strides=ks, padding='VALID')\n\n # TODO implement\n def maxout(x):\n raise NotImplemented()\n\n def fc(x, w, b, act):\n if act:\n return act(tf.add(tf.matmul(x, w), b))\n else:\n return tf.add(tf.matmul(x, w), b)\n\n def conv_net(_X, _weights, _biases):\n # First convolution layer\n #print 'x: {}'.format(_X.get_shape())\n \n conv1 = conv2d(_X, _weights['wc1'], _biases['bc1'])\n # k used to be 2\n conv1 = max_pool(conv1, k=2)\n\n #print 'conv1: {}'.format(conv1.get_shape())\n\n # Second Covolution layer\n conv2 = conv2d(conv1, _weights['wc2'], _biases['bc2'])\n conv2 = max_pool(conv2, k=2)\n\n #print 'conv2: {}'.format(conv2.get_shape())\n\n # Thrid Convolution Layer\n conv3 = conv2d(conv2, _weights['wc3'], _biases['bc3'])\n\n #print 'conv3: {}'.format(conv3.get_shape())\n\n # Fourth Convolution Layer\n conv4 = conv2d(conv3, _weights['wc4'], _biases['bc4'])\n conv4 = max_pool(conv4, k=2)\n\n #print 'conv4: {}'.format(conv4.get_shape())\n\n # In the paper the FC layers suggest that you use maxout, but\n # there isn't a native maxout in TensorFlow, so I used ReLU for now.\n\n # First Fully Connected Layer, flatten out filters first\n fc1 = tf.reshape(conv4, [batch_size, -1])\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#relu\n fc1 = fc(fc1, _weights['wf1'], _biases['bf1'], tf.nn.relu)\n # TODO dropout should be a parameter\n fc1 = tf.nn.dropout(fc1, tf.Variable(tf.constant(0.5)))\n\n\n # Second Fully Connected Layer\n fc2 = fc(fc1, _weights['wf2'], _biases['bf2'], tf.nn.relu)\n # TODO dropout should be a parameter\n fc2 = tf.nn.dropout(fc2, tf.Variable(tf.constant(0.5)))\n\n # Output\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#sigmoid\n output = fc(fc2, _weights['out'], _biases['out'], None)\n return output\n\n # Model Helpers --------------------------------------------------------\n\n\n # Model weights and biases\n weights = {\n # 6x6 conv, 3-channel input, 32-channel outputs\n 'wc1': tf.Variable(tf.truncated_normal([3, 3, channels, 32], stddev=0.01)), #0.01\n # 5x5 conv, 32-channel inputs, 64-channel outputs\n 'wc2': tf.Variable(tf.truncated_normal([5, 5, 32, 64], stddev=0.01)), #0.01\n # 3x3 conv, 64-channel inputs, 128-channel outputs\n 'wc3': tf.Variable(tf.truncated_normal([3, 3, 64, 128], stddev=0.01)), #0.01\n # 3x3 conv, 128-channel inputs, 128-channel outputs\n 'wc4': tf.Variable(tf.truncated_normal([3, 3, 128, 128], stddev=0.1)), #0.1\n # fully connected, 512 inputs, 2048 outputs\n # was 4608 for 84x84\n 'wf1': tf.Variable(tf.truncated_normal([6272, 2048], stddev=0.001)), #0.001\n # fully coneected 2048 inputs, 2048 outputs\n 'wf2': tf.Variable(tf.truncated_normal([2048, 2048], stddev=0.001)), #0.001\n # 2048 inputs, 5 outputs (class prediction)\n 'out': tf.Variable(tf.truncated_normal([2048, n_classes], stddev=0.01)) #0.01\n }\n\n biases = {\n 'bc1': tf.Variable(tf.constant(0.1, shape=[32])),\n 'bc2': tf.Variable(tf.constant(0.1, shape=[64])),\n 'bc3': tf.Variable(tf.constant(0.1, shape=[128])),\n 'bc4': tf.Variable(tf.constant(0.1, shape=[128])),\n 'bf1': tf.Variable(tf.constant(0.01, shape=[2048])),\n 'bf2': tf.Variable(tf.constant(0.01, shape=[2048])),\n 'out': tf.Variable(tf.constant(0.1, shape=[n_classes]))\n }\n\n return conv_net(x, weights, biases)","def cifar10_5layers(input_image, keep_prob, init_method=tf.truncated_normal_initializer(stddev=1e-2)):\n with tf.variable_scope(\"conv1\"):\n W1 = tf.get_variable(name=\"W1\", shape=[5,5,3,32], dtype=tf.float32, \\\n initializer=init_method)\n b1 = tf.get_variable(name=\"b1\", shape=[32], dtype=tf.float32, \\\n initializer=tf.constant_initializer(0.01))\n conv1 = conv_pool_relu(input_image, W1, b1)\n with tf.variable_scope(\"conv2\"):\n W2 = tf.get_variable(name=\"W2\", shape=[5,5,32,64], dtype=tf.float32, \\\n initializer=init_method)\n b2 = tf.get_variable(name=\"b2\", shape=[64], dtype=tf.float32, \\\n initializer=tf.constant_initializer(0.01))\n conv2 = conv_pool_relu(conv1, W2, b2)\n\tconv2 = tf.nn.dropout(conv2, keep_prob)\n with tf.variable_scope(\"conv3\"):\n W3 = tf.get_variable(name=\"W3\", shape=[5,5,64,128], dtype=tf.float32, \\\n initializer=init_method)\n b3 = tf.get_variable(name=\"b3\", shape=[128], dtype=tf.float32, \\\n initializer=tf.constant_initializer(0.01))\n conv3 = conv_pool_relu(conv2, W3, b3)\n\tconv3 = tf.nn.dropout(conv3, keep_prob)\n with tf.variable_scope(\"fc1\"):\n W4 = tf.get_variable(name=\"W4\", shape=[4*4*128,256], dtype=tf.float32, \\\n initializer=init_method)\n b4 = tf.get_variable(name=\"b4\", shape=[256], dtype=tf.float32, \\\n initializer=tf.constant_initializer(0.01))\n conv3_flat = tf.reshape(conv3, [-1, 4*4*128])\n fc1 = fc_relu(conv3_flat, W4, b4)\n\tfc1 = tf.nn.dropout(fc1, keep_prob)\n with tf.variable_scope(\"output\"):\n W5 = tf.get_variable(name=\"W5\", shape=[256,10], dtype=tf.float32, \\\n initializer=init_method)\n b5 = tf.get_variable(name=\"b5\", shape=[10], dtype=tf.float32, \\\n initializer=tf.constant_initializer(0.01))\n\ty_logit = tf.matmul(fc1, W5) + b5\n return y_logit, tf.nn.softmax(y_logit, name=\"softmax\")","def detection_head_graph(self, feature_map, filters):\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"stage_1\", use_bias=True, padding=\"same\")(feature_map)\n x = KL.Activation('relu', name='detection_head_stage_1_activation')(x)\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"stage_2\", use_bias=True, padding=\"same\")(x)\n x = KL.Activation('relu', name='detection_head_stage_2_activation')(x)\n x = KL.Conv2D(3, (1, 1), strides=(1, 1),\n name=\"detection_head_\" + \"final_stage\", use_bias=True, padding=\"same\")(x)\n return x","def encode(self, img):\n with tf.variable_scope('encoder'):\n #conv1 = self.conv_layer(\n # img, [5, 5], [3, 32], stride=2, initializer_type=1, name='conv1')\n #conv2 = self.conv_layer(\n # conv1, [5, 5], [32, 32], stride=2, initializer_type=1, name='conv2')\n conv3 = self.conv_layer(\n img, [5, 5], [self.in_channels, 64], stride=2, initializer_type=1, name='conv3')\n #conv4 = self.conv_bn_layer(\n conv4 = self.conv_layer(\n conv3, [5, 5], [64, 128], stride=2, #is_training=self.is_training,\n initializer_type=1, name='conv4')\n #conv5 = self.conv_bn_layer(\n conv5 = self.conv_layer(\n conv4, [5, 5], [128, 256], stride=2, #is_training=self.is_training,\n initializer_type=1, name='conv5')\n shape = conv5.get_shape().as_list()\n feature_map_size = shape[1]*shape[2]*shape[3]\n conv5_flat = tf.reshape(\n conv5, [-1, feature_map_size], 'conv5_flat')\n #fc6 = self.fc_bn_layer(conv5_flat, 1024, is_training=self.is_training,\n fc6 = self.fc_layer(conv5_flat, 1024,\n initializer_type=1, name='fc6')\n #fc7 = self.fc_layer(fc6, 1024, initializer_type=1, name='fc7')\n return fc6, shape","def VGG(model_type='D', dropout=0.5, num_classes=1000, input_shape=(224, 224, 3)):\n \n model_type = model_type.upper()\n assert model_type in ['A', 'B', 'C', 'D', 'E'], \"Invalid value of 'model_type'\\n\" \\\n \"It should be one of {'A', 'B', 'C', 'D', 'E'}\"\n \n assert (type(input_shape) == tuple), \"Invalid value of 'input_shape'\\n\" \\\n \"It should be of form (<image_height>, <image_width>, <channels>)\"\n \n assert (len(input_shape) == 3), \"Invalid value of 'input_shape'\\n\" \\\n \"It should be of form (<image_height>, <image_width>, <channels>)\"\n \n if(dropout != None):\n assert ((type(dropout) == float) and (0 <= dropout <= 1)), \"Invalid value of 'dropout'.\\n\" \\\n \"It should be a real number between 0 and 1 (inclusive).\"\n\n # Implementing the model\n model = Sequential()\n\n model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu', input_shape=input_shape))\n if model_type in ['B', 'C', 'D', 'E']:\n model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\n\n model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['B', 'C', 'D', 'E']:\n model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\n\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['C']:\n model.add(Conv2D(filters=256, kernel_size=(1, 1), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['D', 'E']:\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['E']:\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\n\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['C']:\n model.add(Conv2D(filters=512, kernel_size=(1, 1), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['D', 'E']:\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['E']:\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\n\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['C']:\n model.add(Conv2D(filters=512, kernel_size=(1, 1), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['D', 'E']:\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n if model_type in ['E']:\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \n activation='relu'))\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\n\n model.add(Flatten())\n model.add(Dense(units=4096, activation='relu'))\n if(dropout != None):\n model.add(Dropout(dropout))\n model.add(Dense(units=4096, activation='relu'))\n if(dropout != None):\n model.add(Dropout(dropout))\n model.add(Dense(units=num_classes, activation='softmax'))\n\n return model","def build_model(img_width,\n\timg_height,\n\tchannels,\n\tnum_classes,\n\tlr=1e-5,\n\tfreeze=False):\n\n\tvgg_model = VGG16(include_top=False, weights='imagenet', input_shape=(img_width, img_height, channels))\n\n\tvgg_output = vgg_model.output\n\tdrop0 = Dropout(0.5)(vgg_output)\n\tflat = Flatten()(drop0)\n\tdense1 = Dense(512, activation='relu')(flat)\n\tdrop1 = Dropout(0.5)(dense1)\n\tpredictions = Dense(num_classes, activation='softmax')(drop1)\n\n\tmodel = Model(inputs=vgg_model.input, outputs=predictions)\n\t\n\tif freeze:\n\t\tfor layer in vgg_model.layers:\n\t\t\tlayer.trainable = False\n\n\tmodel.summary()\n\tadam = Adam(lr=lr, decay=1e-6)\n\tmodel.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy'])\n\treturn model","def build_cnn_layer(embedding_layer, config):\n layers = []\n for i in range(len(config['filters'])):\n cnn_layer = tf.keras.layers.Conv1D(\n kernel_regularizer=tf.keras.regularizers.l2(0.0001),\n activation='relu', filters=config['filters'][i],\n kernel_size=config['kernel_size'][i],\n name='cnn_layer_{}'.format(i + 1))(embedding_layer)\n pooling_layer = tf.keras.layers.MaxPool1D(\n name='max_pool_layer_{}'.format(i + 1))(cnn_layer)\n flatten_layer = tf.keras.layers.Flatten(\n name='flatten_{}'.format(i + 1))(pooling_layer)\n layers.append(flatten_layer)\n return tf.keras.layers.Concatenate(name='concat_layer')(layers)","def init_encoder(self):\n\n vgg = models.vgg16(pretrained=True)\n\n blocks = [self.layer_1,\n self.layer_2,\n self.layer_3,\n self.layer_4,\n self.layer_5]\n\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\n features = list(vgg.features.children())\n\n vgg_layers = []\n for _layer in features:\n if isinstance(_layer, nn.Conv2d):\n vgg_layers.append(_layer)\n\n merged_layers = []\n for idx, conv_block in enumerate(blocks):\n if idx < 2:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit]\n else:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit,\n conv_block.conv3.cbr_unit]\n for _unit in units:\n for _layer in _unit:\n if isinstance(_layer, nn.Conv2d):\n merged_layers.append(_layer)\n\n assert len(vgg_layers) == len(merged_layers)\n\n for l1, l2 in zip(vgg_layers, merged_layers):\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\n assert l1.weight.size() == l2.weight.size()\n assert l1.bias.size() == l2.bias.size()\n l2.weight.data = l1.weight.data\n l2.bias.data = l1.bias.data\n\n blocks = [self.layer_11,\n self.layer_12,\n self.layer_13,\n self.layer_14,\n self.layer_15]\n\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\n features = list(vgg.features.children())\n\n vgg_layers = []\n for _layer in features:\n if isinstance(_layer, nn.Conv2d):\n vgg_layers.append(_layer)\n\n merged_layers = []\n for idx, conv_block in enumerate(blocks):\n if idx < 2:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit]\n else:\n units = [conv_block.conv1.cbr_unit,\n conv_block.conv2.cbr_unit,\n conv_block.conv3.cbr_unit]\n for _unit in units:\n for _layer in _unit:\n if isinstance(_layer, nn.Conv2d):\n merged_layers.append(_layer)\n\n assert len(vgg_layers) == len(merged_layers)\n\n for l1, l2 in zip(vgg_layers, merged_layers):\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\n assert l1.weight.size() == l2.weight.size()\n assert l1.bias.size() == l2.bias.size()\n l2.weight.data = l1.weight.data\n l2.bias.data = l1.bias.data","def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\"sigmoid\"):\n\n # inizializzo il modello come sequenziale\n model = Sequential()\n inputShape = (imageHeight, imageWidth, imageDepth)\n chanDim = -1\n\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\n # Utilizzo 32 filtri 3*3\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\"same\", input_shape=inputShape))\n # con attivazione Rectified Linear Unit\n model.add(Activation(\"relu\"))\n # applico una batch normalization\n model.add(BatchNormalization(axis=chanDim))\n # un MaxPooling 3*3\n model.add(MaxPooling2D(pool_size=(3, 3)))\n # ed un 25% di dropout per ridurre overfitting\n model.add(Dropout(0.25))\n\n # Secondo blocco\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(64, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Terzo blocco\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(Conv2D(128, (3, 3), padding=\"same\"))\n model.add(Activation(\"relu\"))\n model.add(BatchNormalization(axis=chanDim))\n model.add(MaxPooling2D(pool_size=(2, 2)))\n model.add(Dropout(0.25))\n\n # Passo ai Fully Connected Layers\n # Trasformo il modello in un vettore\n model.add(Flatten())\n model.add(Dense(1024))\n model.add(Activation(\"sigmoid\"))\n model.add(BatchNormalization())\n model.add(Dropout(0.5))\n\n # Infine utilizzo l'attivazione per la rete\n model.add(Dense(classesNumber))\n model.add(Activation(finalAct))\n\n return model","def keras_add_layers(model, num_classes, keep_prob):\n # DONE: Implement function\n\n # See also lesson \"FCN-8 Decoder\" for structure, and Long_Shelhamer paper\n\n # Walkthrough video started with 1x1 convolution like this, but notes explained\n # that was already done for us (loaded model is not ordinary VGG but already\n # adapted for FCN). In fact the VGG network provided looks very much like\n # the one generated by the Single-Shot Detector caffe code, so I guess they\n # share some common heritage.\n #conv_1x1 = tf.layers.conv2d(vgg_layer7_out, # at/near end of VGG\n # num_classes, # just road/nonroad for us\n # 1, # as 1x1 conv\n # padding='same',\n # kernel_regularizer = tf.contrib.layers.l2_regularizer(1e-3))\n\n # Using Tensorboard to visualise the structure of the Udacity VGG model provided, and\n # tf.trainable_variables() to list the dimensions and sizes of the weights and biases\n # for each layer, I arrive at this summary of what shape the output of each layer\n # is (knowing that we started with a 160 height x 576 width x 3 colour channel image).\n # All of the convolution layers have SAME padding and [1,1,1,1] strides so they\n # don't reduce the x-y pixel size. All the pooling layers have [1,2,2,1] strides so\n # they halve the pixel size. I'm ignoring the first dimension (across images), as\n # everything works on one image at a time.\n #\n # Layer name Details Output dimensions\n # <input> raw image 160x576x3\n # conv1_1 conv2d 3x3x3x64, Relu 160x576x64\n # conv1_2 conv2d 3x3x64x64, Relu 160x576x64\n # pool1 pool [1,2,2,1] 80x288x64\n # conv2_1 conv2d 3x3x64x128, Relu 80x288x128\n # conv2_2 conv2d 3x3x128x128, Relu 80x288x128\n # pool2 pool [1,2,2,1] 40x144x128\n # conv3_1 conv2d 3x3x128x256, Relu 40x144x256\n # conv3_2 conv2d 3x3x256x256, Relu 40x144x256\n # conv3_3 conv2d 3x3x256x256, Relu 40x144x256\n # pool3 pool [1,2,2,1] 20x72x256 --> layer3_out\n # conv4_1 conv2d 3x3x256x512, Relu 20x72x512\n # conv4_2 conv2d 3x3x512x512, Relu 20x72x512\n # conv4_3 conv2d 3x3x512x512, Relu 20x72x512\n # pool4 pool [1,2,2,1] 10x36x512 --> layer4_out\n # conv5_1 conv2d 3x3x512x512, Relu 10x36x512\n # conv5_2 conv2d 3x3x512x512, Relu 10x36x512\n # conv5_3 conv2d 3x3x512x512, Relu 10x36x512\n # pool5 pool [1,2,2,1] 5x18x512\n # fc6 conv2d 7x7x512x4096, Relu 5x18x4096\n # dropout dropout(keep_prob) 5x18x4096\n # fc7 conv2d 1x1x4096x4096, Relu 5x18x4096\n # dropout_1 dropout(keep_prob) 5x18x4096 --> layer7_out\n # layer8 conv2d_t 10x36\n\n layer3_out = model.get_layer('block3_pool').output\n layer4_out = model.get_layer('block4_pool').output\n\n # Problem here: TF2 library model doesn't have image-shaped layers 6 & 7 like\n # model provided originally with TF1, but instead is flattened amporphous classifier.\n # So we're working with more 'raw' layer as input. TODO should add back\n # two conv2d layers before this to be like the original\n drop_prob = 1.0 - keep_prob\n\n layer5 = model.get_layer('block5_pool')\n\n layer6_conv = tf.keras.layers.Conv2D(4096,\n 7, # 7x7 patch from original Udacity model\n strides=(1,1),\n padding='same',\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)), # guess same as others\n name='layer6_conv')\n\n layer6_dropout = tf.keras.layers.Dropout(drop_prob, name=\"layer6_dropout\")\n\n layer7_conv = tf.keras.layers.Conv2D(4096,\n 1, # 1x1 patch from original Udacity model\n strides=(1,1),\n padding='same',\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)), # guess\n name='layer7_conv')\n\n layer7_dropout = tf.keras.layers.Dropout(drop_prob, name=\"layer7_dropout\")\n\n # Connect up the new layers\n x = layer6_conv(layer5.output)\n x = layer6_dropout(x)\n x = layer7_conv(x)\n layer7 = layer7_dropout(x)\n\n # Create a new model\n mod_model = tf.keras.Model(inputs=model.input, outputs=layer7)\n\n # We should now have the same structure as the original Udacity version of VGG16,\n # but still need to add the decoder and skip connections as before\n\n # Upsample by 2. We need to work our way down from a kernel depth of 4096\n # to just our number of classes (i.e. 2). Should we do this all in one go?\n # Or keep more depth in as we work upwards? For now doing it all in one hit.\n layer8 = tf.keras.layers.Conv2DTranspose(num_classes, #filters, \n 4, # kernel size taken from classroom example, might experiment\n strides=2, # stride causes upsampling\n padding='same',\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\n name='layer8')\n\n # Now we're at 10x36x2 so we have same pixel resolution as layer4_out. Can't directly add\n # in layer4_out because it has filter depth of 512. (Though we could have had our transpose\n # convolution only downsample to 512 for compatibility... might try that later)\n\n # Squash layer4 output with 1x1 convolution so that it has compatible filter depth (i.e. num_classes)\n layer4_squashed = tf.keras.layers.Conv2D(num_classes, # new number of filters,\n 1, # 1x1 convolution so kernel size 1\n padding='same',\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\n name='layer4_squashed')\n # upsample by 2\n layer9 = tf.keras.layers.Conv2DTranspose(num_classes, # filters\n 4, # kernel size taken from classroom example\n strides=(2,2), # stride causes upsampling\n padding='same',\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\n name='layer9')\n\n # Now we're at 20x72x2 so same pixel resolution as layer3_out, but need to squash that from\n # 256 filters to 2 (num_classes) before we can add it in as skip connection\n layer3_squashed = tf.keras.layers.Conv2D(num_classes, # new number of filters\n 1, # 1x1 convolution so kernel size 1\n padding='same',\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\n name='layer3_squashed')\n\n # upsample by 8 to get back to original image size\n layer10 = tf.keras.layers.Conv2DTranspose(num_classes,\n 32, # Finding quite large kernel works nicely\n strides=(8,8), # stride causes upsampling\n padding='same',\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\n name='layer10')\n\n # so now we should be at 160x576x2, same as original image size, 2 classes\n\n # Connect the layers\n x1 = layer8(layer7)\n x2 = layer4_squashed(layer4_out)\n\n # now we can add skip layer of this dimension taken from corresponding encoder layer\n layer8_plus_layer4 = tf.keras.layers.add([x1, x2], name='layer8_plus_layer4')\n #layer8_plus_layer4 = tf.add(layer8, layer4_squashed, name='layer8_plus_layer4')\n\n x1 = layer9(layer8_plus_layer4)\n x2 = layer3_squashed(layer3_out)\n\n # now we can add skip layer of this dimension taken from corresponding encoder layer\n layer9_plus_layer3 = tf.keras.layers.add([x1, x2], name='layer9_plus_layer3')\n #layer9_plus_layer3 = tf.add(layer9, layer3_squashed, name='layer9_plus_layer3')\n\n predictors = layer10(layer9_plus_layer3) # layer 10 should be same size as image\n\n # Create a new model\n mod_model = tf.keras.Model(inputs=model.input, outputs=predictors)\n print(\"Model after adding decoder layers:\")\n mod_model.summary()\n\n return mod_model","def keras_functional_conv_net():\n inputs = tf.keras.layers.Input(shape=(28, 28, 3))\n x = tf.keras.layers.Conv2D(4, kernel_size=3, activation=None)(inputs)\n x = tf.keras.layers.BatchNormalization()(x)\n x = tf.keras.layers.Activation(\"relu\")(x)\n x = tf.keras.layers.Conv2D(16, kernel_size=3, activation=None)(x)\n x = tf.keras.layers.BatchNormalization()(x)\n x = tf.keras.layers.PReLU()(x)\n x = tf.keras.layers.Conv2D(16, kernel_size=3, activation=None)(x)\n outputs = tf.keras.layers.Conv2D(32, kernel_size=3, activation=\"relu\")(x)\n model = tf.keras.Model(inputs=inputs, outputs=outputs)\n\n return model","def __init__(self):\r\n torch.nn.Module.__init__(self)\r\n # Convolution and pooling layers of VGG-16.\r\n self.features = torchvision.models.vgg19_bn(pretrained=False).features\r\n self.features = torch.nn.Sequential(*list(self.features.children())\r\n [:-1]) # Remove pool5.\r\n # Linear classifier.\r\n self.fc = torch.nn.Linear(512**2, 11)","def __init__(self, options):\r\n nn.Module.__init__(self)\r\n # Convolution and pooling layers of VGG-16.\r\n self.basemodel = torchvision.models.resnet18(pretrained=True)\r\n self.options = options\r\n\r\n #label\r\n self.label_primary = nn.Linear(options['primary_dim'], options['proj_dim'])\r\n self.label_dual = nn.Linear(options['dual_dim'], options['proj_dim'])\r\n\r\n #classifer/regressor\r\n self.fc_primary = nn.Linear(512 + options['proj_dim'], options['primary_dim'])\r\n self.fc_dual = nn.Linear(512 + options['proj_dim'], options['dual_dim'])\r\n\r\n\r\n if self.options['fc'] == True:\r\n # Freeze all previous layers.\r\n for param in self.basemodel.parameters():\r\n param.requires_grad = False\r\n # Initialize the fc layers.\r\n nn.init.kaiming_normal_(self.fc_primary.weight.data)\r\n if self.fc_primary.bias is not None:\r\n nn.init.constant_(self.fc_primary.bias.data, val=0)\r\n\r\n nn.init.kaiming_normal_(self.fc_dual.weight.data)\r\n if self.fc_dual.bias is not None:\r\n nn.init.constant_(self.fc_dual.bias.data, val=0)\r\n\r\n nn.init.kaiming_normal_(self.label_primary.weight.data)\r\n if self.label_primary.bias is not None:\r\n nn.init.constant_(self.label_primary.bias.data, val=0)\r\n\r\n nn.init.kaiming_normal_(self.label_dual.weight.data)\r\n if self.label_dual.bias is not None:\r\n nn.init.constant_(self.label_dual.bias.data, val=0)\r\n\r\n\r\n else:\r\n for param in self.basemodel.conv1.parameters():\r\n param.requires_grad = False\r\n for param in self.basemodel.bn1.parameters():\r\n param.requires_grad = False\r\n for param in self.basemodel.layer1.parameters():\r\n param.requires_grad = False\r\n #for param in self.basemodel.layer2.parameters():\r\n # param.requires_grad = False\r\n #for param in self.basemodel.layer3.parameters():\r\n # param.requires_grad = False\r"],"string":"[\n \"def build_vgg16(self):\\n use_batch_norm = self.use_batch_norm\\n\\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\\n is_train = tf.placeholder(tf.bool)\\n\\n conv1_1_feats = convolution(imgs, 3, 3, 64, 1, 1, 'conv1_1')\\n conv1_1_feats = nonlinear(conv1_1_feats, 'relu')\\n conv1_2_feats = convolution(conv1_1_feats, 3, 3, 64, 1, 1, 'conv1_2')\\n conv1_2_feats = nonlinear(conv1_2_feats, 'relu')\\n pool1_feats = max_pool(conv1_2_feats, 2, 2, 2, 2, 'pool1')\\n\\n conv2_1_feats = convolution(pool1_feats, 3, 3, 128, 1, 1, 'conv2_1')\\n conv2_1_feats = nonlinear(conv2_1_feats, 'relu')\\n conv2_2_feats = convolution(conv2_1_feats, 3, 3, 128, 1, 1, 'conv2_2')\\n conv2_2_feats = nonlinear(conv2_2_feats, 'relu')\\n pool2_feats = max_pool(conv2_2_feats, 2, 2, 2, 2, 'pool2')\\n\\n conv3_1_feats = convolution(pool2_feats, 3, 3, 256, 1, 1, 'conv3_1')\\n conv3_1_feats = nonlinear(conv3_1_feats, 'relu')\\n conv3_2_feats = convolution(conv3_1_feats, 3, 3, 256, 1, 1, 'conv3_2')\\n conv3_2_feats = nonlinear(conv3_2_feats, 'relu')\\n conv3_3_feats = convolution(conv3_2_feats, 3, 3, 256, 1, 1, 'conv3_3')\\n conv3_3_feats = nonlinear(conv3_3_feats, 'relu')\\n pool3_feats = max_pool(conv3_3_feats, 2, 2, 2, 2, 'pool3')\\n\\n conv4_1_feats = convolution(pool3_feats, 3, 3, 512, 1, 1, 'conv4_1')\\n conv4_1_feats = nonlinear(conv4_1_feats, 'relu')\\n conv4_2_feats = convolution(conv4_1_feats, 3, 3, 512, 1, 1, 'conv4_2')\\n conv4_2_feats = nonlinear(conv4_2_feats, 'relu')\\n conv4_3_feats = convolution(conv4_2_feats, 3, 3, 512, 1, 1, 'conv4_3')\\n conv4_3_feats = nonlinear(conv4_3_feats, 'relu')\\n pool4_feats = max_pool(conv4_3_feats, 2, 2, 2, 2, 'pool4')\\n\\n conv5_1_feats = convolution(pool4_feats, 3, 3, 512, 1, 1, 'conv5_1')\\n conv5_1_feats = nonlinear(conv5_1_feats, 'relu')\\n conv5_2_feats = convolution(conv5_1_feats, 3, 3, 512, 1, 1, 'conv5_2')\\n conv5_2_feats = nonlinear(conv5_2_feats, 'relu')\\n conv5_3_feats = convolution(conv5_2_feats, 3, 3, 512, 1, 1, 'conv5_3')\\n conv5_3_feats = nonlinear(conv5_3_feats, 'relu')\\n\\n conv5_3_feats_flat = tf.reshape(conv5_3_feats, [self.batch_size, 196, 512])\\n self.conv_feats = conv5_3_feats_flat\\n self.conv_feat_shape = [196, 512]\\n self.num_ctx = 196 \\n self.dim_ctx = 512\\n\\n self.imgs = imgs\\n self.is_train = is_train\",\n \"def build_cnn_vgg16(num_classes):\\n\\n inputs = tf.keras.layers.Input(\\n shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS)\\n )\\n\\n x = inputs\\n x = tf.keras.applications.vgg16.preprocess_input(x)\\n vgg16 = tf.keras.applications.VGG16(\\n input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS),\\n weights=\\\"imagenet\\\",\\n include_top=False\\n )\\n\\n vgg16.trainable = False\\n x = vgg16(x, training=False)\\n\\n x = tf.keras.layers.GlobalAveragePooling2D()(x)\\n x = tf.keras.layers.Dense(\\n units=num_classes,\\n activation=tf.keras.activations.softmax\\n )(x)\\n\\n outputs = x\\n\\n model = tf.keras.Model(\\n inputs=inputs,\\n outputs=outputs\\n )\\n\\n return model\",\n \"def vgg_fcn(images,\\n num_classes=FLAGS.num_classes,\\n is_training=True,\\n dropout_keep_prob=0.5,\\n spatial_squeeze=False, #True,\\n scope='vgg_16',\\n fc_conv_padding='VALID'):\\n with tf.variable_scope(scope, 'vgg_16', [images]) as sc:\\n end_points_collection = sc.name + '_end_points'\\n with slim.arg_scope([slim.conv2d, slim.conv2d_transpose, slim.fully_connected, slim.max_pool2d], outputs_collections=end_points_collection):\\n conv1 = slim.repeat(images, 2, slim.conv2d, 64, [3, 3], scope='conv1')\\n pool1 = slim.max_pool2d(conv1, [2, 2], scope='pool1')\\n conv2 = slim.repeat(pool1, 2, slim.conv2d, 128, [3, 3], scope='conv2')\\n pool2 = slim.max_pool2d(conv2, [2, 2], scope='pool2')\\n conv3 = slim.repeat(pool2, 3, slim.conv2d, 256, [3, 3], scope='conv3')\\n pool3 = slim.max_pool2d(conv3, [2, 2], scope='pool3')\\n conv4 = slim.repeat(pool3, 3, slim.conv2d, 512, [3, 3], scope='conv4')\\n pool4 = slim.max_pool2d(conv4, [2, 2], scope='pool4')\\n conv5 = slim.repeat(pool4, 3, slim.conv2d, 512, [3, 3], scope='conv5')\\n pool5 = slim.max_pool2d(conv5, [2, 2], scope='pool5')\\n fc6 = slim.conv2d(pool5, 4096, [7, 7], stride=1, scope='fc6')\\n drop6 = slim.dropout(fc6, dropout_keep_prob, is_training=is_training, scope='dropout6')\\n fc7 = slim.conv2d(drop6, 4096, [1, 1], scope='fc7')\\n drop7 = slim.dropout(fc7, dropout_keep_prob, is_training=is_training, scope='dropout7')\\n fc8 = slim.conv2d(drop7, num_classes, [1, 1], activation_fn=None, normalizer_fn=None, scope='fc8')\\n #end_points = slim.utils.convert_collection_to_dict(end_points_collection)\\n\\n if spatial_squeeze:\\n fc8 = tf.squeeze(fc8, [1, 2], name='fc8/squeezed')\\n msk_shape = images.shape\\n # it is intialized as bilinar interpolation(calculation predfined)\\n score_fr = slim.conv2d(fc7, num_classes, [1, 1], scope='score_fr')\\n tf.logging.info(\\\"score_fr size: %s\\\"% tf.shape(score_fr))\\n fc32s = slim.conv2d_transpose(inputs=score_fr, num_outputs=num_classes, kernel_size=[64, 64], stride=32, scope='fc32s')\\n tf.logging.info(\\\"fc32s: %s\\\" % tf.shape(fc32s))\\n\\n #fc32s = tf.image.crop_to_bounding_box(fc32s, 19, 19, msk_shape[1], msk_shape[2])\\n \\n upscore2 = slim.conv2d_transpose(inputs=score_fr, num_outputs=num_classes, kernel_size=[4, 4], stride=2, scope='upscore2')\\n\\n deconv_shape1 = upscore2.get_shape() \\n score_pool4 = slim.conv2d(pool4, num_classes, [1, 1], stride=1, scope='score_pool4')\\n\\n #score_pool4 = tf.image.crop_to_bounding_box(score_pool4, 5, 5, deconv_shape1[1], deconv_shape1[2])\\n \\n fuse_pool4 = tf.add(upscore2, score_pool4)\\n\\n fc16s = slim.conv2d_transpose(inputs=fuse_pool4, num_outputs=num_classes, kernel_size=[32, 32], stride=16, scope='fc16s')\\n\\n tf.logging.info(\\\"fc16s size: %s\\\" % tf.shape(fc16s))\\n #fc16s = tf.image.crop_to_bounding_box(fc16s, 27, 27, msk_shape[1], msk_shape[2])\\n \\n upscore_pool4 = slim.conv2d_transpose(inputs=fuse_pool4, num_outputs=num_classes, kernel_size=[4, 4], stride=2, scope='upscore_pool4')\\n\\n upscore_pool3 = slim.conv2d(pool3, num_classes, [1, 1], stride=1, scope='upscore_pool3')\\n deconv_shape2 = upscore_pool4.get_shape()\\n #upscore_pool3 = tf.image.crop_to_bounding_box(upscore_pool3, 9, 9, deconv_shape2[1], deconv_shape[2])\\n fuse_pool3 = tf.add(upscore_pool4, upscore_pool3)\\n\\n fc8s = slim.conv2d_transpose(inputs=fuse_pool3, num_outputs=num_classes, kernel_size=[16, 16], stride=8, scope='fc8s')\\n tf.logging.info(\\\"fc8s size: %s\\\" % tf.shape(fc8s))\\n #fc8s = tf.image.crop_to_bounding_box(fc8s, 31, 31, msk_shape[1], msk_shape[2])\\n\\n\\n annotation_pred = tf.argmax(fc8s, dimension=3, name=\\\"prediction\\\")\\n end_points = slim.utils.convert_collection_to_dict(end_points_collection)\\n\\n tf.get_variable_scope().reuse_variables()\\n\\n return tf.expand_dims(annotation_pred, dim=3), fc8s, end_points\",\n \"def build_model(self):\\n \\n start_time = time.time()\\n print(\\\"build model started\\\")\\n # label\\n self.FA = tf.placeholder(dtype=tf.int32, shape=[None])\\n self.ges = tf.placeholder(dtype=tf.int32, shape=[None])\\n self.obj = tf.placeholder(dtype=tf.int32, shape=[None])\\n \\n self.images = tf.placeholder(dtype=tf.float32, shape=[None, height, width, 3])\\n batch_size = tf.shape(self.images)[0]\\n rgb_scaled = self.images * 255.0\\n\\n # Convert RGB to BGR\\n VGG_MEAN = [103.939, 116.779, 123.68]\\n red, green, blue = tf.split(axis=3, num_or_size_splits=3, value=rgb_scaled)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n bgr = tf.concat(axis=3, values=[\\n blue - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n red - VGG_MEAN[2],\\n ])\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n \\n with tf.variable_scope(\\\"vgg19\\\"):\\n self.conv1_1 = self.conv_layer(bgr, \\\"conv1_1\\\")\\n self.conv1_2 = self.conv_layer(self.conv1_1, \\\"conv1_2\\\")\\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\\n\\n self.conv2_1 = self.conv_layer(self.pool1, \\\"conv2_1\\\")\\n self.conv2_2 = self.conv_layer(self.conv2_1, \\\"conv2_2\\\")\\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\\n\\n self.conv3_1 = self.conv_layer(self.pool2, \\\"conv3_1\\\")\\n self.conv3_2 = self.conv_layer(self.conv3_1, \\\"conv3_2\\\")\\n self.conv3_3 = self.conv_layer(self.conv3_2, \\\"conv3_3\\\")\\n self.conv3_4 = self.conv_layer(self.conv3_3, \\\"conv3_4\\\")\\n self.pool3 = self.max_pool(self.conv3_4, 'pool3')\\n\\n self.conv4_1 = self.conv_layer(self.pool3, \\\"conv4_1\\\")\\n self.conv4_2 = self.conv_layer(self.conv4_1, \\\"conv4_2\\\")\\n self.conv4_3 = self.conv_layer(self.conv4_2, \\\"conv4_3\\\")\\n self.conv4_4 = self.conv_layer(self.conv4_3, \\\"conv4_4\\\")\\n self.pool4 = self.max_pool(self.conv4_4, 'pool4')\\n\\n self.conv5_1 = self.conv_layer(self.pool4, \\\"conv5_1\\\")\\n self.conv5_2 = self.conv_layer(self.conv5_1, \\\"conv5_2\\\")\\n self.conv5_3 = self.conv_layer(self.conv5_2, \\\"conv5_3\\\")\\n self.conv5_4 = self.conv_layer(self.conv5_3, \\\"conv5_4\\\")\\n self.pool5 = self.max_pool(self.conv5_4, 'pool5')\\n\\n \\n shape = self.pool5.get_shape()\\n size = 1\\n for dim in shape[1:]:\\n size *= dim.value\\n \\n # dense\\n with tf.variable_scope('dense') as scope:\\n # Move everything into depth so we can perform a single matrix multiply.\\n reshape = tf.reshape(self.pool5, [-1, size])\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[size, 192]))\\n biases = tf.get_variable('biases', [192], initializer=tf.constant_initializer(0.1))\\n dense = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)\\n\\n\\n # linear layer(WX + b),\\n with tf.variable_scope('softmax_linear_FA') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 2]))\\n biases = tf.get_variable('biases', [2], initializer=tf.constant_initializer(0.1))\\n softmax_linear_FA = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_FA = tf.nn.softmax(softmax_linear_FA)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.FA, logits=softmax_linear_FA, name='cross_entropy')\\n cross_entropy_mean_FA = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n with tf.variable_scope('softmax_linear_ges') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 13]))\\n biases = tf.get_variable('biases', [13], initializer=tf.constant_initializer(0.1))\\n softmax_linear_ges = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_ges = tf.nn.softmax(softmax_linear_ges)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.ges, logits=softmax_linear_ges, name='cross_entropy')\\n cross_entropy_mean_ges = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n with tf.variable_scope('softmax_linear_obj') as scope:\\n weights = tf.get_variable('weights', initializer=tf.truncated_normal(shape=[192, 24]))\\n biases = tf.get_variable('biases', [24], initializer=tf.constant_initializer(0.1))\\n softmax_linear_obj = tf.add(tf.matmul(dense, weights), biases, name=scope.name)\\n self.output_obj = tf.nn.softmax(softmax_linear_obj)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.obj, logits=softmax_linear_obj, name='cross_entropy')\\n cross_entropy_mean_obj = tf.reduce_mean(cross_entropy, name='cross_entropy_mean')\\n\\n self.loss = cross_entropy_mean_FA + cross_entropy_mean_ges + cross_entropy_mean_obj\\n self.lr = tf.placeholder(tf.float32, [])\\n self.global_step = tf.Variable(0, name=\\\"global_step\\\", trainable=False)\\n optimizer = tf.train.AdamOptimizer(self.lr)\\n grads_and_vars = optimizer.compute_gradients(self.loss)\\n self.train_op = optimizer.apply_gradients(grads_and_vars, global_step=self.global_step)\\n self.data_dict = None\\n print((\\\"build model finished: %ds\\\" % (time.time() - start_time)))\",\n \"def build_vgg():\\n input_shape = (256, 256, 3)\\n\\n vgg = keras.applications.VGG19(include_top = False , input_shape = input_shape , weights=\\\"imagenet\\\")\\n features = vgg.get_layer(index = 9).output\\n\\n model = keras.Model(inputs=[vgg.inputs], outputs=[features])\\n return model\",\n \"def vgg_16(input_shape=(224, 224, 3), output_shape=1000):\\n model = Sequential()\\n \\n # layer 1 ~ 2 (filter: 64)\\n model.add(Input(shape=input_shape))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(64, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(64, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 112 x 112 x 64\\n \\n # layer 3 ~ 4 (filter: 128)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(128, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(128, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 56 x 56 x 128\\n \\n # layer 5 ~ 7 (filter: 256)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(256, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(256, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(256, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 28 x 28 x 256\\n \\n # layer 8 ~ 10 (filter: 512)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 14 x 14 x 512\\n \\n # layer 11 ~ 13 (filter: 512)\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(ZeroPadding2D((1, 1)))\\n model.add(Conv2D(512, (3, 3), activation='relu'))\\n model.add(MaxPool2D((2, 2), strides=(2, 2)))\\n # output size: 7 x 7 x 512\\n \\n # layer 14 ~ 16 (Fully Connected)\\n model.add(Flatten())\\n # flatten: 7 x 7 x 512 = 25,088\\n model.add(Dense(4096, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(4096, activation='relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(output_shape, activation='softmax'))\\n # categorized by output shape\\n \\n return model\",\n \"def build(self):\\n\\n # bgr_ = bgr*255.0\\n bgr_= self.X\\n start_time = time.time()\\n print(\\\"build model started\\\")\\n\\n # blue ,green, red = tf.split(axis=3, num_or_size_splits=3, value= bgr)\\n red ,green, blue, = tf.split(axis=3, num_or_size_splits=3, value= bgr_)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n bgr = tf.concat(axis=3, values=[\\n # blue - VGG_MEAN[0],\\n # green - VGG_MEAN[1],\\n # red - VGG_MEAN[2],\\n\\n red - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n blue - VGG_MEAN[2],\\n ])\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n\\n\\n\\n print(bgr.shape)\\n\\n self.conv1_1 = self.conv_layer(bgr, \\\"conv1_1\\\")\\n self.conv1_2 = self.conv_layer(self.conv1_1, \\\"conv1_2\\\")\\n self.pool1 = self.max_pool(self.conv1_2, 'pool1')\\n\\n self.conv2_1 = self.conv_layer(self.pool1, \\\"conv2_1\\\")\\n self.conv2_2 = self.conv_layer(self.conv2_1, \\\"conv2_2\\\")\\n self.pool2 = self.max_pool(self.conv2_2, 'pool2')\\n\\n\\n\\n\\n self.conv3_1 = self.conv_layer(self.pool2, \\\"conv3_1\\\")\\n self.conv3_2 = self.conv_layer(self.conv3_1, \\\"conv3_2\\\")\\n self.conv3_3 = self.conv_layer(self.conv3_2, \\\"conv3_3\\\")\\n self.pool3 = self.max_pool(self.conv3_3, 'pool3')\\n\\n self.conv4_1 = self.conv_layer(self.pool3, \\\"conv4_1\\\")\\n self.conv4_2 = self.conv_layer(self.conv4_1, \\\"conv4_2\\\")\\n self.conv4_3 = self.conv_layer(self.conv4_2, \\\"conv4_3\\\")\\n self.pool4 = self.max_pool(self.conv4_3, 'pool4')\\n\\n\\n\\n\\n\\n self.conv5_1 = self.conv_layer(self.pool4, \\\"conv5_1\\\")\\n self.conv5_2 = self.conv_layer(self.conv5_1, \\\"conv5_2\\\")\\n self.conv5_3 = self.conv_layer(self.conv5_2, \\\"conv5_3\\\")\\n self.pool5 = self.max_pool(self.conv5_3, 'pool5')\\n\\n self.fc6 = self.fc_layer(self.pool5, \\\"fc6\\\")\\n assert self.fc6.get_shape().as_list()[1:] == [4096]\\n self.relu6 = tf.nn.relu(self.fc6)\\n\\n self.fc7 = self.fc_layer(self.relu6, \\\"fc7\\\")\\n self.relu7 = tf.nn.relu(self.fc7)\\n\\n self.fc8 = self.fc_layer(self.relu7, \\\"fc8\\\")\\n\\n # self.fc9 = self.fc_layer(self.fc8,'fc9')\\n # self.relu9 = tf.nn.relu(self.fc9)\\n\\n\\n\\n\\n relu8 = tf.nn.relu(self.fc8)\\n fc9 = self.fc_layer(relu8, 'fc9')\\n print((\\\"build model finished: %ds\\\" % (time.time() - start_time)))\\n return fc9\\n\\n # self.prob = tf.nn.softmax(self.fc8, name=\\\"prob\\\")\",\n \"def _build_preprocessor(self, crop_size=[224,224]):\\n self.image_ph = tf.placeholder(tf.float32)\\n self.cropbox_ph = tf.placeholder(tf.float32, shape=[4]) #y1,x1,y2,x2\\n img = self.image_ph - self.VGG_MEAN\\n batch_img = tf.image.crop_and_resize(\\n tf.expand_dims(img, 0),\\n tf.expand_dims(self.cropbox_ph, 0),\\n [0], crop_size)\\n self.image_after_crop = tf.cast(tf.squeeze(batch_img) + self.VGG_MEAN, tf.uint8)\\n vgg_graph_def = tf.GraphDef()\\n with open(FLAGS.vgg_model_frozen, \\\"rb\\\") as f:\\n vgg_graph_def.ParseFromString(f.read())\\n features = tf.import_graph_def(\\n vgg_graph_def, input_map={'inputs': batch_img},\\n return_elements=[FLAGS.feature_layer])[0]\\n features_dim = features.get_shape().as_list()\\n features_dim[1] = features_dim[2] = 8\\n features, num_features = extract_features(features)\\n self.features_dim = features_dim\\n #logging.debug('features_dim', features_dim)\\n self.num_features = num_features\\n self.features = tf.reshape(features, [num_features, features_dim[3]])\",\n \"def build_vgg(self, weights=\\\"imagenet\\\"): \\n \\n # Input image to extract features from\\n img = Input(shape=(self.img_rows, self.img_cols, 3))\\n\\n # Mean center and rescale by variance as in PyTorch\\n processed = Lambda(lambda x: (x-self.mean) / self.std)(img)\\n \\n # If inference only, just return empty model \\n if self.inference_only:\\n model = Model(inputs=img, outputs=[img for _ in range(len(self.vgg_layers))])\\n model.trainable = False\\n model.compile(loss='mse', optimizer='adam')\\n return model\\n \\n # Get the vgg network from Keras applications\\n if weights in ['imagenet', None]:\\n vgg = VGG16(weights=weights, include_top=False)\\n else:\\n vgg = VGG16(weights=None, include_top=False)\\n vgg.load_weights(weights, by_name=True)\\n\\n # Output the first three pooling layers\\n vgg.outputs = [vgg.layers[i].output for i in self.vgg_layers] \\n \\n # Create model and compile\\n model = Model(inputs=img, outputs=vgg(processed))\\n model.trainable = False\\n model.compile(loss='mse', optimizer='adam')\\n\\n return model\",\n \"def __init__(self, input_shape=(3, 244, 244), include_classifier=True,\\n **kwargs):\\n self._name = \\\"VGG16\\\"\\n self._weightsUrl = {\\n 'th': 'https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg16_weights_th_dim_ordering_th_kernels.h5',\\n 'tf': 'https://github.com/fchollet/deep-learning-models/releases/download/v0.1/vgg16_weights_tf_dim_ordering_tf_kernels.h5'\\n }\\n\\n # If using the Tensor Flow backend we have to transform input shape\\n if K.image_dim_ordering() == \\\"tf\\\":\\n input_shape = (input_shape[1], input_shape[2], input_shape[0])\\n\\n self._inLayer = Input(shape=input_shape)\\n\\n self._net = Convolution2D(64, 3, 3, activation='relu',\\n border_mode='same',\\n name='block1_conv1')(self._inLayer)\\n self._net = Convolution2D(64, 3, 3, activation='relu',\\n border_mode='same',\\n name='block1_conv2')(self._net)\\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\\n name='block1_pool')(self._net)\\n\\n self._net = Convolution2D(128, 3, 3, activation='relu',\\n border_mode='same',\\n name='block2_conv1')(self._net)\\n self._net = Convolution2D(128, 3, 3, activation='relu',\\n border_mode='same',\\n name='block2_conv2')(self._net)\\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\\n name='block2_pool')(self._net)\\n\\n self._net = Convolution2D(256, 3, 3, activation='relu',\\n border_mode='same',\\n name='block3_conv1')(self._net)\\n self._net = Convolution2D(256, 3, 3, activation='relu',\\n border_mode='same',\\n name='block3_conv2')(self._net)\\n self._net = Convolution2D(256, 3, 3, activation='relu',\\n border_mode='same',\\n name='block3_conv3')(self._net)\\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\\n name='block3_pool')(self._net)\\n\\n self._net = Convolution2D(512, 3, 3, activation='relu',\\n border_mode='same',\\n name='block4_conv1')(self._net)\\n self._net = Convolution2D(512, 3, 3, activation='relu',\\n border_mode='same',\\n name='block4_conv2')(self._net)\\n self._net = Convolution2D(512, 3, 3, activation='relu',\\n border_mode='same',\\n name='block4_conv3')(self._net)\\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\\n name='block4_pool')(self._net)\\n\\n self._net = Convolution2D(512, 3, 3, activation='relu',\\n border_mode='same',\\n name='block5_conv1')(self._net)\\n self._net = Convolution2D(512, 3, 3, activation='relu',\\n border_mode='same',\\n name='block5_conv2')(self._net)\\n self._net = Convolution2D(512, 3, 3, activation='relu',\\n border_mode='same',\\n name='block5_conv3')(self._net)\\n self._net = MaxPooling2D((2, 2), strides=(2, 2),\\n name='block5_pool')(self._net)\\n\\n # Classification block\\n if include_classifier:\\n self._net = Flatten(name='flatten')(self._net)\\n self._net = Dense(4096, activation='relu', name='fc1')(self._net)\\n self._net = Dense(4096, activation='relu', name='fc2')(self._net)\\n self._net = Dense(1000, activation='softmax',\\n name='predictions')(self._net)\\n\\n # Create the model\\n self._model = Model(self._inLayer, self._net)\\n super(VGG16, self).__init__(**kwargs)\",\n \"def VGGWithCustomLayers(nb_classes, input_shape, fc_size):\\n # setup model\\n base_model = VGGFace(include_top=False, input_tensor=Input(shape=input_shape))\\n x = base_model.output\\n x = GlobalAveragePooling2D()(x)\\n x = Dense(fc_size, activation='relu')(x) # new FC layer, random init\\n x = Dense(fc_size * 2, activation='relu')(x) # new FC layer, random init\\n x = Dense(fc_size * 4, activation='relu')(x) # new FC layer, random init\\n predictions = Dense(nb_classes, activation='softmax')(x) # new softmax layer\\n model = Model(outputs=predictions, inputs=base_model.input)\\n return model, base_model\",\n \"def __init__(self, num_classes):\\n super(VGG16, self).__init__()\\n self.vgg16_feature_extractor = VGG16FeatureExtraction(weights_update=True)\\n self.max_pool = nn.MaxPool2d(kernel_size=2, stride=2)\\n self.classifier = VGG16Classfier()\\n self.fc3 = _fc(in_channels=4096, out_channels=num_classes)\",\n \"def build_vgg16_notop(image_dimensions, pooling, size_final_dense, num_classes, trainable=False, weights='imagenet'):\\n\\n vgg16_base = VGG16(weights=weights\\n , include_top=False # Ignore the final dense layers, we'll train our own\\n , input_shape=image_dimensions\\n , pooling=pooling)\\n vgg16_base.trainable=trainable\\n\\n image_input = Input(shape=image_dimensions)\\n\\n x = vgg16_base(image_input)\\n x = Flatten()(x)\\n x = Dense(size_final_dense,activation='relu')(x)\\n out = Dense(num_classes,activation='softmax')(x) # Task is classification\\n\\n model = Model(image_input, out)\\n return(model)\",\n \"def build_vgg(self):\\n vgg = VGG19(weights=\\\"imagenet\\\")\\n # Set outputs to outputs of last conv. layer in block 3\\n # See architecture at: https://github.com/keras-team/keras/blob/master/keras/applications/vgg19.py\\n vgg.outputs = [vgg.layers[9].output]\\n\\n img = Input(shape=self.hr_shape)\\n\\n # Extract image features\\n img_features = vgg(img)\\n\\n return Model(img, img_features)\",\n \"def build(self, input_image, num_class):\\n x = build_resnet(101)\\n # add classifier\\n x = Conv2D(num_class, (1, 1), kernel_initializer='he_normal', activation='linear', padding='valid', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x)\",\n \"def VGGFace(input_shape=(224, 224, 3), n_classes=10, include_top=True):\\n # Create the Tensor\\n input = Input(shape=input_shape)\\n\\n # Block 1\\n # 1st Convolutional Layer\\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv1')(input)\\n x = Activation('relu', name='block1_relu1')(x)\\n\\n # 2nd Convolutional Layer\\n x = Conv2D(64, (3, 3), strides=(1, 1), padding='same', name='block1_conv2')(x)\\n x = Activation('relu', name='block1_relu2')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block1_pool')(x)\\n\\n # Block 2\\n # 3rd Convolutional Layer\\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv1')(x)\\n x = Activation('relu', name='block2_relu1')(x)\\n\\n # 4th Convolutional Layer\\n x = Conv2D(128, (3, 3), strides=(1, 1), padding='same', name='block2_conv2')(x)\\n x = Activation('relu', name='block2_relu2')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block2_pool')(x)\\n\\n # Block 3\\n # 5th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv1')(x)\\n x = Activation('relu', name='block3_relu1')(x)\\n\\n # 6th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv2')(x)\\n x = Activation('relu', name='block3_relu2')(x)\\n\\n # 7th Convolutional Layer\\n x = Conv2D(256, (3, 3), strides=(1, 1), padding='same', name='block3_conv3')(x)\\n x = Activation('relu', name='block3_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block3_pool')(x)\\n\\n # Block 4\\n # 8th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv1')(x)\\n x = Activation('relu', name='block4_relu1')(x)\\n\\n # 9th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv2')(x)\\n x = Activation('relu', name='block4_relu2')(x)\\n\\n # 10th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block4_conv3')(x)\\n x = Activation('relu', name='block4_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block4_pool')(x)\\n\\n # Block 5\\n # 11th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv1')(x)\\n x = Activation('relu', name='block5_relu1')(x)\\n\\n # 12th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv2')(x)\\n x = Activation('relu', name='block5_relu2')(x)\\n\\n # 13th Convolutional Layer\\n x = Conv2D(512, (3, 3), strides=(1, 1), padding='same', name='block5_conv3')(x)\\n x = Activation('relu', name='block5_relu3')(x)\\n x = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='block5_pool')(x)\\n\\n # Block 6\\n # 14th Convulation Layer\\n x = Conv2D(4096, (7, 7), strides=(1, 1), name='fc1_conv1')(x)\\n x = Activation('relu', name='fc1_relu1')(x)\\n x = Dropout(0.5)(x)\\n\\n # 15th Convulation Layer\\n x = Conv2D(4096, (1, 1), strides=(1, 1), name='fc2_conv1')(x)\\n x = Activation('relu', name='fc2_relu2')(x)\\n x = Dropout(0.5, name='fc2_dropout')(x)\\n\\n # 16th Convulation Layer\\n x = Conv2D(2622, (1, 1), strides=(1, 1), name='fc3_conv1')(x)\\n x = Flatten(name='fc3_flatten')(x)\\n\\n if include_top:\\n # Output Layer\\n x = Activation('softmax', name='predictions_softmax')(x)\\n\\n # Create model\\n model = keras.models.Model(input, x, name='vggface')\\n return model\",\n \"def __init__(self, dropout_rate, num_classes, include_top, layer):\\r\\n super(VGG16_Rand, self).__init__()\\r\\n print(\\\"CIFAR VGG16_Rand is used\\\")\\r\\n self.dropout_rate = dropout_rate\\r\\n self.num_classes = num_classes\\r\\n self.include_top = include_top\\r\\n self.layer = layer\\r\\n self.bias = True\\r\\n\\r\\n # Define the building blocks\\r\\n if layer <= 11:\\r\\n self.conv11 = CONV_3x3rand(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 12:\\r\\n self.conv12 = nn.Sequential(CONV_3x3rand(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 21:\\r\\n self.conv21 = CONV_3x3rand(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 22:\\r\\n self.conv22 = nn.Sequential(CONV_3x3rand(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 31:\\r\\n self.conv31 = CONV_3x3rand(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 32:\\r\\n self.conv32 = CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 33:\\r\\n self.conv33 = nn.Sequential(CONV_3x3rand(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 41:\\r\\n self.conv41 = CONV_3x3rand(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 42:\\r\\n self.conv42 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 43:\\r\\n self.conv43 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n if layer <= 51:\\r\\n self.conv51 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 52:\\r\\n self.conv52 = CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n else:\\r\\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias)\\r\\n\\r\\n if layer <= 53:\\r\\n self.conv53 = nn.Sequential(CONV_3x3rand(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=self.bias),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n self.avgpool = nn.AdaptiveAvgPool2d(1)\\r\\n self.fc = nn.Sequential(nn.Linear(512, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, num_classes))\\r\\n\\r\\n # Initialize the weights\\r\\n for m in self.modules():\\r\\n if isinstance(m, nn.Conv2d):\\r\\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\\r\\n elif isinstance(m, nn.BatchNorm2d):\\r\\n # raise Exception('You are using a model without BN!!!')\\r\\n nn.init.constant_(m.weight, 1)\\r\\n nn.init.constant_(m.bias, 0)\",\n \"def vgg_16(inputs,\\n num_classes=1000,\\n is_training=True,\\n dropout_keep_prob=0.5,\\n spatial_squeeze=True,\\n scope='vgg_16',\\n fc_conv_padding='VALID',\\n global_pool=False):\\n with tf.variable_scope(scope, 'vgg_16', [inputs]) as sc:\\n end_points_collection = sc.original_name_scope + '_end_points'\\n # Collect outputs for conv2d, fully_connected and max_pool2d.\\n with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],\\n outputs_collections=end_points_collection):\\n net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')\\n net = slim.max_pool2d(net, [2, 2], scope='pool1')\\n net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')\\n net = slim.max_pool2d(net, [2, 2], scope='pool2')\\n net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')\\n net = slim.max_pool2d(net, [2, 2], scope='pool3')\\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')\\n net = slim.max_pool2d(net, [2, 2], scope='pool4')\\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')\\n net = slim.max_pool2d(net, [2, 2], scope='pool5')\\n\\n # if num_classes == 0:\\n # return net\\n\\n # Use conv2d instead of fully_connected layers.\\n net = slim.conv2d(net, 4096, [7, 7], padding=fc_conv_padding, scope='fc6')\\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\\n scope='dropout6')\\n net = slim.conv2d(net, 4096, [1, 1], scope='fc7')\\n # Convert end_points_collection into a end_point dict.\\n end_points = slim.utils.convert_collection_to_dict(end_points_collection)\\n if global_pool:\\n net = tf.reduce_mean(net, [1, 2], keep_dims=True, name='global_pool')\\n end_points['global_pool'] = net\\n if num_classes:\\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\\n scope='dropout7')\\n net = slim.conv2d(net, num_classes, [1, 1],\\n activation_fn=None,\\n normalizer_fn=None,\\n scope='fc8')\\n if spatial_squeeze:\\n net = tf.squeeze(net, [1, 2], name='fc8/squeezed')\\n end_points[sc.name + '/fc8'] = net\\n return net, end_points\",\n \"def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\\n dtype=np.float32):\\n self.params = {}\\n self.reg = reg\\n self.dtype = dtype\\n \\n ############################################################################\\n # TODO: Initialize weights and biases for the three-layer convolutional #\\n # network. Weights should be initialized from a Gaussian with standard #\\n # deviation equal to weight_scale; biases should be initialized to zero. #\\n # All weights and biases should be stored in the dictionary self.params. #\\n ############################################################################\\n \\n # Store weights and biases for the convolutional layer using the keys 'W1' and 'b1'; \\n C, H, W = input_dim\\n filter_sizes = (filter_size, filter_size)\\n self.params['W1'] = np.random.normal(0, weight_scale, [num_filters, C, filter_sizes[0], filter_sizes[1]])\\n self.params['b1'] = np.zeros((num_filters, ))\\n\\n # use keys 'W2' and 'b2' for the weights and biases of the hidden affine layer;\\n # In this case, ConvLayer doesn't reduce the spatial size of the input, (N, C, H, W) -> Conv -> (N, F, H, W)\\n # To satisfy this constraint, (W + 2 * pad - filter_size) / stride + 1 = W need to hold, which led to pad = (F - S) / 2 where S == 1\\n # (N, C, H, W) -> Conv -> (N, F, H, W) -> Pooling -> (N, F, H/2, W/2)\\n # In a FC_NN, FCL weights (input_dim, hidden_dim) where every img is flatten into a 1D array of length D = F * H/2 * W/2.\\n self.params['W2'] = np.random.normal(0, weight_scale, [num_filters * (H / 2) * (W / 2), hidden_dim])\\n self.params['b2'] = np.zeros((hidden_dim, ))\\n\\n # And the keys 'W3' and 'b3' for the weights and biases of the output affine layer. \\n self.params['W3'] = np.random.normal(0, weight_scale, [hidden_dim, num_classes])\\n self.params['b3'] = np.zeros((num_classes, ))\\n\\n \\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n for k, v in self.params.iteritems():\\n self.params[k] = v.astype(dtype)\",\n \"def __init__(self, img_rows=400, img_cols=400, vgg_weights=\\\"imagenet\\\", inference_only=False, net_name='default', gpus=1, vgg_device=None):\\n \\n # Settings\\n self.img_rows = img_rows\\n self.img_cols = img_cols\\n self.img_overlap = 30\\n self.inference_only = inference_only\\n self.net_name = net_name\\n self.gpus = gpus\\n self.vgg_device = vgg_device\\n\\n # Scaling for VGG input\\n self.mean = [0.485, 0.456, 0.406]\\n self.std = [0.229, 0.224, 0.225]\\n \\n #get PowerSpect_CMB\\n reader = np.zeros((2507,))\\n fp = open('./data/COM_PowerSpect_CMB-base-plikHM-TTTEEE-lowl-lowE-lensing-minimum-theory_R3.01.txt')\\n \\n for i,line in enumerate(fp):\\n if i >= 1:\\n reader[i-1] = line.split()[1]\\n \\n fp.close() \\n readers = np.log(reader)\\n self.cl = K.constant(readers)\\n # Assertions\\n assert self.img_rows >= 256, 'Height must be >256 pixels'\\n assert self.img_cols >= 256, 'Width must be >256 pixels'\\n\\n # Set current epoch\\n self.current_epoch = 0\\n \\n # VGG layers to extract features from (first maxpooling layers, see pp. 7 of paper)\\n self.vgg_layers = [3, 6, 10]\\n\\n # Instantiate the vgg network\\n if self.vgg_device:\\n with tf.device(self.vgg_device):\\n self.vgg = self.build_vgg(vgg_weights)\\n else:\\n self.vgg = self.build_vgg(vgg_weights)\\n \\n # Create UNet-like model\\n if self.gpus <= 1:\\n self.model, inputs_mask= self.build_pconv_unet()\\n self.compile_pconv_unet(self.model, inputs_mask) \\n else:\\n with tf.device(\\\"/cpu:0\\\"):\\n self.model, inputs_mask = self.build_pconv_unet()\\n self.model = multi_gpu_model(self.model, gpus=self.gpus)\\n self.compile_pconv_unet(self.model, inputs_mask)\",\n \"def build_vgg(self):\\n # Get the vgg network. Extract features from Block 5, last convolution.\\n vgg = tf.keras.applications.VGG19(weights=\\\"imagenet\\\", input_shape=self.hr_shape, include_top=False)\\n vgg.trainable = False\\n for layer in vgg.layers:\\n layer.trainable = False\\n\\n # Create model and compile\\n model = tf.keras.models.Model(inputs=vgg.input, outputs=vgg.get_layer(\\\"block5_conv4\\\").output)\\n\\n return model\",\n \"def __init__(self, dropout_rate, num_classes, include_top, layer):\\r\\n super(VGG16_Shuffle, self).__init__()\\r\\n print(\\\"CIFAR VGG16_Shuffle is used\\\")\\r\\n self.dropout_rate = dropout_rate\\r\\n self.num_classes = num_classes\\r\\n self.include_top = include_top\\r\\n self.layer = layer\\r\\n\\r\\n # Define the building blocks\\r\\n if layer == 11:\\r\\n self.conv11 = CONV_3x3shuffle(3, 64, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv11 = CONV_3x3(3, 64, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 12:\\r\\n self.conv12 = nn.Sequential(CONV_3x3shuffle(64, 64, kernelsize=3, stride=1, padding=1),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv12 = nn.Sequential(CONV_3x3(64, 64, kernelsize=3, stride=1, padding=1, bias=False),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n # self.conv12 = CONV_3x3(64, 64, kernelsize=3, stride=2, padding=1, bias=False)\\r\\n\\r\\n if layer == 21:\\r\\n self.conv21 = CONV_3x3shuffle(64, 128, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv21 = CONV_3x3(64, 128, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 22:\\r\\n self.conv22 = nn.Sequential(CONV_3x3shuffle(128, 128, kernelsize=3, stride=1, padding=1),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv22 = nn.Sequential(CONV_3x3(128, 128, kernelsize=3, stride=1, padding=1, bias=False),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n # self.conv22 = CONV_3x3(128, 128, kernelsize=3, stride=2, padding=1, bias=False)\\r\\n\\r\\n if layer == 31:\\r\\n self.conv31 = CONV_3x3shuffle(128, 256, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv31 = CONV_3x3(128, 256, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 32:\\r\\n self.conv32 = CONV_3x3shuffle(256, 256, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv32 = CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 33:\\r\\n self.conv33 = nn.Sequential(CONV_3x3shuffle(256, 256, kernelsize=3, stride=1, padding=1),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv33 = nn.Sequential(CONV_3x3(256, 256, kernelsize=3, stride=1, padding=1, bias=False),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n # self.conv33 = CONV_3x3(256, 256, kernelsize=3, stride=2, padding=1, bias=False)\\r\\n\\r\\n if layer == 41:\\r\\n self.conv41 = CONV_3x3shuffle(256, 512, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv41 = CONV_3x3(256, 512, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 42:\\r\\n self.conv42 = CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv42 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 43:\\r\\n self.conv43 = nn.Sequential(CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv43 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n # self.conv43 = CONV_3x3(512, 512, kernelsize=3, stride=2, padding=1, bias=False)\\r\\n\\r\\n if layer == 51:\\r\\n self.conv51 = CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv51 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 52:\\r\\n self.conv52 = CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1)\\r\\n else:\\r\\n self.conv52 = CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False)\\r\\n\\r\\n if layer == 53:\\r\\n self.conv53 = nn.Sequential(CONV_3x3shuffle(512, 512, kernelsize=3, stride=1, padding=1),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n else:\\r\\n self.conv53 = nn.Sequential(CONV_3x3(512, 512, kernelsize=3, stride=1, padding=1, bias=False),\\r\\n nn.MaxPool2d(kernel_size=2, stride=2))\\r\\n\\r\\n self.avgpool = nn.AdaptiveAvgPool2d(1)\\r\\n self.fc = nn.Sequential(nn.Linear(512, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, 4096),\\r\\n nn.ReLU(True),\\r\\n nn.Linear(4096, num_classes))\\r\\n\\r\\n # Initialize the weights\\r\\n for m in self.modules():\\r\\n if isinstance(m, nn.Conv2d):\\r\\n nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')\\r\\n elif isinstance(m, nn.BatchNorm2d):\\r\\n # raise Exception('You are using a model without BN!!!')\\r\\n nn.init.constant_(m.weight, 1)\\r\\n nn.init.constant_(m.bias, 0)\",\n \"def vgg_16(inputs,\\n num_classes=1000,\\n is_training=True,\\n dropout_keep_prob=0.5,\\n spatial_squeeze=True,\\n scope='vgg_16'):\\n with tf.name_scope(scope, 'vgg_16', [inputs]) as sc:\\n end_points_collection = sc + '_end_points'\\n # Collect outputs for conv2d, fully_connected and max_pool2d.\\n with slim.arg_scope([slim.conv2d, slim.fully_connected, slim.max_pool2d],\\n outputs_collections=end_points_collection):\\n net = slim.repeat(inputs, 2, slim.conv2d, 64, [3, 3], scope='conv1')\\n net = slim.max_pool2d(net, [2, 2], scope='pool1')\\n net = slim.repeat(net, 2, slim.conv2d, 128, [3, 3], scope='conv2')\\n net = slim.max_pool2d(net, [2, 2], scope='pool2')\\n net = slim.repeat(net, 3, slim.conv2d, 256, [3, 3], scope='conv3')\\n net = slim.max_pool2d(net, [2, 2], scope='pool3')\\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv4')\\n net = slim.max_pool2d(net, [2, 2], scope='pool4')\\n net = slim.repeat(net, 3, slim.conv2d, 512, [3, 3], scope='conv5')\\n net = slim.max_pool2d(net, [2, 2], scope='pool5')\\n # Use conv2d instead of fully_connected layers.\\n net = slim.conv2d(net, 4096, [3, 3], padding='VALID', scope='fc6')\\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\\n scope='dropout6')\\n net = slim.conv2d(net, 4096, [1, 1], scope='fc7')\\n net = slim.dropout(net, dropout_keep_prob, is_training=is_training,\\n scope='dropout7')\\n net = slim.conv2d(net, num_classes, [1, 1],\\n activation_fn=None,\\n normalizer_fn=None,\\n scope='fc8')\\n # Convert end_points_collection into a end_point dict.\\n end_points = slim.utils.convert_collection_to_dict(end_points_collection)\\n if spatial_squeeze:\\n net = tf.squeeze(net, [1, 2], name='fc8/squeezed')\\n end_points[sc + '/fc8'] = net\\n return net, end_points\",\n \"def instantiate_VGG_model(img_input_shape):\\r\\n # Load the VGG model\\r\\n vgg_conv = VGG16(weights='imagenet', include_top=False, input_shape=img_input_shape)\\r\\n \\r\\n # Freeze the layers except the last 4 layers\\r\\n for layer in vgg_conv.layers[:-4]:\\r\\n layer.trainable = False\\r\\n \\r\\n # Create the model\\r\\n model = models.Sequential()\\r\\n model.add(vgg_conv)\\r\\n \\r\\n # Add new layers\\r\\n model.add(layers.Flatten())\\r\\n model.add(layers.Dense(256, activation='relu'))\\r\\n model.add(layers.Dropout(0.25))\\r\\n model.add(layers.Dense(nb_class, activation='softmax'))\\r\\n \\r\\n model.compile(loss='categorical_crossentropy',\\r\\n optimizer=optimizers.RMSprop(lr=1e-4),\\r\\n metrics=['acc'])\\r\\n return model\",\n \"def build_finetuned_model(args, input_shape, fc_size):\\n # setup model\\n vgg, base_vgg = VGGWithCustomLayers(args.nb_classes, input_shape, fc_size)\\n # setup layers to be trained or not\\n setup_trainable_layers(vgg, args.layers_to_freeze)\\n # compiling the model\\n vgg.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy'])\\n\\n return vg\",\n \"def VGGModel(input_shape):\\n \\n\\n X_input = Input(input_shape)\\n \\n # Creating a Neural Network (VGG-16)\\n\\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(X_input)\\n X = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(X)\\n\\n # Block 2\\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(X)\\n X = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(X)\\n\\n # Block 3\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(X)\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(X)\\n X = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(X)\\n\\n # Block 4\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(X)\\n\\n # Block 5\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(X)\\n X = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(X)\\n X = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(X)\\n \\n X = Flatten()(X)\\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc')(X)\\n X = Dense(4096, activation='relu', kernel_initializer = 'he_normal', name='fc2')(X)\\n X = Dense(2048, activation='relu', kernel_initializer = 'he_normal', name='fc3')(X)\\n X = Dense(1024, activation='relu', kernel_initializer = 'he_normal', name='fc4')(X)\\n X = Dense(512, activation='relu', kernel_initializer = 'he_normal', name='fc5')(X)\\n X = Dense(256, activation='relu', kernel_initializer = 'he_normal', name='fc6')(X)\\n X = Dense(2, activation='linear', name='regression')(X)\\n model = Model(inputs=X_input, outputs = X, name='HappyModel')\\n print(model.summary())\\n \\n return model\",\n \"def create_cnn(num_half_rows, num_half_columns, num_channels):\\n\\n error_checking.assert_is_integer(num_half_rows)\\n error_checking.assert_is_integer(num_half_columns)\\n error_checking.assert_is_integer(num_channels)\\n\\n error_checking.assert_is_greater(num_half_rows, 0)\\n error_checking.assert_is_greater(num_half_columns, 0)\\n error_checking.assert_is_greater(num_channels, 0)\\n\\n regularizer_object = keras.regularizers.l1_l2(l1=L1_WEIGHT, l2=L2_WEIGHT)\\n\\n num_grid_rows = 2 * num_half_rows + 1\\n num_grid_columns = 2 * num_half_columns + 1\\n input_layer_object = keras.layers.Input(\\n shape=(num_grid_rows, num_grid_columns, num_channels)\\n )\\n\\n current_num_filters = None\\n current_layer_object = None\\n\\n # Add convolutional layers.\\n for _ in range(NUM_CONV_LAYER_SETS):\\n for _ in range(NUM_CONV_LAYERS_PER_SET):\\n\\n if current_num_filters is None:\\n current_num_filters = (\\n num_channels * NUM_CHANNELS_TO_FIRST_NUM_FILTERS)\\n this_input_layer_object = input_layer_object\\n\\n else:\\n current_num_filters *= 2\\n this_input_layer_object = current_layer_object\\n\\n current_layer_object = keras.layers.Conv2D(\\n filters=current_num_filters,\\n kernel_size=(NUM_CONV_FILTER_ROWS, NUM_CONV_FILTER_COLUMNS),\\n strides=(1, 1), padding='valid', data_format='channels_last',\\n dilation_rate=(1, 1), activation=None, use_bias=True,\\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\\n kernel_regularizer=regularizer_object\\n )(this_input_layer_object)\\n\\n current_layer_object = keras.layers.LeakyReLU(\\n alpha=SLOPE_FOR_RELU\\n )(current_layer_object)\\n\\n if CONV_LAYER_DROPOUT_FRACTION is not None:\\n current_layer_object = keras.layers.Dropout(\\n rate=CONV_LAYER_DROPOUT_FRACTION\\n )(current_layer_object)\\n\\n if USE_BATCH_NORMALIZATION:\\n current_layer_object = keras.layers.BatchNormalization(\\n axis=-1, center=True, scale=True\\n )(current_layer_object)\\n\\n current_layer_object = keras.layers.MaxPooling2D(\\n pool_size=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\\n strides=(NUM_POOLING_ROWS, NUM_POOLING_COLUMNS),\\n padding='valid', data_format='channels_last'\\n )(current_layer_object)\\n\\n these_dimensions = numpy.array(\\n current_layer_object.get_shape().as_list()[1:], dtype=int)\\n num_features = numpy.prod(these_dimensions)\\n\\n current_layer_object = keras.layers.Flatten()(current_layer_object)\\n\\n # Add intermediate dense layers.\\n _, num_outputs_by_dense_layer = (\\n architecture_utils.get_dense_layer_dimensions(\\n num_input_units=num_features, num_classes=NUM_CLASSES,\\n num_dense_layers=NUM_DENSE_LAYERS)\\n )\\n\\n for k in range(NUM_DENSE_LAYERS - 1):\\n current_layer_object = keras.layers.Dense(\\n num_outputs_by_dense_layer[k], activation=None, use_bias=True,\\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\\n kernel_regularizer=regularizer_object\\n )(current_layer_object)\\n\\n current_layer_object = keras.layers.LeakyReLU(\\n alpha=SLOPE_FOR_RELU\\n )(current_layer_object)\\n\\n if DENSE_LAYER_DROPOUT_FRACTION is not None:\\n current_layer_object = keras.layers.Dropout(\\n rate=DENSE_LAYER_DROPOUT_FRACTION\\n )(current_layer_object)\\n\\n if USE_BATCH_NORMALIZATION:\\n current_layer_object = keras.layers.BatchNormalization(\\n axis=-1, center=True, scale=True\\n )(current_layer_object)\\n\\n # Add output layer (also dense).\\n current_layer_object = keras.layers.Dense(\\n NUM_CLASSES, activation=None, use_bias=True,\\n kernel_initializer='glorot_uniform', bias_initializer='zeros',\\n kernel_regularizer=regularizer_object\\n )(current_layer_object)\\n\\n current_layer_object = keras.layers.Activation(\\n 'softmax'\\n )(current_layer_object)\\n\\n if DENSE_LAYER_DROPOUT_FRACTION is not None and NUM_DENSE_LAYERS == 1:\\n current_layer_object = keras.layers.Dropout(\\n rate=DENSE_LAYER_DROPOUT_FRACTION\\n )(current_layer_object)\\n\\n # Put the whole thing together and compile.\\n cnn_model_object = keras.models.Model(\\n inputs=input_layer_object, outputs=current_layer_object)\\n cnn_model_object.compile(\\n loss=keras.losses.categorical_crossentropy,\\n optimizer=keras.optimizers.Adam(),\\n metrics=LIST_OF_METRIC_FUNCTIONS)\\n\\n cnn_model_object.summary()\\n return cnn_model_object\",\n \"def __init__(self):\\n torch.nn.Module.__init__(self)\\n ######################### Convolution and pooling layers of VGG-16.\\n self.features = torchvision.models.vgg16(pretrained=True).features # fine tune?\\n self.features = torch.nn.Sequential(*list(self.features.children())\\n [:-22]) # Remove pool2 and rest, lack of computational resource\\n # No grad for convVGG\\n # for param in self.features.parameters():\\n # param.requires_grad = False\\n\\n #################### Channel Grouping Net\\n # self.fc1_ = torch.nn.Linear(128, 128*16)#lack of resource\\n # self.fc2_ = torch.nn.Linear(128, 128*16)\\n # self.fc3_ = torch.nn.Linear(128, 128*16)\\n #\\n # torch.nn.init.kaiming_normal_(self.fc1_.weight.data, nonlinearity='relu')\\n # if self.fc1_.bias is not None:\\n # torch.nn.init.constant_(self.fc1_.bias.data, val=0) # fc层的bias进行constant初始化\\n # torch.nn.init.kaiming_normal_(self.fc2_.weight.data, nonlinearity='relu')\\n # if self.fc2_.bias is not None:\\n # torch.nn.init.constant_(self.fc2_.bias.data, val=0) # fc层的bias进行constant初始化\\n # torch.nn.init.kaiming_normal_(self.fc3_.weight.data, nonlinearity='relu')\\n # if self.fc3_.bias is not None:\\n # torch.nn.init.constant_(self.fc3_.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n self.fc1 = torch.nn.Linear(128*28*28, 128)\\n self.fc2 = torch.nn.Linear(128*28*28, 128)\\n self.fc3 = torch.nn.Linear(128*28*28, 128)\\n\\n\\n torch.nn.init.kaiming_normal_(self.fc1.weight.data, nonlinearity='relu')\\n if self.fc1.bias is not None:\\n torch.nn.init.constant_(self.fc1.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.fc2.weight.data, nonlinearity='relu')\\n if self.fc2.bias is not None:\\n torch.nn.init.constant_(self.fc2.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.fc3.weight.data, nonlinearity='relu')\\n if self.fc3.bias is not None:\\n torch.nn.init.constant_(self.fc3.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n self.layerNorm=nn.LayerNorm([224,224])\\n\\n # global grad for hook\\n self.image_reconstruction = None\\n self.register_hooks()\\n self.GradWeight=1e-1\\n\\n # ################### STN input N*3*448*448\\n # self.localization = [\\n # nn.Sequential(\\n # nn.MaxPool2d(4,stride=4),#112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5,stride=1,padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3,stride=1,padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) #output 64*14*14\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.MaxPool2d(4, stride=4), # 112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) # output 64*14*14\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.MaxPool2d(4, stride=4), # 112\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(3, 32, kernel_size=5, stride=1, padding=2), # 112\\n # nn.MaxPool2d(2, stride=2), # 56\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(32, 48, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 56/2=28\\n # nn.ReLU(True),\\n #\\n # nn.Conv2d(48, 64, kernel_size=3, stride=1, padding=1),\\n # nn.MaxPool2d(2, stride=2), # 28/2=14\\n # nn.ReLU(True) # output 64*14*14\\n # ).cuda()\\n # ]\\n # # Regressor for the 3 * 2 affine matrix\\n # self.fc_loc = [\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda(),\\n # nn.Sequential(\\n # nn.Linear(64 * 14 * 14, 32),\\n # nn.ReLU(True),\\n # nn.Linear(32, 3 * 2)\\n # ).cuda()\\n # ]\\n # # Initialize the weights/bias with identity transformation\\n # for fc_locx in self.fc_loc:\\n # fc_locx[2].weight.data.zero_()\\n # fc_locx[2].bias.data.copy_(torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float))\\n\\n ########################Bilinear CNN output 256 channels\\n self.bcnnConv_1=torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n self.bcnnConv_2 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n self.bcnnConv_3 = torch.nn.Sequential(*list(torchvision.models.vgg16(pretrained=True).features.children())\\n [:-1]) # Remove pool3 and rest.\\n #BCNN Linear classifier.\\n self.bfc1 = torch.nn.Linear(512*512, 200)\\n self.bfc2 = torch.nn.Linear(512*512, 200)\\n self.bfc3 = torch.nn.Linear(512*512, 200)\\n torch.nn.init.kaiming_normal_(self.bfc1.weight.data) # 何凯明初始化\\n if self.bfc1.bias is not None:\\n torch.nn.init.constant_(self.bfc1.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.bfc2.weight.data) # 何凯明初始化\\n if self.bfc2.bias is not None:\\n torch.nn.init.constant_(self.bfc2.bias.data, val=0) # fc层的bias进行constant初始化\\n torch.nn.init.kaiming_normal_(self.bfc3.weight.data) # 何凯明初始化\\n if self.bfc3.bias is not None:\\n torch.nn.init.constant_(self.bfc3.bias.data, val=0) # fc层的bias进行constant初始化\\n\\n # self.CBP1 = CompactBilinearPooling(512, 512, 50000)\\n # self.CBP2 = CompactBilinearPooling(512, 512, 50000)\\n # self.CBP3 = CompactBilinearPooling(512, 512, 50000)\",\n \"def create_vggvox(embedding_dims, name=\\\"vggvox\\\"):\\n model = tf.keras.Sequential(name=name)\\n model.add(tf.keras.layers.Conv2D(96, (7,7), strides=(2,2), padding=\\\"valid\\\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\\\"{name}_conv1\\\"))\\n model.add(tf.keras.layers.BatchNormalization())\\n model.add(tf.keras.layers.ReLU())\\n model.add(tf.keras.layers.MaxPooling2D((3,3), strides=(2,2), name=\\\"mpool1\\\"))\\n model.add(tf.keras.layers.Conv2D(256, (5,5), strides=(2,2), padding=\\\"valid\\\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\\\"{name}_conv2\\\"))\\n model.add(tf.keras.layers.BatchNormalization())\\n model.add(tf.keras.layers.ReLU())\\n model.add(tf.keras.layers.MaxPooling2D((3,3), strides=(2,2), name=\\\"mpool2\\\"))\\n model.add(tf.keras.layers.Conv2D(384, (3,3), strides=(1,1), padding=\\\"same\\\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\\\"{name}_conv3\\\"))\\n model.add(tf.keras.layers.BatchNormalization())\\n model.add(tf.keras.layers.ReLU())\\n model.add(tf.keras.layers.Conv2D(256, (3,3), strides=(1,1), padding=\\\"same\\\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\\\"{name}_conv4\\\"))\\n model.add(tf.keras.layers.BatchNormalization())\\n model.add(tf.keras.layers.ReLU())\\n model.add(tf.keras.layers.Conv2D(256, (3,3), strides=(1,1), padding=\\\"same\\\", kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\\\"{name}_conv5\\\"))\\n model.add(tf.keras.layers.BatchNormalization())\\n model.add(tf.keras.layers.ReLU())\\n model.add(tf.keras.layers.MaxPooling2D((5,3), strides=(3,2), name=f\\\"{name}_mpool5\\\"))\\n model.add(tf.keras.layers.Conv2D(4096, (9,1), strides=1, kernel_regularizer=tf.keras.regularizers.L2(5e-4), padding=\\\"valid\\\", name=f\\\"{name}_fc6\\\"))\\n model.add(tf.keras.layers.BatchNormalization())\\n model.add(tf.keras.layers.ReLU())\\n model.add(tf.keras.layers.Lambda(lambda x: tf.math.reduce_mean(x, axis=[1,2], name=f\\\"{name}_apool6\\\")))\\n model.add(tf.keras.layers.Flatten())\\n model.add(tf.keras.layers.Dense(embedding_dims, kernel_regularizer=tf.keras.regularizers.L2(5e-4), name=f\\\"{name}_embeddings\\\"))\\n model.add(tf.keras.layers.BatchNormalization())\\n model.add(tf.keras.layers.ReLU())\\n return model\",\n \"def _build_model(self):\\n fc0_std = 0.2 # std of random initialization for fc0 matrix\\n fc0_shape = [4, 4, 1024] # shape of the fc0 reshaped output (for batch size = 1)\\n fc0_size = fc0_shape[0] * fc0_shape[1] * fc0_shape[2] # size of the fc0 output\\n\\n # if input is not a variable connecting the discriminator to another network (ex, generator output),\\n # initialize a placeholder\\n if self._input_data is None:\\n # placeholder for input data\\n self._input_data = tf.placeholder(tf.float32, [None, self.input_size], name=self.nid + \\\"_input\\\")\\n\\n # project and reshape the input array - basically an fc layer doing matrix multiplication and bias addition\\n with tf.variable_scope(self.nid+\\\"_fc0\\\"):\\n W = tf.get_variable(\\\"W\\\", shape=[self.input_size, fc0_size], dtype=tf.float32,\\n initializer=tf.random_normal_initializer(stddev=fc0_std))\\n b = tf.get_variable(\\\"b\\\", shape=[fc0_size], dtype=tf.float32,\\n initializer=tf.random_normal_initializer(stddev=fc0_std))\\n fc0_output = tf.reshape(tf.nn.bias_add(tf.matmul(self._input_data, W), b), [-1] + fc0_shape)\\n\\n fsconv_input = fc0_output # initial fsconv input is the output of the fc layer\\n\\n # filter's first 2 dimensions, the rest two are auto computed\\n filter_shape = [5, 5]\\n # generate output shapes for each fsconv layer\\n output_shapes = [[int(2 ** x), int(2 ** x), int(fc0_shape[2] * 4 / (2 ** x))]\\n for x in range(3, 10) if int(2**x) <= np.min(self.output_size[:2])]\\n # set the last output shape to be 3-channeled (or as required by the model)\\n output_shapes[-1][2] = self.output_size[2]\\n\\n fsconv_shapes = [fc0_output.get_shape().as_list()]\\n\\n batch_size = tf.shape(fsconv_input)[0] # workaround since conv2d_transpose explicitly needs batch size\\n\\n # create the intermediate fsconv layers\\n for output_shape in output_shapes:\\n with tf.variable_scope(self.nid+\\\"_fsconv-{}x{}\\\".format(output_shape[0], output_shape[1])):\\n W_shape = filter_shape+[output_shape[2]]+[fsconv_input.get_shape().as_list()[-1]]\\n W = tf.get_variable(\\\"W\\\", initializer=tf.truncated_normal(W_shape, stddev=0.1))\\n b = tf.get_variable(\\\"b\\\", shape=output_shape[-1:], initializer=tf.constant_initializer(0.0))\\n # fractionally-strided convolution network\\n # conv2d_transpose does not accept variable batch sizes and batch size needs to be explicitly specified\\n # a workaround is to compute it during run-time and pass it with the output_shape\\n # https://github.com/tensorflow/tensorflow/issues/833\\n fsconv = tf.nn.conv2d_transpose(fsconv_input, W,\\n output_shape=[batch_size]+output_shape, strides=[1, 2, 2, 1])\\n fsconv = tf.nn.bias_add(fsconv, b)\\n fsconv = tf.nn.relu(fsconv) # apply relu layer\\n # store the shape for verbose\\n fsconv_shapes.append(fsconv.get_shape().as_list())\\n fsconv_input = fsconv\\n\\n if self._verbose:\\n print(\\\"FSConv layer output shapes - {}\\\".format(fsconv_shapes))\\n\\n self._model = fsconv\",\n \"def __init__(self, nfeat, nhid, nclass, dropout, alpha):\\n super(GCN, self).__init__()\\n self.dropout = dropout\\n\\n self.conv1 = GraphConvolutionLayer(nfeat, nhid, dropout=dropout, alpha=alpha, not_final=True)\\n \\n self.add_module('conv1', self.conv1)\\n\\n self.conv2 = GraphConvolutionLayer(nhid, nclass, dropout=dropout, alpha=alpha, not_final=False)\",\n \"def vgg_bsd(args, x, train_phase):\\n # Sure layers weight & bias\\n nf = int(args.n_filters)\\n nf2 = int((args.filter_gain)*nf)\\n nf3 = int((args.filter_gain**2)*nf)\\n nf4 = int((args.filter_gain**3)*nf)\\n bs = args.batch_size\\n fs = args.filter_size\\n nch = args.n_channels\\n tp = train_phase\\n\\n fm = {}\\n # Convolutional Layers\\n with tf.name_scope('stage1') as scope:\\n cv1 = linear(x, nf, fs, name='1_1')\\n cv1 = tf.nn.relu(cv1, name='1_1')\\n\\n cv2 = linear(cv1, nf, fs, name='1_2')\\n cv2 = Zbn(cv2, tp, name='bn1')\\n cv2 = tf.nn.relu(cv2)\\n fm[1] = linear(cv2, 1, 1, name='fm1')\\n\\n with tf.name_scope('stage2') as scope:\\n cv3 = tf.nn.max_pool(cv2, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\\n cv3 = linear(cv3, nf2, fs, name='2_1')\\n cv3 = tf.nn.relu(cv3, name='2_1')\\n\\n cv4 = linear(cv3, nf2, fs, name='2_2')\\n cv4 = Zbn(cv4, train_phase, name='bn2')\\n cv4 = tf.nn.relu(cv4)\\n fm[2] = linear(cv4, 1, 1, name='fm2')\\n\\n with tf.name_scope('stage3') as scope:\\n cv5 = tf.nn.max_pool(cv4, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\\n cv5 = linear(cv5, nf3, fs, name='3_1')\\n cv5 = tf.nn.relu(cv5, name='3_1')\\n\\n cv6 = linear(cv5, nf3, fs, name='3_2')\\n cv6 = Zbn(cv6, train_phase, name='bn3')\\n cv6 = tf.nn.relu(cv6)\\n fm[3] = linear(cv6, 1, 1, name='fm3')\\n\\n with tf.name_scope('stage4') as scope:\\n cv7 = tf.nn.max_pool(cv6, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\\n cv7 = linear(cv7, nf4, fs, name='4_1')\\n cv7 = tf.nn.relu(cv7, name='4_1')\\n\\n cv8 = linear(cv7, nf4, fs, name='4_2')\\n cv8 = Zbn(cv8, train_phase, name='bn4')\\n cv8 = tf.nn.relu(cv8)\\n fm[4] = linear(cv8, 1, 1, name='fm4')\\n\\n with tf.name_scope('stage5') as scope:\\n cv9 = tf.nn.max_pool(cv8, ksize=(1,3,3,1), strides=(1,2,2,1), padding='SAME')\\n cv9 = linear(cv9, nf4, fs, name='5_1')\\n cv9 = tf.nn.relu(cv9, name='5_1')\\n\\n cv10 = linear(cv9, nf4, fs, name='5_2')\\n cv10 = Zbn(cv10, train_phase, name='bn5')\\n cv10 = tf.nn.relu(cv10)\\n fm[5] = linear(cv10, 1, 1, name='fm5')\\n\\n fms = {}\\n side_preds = []\\n xsh = tf.shape(x)\\n with tf.name_scope('fusion') as scope:\\n for key in fm.keys():\\n fms[key] = tf.image.resize_images(fm[key], tf.stack([xsh[1], xsh[2]]))\\n side_preds.append(fms[key])\\n side_preds = tf.concat(axis=3, values=side_preds)\\n\\n fms['fuse'] = linear(side_preds, 1, 1, bias_init=0.01, name='fuse')\\n return fms\",\n \"def Vgg19_simple_api(input, reuse, nchannels, rgb=False):\\n VGG_MEAN = [103.939, 116.779, 123.68]\\n with tf.variable_scope(\\\"VGG19\\\", reuse=reuse) as vs:\\n start_time = time.time()\\n print(\\\"build model started\\\")\\n\\n if rgb == True:\\n rgb_scaled = input * 255.0\\n # Convert RGB to BGR\\n if tf.__version__ <= '0.11':\\n red, green, blue = tf.split(3, 3, rgb_scaled)\\n else: # TF 1.0\\n # print(rgb_scaled)\\n red, green, blue = tf.split(rgb_scaled, 3, 3)\\n assert red.get_shape().as_list()[1:] == [224, 224, 1]\\n assert green.get_shape().as_list()[1:] == [224, 224, 1]\\n assert blue.get_shape().as_list()[1:] == [224, 224, 1]\\n if tf.__version__ <= '0.11':\\n bgr = tf.concat(3, [\\n blue - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n red - VGG_MEAN[2],\\n ])\\n else:\\n bgr = tf.concat(\\n [\\n blue - VGG_MEAN[0],\\n green - VGG_MEAN[1],\\n red - VGG_MEAN[2],\\n ], axis=3)\\n assert bgr.get_shape().as_list()[1:] == [224, 224, 3]\\n\\n \\\"\\\"\\\" input layer \\\"\\\"\\\"\\n net_in = InputLayer(bgr, name='input')\\n\\n else:\\n assert input.get_shape().as_list()[1:] == [224, 224, nchannels]\\n net_in = InputLayer(input, name = 'input')\\n\\n\\n \\\"\\\"\\\" conv1 \\\"\\\"\\\"\\n network = Conv2d(net_in, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv1_1')\\n network = Conv2d(network, n_filter=64, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv1_2')\\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool1')\\n \\\"\\\"\\\" conv2 \\\"\\\"\\\"\\n network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv2_1')\\n network = Conv2d(network, n_filter=128, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv2_2')\\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool2')\\n \\\"\\\"\\\" conv3 \\\"\\\"\\\"\\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_1')\\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_2')\\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_3')\\n network = Conv2d(network, n_filter=256, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv3_4')\\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool3')\\n \\\"\\\"\\\" conv4 \\\"\\\"\\\"\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_1')\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_2')\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_3')\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv4_4')\\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool4') # (batch_size, 14, 14, 512)\\n conv = network\\n \\\"\\\"\\\" conv5 \\\"\\\"\\\"\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_1')\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_2')\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_3')\\n network = Conv2d(network, n_filter=512, filter_size=(3, 3), strides=(1, 1), act=tf.nn.relu, padding='SAME', name='conv5_4')\\n network = MaxPool2d(network, filter_size=(2, 2), strides=(2, 2), padding='SAME', name='pool5') # (batch_size, 7, 7, 512)\\n \\\"\\\"\\\" fc 6~8 \\\"\\\"\\\"\\n network = FlattenLayer(network, name='flatten')\\n network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc6')\\n network = DenseLayer(network, n_units=4096, act=tf.nn.relu, name='fc7')\\n network = DenseLayer(network, n_units=1000, act=tf.identity, name='fc8')\\n print(\\\"build model finished: %fs\\\" % (time.time() - start_time))\\n return network, conv\",\n \"def __init__(self, input_dim=(3, 32, 32), hidden_dims_CNN = ((32, 5, 1, 1), (2, 2, 2)),\\n hidden_dims_FC = ((1024), (0.5)), num_classes=10, weight_scale=1e-3, \\n reg=0.0, dtype=np.float32):\\n self.params = {}\\n self.fix_params = {}\\n self.reg = reg\\n self.dtype = dtype\\n \\n C_input, H_input, W_input = input_dim\\n pre_C = C_input \\n pre_H = H_input\\n pre_W = W_input\\n \\n num_CNN = len(hidden_dims_CNN)\\n num_FC = len(hidden_dims_FC)\\n\\n for i in range(0, num_CNN):\\n W_name = \\\"W\\\" + str(i)\\n b_name = \\\"b\\\" + str(i)\\n conv_param_name = \\\"conv_param\\\" + str(i)\\n gamma_name = \\\"gamma\\\" + str(i)\\n beta_name = \\\"beta\\\" + str(i)\\n bn_param_name = \\\"bn_param\\\" + str(i)\\n pool_param_name = \\\"pool_param\\\" + str(i)\\n\\n if num_CNN == 1:\\n num_filters, filter_size, stride, pad = hidden_dims_CNN[0] # (F, filter_size, stride, pad)\\n pool_stride, pool_height, pool_width = hidden_dims_CNN[1] # (pooling_stride, pooling_size)\\n else:\\n num_filters, filter_size, stride, pad = hidden_dims_CNN[i][0] # (F, filter_size, stride, pad)\\n pool_stride, pool_height, pool_width = hidden_dims_CNN[i][1] # (pooling_stride, pooling_size)\\n \\n if weight_scale == -1:\\n self.params[W_name] = np.random.randn(num_filters, pre_C, filter_size, filter_size) / np.sqrt(filter_size * filter_size * pre_C)\\n else: \\n self.params[W_name] = np.random.randn(num_filters, pre_C, filter_size, filter_size) * weight_scale\\n self.params[b_name] = np.zeros(num_filters)\\n self.fix_params[conv_param_name] = {'stride': stride, 'pad': pad}\\n \\n self.params[gamma_name] = np.random.randn(num_filters)\\n self.params[beta_name] = np.random.randn(num_filters)\\n self.fix_params[bn_param_name] = {'mode': 'train'}\\n\\n self.fix_params[pool_param_name] = {'pool_height': pool_height, 'pool_width': pool_width, 'stride': pool_stride}\\n \\n pre_H, pre_W = cnn_out_shape(pre_H, pre_W, filter_size, filter_size, stride, pad)\\n pre_C = num_filters \\n pre_H, pre_W = pool_out_shape(pre_H, pre_W, pool_height, pool_width, pool_stride)\\n\\n pre_fc_dim = pre_H * pre_W * pre_C\\n\\n for i in range(0, num_FC):\\n W_name = \\\"W\\\" + str(i + num_CNN)\\n b_name = \\\"b\\\" + str(i + num_CNN)\\n gamma_name = \\\"gamma\\\" + str(i + num_CNN)\\n beta_name = \\\"beta\\\" + str(i + num_CNN)\\n bn_param_name = \\\"bn_param\\\" + str(i + num_CNN)\\n drop_name = \\\"drop_ratio\\\" + str(i + num_CNN)\\n \\n if num_FC == 1 :\\n fc_num = hidden_dims_FC[0]\\n drop_ratio = hidden_dims_FC[1]\\n else:\\n fc_num = hidden_dims_FC[i][0]\\n drop_ratio = hidden_dims_FC[i][1]\\n\\n if weight_scale == -1:\\n self.params[W_name] = np.random.randn(pre_fc_dim, fc_num) / np.sqrt(pre_fc_dim)\\n else:\\n self.params[W_name] = np.random.randn(pre_fc_dim, fc_num) * weight_scale\\n self.params[b_name] = np.zeros(fc_num)\\n\\n self.params[gamma_name] = np.random.randn(fc_num)\\n self.params[beta_name] = np.random.randn(fc_num)\\n self.fix_params[bn_param_name] = {'mode': 'train'}\\n\\n self.fix_params[drop_name] = {'mode': 'train', 'p': drop_ratio}\\n\\n pre_fc_dim = fc_num\\n\\n total_layer = num_CNN + num_FC\\n W_name = \\\"W\\\" + str(total_layer)\\n b_name = \\\"b\\\" + str(total_layer)\\n if weight_scale == -1:\\n self.params[W_name] = np.random.randn(pre_fc_dim, num_classes) / np.sqrt(pre_fc_dim)\\n else:\\n self.params[W_name] = np.random.randn(pre_fc_dim, num_classes) * weight_scale\\n self.params[b_name] = np.zeros(num_classes)\\n\\n\\n self.num_CNN = num_CNN\\n self.num_FC = num_FC\\n self.total_layer = num_CNN + num_FC\\n\\n for k, v in self.params.iteritems():\\n self.params[k] = v.astype(dtype)\",\n \"def vgg16_general(features, labels, mode):\\n\\n input_layer = tf.reshape(features, [-1, SIZE, SIZE, 3])\\n\\n # 1st stack of convolutional layers\\n conv3_64_0 = tf.layers.conv2d(\\n inputs=input_layer,\\n filters=64,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv3_64_1 = tf.layers.conv2d(\\n inputs=conv3_64_0,\\n filters=64,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n maxpool_0 = tf.layers.max_pooling2d(\\n inputs=conv3_64_1,\\n pool_size=[2, 2],\\n strides=2)\\n\\n # 2nd stack of convolutional layers\\n conv3_128_0 = tf.layers.conv2d(\\n inputs=maxpool_0,\\n filters=128,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv3_128_1 = tf.layers.conv2d(\\n inputs=conv3_128_0,\\n filters=128,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n maxpool_1 = tf.layers.max_pooling2d(\\n inputs=conv3_128_1,\\n pool_size=[2, 2],\\n strides=2)\\n\\n # 3rd stack of convolutional layers\\n conv3_256_0 = tf.layers.conv2d(\\n inputs=maxpool_1,\\n filters=256,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv3_256_1 = tf.layers.conv2d(\\n inputs=conv3_256_0,\\n filters=256,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv1_256_0 = tf.layers.conv2d(\\n inputs=conv3_256_1,\\n filters=256,\\n kernel_size=[1, 1],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n maxpool_2 = tf.layers.max_pooling2d(\\n inputs=conv1_256_0,\\n pool_size=[2, 2],\\n strides=2)\\n\\n # 4th stack of convolutional layers\\n conv3_512_0 = tf.layers.conv2d(\\n inputs=maxpool_2,\\n filters=512,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv3_512_1 = tf.layers.conv2d(\\n inputs=conv3_512_0,\\n filters=512,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv1_512_0 = tf.layers.conv2d(\\n inputs=conv3_512_1,\\n filters=512,\\n kernel_size=[1, 1],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n maxpool_3 = tf.layers.max_pooling2d(\\n inputs=conv1_512_0,\\n pool_size=[2, 2],\\n strides=2)\\n\\n # 5th stack of convolutional layers\\n conv3_512_2 = tf.layers.conv2d(\\n inputs=maxpool_3,\\n filters=512,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv3_512_3 = tf.layers.conv2d(\\n inputs=conv3_512_2,\\n filters=512,\\n kernel_size=[3, 3],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv1_512_1 = tf.layers.conv2d(\\n inputs=conv3_512_3,\\n filters=512,\\n kernel_size=[1, 1],\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n maxpool_4 = tf.layers.max_pooling2d(\\n inputs=conv1_512_1,\\n pool_size=[2, 2],\\n strides=2)\\n\\n # Flatten tensor for dense layers\\n _, new_size, _, new_channels = maxpool_4.shape\\n maxpool_4_flat = tf.reshape(maxpool_4, [-1, new_size * new_size * new_channels])\\n\\n # Dense layers\\n fc_4096_0 = tf.layers.dense(\\n inputs=maxpool_4_flat,\\n units=4096,\\n activation=tf.nn.relu)\\n\\n fc_4096_1 = tf.layers.dense(\\n inputs=fc_4096_0,\\n units=4096,\\n activation=tf.nn.relu)\\n\\n return fc_4096_1\",\n \"def build(self, input_shape: tf.Tensor):\\n self.conv = tf.keras.layers.Conv2D(\\n self.channels, (1, 1), input_shape=input_shape)\\n self.bn = tf.keras.layers.BatchNormalization(momentum=self.momentum)\",\n \"def create_vgg_up_block(filters, in_features, activation, kernel_size=3, batch_norm=False):\\n layers = []\\n if isinstance(filters, int):\\n filters = [filters]\\n\\n if not isinstance(filters, list):\\n raise ValueError(\\\"Filters has to be a list\\\")\\n\\n in_feat = in_features\\n\\n layers.append(Conv2d_Up(in_features=in_feat, out_features=filters[0], activation=activation, kernel_size=kernel_size, batch_norm=batch_norm))\\n in_feat = filters[0]\\n\\n for n in range(len(filters))[1:]:\\n out_feat = filters[n]\\n conv = Conv2d_same(in_features=in_feat, out_features=out_feat, activation=activation, kernel_size=kernel_size, batch_norm=batch_norm)\\n layers.append(conv)\\n in_feat = out_feat\\n\\n out_feat = filters[-1]\\n return layers, out_feat\",\n \"def cnn_model_fn(features, labels, mode, num_classes=20):\\n # Write this function\\n # Input Layer\\n input_layer = tf.reshape(features[\\\"x\\\"], [-1, 256, 256, 3])\\n img_num = input_layer.get_shape().as_list()[0]\\n input_image_layer = input_layer\\n\\n '''\\n if img_num is not None:\\n for img_idx in range(img_num):\\n image = input_layer[img_idx,:]\\n image = tf.random_crop(value = image, size = [224, 224, 3])\\n image = tf.image.flip_left_right(image)\\n image = tf.image.resize_image_with_crop_or_pad(image=image,target_height = 224, target_width = 224)\\n input_image_layer.append(image)\\n\\n input_image_layer = tf.convert_to_tensor(input_image_layer, dtype=tf.float32)\\n else:\\n input_image_layer = input_layer\\n print('img_num shape {}: input_layer is {} '.format(img_num, np.shape(input_layer.get_shape().as_list())))\\n print(\\\"img_num is None\\\")\\n '''\\n\\n # Convolutional Layer #1\\n conv1_1 = tf.layers.conv2d(\\n inputs=input_image_layer,\\n filters=64,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n # pad = 1\\n conv1_2 = tf.layers.conv2d(\\n inputs=conv1_1,\\n filters=64,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n pool1 = tf.layers.max_pooling2d(inputs=conv1_2, pool_size=[2, 2], strides=2)\\n\\n\\n conv2_1 = tf.layers.conv2d(\\n inputs=pool1,\\n filters=128,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n\\n conv2_2 = tf.layers.conv2d(\\n inputs= conv2_1,\\n filters=128,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n pool2 = tf.layers.max_pooling2d(inputs=conv2_2, pool_size=[2, 2], strides=2)\\n\\n conv3_1 = tf.layers.conv2d(\\n inputs= pool2,\\n filters=256,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv3_2 = tf.layers.conv2d(\\n inputs= conv3_1,\\n filters=256,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv3_3 = tf.layers.conv2d(\\n inputs= conv3_2,\\n filters=256,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n pool3 = tf.layers.max_pooling2d(inputs=conv3_3, pool_size=[2, 2], strides=2)\\n\\n\\n conv4_1 = tf.layers.conv2d(\\n inputs= pool3,\\n filters=512,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv4_2 = tf.layers.conv2d(\\n inputs= conv4_1,\\n filters=512,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv4_3 = tf.layers.conv2d(\\n inputs= conv4_2,\\n filters=512,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n pool4 = tf.layers.max_pooling2d(inputs=conv4_3, pool_size=[2, 2], strides=2)\\n\\n conv5_1 = tf.layers.conv2d(\\n inputs= pool4,\\n filters=512,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv5_2 = tf.layers.conv2d(\\n inputs= conv5_1,\\n filters=512,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n conv5_3 = tf.layers.conv2d(\\n inputs= conv5_2,\\n filters=512,\\n kernel_size=[3, 3],\\n strides=(1, 1),\\n padding=\\\"same\\\",\\n activation=tf.nn.relu)\\n\\n pool5 = tf.layers.max_pooling2d(inputs=conv5_3, pool_size=[2, 2], strides=2)\\n\\n # Dense Layer\\n pool5_shape = pool5.get_shape()\\n pool5_list = pool5_shape.as_list()\\n pool5_product = np.int32(pool5_list[1]*pool5_list[2]*pool5_list[3])\\n pool5_flat = tf.reshape(pool5, [-1, pool5_product])\\n\\n dense6 = tf.layers.dense(inputs=pool5_flat, units=4096,activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(mean=0.0,stddev=0.01),bias_initializer=tf.zeros_initializer(),)\\n dropout6 = tf.layers.dropout(\\n inputs=dense6, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\\n\\n\\n dense7 = tf.layers.dense(inputs=dropout6, units= 4096, activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(mean=0.0,stddev=0.01),\\n bias_initializer=tf.zeros_initializer(),)\\n dropout7 = tf.layers.dropout(\\n inputs=dense7, rate=0.5, training=mode == tf.estimator.ModeKeys.TRAIN)\\n\\n # Logits Layer\\n logits = tf.layers.dense(inputs=dropout7, units=20)\\n\\n\\n predictions = {\\n # Generate predictions (for PREDICT and EVAL mode)\\n \\\"classes\\\": tf.argmax(input=logits, axis=1),\\n # Add `softmax_tensor` to the graph. It is used for PREDICT and by the\\n # `logging_hook`.\\n \\\"probabilities\\\": tf.nn.sigmoid(logits, name=\\\"sigmoid_tensor\\\")\\n }\\n\\n if mode == tf.estimator.ModeKeys.PREDICT:\\n return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)\\n\\n\\n # Calculate Loss (for both TRAIN and EVAL modes)\\n\\n loss = tf.identity(tf.losses.sigmoid_cross_entropy(multi_class_labels=labels,logits=logits))\\n\\n # Configure the Training Op (for TRAIN mode)\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n grad_input = tf.gradients(loss,input_layer)\\n grad_conv1_1 = tf.gradients(loss, conv1_1)\\n grad_conv2_1 = tf.gradients(loss, conv2_1)\\n grad_conv3_1 = tf.gradients(loss, conv3_1)\\n grad_conv4_1 = tf.gradients(loss, conv4_1)\\n grad_conv5_1 = tf.gradients(loss, conv5_1)\\n grad_dense6 = tf.gradients(loss, dense6)\\n grad_dense7 = tf.gradients(loss, dense7)\\n\\n starter_learning_rate = 0.001\\n global_step = tf.train.get_global_step()\\n learning_rate = tf.train.exponential_decay(learning_rate= starter_learning_rate, global_step = global_step,\\n decay_steps = 100000, decay_rate= 0.5, staircase=True)\\n optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)\\n train_op = optimizer.minimize(\\n loss=loss,\\n global_step=tf.train.get_global_step())\\n #tf.summary()\\n # print(\\\"Training\\\")\\n tf.summary.scalar(name= 'train_loss', tensor = loss )\\n tf.summary.scalar(name= 'learning rate', tensor = learning_rate)\\n tf.summary.histogram(name='grad_dense7', values=grad_input)\\n tf.summary.histogram(name='grad_conv1_1', values= grad_conv1_1)\\n tf.summary.histogram(name='grad_conv2_1', values=grad_conv2_1)\\n tf.summary.histogram(name='grad_conv3_1', values=grad_conv3_1)\\n tf.summary.histogram(name='grad_conv4_1', values=grad_conv4_1)\\n tf.summary.histogram(name='grad_conv5_1', values=grad_conv5_1)\\n tf.summary.histogram(name='grad_dense6', values=grad_dense6)\\n tf.summary.histogram(name='grad_dense7', values=grad_dense7)\\n\\n tf.summary.image(name='image', tensor= input_layer)\\n\\n summary_hook = tf.train.SummarySaverHook(\\n 10,\\n output_dir='./models/03_VGG_Test0301',\\n summary_op=tf.summary.merge_all())\\n\\n return tf.estimator.EstimatorSpec(\\n mode=mode, loss=loss, train_op=train_op, training_hooks = [summary_hook])\\n\\n # Add evaluation metrics (for EVAL mode)\\n eval_metric_ops = {\\n \\\"accuracy\\\": tf.metrics.accuracy(\\n labels=labels, predictions=predictions[\\\"classes\\\"])}\\n return tf.estimator.EstimatorSpec(\\n mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)\",\n \"def init(self):\\n self.reparam_layers = []\\n if self.model_type == \\\"GCN\\\":\\n for i in range(self.num_layers):\\n if self.reparam_all_layers is True:\\n is_reparam = True\\n elif isinstance(self.reparam_all_layers, tuple):\\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\\n is_reparam = i in reparam_all_layers\\n else:\\n raise\\n if is_reparam:\\n self.reparam_layers.append(i)\\n setattr(self, \\\"conv{}\\\".format(i + 1),\\n GCNConv(self.num_features if i == 0 else self.latent_size,\\n self.latent_size if i != self.num_layers - 1 else self.num_classes,\\n cached=True,\\n reparam_mode=self.reparam_mode if is_reparam else None,\\n prior_mode=self.prior_mode if is_reparam else None,\\n sample_size=self.sample_size,\\n bias=True if self.with_relu else False,\\n val_use_mean=self.val_use_mean,\\n normalize=self.normalize,\\n ))\\n # self.conv1 = ChebConv(self.num_features, 16, K=2)\\n # self.conv2 = ChebConv(16, self.num_features, K=2)\\n\\n elif self.model_type == \\\"GAT\\\":\\n latent_size = int(self.latent_size / 2) # Under the default setting, latent_size = 8\\n for i in range(self.num_layers):\\n if i == 0:\\n input_size = self.num_features\\n else:\\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\\n input_size = latent_size * 8 * 2\\n else:\\n input_size = latent_size * 8\\n if self.reparam_all_layers is True:\\n is_reparam = True\\n elif isinstance(self.reparam_all_layers, tuple):\\n reparam_all_layers = tuple([kk + self.num_layers if kk < 0 else kk for kk in self.reparam_all_layers])\\n is_reparam = i in reparam_all_layers\\n else:\\n raise\\n if is_reparam:\\n self.reparam_layers.append(i)\\n setattr(self, \\\"conv{}\\\".format(i + 1), GATConv(\\n input_size,\\n latent_size if i != self.num_layers - 1 else self.num_classes,\\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\\n reparam_mode=self.reparam_mode if is_reparam else None,\\n prior_mode=self.prior_mode if is_reparam else None,\\n val_use_mean=self.val_use_mean,\\n struct_dropout_mode=self.struct_dropout_mode,\\n sample_size=self.sample_size,\\n ))\\n if self.struct_dropout_mode[0] == 'DNsampling' or (self.struct_dropout_mode[0] == 'standard' and len(self.struct_dropout_mode) == 3):\\n setattr(self, \\\"conv{}_1\\\".format(i + 1), GATConv(\\n input_size,\\n latent_size if i != self.num_layers - 1 else self.num_classes,\\n heads=8 if i != self.num_layers - 1 else 1, concat=True,\\n reparam_mode=self.reparam_mode if is_reparam else None,\\n prior_mode=self.prior_mode if is_reparam else None,\\n val_use_mean=self.val_use_mean,\\n struct_dropout_mode=self.struct_dropout_mode,\\n sample_size=self.sample_size,\\n ))\\n # On the Pubmed dataset, use heads=8 in conv2.\\n \\n else:\\n raise Exception(\\\"Model_type {} is not valid!\\\".format(self.model_type))\\n\\n self.reparam_layers = sorted(self.reparam_layers)\\n \\n if self.model_type == \\\"GCN\\\":\\n if self.with_relu:\\n reg_params = [getattr(self, \\\"conv{}\\\".format(i+1)).parameters() for i in range(self.num_layers - 1)]\\n self.reg_params = itertools.chain(*reg_params)\\n self.non_reg_params = getattr(self, \\\"conv{}\\\".format(self.num_layers)).parameters()\\n else:\\n self.reg_params = OrderedDict()\\n self.non_reg_params = self.parameters()\\n else:\\n self.reg_params = self.parameters()\\n self.non_reg_params = OrderedDict()\\n self.to(self.device)\",\n \"def build_vgg(hr_shape):\\n \\n vgg = VGG19(weights=\\\"imagenet\\\")\\n # Set outputs to outputs of last conv. layer in block 3\\n # See architecture at: https://github.com/keras-team/keras/blob/master/keras/applications/vgg19.py\\n vgg.outputs = [vgg.layers[9].output]\\n\\n img = Input(hr_shape)\\n\\n # Extract image features\\n img_features = vgg(img)\\n\\n return Model(img, img_features)\",\n \"def __init__(self, num_classes=200):\\n nn.Module.__init__(self)\\n # Convolution and pooling layers of VGG-16.\\n self.features = vgg16(pretrained=True).features\\n self.features_conv5_1 = nn.Sequential(*list(self.features.children())[:-5])\\n self.features_conv5_2 = nn.Sequential(*list(self.features.children())[-5:-3])\\n self.features_conv5_3 = nn.Sequential(*list(self.features.children())[-3:-1])\\n self.bilinear_proj = nn.Sequential(nn.Conv2d(512, 8192, kernel_size=1, bias=False),\\n nn.BatchNorm2d(8192),\\n nn.ReLU(inplace=True))\\n # Linear classifier.\\n self.fc = torch.nn.Linear(8192 * 3, num_classes)\",\n \"def _build(self, generation):\\n with tf.variable_scope ('discriminator') as scope:\\n \\n image_unflatten = unflatten_layer ( self.images )\\n gen_unflatten = unflatten_layer ( generation )\\n\\n # Conv Layer 1 - image\\n conv1_out_image, params = conv_2d_layer (\\n input = image_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n name = 'conv_1_img',\\n visualize = True ) \\n pool1_out_img = max_pool_2d_layer ( input = conv1_out_image, name = 'pool_1_img')\\n lrn1_out_img = local_response_normalization_layer (pool1_out_img, name = 'lrn_1_img' ) \\n \\n # Conv Layer 1 - gen\\n conv1_out_gen, params = conv_2d_layer (\\n input = gen_unflatten,\\n neurons = CONV_1_N,\\n filter_size = CONV_1_FILT,\\n params = params,\\n name = 'conv_1_gen',\\n visualize = False )\\n\\n pool1_out_gen = max_pool_2d_layer ( input = conv1_out_gen, name = 'pool_1_gen')\\n lrn1_out_gen = local_response_normalization_layer (pool1_out_gen, name = 'lrn_1_gen' ) \\n process_params(params, name = self.name)\\n c1_params = params\\n\\n\\n\\n\\n\\n # Conv Layer 2 - image\\n conv2_out_image, params = conv_2d_layer (\\n input = lrn1_out_img,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n name = 'conv_2_img' )\\n\\n pool2_out_img = max_pool_2d_layer ( input = conv2_out_image, name = 'pool_2_img')\\n lrn2_out_img = local_response_normalization_layer (pool2_out_img, name = 'lrn_2_img' ) \\n\\n\\n # Conv Layer 2 - gen\\n conv2_out_gen, params = conv_2d_layer (\\n input = lrn1_out_gen,\\n neurons = CONV_2_N,\\n filter_size = CONV_2_FILT,\\n params = params,\\n name = 'conv_2_gen' )\\n\\n pool2_out_gen = max_pool_2d_layer ( input = conv2_out_gen, name = 'pool_2_gen')\\n lrn2_out_gen = local_response_normalization_layer (pool2_out_gen, name = 'lrn_2_gen' ) \\n process_params(params, name = self.name)\\n c2_params = params\\n\\n # Dropout Layer\\n flat_gen = flatten_layer(lrn2_out_gen)\\n flat_img = flatten_layer(lrn2_out_img)\\n\\n flat_gen_dropout = dropout_layer ( input = flat_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_1_gen') \\n\\n flat_img_dropout = dropout_layer ( input = flat_img,\\n prob = self.dropout_prob,\\n name = 'dropout_1_img') \\n\\n\\n\\n # Dot Product Layer 1 -img\\n fc1_out_img, params = dot_product_layer ( input = flat_img_dropout,\\n neurons = HIDDEN_1,\\n name = 'image_disc_dot_1')\\n # Dot Product Layer 1 - gen\\n fc1_out_gen, params = dot_product_layer ( input = flat_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_1')\\n\\n process_params(params, name = self.name)\\n d1_params = params\\n \\n ##\\n fc1_out_gen_dropout = dropout_layer ( input = fc1_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_2_gen') \\n fc1_out_img_dropout = dropout_layer ( input = fc1_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_2_img')\\n\\n # Dot Product Layer 2 -img\\n fc2_out_img, params = dot_product_layer ( input = fc1_out_img_dropout,\\n neurons = HIDDEN_2,\\n name = 'image_disc_dot_2')\\n # Dot Product Layer 2 - gen\\n fc2_out_gen, params = dot_product_layer ( input = fc1_out_gen_dropout,\\n params = params,\\n neurons = HIDDEN_2,\\n name = 'gen_disc_dot_2')\\n process_params(params, name = self.name)\\n d2_params = params\\n\\n ##\\n fc2_out_gen_dropout = dropout_layer ( input = fc2_out_gen,\\n prob = self.dropout_prob,\\n name = 'dropout_3_gen') \\n fc2_out_img_dropout = dropout_layer ( input = fc2_out_img,\\n prob = self.dropout_prob,\\n name = 'dropout_3_img')\\n\\n # Dot Product Layer 1 -img\\n self.real, params = dot_product_layer ( input = fc2_out_img_dropout,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'real')\\n # Dot Product Layer 1 -gen\\n self.fake, params = dot_product_layer ( input = fc2_out_gen_dropout,\\n params = params,\\n neurons = 1,\\n activation = 'sigmoid',\\n name = 'fake')\\n\\n process_params(params, name = self.name)\\n d3_params = params\\n self.params = [c1_params, c2_params, d1_params, d2_params, d3_params] \\n\\n\\n with tf.variable_scope (self.name + '_objectives') as scope: \\n with tf.variable_scope( self.name + 'discriminator_obj') as scope: \\n # discriminator_obj = - 0.5 * tf.reduce_mean(log(self.real)) - \\\\\\n # 0.5 * tf.reduce_mean(log(1-self.fake))\\n discriminator_obj = 0.5 * tf.reduce_mean ((self.real-1)**2) + \\\\\\n 0.5 * tf.reduce_mean ((self.fake)**2)\\n tf.summary.scalar('discriminator_obj', discriminator_obj)\\n tf.add_to_collection( self.name + '_objectives', discriminator_obj ) \\n\\n with tf.variable_scope (self.name + '_probabilites') as scope: \\n tf.summary.scalar('fake_probability', tf.reduce_mean(self.fake))\\n tf.summary.scalar('real_probability', tf.reduce_mean(self.real))\\n \\n self._cook_optimizer( \\n lr = DIS_GAN_LR, \\n optimizer = DIS_GAN_OPTIMIZER,\\n l1_coeff = DIS_GAN_L1_COEFF,\\n l2_coeff = DIS_GAN_WEIGHT_DECAY_COEFF)\",\n \"def __init__(self, embed_size):\\n super(ImgAttentionEncoder, self).__init__()\\n vggnet_feat = models.vgg19(pretrained=True).features\\n modules = list(vggnet_feat.children())[:-2]\\n self.cnn = nn.Sequential(*modules)\\n self.fc = nn.Sequential(nn.Linear(self.cnn[-3].out_channels, embed_size),\\n nn.Tanh()) # feature vector of image\",\n \"def vgg16(**kwargs):\\r\\n return VGG16(**kwargs)\",\n \"def __cnnNetFn(self, input, is_training):\\n with tf.variable_scope('CNN'):\\n conv1 = tf.layers.conv2d(input, 32, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv1_bn = tf.layers.batch_normalization(conv1)\\n conv2 = tf.layers.conv2d(conv1_bn, 32, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv2_bn = tf.layers.batch_normalization(conv2)\\n conv2_pool = tf.layers.max_pooling2d(conv2_bn, 2, 2, padding='SAME')\\n conv2_drop = tf.layers.dropout(conv2_pool, rate=0.2, training=is_training)\\n\\n conv3 = tf.layers.conv2d(conv2_drop, 64, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv3_bn = tf.layers.batch_normalization(conv3)\\n conv4 = tf.layers.conv2d(conv3_bn, 64, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv4_bn = tf.layers.batch_normalization(conv4)\\n conv4_pool = tf.layers.max_pooling2d(conv4_bn, 2, 2, padding='SAME')\\n conv4_drop = tf.layers.dropout(conv4_pool, rate=0.3, training=is_training)\\n\\n conv5 = tf.layers.conv2d(conv4_drop, 128, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv5_bn = tf.layers.batch_normalization(conv5)\\n conv6 = tf.layers.conv2d(conv5_bn, 128, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv6_pool = tf.layers.max_pooling2d(conv6, 2, 2, padding='SAME')\\n\\n csnn_features = tf.stop_gradient(self.__csnn.getTrainOp(input))\\n csnn_features = tf.identity(csnn_features)\\n if self.__use_csnn:\\n joint_features = tf.concat((conv6_pool, csnn_features), axis=3)\\n else:\\n joint_features = conv6_pool\\n\\n conv6_bn = tf.layers.batch_normalization(joint_features)\\n\\n conv7 = tf.layers.conv2d(conv6_bn, 256, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv7_bn = tf.layers.batch_normalization(conv7)\\n conv8 = tf.layers.conv2d(conv7_bn, 256, 3, activation=\\\"elu\\\", padding='SAME',\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(self.__weight_decay))\\n conv8_bn = tf.layers.batch_normalization(conv8)\\n conv8_pool = tf.layers.max_pooling2d(conv8_bn, 2, 2, padding='SAME')\\n conv8_drop = tf.layers.dropout(conv8_pool, rate=0.4, training=is_training)\\n\\n flat = tf.contrib.layers.flatten(conv8_drop)\\n logits = tf.layers.dense(flat, self.__num_classes)\\n return logits, csnn_features\",\n \"def inference(self,image, keep_prob):\\n\\tNUM_OF_CLASSESS = 51\\n\\tIMAGE_SIZE = 224\\n print(\\\"setting up vgg initialized conv layers ...\\\")\\n model_data = self.data\\n mean = model_data['normalization'][0][0][0]\\n mean_pixel = np.mean(mean, axis=(0, 1))\\n\\n weights = np.squeeze(model_data['layers'])\\n\\n processed_image = self.process_image(image, mean_pixel)\\n\\n with tf.variable_scope(\\\"inference\\\"):\\n image_net = self.vgg_net(weights, processed_image)\\n conv_final_layer = image_net[\\\"conv5_3\\\"]\\n\\n pool5 = self.max_pool_2x2(conv_final_layer)\\n\\n W6 = self.weight_variable([7, 7, 512, 4096], name=\\\"W6\\\")\\n b6 = self.bias_variable([4096], name=\\\"b6\\\")\\n conv6 = self.conv2d_basic(pool5, W6, b6)\\n relu6 = tf.nn.relu(conv6, name=\\\"relu6\\\")\\n relu_dropout6 = tf.nn.dropout(relu6, keep_prob=keep_prob)\\n\\n W7 = self.weight_variable([1, 1, 4096, 4096], name=\\\"W7\\\")\\n b7 = self.bias_variable([4096], name=\\\"b7\\\")\\n conv7 = self.conv2d_basic(relu_dropout6, W7, b7)\\n relu7 = tf.nn.relu(conv7, name=\\\"relu7\\\")\\n relu_dropout7 = tf.nn.dropout(relu7, keep_prob=keep_prob)\\n\\n W8 = self.weight_variable([1, 1, 4096, NUM_OF_CLASSESS], name=\\\"W8\\\")\\n b8 = self.bias_variable([NUM_OF_CLASSESS], name=\\\"b8\\\")\\n conv8 = self.conv2d_basic(relu_dropout7, W8, b8)\\n # annotation_pred1 = tf.argmax(conv8, dimension=3, name=\\\"prediction1\\\")\\n\\n # now to upscale to actual image size\\n deconv_shape1 = image_net[\\\"pool4\\\"].get_shape()\\n W_t1 = self.weight_variable([4, 4, deconv_shape1[3].value, NUM_OF_CLASSESS], name=\\\"W_t1\\\")\\n b_t1 = self.bias_variable([deconv_shape1[3].value], name=\\\"b_t1\\\")\\n conv_t1 = self.conv2d_transpose_strided(conv8, W_t1, b_t1, output_shape=tf.shape(image_net[\\\"pool4\\\"]))\\n fuse_1 = tf.add(conv_t1, image_net[\\\"pool4\\\"], name=\\\"fuse_1\\\")\\n\\n deconv_shape2 = image_net[\\\"pool3\\\"].get_shape()\\n W_t2 = self.weight_variable([4, 4, deconv_shape2[3].value, deconv_shape1[3].value], name=\\\"W_t2\\\")\\n b_t2 = self.bias_variable([deconv_shape2[3].value], name=\\\"b_t2\\\")\\n conv_t2 = self.conv2d_transpose_strided(fuse_1, W_t2, b_t2, output_shape=tf.shape(image_net[\\\"pool3\\\"]))\\n fuse_2 = tf.add(conv_t2, image_net[\\\"pool3\\\"], name=\\\"fuse_2\\\")\\n\\n shape = tf.shape(image)\\n deconv_shape3 = tf.pack([shape[0], shape[1], shape[2], NUM_OF_CLASSESS])\\n W_t3 = self.weight_variable([16, 16, NUM_OF_CLASSESS, deconv_shape2[3].value], name=\\\"W_t3\\\")\\n b_t3 = self.bias_variable([NUM_OF_CLASSESS], name=\\\"b_t3\\\")\\n conv_t3 = self.conv2d_transpose_strided(fuse_2, W_t3, b_t3, output_shape=deconv_shape3, stride=8)\\n\\n annotation_pred = tf.argmax(conv_t3, dimension=3, name=\\\"prediction\\\")\\n\\n return tf.expand_dims(annotation_pred, dim=3), conv_t3\",\n \"def __init__(self, in_channels, out_channels, pool=True, last=False, stride=1):\\n super(Vggish, self).__init__()\\n # The two convolutional layers\\n self.conv_1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(3, 3),\\n stride=(stride, stride), padding=(1, 1), bias=False)\\n self.conv_2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels, kernel_size=(3, 3),\\n stride=(stride, stride), padding=(1, 1), bias=False)\\n\\n # Batch normalization\\n self.bn_1 = nn.BatchNorm2d(out_channels)\\n self.bn_2 = nn.BatchNorm2d(out_channels)\\n\\n # Flags\\n self.last = last\\n self.pool = pool\\n\\n # Setting up the max pooling\\n self.max_pool = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2), return_indices=True)\\n\\n # Weights initialization\\n def _weights_init(m):\\n if isinstance(m, nn.Conv2d or nn.Linear or nn.GRU or nn.LSTM):\\n init.xavier_normal_(m.weight)\\n # m.bias.data.zero_()\\n elif isinstance(m, nn.BatchNorm2d or nn.BatchNorm1d):\\n m.weight.data.fill_(1)\\n m.bias.data.zero_()\\n\\n self.apply(_weights_init)\",\n \"def __init__(self, filter1x1, ker_size, filters):\\n super(reduce, self).__init__()\\n self.con1 = layers.Conv2D(\\n filter1x1, kernel_size=1, padding=\\\"same\\\", activation=\\\"relu\\\"\\n )\\n self.conv = layers.Conv2D(\\n filters, kernel_size=ker_size, padding=\\\"same\\\", activation=\\\"relu\\\"\\n )\",\n \"def _make_conv_level(in_channels, out_channels, num_convs, norm_func,\\n stride=1, dilation=1):\\n layers = []\\n for i in range(num_convs):\\n layers.extend([\\n nn.Conv2D(in_channels, out_channels, kernel_size=3,\\n stride=stride if i == 0 else 1,\\n padding=dilation, bias_attr=False, dilation=dilation),\\n norm_func(out_channels),\\n nn.ReLU()])\\n\\n in_channels = out_channels\\n\\n return nn.Sequential(*layers)\",\n \"def VGG_create(desc=None, isigma=None, img_normalize=None, use_scale_orientation=None, scale_factor=None, dsc_normalize=None): # real signature unknown; restored from __doc__\\n pass\",\n \"def _build_model(self, image_input_source, encoder_input_source, dropout_toggle):\\n\\t\\t# We have to match this output size.\\n\\t\\tbatch, input_height, input_width, input_depth = image_input_source.get_shape().as_list()\\n\\t\\n\\t\\tfilter_sizes = [64, 64, 64] # Like VGG net, except made by a stupid person.\\n\\t\\n\\t\\t# Convolutional ops will go here.\\n\\t\\tc0, wc0, bc0 = self._build_conv(image_input_source, [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tc1 = self._build_max_pool(c0, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc2, wc2, bc2 = self._build_conv(self._build_dropout(c1, dropout_toggle), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tc3 = self._build_max_pool(c2, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tc4, wc4, bc4 = self._build_conv(self._build_dropout(c3, dropout_toggle), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tc5 = self._build_max_pool(c4, [1, 2, 2, 1], [1, 2, 2, 1])\\n\\t\\tconv_output = c5\\n\\t\\n\\t\\t# Transition to FC layers.\\n\\t\\tpre_flat_shape = conv_output.get_shape().as_list()\\n\\t\\tflatten = tf.reshape(conv_output, [-1, pre_flat_shape[1]*pre_flat_shape[2]*pre_flat_shape[3]])\\n\\t\\n\\t\\t# Dense connections\\n\\t\\tfc0, wf0, bf0 = self._build_fc(flatten, 512)\\n\\t\\tfc1, wf1, bf1 = self._build_fc(fc0, 512)\\n\\t\\tfc2, wf2, bf2 = self._build_fc(self._build_dropout(fc1, dropout_toggle), self.REPRESENTATION_SIZE)\\n\\t\\tfc_out = fc2\\n\\t\\n\\t\\t# Output point and our encoder mix-in.\\n\\t\\tmu_output, wmu, bmu = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tz_output, wz, bz = self._build_fc(fc_out, self.REPRESENTATION_SIZE)\\n\\t\\tencoded_output = tf.random_normal(mean=mu_output, stddev=z_output, shape=z_output.get_shape()) #tf.nn.softmax(fc_out)\\n\\t\\tencoded_input = self._build_dropout(encoder_input_source + encoded_output, dropout_toggle) # Mix input and enc.\\n\\t\\tencoded_input.set_shape(encoded_output.get_shape()) # Otherwise we can't ascertain the size.\\n\\t\\n\\t\\t# More dense connections on the offset.\\n\\t\\tdfc2, dwf2, dbf2 = self._build_fc(encoded_input, 512, weight=tf.transpose(wf2), bias=tf.transpose(bf1))\\n\\t\\tdfc1, dwf1, dbf1 = self._build_fc(dfc2, 512, weight=tf.transpose(wf1), bias=tf.transpose(bf0))\\n\\t\\tdfc0, dwf0, dbf0 = self._build_fc(self._build_dropout(dfc1, dropout_toggle), flatten.get_shape().as_list()[-1], weight=tf.transpose(wf0))\\n\\t\\n\\t\\t# Expand for more convolutional operations.\\n\\t\\tunflatten = tf.reshape(dfc0, [-1, pre_flat_shape[1], pre_flat_shape[2], pre_flat_shape[3]]) #pre_flat_shape)\\n\\t\\n\\t\\t# More convolutions here.\\n\\t\\tdc5 = self._build_unpool(unflatten, [1, 2, 2, 1])\\n\\t\\tdc4, wdc4, bdc4 = self._build_deconv(self._build_dropout(dc5, dropout_toggle), c3.get_shape().as_list(), [3, 3, filter_sizes[1], filter_sizes[2]], [1, 1, 1, 1])\\n\\t\\tdc3 = self._build_unpool(dc4, [1, 2, 2, 1])\\n\\t\\tdc2, wdc2, bdc2 = self._build_deconv(self._build_dropout(dc3, dropout_toggle), c1.get_shape().as_list(), [3, 3, filter_sizes[0], filter_sizes[1]], [1, 1, 1, 1])\\n\\t\\tdc1 = self._build_unpool(dc2, [1, 2, 2, 1])\\n\\t\\tdc0, wdc0, bdc0 = self._build_deconv(dc1, [batch, input_height, input_width, input_depth], [3, 3, input_depth, filter_sizes[0]], [1, 1, 1, 1], activate=False)\\n\\t\\tdeconv_output = dc0\\n\\t\\n\\t\\t# Return result + encoder output\\n\\t\\treturn deconv_output, encoded_output\",\n \"def _make_conv_layers(self):\\n conv = nn.Sequential(\\n nn.Conv2d(in_channels=3, out_channels=64, kernel_size=7, stride=2, padding=1), # padding=3 so, output is 224.\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(kernel_size=2, stride=2),\\n\\n nn.Conv2d(64, 192, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(192, 128, 1, padding=1), ## kernel size = 1 이므로 padding = 0(defalut)\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(128, 256, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 256, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(256, 512, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(512, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1), \\n nn.LeakyReLU(0.1, inplace=True),\\n nn.MaxPool2d(2,2),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n\\n nn.Conv2d(1024, 512, 1, padding=1),\\n nn.LeakyReLU(0.1, inplace=True),\\n nn.Conv2d(512, 1024, 3, padding=1),\\n nn.LeakyReLU(0.1, inplace=True)\\n )\\n return conv\",\n \"def vgg16_bn(model_dir, tag, num_classes, use_cls, batchnorm=True):\\n cfg = [[64, 64, 'M'], [128, 128, 'M'], [256, 256, 256, 'M'], [512, 512, 512, 512, 512, 512], [1024, 'D', 1024, 'D']]\\n net = VGG(model_dir, tag, cfg, num_classes, use_cls, batchnorm=batchnorm)\\n\\n return net\",\n \"def create_model():\\n \\n cnn = tf.keras.Sequential()\\n \\n cnn.add(tf.keras.layers.InputLayer(input_shape=(img_height,img_width,1)))\\n \\n # Normalization\\n cnn.add(tf.keras.layers.BatchNormalization())\\n \\n # Conv + Maxpooling\\n cnn.add(tf.keras.layers.Convolution2D(64, (4, 4), padding='same', activation='relu'))\\n cnn.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\\n\\n # Dropout\\n cnn.add(tf.keras.layers.Dropout(0.1))\\n \\n # Conv + Maxpooling\\n cnn.add(tf.keras.layers.Convolution2D(64, (4, 4), activation='relu'))\\n cnn.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\\n\\n # Dropout\\n cnn.add(tf.keras.layers.Dropout(0.3))\\n\\n # Converting 3D feature to 1D feature Vektor\\n cnn.add(tf.keras.layers.Flatten())\\n\\n # Fully Connected Layer\\n cnn.add(tf.keras.layers.Dense(256, activation='relu'))\\n\\n # Dropout\\n cnn.add(tf.keras.layers.Dropout(0.5))\\n \\n # Fully Connected Layer\\n cnn.add(tf.keras.layers.Dense(64, activation='relu'))\\n \\n # Normalization\\n cnn.add(tf.keras.layers.BatchNormalization())\\n\\n cnn.add(tf.keras.layers.Dense(num_classes, activation='softmax'))\\n cnn.compile(loss='sparse_categorical_crossentropy', optimizer=tf.compat.v1.train.AdamOptimizer(), metrics=['accuracy'])\\n\\n return cnn\",\n \"def vgg_based_model(num_cls, input_shape=(150, 150, 3), weights=None):\\n # Create a base model\\n base_model = VGG16(include_top=False, weights='imagenet', input_shape=input_shape)\\n\\n # Add new classifier\\n last = base_model.output\\n x = Flatten()(last)\\n x = Dense(256, activation='relu')(x)\\n x = Dropout(0.5)(x)\\n predictions = Dense(num_cls, activation='softmax')(x)\\n model = Model(input=base_model.input, output=predictions)\\n\\n if weights:\\n model.load_weights(weights)\\n\\n return model, base_model\",\n \"def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, dtype):\\n super(ConvGRUCell, self).__init__()\\n self.height, self.width = input_size\\n self.padding = kernel_size[0] // 2, kernel_size[1] // 2\\n self.hidden_dim = hidden_dim\\n self.bias = bias\\n self.dtype = dtype\\n\\n self.conv_gates = nn.Conv2d(in_channels=input_dim + hidden_dim,\\n out_channels=2*self.hidden_dim, # for update_gate,reset_gate respectively\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\\n\\n self.conv_can = nn.Conv2d(in_channels=input_dim+hidden_dim,\\n out_channels=self.hidden_dim, # for candidate neural memory\\n kernel_size=kernel_size,\\n padding=self.padding,\\n bias=self.bias).type(dtype)\",\n \"def __init__(self, n_input_channels=3, n_conv_output_channels=16, k=3, s=1, pad=1, p = 0.5):\\n super(ModelCNN, self).__init__()\\n # 1. Convolutional layers\\n # Single image is in shape: 3x96x96 (CxHxW, H==W), RGB images\\n self.conv1 = nn.Conv2d(in_channels = n_input_channels, out_channels = n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn1 = nn.BatchNorm2d(n_conv_output_channels)\\n self.conv2 = nn.Conv2d(in_channels = n_conv_output_channels, out_channels = 2*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn2 = nn.BatchNorm2d(2*n_conv_output_channels)\\n self.conv3 = nn.Conv2d(in_channels = 2*n_conv_output_channels, out_channels = 4*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn3 = nn.BatchNorm2d(4*n_conv_output_channels)\\n self.conv4 = nn.Conv2d(in_channels = 4*n_conv_output_channels, out_channels = 8*n_conv_output_channels, kernel_size = k, stride = s, padding = pad)\\n self.bn4 = nn.BatchNorm2d(8*n_conv_output_channels)\\n self.pool = nn.MaxPool2d(kernel_size = k - 1, stride = 2*s, padding = pad - pad)\\n \\n self.dropout = nn.Dropout(p = p)\\n \\n # 2. FC layers to final output\\n self.fc1 = nn.Linear(in_features = 288*n_conv_output_channels, out_features = 32*n_conv_output_channels)\\n self.fc_bn1 = nn.BatchNorm1d(32*n_conv_output_channels)\\n self.fc2 = nn.Linear(in_features = 32*n_conv_output_channels, out_features = 16*n_conv_output_channels)\\n self.fc_bn2 = nn.BatchNorm1d(16*n_conv_output_channels)\\n self.fc3 = nn.Linear(in_features = 16*n_conv_output_channels, out_features = 8*n_conv_output_channels)\\n self.fc_bn3 = nn.BatchNorm1d(8*n_conv_output_channels)\\n self.fc4 = nn.Linear(in_features = 8*n_conv_output_channels, out_features = 1)\",\n \"def create_model(input_tensor, mode, hyper_params):\\n model = {}\\n with tf.variable_scope('vgg16') as scope:\\n net = tf.cast(input_tensor[\\\"image\\\"], dtype=tf.float32, name=\\\"input/cast\\\")\\n model[\\\"image\\\"] = net\\n mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')\\n net = net - mean\\n model[\\\"image-normalized\\\"] = net\\n\\n net = _create_conv2_block(model, net, filters=64, layer_number=1)\\n net = _create_conv2_block(model, net, filters=128, layer_number=2)\\n net = _create_conv3_block(model, net, filters=256, layer_number=3)\\n net = _create_conv3_block(model, net, filters=512, layer_number=4)\\n net = _create_conv3_block(model, net, filters=512, layer_number=5)\\n print(net.get_shape())\\n\\n if not hyper_params.vgg16.encoder_only:\\n net = tf.layers.conv2d(inputs=net, filters=4096, kernel_size=(7, 7), strides=(1, 1), name=\\\"fc1\\\", activation=tf.nn.relu)\\n model[\\\"vgg16/fc1\\\"] = net\\n net = tf.layers.conv2d(inputs=net, filters=4096, kernel_size=(1, 1), strides=(1, 1), name=\\\"fc2\\\", activation=tf.nn.relu)\\n model[\\\"vgg16/fc2\\\"] = net\\n net = tf.layers.conv2d(inputs=net, filters=1000, kernel_size=(1, 1), strides=(1, 1), name=\\\"logits\\\", activation=None)\\n model[\\\"logits\\\"] = net\\n net = tf.nn.softmax(net)\\n model[\\\"probs\\\"] = net\\n return model\",\n \"def create():\\n with torch.set_grad_enabled(False):\\n model = torch.hub.load(\\n \\\"pytorch/vision:v0.6.0\\\", \\\"vgg11\\\", pretrained=True).eval()\\n\\n with_cuda = torch.cuda.is_available()\\n if with_cuda:\\n model.to(\\\"cuda\\\")\\n else:\\n logging.warn(\\\"Running on CPU, no CUDA detected.\\\")\\n\\n def call(features):\\n images = features[\\\"image\\\"].numpy()\\n # Normalize according to the documentation. Note that the pro-processing\\n # will already have the range normalized to [0, 1].\\n mean = [0.485, 0.456, 0.406]\\n std = [0.229, 0.224, 0.225]\\n images_normalized = (images - mean) / std\\n # Reshape from [batch, h, w, c] -> [batch, c, h, w]\\n images_normalized_bchw = np.transpose(\\n images_normalized, [0, 3, 1, 2]).astype(np.float32).copy()\\n with torch.no_grad():\\n images_torch = torch.from_numpy(images_normalized_bchw)\\n if with_cuda:\\n images_torch = images_torch.to(\\\"cuda\\\")\\n logits = model(images_torch)\\n return torch.nn.functional.softmax(logits, dim=-1).cpu().numpy()\\n\\n preprocess_config = \\\"resize_small(256)|central_crop(224)|value_range(0,1)\\\"\\n preprocess_fn = pipeline_builder.get_preprocess_fn(\\n preprocess_config, remove_tpu_dtypes=False)\\n return call, preprocess_fn\",\n \"def __init__(self, layers, input_size):\\n super(ConvNetMaker, self).__init__()\\n self.conv_layers = []\\n self.fc_layers = []\\n # h, w, d = 32, 32, 3\\n h, w, d = input_size, input_size, 3\\n previous_layer_filter_count = 3\\n previous_layer_size = h * w * d\\n num_fc_layers_remained = len([1 for l in layers if l.startswith('FC')])\\n for layer in layers:\\n if layer.startswith('Conv'):\\n filter_count = int(layer[4:])\\n self.conv_layers += [\\n nn.Conv2d(previous_layer_filter_count,\\n filter_count,\\n kernel_size=3,\\n padding=1),\\n nn.BatchNorm2d(filter_count),\\n nn.ReLU(inplace=True)\\n ]\\n\\n previous_layer_filter_count = filter_count\\n d = filter_count\\n previous_layer_size = h * w * d\\n elif layer.startswith('MaxPool'):\\n self.conv_layers += [nn.MaxPool2d(kernel_size=2, stride=2)]\\n h, w = int(h / 2.0), int(w / 2.0)\\n previous_layer_size = h * w * d\\n elif layer.startswith('FC'):\\n num_fc_layers_remained -= 1\\n current_layer_size = int(layer[2:])\\n if num_fc_layers_remained == 0:\\n self.fc_layers += [nn.Linear(previous_layer_size,\\n current_layer_size)]\\n else:\\n self.fc_layers += [nn.Linear(previous_layer_size,\\n current_layer_size),\\n nn.ReLU(inplace=True)]\\n previous_layer_size = current_layer_size\\n\\n conv_layers = self.conv_layers\\n fc_layers = self.fc_layers\\n self.conv_layers = nn.Sequential(*conv_layers)\\n self.fc_layers = nn.Sequential(*fc_layers)\",\n \"def __init__(self, in_channels, out_channels):\\n super(CNN, self).__init__()\\n self.conv1 = nn.Conv1d(in_channels=in_channels, out_channels=out_channels, kernel_size=5, padding=1)\",\n \"def __init__(self, vgg_net):\\n super().__init__()\\n # create a conv layer that corresponds to the first linear layer\\n linear1 = vgg_net.classifier[0]\\n conv = nn.Conv2d(512, 4096, 7, 7)\\n\\n # copy data into it\\n conv.bias.data.copy_(linear1.bias.data)\\n conv.weight.data.view(4096, -1).copy_(linear1.weight.data)\\n\\n # replace the layer in the sequential classifier part\\n vgg_net.classifier = nn.Sequential(\\n conv, nn.Flatten(1), *vgg_net.classifier[1:]\\n )\\n\\n self.vgg_net = vgg_net\",\n \"def __init__(self, img_size, multi_layers=False):\\n super().__init__()\\n\\n vgg = VGG16(include_top=False, input_shape=(img_size[0], img_size[1], 3))\\n if multi_layers:\\n layer_ids = [2, 5, 9, 13, 17]\\n layer_outputs = [\\n Flatten()(vgg.layers[layer_id].output) for layer_id in layer_ids]\\n features = Concatenate(axis=-1)(layer_outputs)\\n else:\\n layer_ids = [13] # 13 -> conv4_3\\n features = [\\n Flatten()(vgg.layers[layer_id].output) for layer_id in layer_ids]\\n\\n self._model = Model(inputs=vgg.input, outputs=features)\",\n \"def init_encoder(self):\\n\\n vgg = models.vgg16(pretrained=True)\\n\\n blocks = [self.layer_1,\\n self.layer_2,\\n self.layer_3,\\n self.layer_4,\\n self.layer_5]\\n\\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\\n features = list(vgg.features.children())\\n\\n vgg_layers = []\\n for _layer in features:\\n if isinstance(_layer, nn.Conv2d):\\n vgg_layers.append(_layer)\\n\\n merged_layers = []\\n for idx, conv_block in enumerate(blocks):\\n if idx < 2:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit]\\n else:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit,\\n conv_block.conv3.cbr_unit]\\n for _unit in units:\\n for _layer in _unit:\\n if isinstance(_layer, nn.Conv2d):\\n merged_layers.append(_layer)\\n\\n assert len(vgg_layers) == len(merged_layers)\\n\\n for l1, l2 in zip(vgg_layers, merged_layers):\\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\\n assert l1.weight.size() == l2.weight.size()\\n assert l1.bias.size() == l2.bias.size()\\n l2.weight.data = l1.weight.data\\n l2.bias.data = l1.bias.data\",\n \"def run_vgg_experiment(args, device):\\n validation_ratio, record_train_acc, record_val_acc, record_test_acc = utils.configure_training_mode(args)\\n\\n train_loader, validation_loader, test_loader = datasets.build_cifar10_loaders(args.batch_size,\\n validation_ratio=validation_ratio,\\n train_validation_split_seed=0)\\n local_loss_list = utils.get_loss(args)\\n nonlinearity = utils.get_nonlinearity(args)\\n\\n optimizer_local, local_opt_arguments_dict, local_scheduler_arguments_dict, \\\\\\n optimizer_final, final_opt_arguments_dict, final_scheduler_arguments_dict = \\\\\\n utils.choose_optimizers_and_parameters(args)\\n\\n conv_sizes = [128, 256, 256, 512, 512, 512]\\n\\n if args.vgg_conv_size_multiplier != 1:\\n for i in range(len(conv_sizes)):\\n conv_sizes[i] = conv_sizes[i] * args.vgg_conv_size_multiplier\\n do_pooling = [False, True, False, True, True, True]\\n\\n if args.divisive_norm_conv:\\n divisive_norm_list_conv = [networks.DivisiveNorm(args.divnorm_power, args.grouping_dim, args.grouped_var_delta)\\n for i in range(len(conv_sizes))]\\n else:\\n divisive_norm_list_conv = None\\n\\n kernel_sizes = [3 for i in range(len(conv_sizes))]\\n fc_layers = [1024]\\n\\n if args.divisive_norm_fc:\\n divisive_norm_list_fc = [networks.DivisiveNorm(args.divnorm_power, args.grouping_dim,\\n args.grouped_var_delta)\\n for i in range(len(fc_layers))]\\n else:\\n divisive_norm_list_fc = None\\n\\n alt_feedback_type = None\\n if args.feedback_alignment:\\n alt_feedback_type = 'feedback_alignment'\\n elif args.sign_symmetry:\\n alt_feedback_type = 'sign_symmetry'\\n\\n net = networks.Network(nonlinearity, local_loss_list, optimizer_local,\\n torch.optim.lr_scheduler.MultiStepLR, conv_sizes, kernel_sizes,\\n do_pooling, fc_layers, 'max', 'CIFAR10', bias=False,\\n local_opt_arguments_dict=local_opt_arguments_dict,\\n local_scheduler_arguments_dict=local_scheduler_arguments_dict,\\n dropout_p=args.dropout_p, batch_norm=args.batch_norm,\\n divisive_norm_list_conv=divisive_norm_list_conv, divisive_norm_list_fc=divisive_norm_list_fc,\\n spatial_dropout=args.spatial_dropout, alt_feedback_type=alt_feedback_type)\\n\\n net = net.to(device)\\n print(net)\\n\\n final_loss = nn.CrossEntropyLoss()\\n\\n if args.backprop:\\n final_opt = optimizer_final(net.parameters(), **final_opt_arguments_dict)\\n compute_local_loss = False\\n update_local_loss = False\\n else:\\n final_opt = optimizer_final(net.softmax_layer.parameters(), **final_opt_arguments_dict)\\n compute_local_loss = True\\n update_local_loss = True\\n\\n final_scheduler = torch.optim.lr_scheduler.MultiStepLR(final_opt, **final_scheduler_arguments_dict)\\n\\n train_acc, val_acc, test_acc = utils.train_network(\\n net, device, final_loss, final_opt, final_scheduler, args.n_epochs, train_loader, validation_loader,\\n test_loader, compute_local_loss=compute_local_loss, update_local_loss=update_local_loss,\\n record_train_acc=record_train_acc, record_val_acc=record_val_acc, record_test_acc=record_test_acc,\\n print_results=True, backprop_batch_manhattan=args.backprop_batch_manhattan)\\n\\n return train_acc, val_acc, test_acc\",\n \"def create_cnn(num_features: int = None) -> models.Model:\\n nclass = num_features or 5\\n inp = Input(shape=(187, 1))\\n img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\\\"valid\\\")(inp)\\n # img_1 = Convolution1D(16, kernel_size=5, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = MaxPool1D(pool_size=2)(img_1)\\n img_1 = Dropout(rate=0.1)(img_1)\\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = MaxPool1D(pool_size=2)(img_1)\\n img_1 = Dropout(rate=0.1)(img_1)\\n img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n # img_1 = Convolution1D(32, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = MaxPool1D(pool_size=2)(img_1)\\n img_1 = Dropout(rate=0.1)(img_1)\\n img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n # img_1 = Convolution1D(256, kernel_size=3, activation=activations.relu, padding=\\\"valid\\\")(img_1)\\n img_1 = GlobalMaxPool1D()(img_1)\\n img_1 = Dropout(rate=0.2)(img_1)\\n\\n dense_1 = Dense(64, activation=activations.relu, name=\\\"dense_1\\\")(img_1)\\n dense_1 = Dense(64, activation=activations.relu, name=\\\"dense_2\\\")(dense_1)\\n dense_1 = Dense(nclass, activation=activations.softmax, name=\\\"dense_3_mitbih\\\")(dense_1)\\n\\n model = models.Model(inputs=inp, outputs=dense_1)\\n opt = optimizers.Adam(learning_rate=0.001)\\n\\n model.compile(optimizer=opt,\\n loss=losses.sparse_categorical_crossentropy,\\n metrics=['accuracy'])\\n model.summary()\\n return model\",\n \"def create_vgg_down_block(filters, in_features, activation, kernel_size=3, strategy='stride', batch_norm=False):\\n layers = []\\n if isinstance(filters, int):\\n filters = [filters]\\n\\n if not isinstance(filters, list):\\n raise ValueError(\\\"Filters has to be a list\\\")\\n\\n in_feat = in_features\\n for n in range(len(filters))[:-1]:\\n out_feat = filters[n]\\n conv = Conv2d_same(in_features=in_feat, out_features=out_feat, activation=activation, kernel_size=kernel_size, batch_norm=batch_norm)\\n layers.append(conv)\\n in_feat = out_feat\\n\\n layers.append(Conv2d_Down(in_features=in_feat, out_features=filters[-1], activation=activation, kernel_size=kernel_size, strategy=strategy, batch_norm=batch_norm))\\n out_feat = filters[-1]\\n return layers, out_feat\",\n \"def layers(vgg_layer3_out, vgg_layer4_out, vgg_layer7_out, num_classes, is_training):\\n # Build the decode part of FCN-8\\n vgg_layer7_n = tf.layers.batch_normalization(vgg_layer7_out,\\n name=\\\"new_vgg_layer7_normalization\\\",\\n training = is_training)\\n filters = 4096 if USE_ORIGINAL_NUM_FILTERS else num_classes\\n conv_layer_7 = tf.layers.conv2d(vgg_layer7_n, filters, 1, strides=(1, 1),\\n padding='same',\\n activation=tf.nn.relu,\\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\\n name='new_conv_layer_7')\\n conv_layer_7 = tf.layers.batch_normalization(conv_layer_7,\\n name=\\\"new_conv_layer_7_normalization\\\",\\n training = is_training)\\n\\n filters = 512 if USE_ORIGINAL_NUM_FILTERS else num_classes\\n dconv_layer_7 = tf.layers.conv2d_transpose(conv_layer_7, filters, 4, strides=(2, 2),\\n padding='same', activation=tf.nn.relu,\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\\n name='new_dconv_layer_7')\\n dconv_layer_7 = tf.layers.batch_normalization(dconv_layer_7,\\n name=\\\"new_dconv_layer_7_normalization\\\",\\n training = is_training)\\n\\n vgg_layer4_n = tf.layers.batch_normalization(vgg_layer4_out,\\n name=\\\"new_vgg_layer4_normalization\\\",\\n training = is_training)\\n filters = 512 if USE_ORIGINAL_NUM_FILTERS else num_classes\\n conv_layer_4 = tf.layers.conv2d(vgg_layer4_n, filters, 1, strides=(1, 1),\\n padding='same',\\n activation=tf.nn.relu,\\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\\n name='new_conv_layer_4')\\n conv_layer_4 = tf.layers.batch_normalization(conv_layer_4,\\n name=\\\"new_conv_layer_4_normalization\\\",\\n training = is_training)\\n\\n skip_layer_4 = tf.add(conv_layer_4, dconv_layer_7, name='new_skip_layer_4')\\n\\n filters = 256 if USE_ORIGINAL_NUM_FILTERS else num_classes\\n dconv_layer_4 = tf.layers.conv2d_transpose(skip_layer_4, filters, 4, strides=(2, 2),\\n padding='same',\\n activation=tf.nn.relu,\\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\\n name='new_dconf_layer_4')\\n dconv_layer_4 = tf.layers.batch_normalization(dconv_layer_4,\\n name=\\\"new_dconv_layer_4_normalization\\\",\\n training = is_training)\\n\\n vgg_layer3_n = tf.layers.batch_normalization(vgg_layer3_out,\\n name=\\\"new_vgg_layer3_normalization\\\",\\n training = is_training)\\n filters = 256 if USE_ORIGINAL_NUM_FILTERS else num_classes\\n conv_layer_3 = tf.layers.conv2d(vgg_layer3_n, filters, 1, strides=(1, 1),\\n padding='same',\\n activation=tf.nn.relu,\\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\\n name='new_conv_layer_3')\\n conv_layer_3 = tf.layers.batch_normalization(conv_layer_3,\\n name=\\\"new_conv_layer_3_normalization\\\",\\n training = is_training)\\n\\n skip_layer_3 = tf.add(conv_layer_3, dconv_layer_4, name='new_skip_layer_3')\\n\\n dconv_layer_3 = tf.layers.conv2d_transpose(skip_layer_3, num_classes, 16, strides=(8, 8),\\n padding='same',\\n activation=tf.nn.relu,\\n kernel_initializer=tf.truncated_normal_initializer(stddev=0.01),\\n kernel_regularizer=tf.contrib.layers.l2_regularizer(1e-3),\\n name='new_dconf_layer_3')\\n dconv_layer_3 = tf.layers.batch_normalization(dconv_layer_3,\\n name=\\\"new_dconv_layer_3_normalization\\\",\\n training = is_training)\\n\\n # Debug info\\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(vgg_layer7_out)],\\n message='vgg_layer7_out = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [vgg_layer7_out],\\n message='vgg_layer7_out = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(dconv_layer_7)],\\n message='dconv_layer_7 = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [dconv_layer_7],\\n message='dconv_layer_7 = ', summarize = 10, first_n = 3)\\n\\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(vgg_layer4_out)],\\n message='vgg_layer4_out = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [vgg_layer4_out],\\n message='vgg_layer4_out = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(dconv_layer_4)],\\n message='dconv_layer_4 = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [dconv_layer_4],\\n message='dconv_layer_4 = ', summarize = 10, first_n = 3)\\n\\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(vgg_layer3_out)],\\n message='vgg_layer3_out = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [vgg_layer3_out],\\n message='vgg_layer3_out = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [tf.shape(dconv_layer_3)],\\n message='dconf_layer_3 = ', summarize = 10, first_n = 3)\\n dconv_layer_3 = tf.Print(dconv_layer_3, [dconv_layer_3],\\n message='dconf_layer_3 = ', summarize = 10, first_n = 3)\\n\\n return dconv_layer_3\",\n \"def build_model(\\n data_tensor,\\n reuse,\\n training,\\n output_shape,\\n data_format='NHWC'):\\n if isinstance(output_shape, list):\\n output_shape = output_shape[-1]\\n elif isinstance(output_shape, dict):\\n output_shape = output_shape['output']\\n # norm_moments_training = training # Force instance norm\\n # normalization_type = 'no_param_batch_norm_original'\\n # output_normalization_type = 'batch_norm_original_renorm'\\n output_normalization_type = 'instance_norm'\\n data_tensor, long_data_format = tf_fun.interpret_data_format(\\n data_tensor=data_tensor,\\n data_format=data_format)\\n\\n # Build model\\n with tf.variable_scope('vgg', reuse=reuse):\\n vgg = vgg16.Vgg16(\\n vgg16_npy_path='/media/data_cifs/clicktionary/pretrained_weights/vgg16.npy')\\n vgg(rgb=data_tensor, train=training, ff_reuse=reuse)\\n\\n with tf.variable_scope('fgru', reuse=reuse):\\n # Get side weights\\n h2_rem = [\\n vgg.conv1_2,\\n vgg.conv2_2,\\n vgg.conv3_3,\\n vgg.conv4_3,\\n vgg.conv5_3]\\n res_act = []\\n for idx, h in enumerate(h2_rem):\\n res = normalization.apply_normalization(\\n activity=h,\\n name='output_norm1_%s' % idx,\\n normalization_type=output_normalization_type,\\n data_format=data_format,\\n training=training,\\n trainable=training,\\n reuse=reuse)\\n res_act += [tf.image.resize_bilinear(\\n res,\\n data_tensor.get_shape().as_list()[1:3],\\n align_corners=True)]\\n\\n activity = tf.layers.conv2d(\\n tf.concat(res_act, -1),\\n filters=output_shape,\\n kernel_size=(1, 1),\\n padding='same',\\n data_format=long_data_format,\\n name='out',\\n activation=None,\\n trainable=training,\\n use_bias=True,\\n reuse=reuse)\\n\\n if long_data_format is 'channels_first':\\n activity = tf.transpose(activity, (0, 2, 3, 1))\\n extra_activities = {} # idx: v for idx, v in enumerate(hs_0)}\\n if activity.dtype != tf.float32:\\n activity = tf.cast(activity, tf.float32)\\n return activity, extra_activities\",\n \"def model(self, input_shape=(3, 224, 224), nclasses=3):\\n inputs = Input(input_shape)\\n\\n pad1_1 = ZeroPadding2D(padding=(1, 1))(inputs)\\n conv1_1 = Conv2D(64, 3, 3, activation='relu', name='conv1_1')(pad1_1)\\n pad1_2 = ZeroPadding2D(padding=(1, 1))(conv1_1)\\n conv1_2 = Conv2D(64, 3, 3, activation='relu', name='conv1_2')(pad1_2)\\n pool1 = MaxPooling2D((2, 2), strides=(2, 2))(conv1_2)\\n\\n pad2_1 = ZeroPadding2D((1, 1))(pool1)\\n conv2_1 = Conv2D(128, 3, 3, activation='relu', name='conv2_1')(pad2_1)\\n pad2_2 = ZeroPadding2D((1, 1))(conv2_1)\\n conv2_2 = Conv2D(128, 3, 3, activation='relu', name='conv2_2')(pad2_2)\\n pool2 = MaxPooling2D((2, 2), strides=(2, 2))(conv2_2)\\n\\n pad3_1 = ZeroPadding2D((1, 1))(pool2)\\n conv3_1 = Conv2D(256, 3, 3, activation='relu', name='conv3_1')(pad3_1)\\n pad3_2 = ZeroPadding2D((1, 1))(conv3_1)\\n conv3_2 = Conv2D(256, 3, 3, activation='relu', name='conv3_2')(pad3_2)\\n pad3_3 = ZeroPadding2D((1, 1))(conv3_2)\\n conv3_3 = Conv2D(256, 3, 3, activation='relu', name='conv3_3')(pad3_3)\\n pool3 = MaxPooling2D((2, 2), strides=(2, 2))(conv3_3)\\n\\n pad4_1 = ZeroPadding2D((1, 1))(pool3)\\n conv4_1 = Conv2D(512, 3, 3, activation='relu', name='conv4_1')(pad4_1)\\n pad4_2 = ZeroPadding2D((1, 1))(conv4_1)\\n conv4_2 = Conv2D(512, 3, 3, activation='relu', name='conv4_2')(pad4_2)\\n pad4_3 = ZeroPadding2D((1, 1))(conv4_2)\\n conv4_3 = Conv2D(512, 3, 3, activation='relu', name='conv4_3')(pad4_3)\\n pool4 = MaxPooling2D((2, 2), strides=(2, 2))(conv4_3)\\n\\n pad5_1 = ZeroPadding2D((1, 1))(pool4)\\n conv5_1 = Conv2D(512, 3, 3, activation='relu', name='conv5_1')(pad5_1)\\n pad5_2 = ZeroPadding2D((1, 1))(conv5_1)\\n conv5_2 = Conv2D(512, 3, 3, activation='relu', name='conv5_2')(pad5_2)\\n pad5_3 = ZeroPadding2D((1, 1))(conv5_2)\\n conv5_3 = Conv2D(512, 3, 3, activation='relu', name='conv5_3')(pad5_3)\\n pool5 = MaxPooling2D((2, 2), strides=(2, 2))(conv5_3)\\n\\n # fc5 = base_model.layers[-8].output\\n fc6 = Flatten()(pool5)\\n fc7_1 = Dense(256, activation='relu', name='fc7_1')(fc6)\\n dropout7_1 = Dropout(0.3, name='dropout7_1')(fc7_1)\\n fc7_2 = Dense(128, activation='relu', name='fc7_2')(dropout7_1)\\n # dropout7_2 = Dropout(0.2, name='dropout7_2')(fc7_2)\\n # fc7_3 = Dense(128, activation=\\\"relu\\\", name=\\\"fc7_pre3\\\")(dropout7_2)\\n prediction = Dense(nclasses, activation='softmax')(fc7_2)\\n model = Model(inputs, prediction)\\n model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\\n # model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])\\n return model\",\n \"def create_tcnn_bottom(vgg_weights_path, conv1_1_weigths):\\r\\n\\t# Create inputs for the 5 frames\\r\\n\\tinput_shape=(224, 224, 3)\\r\\n\\tframe1 = Input(shape=input_shape)\\r\\n\\tframe2 = Input(shape=input_shape)\\r\\n\\tframe3 = Input(shape=input_shape)\\r\\n\\tframe4 = Input(shape=input_shape)\\r\\n\\tframe5 = Input(shape=input_shape)\\r\\n\\t\\r\\n\\t# Convolution for each frame\\r\\n\\tframe1_conv = ZeroPadding2D((1,1))(frame1)\\r\\n\\tframe1_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1a')(frame1_conv)\\r\\n\\r\\n\\tframe2_conv = ZeroPadding2D((1,1))(frame2)\\r\\n\\tframe2_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1b')(frame2_conv)\\r\\n\\r\\n\\tframe3_conv = ZeroPadding2D((1,1))(frame3)\\r\\n\\tframe3_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1c')(frame3_conv)\\r\\n\\r\\n\\tframe4_conv = ZeroPadding2D((1,1))(frame4)\\r\\n\\tframe4_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1d')(frame4_conv)\\r\\n\\r\\n\\tframe5_conv = ZeroPadding2D((1,1))(frame5)\\r\\n\\tframe5_conv = Convolution2D(64, (3, 3), activation='relu', name='conv1_1e')(frame5_conv)\\r\\n\\t\\r\\n\\t# Temporal aggregation by averaging\\r\\n\\ttemp_aggr = average([frame1_conv, frame2_conv, frame3_conv, frame4_conv, frame5_conv])\\r\\n\\r\\n\\t# Then standard VGG-16 architecture\\r\\n\\toutput = ZeroPadding2D((1,1))(temp_aggr)\\r\\n\\toutput = Convolution2D(64, (3, 3), activation='relu', name='conv1_2')(output)\\r\\n\\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\\r\\n\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(128, (3, 3), activation='relu', name='conv2_1')(output)\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(128, (3, 3), activation='relu', name='conv2_2')(output)\\r\\n\\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\\r\\n\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(256, (3, 3), activation='relu', name='conv3_1')(output)\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(256, (3, 3), activation='relu', name='conv3_2')(output)\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(256, (3, 3), activation='relu', name='conv3_3')(output)\\r\\n\\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\\r\\n\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv4_1')(output)\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv4_2')(output)\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv4_3')(output)\\r\\n\\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\\r\\n\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv5_1')(output)\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv5_2')(output)\\r\\n\\toutput = ZeroPadding2D((1,1))(output)\\r\\n\\toutput = Convolution2D(512, (3, 3), activation='relu', name='conv5_3')(output)\\r\\n\\toutput = MaxPooling2D((2,2), strides=(2,2))(output)\\r\\n\\r\\n\\tinputs = [frame1, frame2, frame3, frame4, frame5]\\r\\n\\tmodel = Model(inputs=inputs, outputs=output)\\r\\n\\t\\r\\n\\t# load VGG-face weigths\\r\\n\\tmodel.load_weights(vgg_weights_path, by_name=True)\\r\\n\\tfor layer in ['conv1_1a', 'conv1_1b', 'conv1_1c', 'conv1_1d', 'conv1_1e']:\\r\\n\\t\\tmodel.get_layer(layer).set_weights(conv1_1_weigths)\\r\\n\\r\\n\\treturn model\",\n \"def build_network(self):\\n net = self.ccf_data\\n\\n # Reshape [length] -> [length, 1].\\n net = tf.expand_dims(net, -1)\\n\\n # create summary object\\n summary = []\\n\\n for i in self.hparams.conv_block_filters:\\n for _ in range(self.hparams.conv_layers_per_block):\\n input_shape = net.shape.as_list()\\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\\n activation=tf.nn.relu)\\n net = conv_op(net)\\n summary.append(\\\"Conv1D-{}-{}. Input shape: {}. Output shape: {}\\\".format(self.hparams.kernel_size, i, input_shape,\\n net.shape.as_list()))\\n pool_size = 2\\n strides = 2\\n max_pool = tf.keras.layers.MaxPool1D(pool_size=pool_size, strides=strides)\\n net = max_pool(net)\\n summary.append(\\\"MaxPool1D-{}. Pool Size: {}. Strides: {}\\\".format(self.hparams.kernel_size, pool_size, strides))\\n\\n for i in self.hparams.final_conv_num_filters:\\n conv_op = tf.keras.layers.Conv1D(filters=i, kernel_size=self.hparams.kernel_size, padding='same',\\n activation=tf.nn.relu)\\n net = conv_op(net)\\n flatten = tf.keras.layers.Flatten()\\n net = flatten(net)\\n\\n for i in self.hparams.dense_num_layers:\\n dense = tf.keras.layers.Dense(i, activation=tf.nn.relu)\\n net = dense(net)\\n\\n # output layer\\n output = tf.keras.layers.Dense(1)\\n net = tf.squeeze(output(net))\\n\\n self.summary = \\\"\\\\n\\\".join(summary)\\n self.predicted_rv = net\",\n \"def build_cnn(self):\\n model = Sequential()\\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\\n model.add(Conv2D(24, (1, 3), activation = 'relu', input_shape = (1, grid_size*grid_size+2, 1)))\\n model.add(Flatten())\\n model.add(Dense(len(ACTIONS), activation = 'linear'))\\n model.compile(loss = 'mse', optimizer = Adam(lr = alpha))\\n\\n return model\",\n \"def forward(self, x):\\n sources = list()\\n loc = list()\\n conf = list()\\n\\n # apply vgg up to conv4_3 relu\\n #print('Reached start of vgg')\\n for k in self.vgg._modules.keys():\\n if int(k) < 23:\\n #print('Reached ' + k + ' ', x.size())\\n x = self.vgg._modules[k].cuda()(x)\\n #print('Reached L2Norm')\\n s = self.L2Norm(x)\\n sources.append(s)\\n\\n #print('Reached after L2Norm')\\n # apply vgg up to fc7\\n for k in self.vgg._modules.keys():\\n if int(k) >= 23:\\n #print('Reached ' + k + ' ', x.size())\\n x = self.vgg._modules[k].cuda()(x)\\n sources.append(x)\\n #print('Reached end of VGG')\\n\\n # apply extra layers and cache source layer outputs\\n for k, v in enumerate(self.extras):\\n x = F.relu(v(x), inplace=True)\\n if k % 2 == 1:\\n sources.append(x)\\n\\n # apply multibox head to source layers\\n for (x, l, c) in zip(sources, self.loc, self.conf):\\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\\n\\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\\n\\n if self.phase == \\\"test\\\":\\n output = self.detect(\\n loc.view(loc.size(0), -1, 4), # loc preds\\n self.softmax(conf.view(-1, self.num_classes)), # conf preds\\n self.priors # default boxes\\n )\\n else:\\n output = (\\n loc.view(loc.size(0), -1, 4),\\n conf.view(conf.size(0), -1, self.num_classes),\\n self.priors\\n )\\n return output\",\n \"def model(pretrained=False, **kwargs):\\r\\n\\r\\n layers = make_layers(cfg['O'], dilation=dilation['D1'])\\r\\n cnv = np.cumsum(cnvs['OI']) if kwargs['args'].IN or kwargs['args'].INL else np.cumsum(cnvs['O'])\\r\\n model = VGG(layers, cnvs=cnv, **kwargs)\\r\\n if pretrained:\\r\\n pre2local_keymap = [('features.{}.weight'.format(i), 'conv1_2.{}.weight'.format(i)) for i in range(10)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i), 'conv1_2.{}.bias'.format(i)) for i in range(10)]\\r\\n pre2local_keymap += [('features.{}.weight'.format(i + 10), 'conv3.{}.weight'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i + 10), 'conv3.{}.bias'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.weight'.format(i + 17), 'conv4.{}.weight'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i + 17), 'conv4.{}.bias'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.weight'.format(i + 24), 'conv5.{}.weight'.format(i)) for i in range(7)]\\r\\n pre2local_keymap += [('features.{}.bias'.format(i + 24), 'conv5.{}.bias'.format(i)) for i in range(7)]\\r\\n pre2local_keymap = dict(pre2local_keymap)\\r\\n\\r\\n\\r\\n model_dict = model.state_dict()\\r\\n pretrained_file = os.path.join(kwargs['args'].pretrained_model_dir, kwargs['args'].pretrained_model)\\r\\n if os.path.isfile(pretrained_file):\\r\\n pretrained_dict = torch.load(pretrained_file)\\r\\n print('load pretrained model from {}'.format(pretrained_file))\\r\\n else:\\r\\n pretrained_dict = model_zoo.load_url(model_urls['vgg16'])\\r\\n print('load pretrained model from {}'.format(model_urls['vgg16']))\\r\\n # 0. replace the key\\r\\n pretrained_dict = {pre2local_keymap[k] if k in pre2local_keymap.keys() else k: v for k, v in\\r\\n pretrained_dict.items()}\\r\\n # *. show the loading information\\r\\n for k in pretrained_dict.keys():\\r\\n if k not in model_dict:\\r\\n print('Key {} is removed from vgg16'.format(k))\\r\\n print(' ')\\r\\n for k in model_dict.keys():\\r\\n if k not in pretrained_dict:\\r\\n print('Key {} is new added for DA Net'.format(k))\\r\\n # 1. filter out unnecessary keys\\r\\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\\r\\n # 2. overwrite entries in the existing state dict\\r\\n model_dict.update(pretrained_dict)\\r\\n # 3. load the new state dict\\r\\n model.load_state_dict(model_dict)\\r\\n return model\",\n \"def __init__(self, in_classes=1, channelscale=64):\\n super(DetectPatchAndSegm, self).__init__()\\n self.unetvgg1 = UNetSimple(in_classes=in_classes, channelscale=64, out_classes=2)#UNetVgg()\\n self.unetvgg2 = UNetSimple(in_classes=3, channelscale=128, out_classes=3)#in is 2 patches and original image\\n self.sft = nn.Softmax2d()\",\n \"def __init__(self, count, kernel_size, channels, padding_mode):\\n super().__init__()\\n self._count = count\\n self._kernel_size = kernel_size\\n self._channels = channels\\n self._padding_mode = padding_mode\\n\\n if kernel_size % 2 == 0:\\n raise ValueError('Kernel size must be an odd number')\\n\\n self._cnn_layers = []\\n\\n input_count = count\\n self._number_of_layers = 0\\n while input_count > 4:\\n next_power = self._next_power_of_two(input_count)\\n # Padding inputs to the target size 'pad_to' ensures that after applying\\n # convolution, the result is another power of two (< next_power).\\n pad_to = next_power + kernel_size - 1\\n pad_size = (pad_to - input_count) // 2\\n # If pad size is odd, pad asymmetrically.\\n extra_pad_right = (pad_to - input_count) % 2\\n padding = (pad_size, pad_size + extra_pad_right)\\n\\n self._cnn_layers.append(Pad1D(padding, padding_mode))\\n # Use valid to prevent automatic 0 padding.\\n self._cnn_layers.append(\\n tf.keras.layers.Conv1D(channels, kernel_size, padding='valid'))\\n # The output of the CNN is now an exact power of 2, so pooling reduces\\n # to the next smaller power of two.\\n self._cnn_layers.append(tf.keras.layers.MaxPool1D(pool_size=2))\\n input_count = next_power // 2\\n self._number_of_layers += 1\",\n \"def fcn32(vgg16, l2=0):\\n\\n x = keras.layers.Conv2D(filters=21, kernel_size=(1,1), strides=(1,1), padding='same', activation='linear',\\n kernel_initializer=keras.initializers.Zeros(),\\n kernel_regularizer=keras.regularizers.L2(l2=l2),\\n name='score7')(vgg16.get_layer('drop7').output)\\n\\n x = keras.layers.Conv2DTranspose(filters=21, kernel_size=(64,64), strides=(32,32),\\n padding='same', use_bias=False, activation='softmax',\\n kernel_initializer=BilinearInitializer(),\\n kernel_regularizer=keras.regularizers.L2(l2=l2),\\n name='fcn32')(x)\\n\\n return keras.Model(vgg16.input, x)\",\n \"def __init__(self, num_blocks=3, layers_per_block=2, base_num_channels=16,\\n upconv=False, fc_layer_sizes=None, upconv_reshape_size=None,\\n conditioning_layer_sizes=None, channels_out=3, alpha=0.3,\\n conditioning_postprocessing=None,\\n final_sigmoid=False, conditioning_type=\\\"mult_and_add\\\",\\n kernel_initializer_mode=\\\"fan_in\\\"):\\n\\n super(ConditionalConvnet, self).__init__()\\n self._num_blocks = num_blocks\\n self._layers_per_block = layers_per_block\\n self._base_num_channels = base_num_channels\\n self._channels_out = channels_out\\n self._upconv = upconv\\n self._fc_layer_sizes = fc_layer_sizes\\n self._upconv_reshape_size = upconv_reshape_size\\n self._final_sigmoid = final_sigmoid\\n if upconv_reshape_size is not None and ((not upconv) or\\n (fc_layer_sizes is None)):\\n raise ValueError(\\\"upconv_reshape_size should be supplied only if \\\"\\n \\\"upconv=True and fc_layer_sizes is not None.\\\")\\n self._conditioning_layer_sizes = conditioning_layer_sizes\\n self._nonlinearity = lambda x: tf.nn.leaky_relu(x, alpha)\\n if conditioning_postprocessing is not None:\\n self._conditioning_postprocessing = conditioning_postprocessing()\\n else:\\n self._conditioning_postprocessing = None\\n if conditioning_type not in [\\\"mult_and_add\\\", \\\"concat\\\", \\\"input\\\"]:\\n raise ValueError(\\\"Unknown conditioning_type {}\\\".format(conditioning_type))\\n self._conditioning_type = conditioning_type\\n scale_factor = 2. / (1. + alpha**2)\\n self._kernel_initializer = tf.keras.initializers.VarianceScaling(\\n mode=kernel_initializer_mode, scale=scale_factor)\",\n \"def __init__(self, input_dim, conv_layers, num_labels, batch_size):\\n super(CRF, self).__init__()\\n\\n self.input_dim = input_dim\\n self.crf_input_dim = None # Calculated inside init_params() based on Conv layer I/O dims\\n self.conv_layers = conv_layers\\n self.num_labels = num_labels\\n self.batch_size = batch_size\\n\\t\\t#Uncomment below and remove self.use_cuda=False once all tensors are set to run on cuda\\n #self.use_cuda = torch.cuda.is_available()\\n self.use_cuda=False\\n self.conv_objects = torch.nn.ModuleList() # Stores multiple Conv objects\\n self.Ks = [] # Stores multiple Conv filters\\n self.W = None # CRF parameter (node potential)\\n self.T = None # CRF parameter (transition weights between node pairs)\\n\\n ### Use GPU if available\\n if self.use_cuda:\\n [m.cuda() for m in self.modules()]\",\n \"def vgg16_bn(pretrained,**kwargs):\\n model = VGG(make_layers(cfg['D'], batch_norm=True), **kwargs)\\n if pretrained:\\n model_dict = paddle.load('./pre_model/vgg16_bn.paddle')\\n model.set_state_dict(model_dict)\\n return model\",\n \"def cnn_model_fn(features):\\n print(\\\"features shape\\\", features.shape)\\n\\n input_layer = tf.reshape(features, [-1, 28, 28, 1])\\n\\n conv1 = tf.layers.conv2d(inputs=input_layer, filters=64, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv1)\\n pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2, padding=\\\"same\\\")\\n print(pool1)\\n conv2 = tf.layers.conv2d(inputs=pool1, filters=128, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv2)\\n pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2, padding=\\\"same\\\")\\n print(pool2)\\n conv3 = tf.layers.conv2d(inputs=pool2, filters=256, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv3)\\n conv4 = tf.layers.conv2d(inputs=conv3, filters=256, kernel_size=[3, 3], padding=\\\"same\\\", activation=tf.nn.relu)\\n print(conv4)\\n pool3 = tf.layers.max_pooling2d(inputs=conv4, pool_size=[2, 2], strides=2, padding=\\\"same\\\")\\n print(pool3)\\n pool3_flat = tf.reshape(pool3, [-1, 4 * 4 * 256])\\n print(pool3_flat)\\n fc1 = tf.layers.dense(inputs=pool3_flat, units=1024, activation=tf.nn.relu)\\n print(fc1)\\n fc2 = tf.layers.dense(inputs=fc1, units=1024, activation=tf.nn.relu)\\n print(fc2)\\n fc2_bn = tf.nn.batch_normalization(x=fc2, mean=0, variance=1, scale=1, offset=0, variance_epsilon=1e-6)\\n print(fc2_bn)\\n fc3 = tf.layers.dense(inputs=fc2_bn, units=10)\\n print(fc3)\\n return fc3\",\n \"def __init__(self, num_gpus):\\n\\n super(Critic, self).__init__()\\n n_in = IMG_CHANNELS\\n n_out = 1\\n\\n feature_map = IMG_SIZE\\n kernel_size = 4\\n stride = 2\\n padding = 1\\n bias = False\\n\\n self.num_gpus = num_gpus\\n\\n self.network = nn.Sequential(\\n # nodes = IMG_CHANNELS * IMG_SIZE * IMG_SIZE\\n nn.Conv2d(n_in, feature_map, kernel_size, stride, padding, bias=bias),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = feature_map * 2\\n nn.Conv2d(feature_map, feature_map * 2, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 2),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = feature_map * 4\\n nn.Conv2d(feature_map * 2, feature_map * 4, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 4),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = feature_map * 8\\n nn.Conv2d(feature_map * 4, feature_map * 8, kernel_size, stride, padding, bias=bias),\\n nn.BatchNorm2d(feature_map * 8),\\n nn.LeakyReLU(0.2, inplace=True),\\n\\n # nodes = feature_map * 8\\n nn.Conv2d(feature_map * 8, n_out, kernel_size, 1, 0, bias=bias),\\n # scratched sigmoid activation function\\n )\",\n \"def build_model():\\n\\n if K.image_data_format() == 'channels_first':\\n input_shape = (3, img_width, img_height)\\n else:\\n input_shape = (img_width, img_height, 3)\\n\\n model = Sequential()\\n model.add(Conv2D(32, (3, 3), input_shape=input_shape))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n\\n model.add(Conv2D(32, (3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n\\n model.add(Conv2D(64, (3, 3)))\\n model.add(Activation('relu'))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n\\n model.add(Flatten())\\n\\n # FC layer\\n model.add(Dense(64))\\n model.add(Activation('relu'))\\n model.add(Dropout(0.5))\\n model.add(Dense(1))\\n model.add(Activation('sigmoid'))\\n\\n model.compile(loss='binary_crossentropy',\\n optimizer='adadelta',\\n metrics=['accuracy'])\\n\\n return model\",\n \"def __init__(self, n_filters = 64,\\n n_kernels = 3,\\n n_outputs = 10,\\n inp_shape = (28,28),\\n residual=True,\\n regularizer = None,\\n intializer = None,\\n use_pool= False,\\n use_dropout = False,\\n use_batchnorm = False\\n ):\\n super(CNNModel, self).__init__()\\n self.conv_dim = len(inp_shape)-1\\n self.n_filters = n_filters\\n self.initializer = intializer\\n self.n_kernels = n_kernels\\n self.projection = 3\\n self.n_outputs = n_outputs\\n self.num_layers = 1\\n self.inp_shape = inp_shape\\n self.regularizer = regularizer\\n self.use_pool = use_pool\\n self.residual = residual\\n self.use_dropout = use_dropout\\n self.use_batchnorm = use_batchnorm\\n\\n kernel_initializer = initializers.RandomNormal(mean=0.0, stddev=0.05)\\n\\n if self.conv_dim == 1:\\n self.input_layer = layers.Conv1D(self.n_filters, (self.projection),\\n activation = \\\"linear\\\",\\n input_shape = self.inp_shape,\\n name ='cnn_input',\\n padding = 'same',\\n kernel_regularizer = self.regularizer,\\n bias_regularizer = self.regularizer,\\n kernel_initializer=kernel_initializer,\\n bias_initializer=initializers.get(\\\"zeros\\\")\\n )\\n self.output_layer = layers.Conv1D(self.n_kernels, (self.projection),\\n activation=\\\"linear\\\",\\n input_shape=(None, self.inp_shape[0], self.n_filters),\\n name='cnn_output',\\n padding = 'same',\\n kernel_regularizer=self.regularizer,\\n bias_regularizer=self.regularizer,\\n kernel_initializer=kernel_initializer,\\n bias_initializer=initializers.get(\\\"zeros\\\")\\n )\\n if self.use_pool:\\n self.pool = layers.MaxPool1D()\\n elif self.conv_dim == 2:\\n self.input_layer = layers.Conv2D(self.n_filters, (self.projection,self.projection),\\n activation=\\\"linear\\\",\\n input_shape=self.inp_shape,\\n name='cnn_input',\\n padding = 'same',\\n kernel_regularizer=self.regularizer,\\n bias_regularizer=self.regularizer,\\n kernel_initializer=kernel_initializer,\\n bias_initializer=initializers.get(\\\"zeros\\\")\\n )\\n self.output_layer = layers.Conv2D(self.n_kernels, (self.projection, self.projection),\\n activation= \\\"linear\\\",\\n input_shape=(None, self.inp_shape[0],self.inp_shape[1], self.n_filters),\\n name=\\\"cnn_output\\\",\\n padding = 'same',\\n kernel_regularizer=self.regularizer,\\n bias_regularizer=self.regularizer,\\n kernel_initializer=kernel_initializer,\\n bias_initializer=initializers.get(\\\"zeros\\\")\\n )\\n if self.use_pool:\\n self.pool = layers.MaxPool2D()\\n self.list_cnn = [self.input_layer]\\n self.flatten = layers.Flatten()\\n\\n #compute input shape after flatten for the dense layer\\n if not self.use_pool:\\n self.class_inp = np.prod(self.inp_shape[:-1])*self.n_kernels\\n else:\\n self.class_inp = np.prod(self.inp_shape[:-1])*self.n_kernels//(2**self.conv_dim)\\n # self.classify = MyDenseLayer(\\n # self.n_outputs,shape = (None,self.class_inp),\\n # layer_name = 'classify',\\n # initializer = \\\"RandomNormal\\\")\\n self.classify = layers.Dense(units = self.n_outputs,\\n activation = 'softmax', use_bias = True,\\n input_shape = self.class_inp,\\n kernel_initializer = kernel_initializer, bias_initializer=initializers.get(\\\"zeros\\\"),\\n name = 'classification_layer')\",\n \"def __init__(self, input_dim=(3, 32, 32), num_filters=32, filter_size=7,\\n hidden_dim=100, num_classes=10, weight_scale=1e-3, reg=0.0,\\n dtype=np.float32):\\n self.params = {}\\n self.reg = reg\\n self.dtype = dtype\\n \\n ############################################################################\\n # TODO: Initialize weights and biases for the three-layer convolutional #\\n # network. Weights should be initialized from a Gaussian with standard #\\n # deviation equal to weight_scale; biases should be initialized to zero. #\\n # All weights and biases should be stored in the dictionary self.params. #\\n # Store weights and biases for the convolutional layer using the keys 'W1' #\\n # and 'b1'; use keys 'W2' and 'b2' for the weights and biases of the #\\n # hidden affine layer, and keys 'W3' and 'b3' for the weights and biases #\\n # of the output affine layer. #\\n ############################################################################ \\n C, H, W = input_dim;\\n\\n # Dimensions of data output by convolutional layer\\n S = 1; pad = (filter_size - 1) / 2; # Stride and image padding\\n hconv = (H - filter_size + 2*pad)/S + 1;\\n wconv = (W - filter_size + 2*pad)/S + 1;\\n\\n # Get dimensions of 2x2 max-pool output\\n hmp = hconv / 2;\\n wmp = wconv / 2;\\n\\n # Get dimensions of vector fed into affine layer\\n # Convert maxpool output by using np.reshape(v1,(N,-1))\\n # Recover by using np.reshape(dv1,v1.shape)\\n laff = hmp*wmp*num_filters;\\n\\n # Determine starting weight and bias matrices\\n self.params['W1'] = weight_scale * np.random.randn(num_filters, C, filter_size, filter_size);\\n self.params['b1'] = np.zeros(num_filters);\\n self.params['W2'] = weight_scale * np.random.randn(laff, hidden_dim);\\n self.params['b2'] = np.zeros(hidden_dim);\\n self.params['W3'] = weight_scale * np.random.rand(hidden_dim,num_classes);\\n self.params['b3'] = np.zeros(num_classes);\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n for k, v in self.params.iteritems():\\n self.params[k] = v.astype(dtype)\",\n \"def __init__(self):\\n super(CNN, self).__init__()\\n\\n self.conv0 = nn.Conv2d(3, 3, kernel_size=5, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv0.weight)\\n\\n self.conv1 = nn.Conv2d(3, 30, kernel_size=5, stride=2, padding=0)\\n self.conv1.weight = nn.Parameter(get_filters())\\n\\n self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\\n\\n self.conv2 = nn.Conv2d(30, 16, kernel_size=3, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv2.weight)\\n\\n self.conv3 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv3.weight)\\n\\n self.conv4 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv4.weight)\\n\\n self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)\\n\\n self.conv5 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv5.weight)\\n\\n self.conv6 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv6.weight)\\n\\n self.conv7 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv7.weight)\\n\\n self.conv8 = nn.Conv2d(16, 16, kernel_size=3, stride=1, padding=0)\\n nn.init.xavier_uniform_(self.conv8.weight)\\n\\n self.fc = nn.Linear(16 * 5 * 5, 2)\\n\\n self.drop1 = nn.Dropout(p=0.5) # used only for the NC dataset\",\n \"def get_network(x):\\n n_classes = 5\\n batch_size = x.get_shape().as_list()[0]\\n channels = x.get_shape().as_list()[3]\\n\\n # Model Helpers --------------------------------------------------------\\n\\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#conv2d\\n def conv2d(img, w, b):\\n \\n x = tf.nn.conv2d(img, w, strides=[1, 1, 1, 1], padding='VALID')\\n z = tf.nn.bias_add(x, b)\\n return tf.nn.relu(z)\\n\\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#max_pool\\n def max_pool(img, k):\\n ks = [1, k, k, 1]\\n return tf.nn.max_pool(img, ksize=ks, strides=ks, padding='VALID')\\n\\n # TODO implement\\n def maxout(x):\\n raise NotImplemented()\\n\\n def fc(x, w, b, act):\\n if act:\\n return act(tf.add(tf.matmul(x, w), b))\\n else:\\n return tf.add(tf.matmul(x, w), b)\\n\\n def conv_net(_X, _weights, _biases):\\n # First convolution layer\\n #print 'x: {}'.format(_X.get_shape())\\n \\n conv1 = conv2d(_X, _weights['wc1'], _biases['bc1'])\\n # k used to be 2\\n conv1 = max_pool(conv1, k=2)\\n\\n #print 'conv1: {}'.format(conv1.get_shape())\\n\\n # Second Covolution layer\\n conv2 = conv2d(conv1, _weights['wc2'], _biases['bc2'])\\n conv2 = max_pool(conv2, k=2)\\n\\n #print 'conv2: {}'.format(conv2.get_shape())\\n\\n # Thrid Convolution Layer\\n conv3 = conv2d(conv2, _weights['wc3'], _biases['bc3'])\\n\\n #print 'conv3: {}'.format(conv3.get_shape())\\n\\n # Fourth Convolution Layer\\n conv4 = conv2d(conv3, _weights['wc4'], _biases['bc4'])\\n conv4 = max_pool(conv4, k=2)\\n\\n #print 'conv4: {}'.format(conv4.get_shape())\\n\\n # In the paper the FC layers suggest that you use maxout, but\\n # there isn't a native maxout in TensorFlow, so I used ReLU for now.\\n\\n # First Fully Connected Layer, flatten out filters first\\n fc1 = tf.reshape(conv4, [batch_size, -1])\\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#relu\\n fc1 = fc(fc1, _weights['wf1'], _biases['bf1'], tf.nn.relu)\\n # TODO dropout should be a parameter\\n fc1 = tf.nn.dropout(fc1, tf.Variable(tf.constant(0.5)))\\n\\n\\n # Second Fully Connected Layer\\n fc2 = fc(fc1, _weights['wf2'], _biases['bf2'], tf.nn.relu)\\n # TODO dropout should be a parameter\\n fc2 = tf.nn.dropout(fc2, tf.Variable(tf.constant(0.5)))\\n\\n # Output\\n # https://www.tensorflow.org/versions/r0.8/api_docs/python/nn.html#sigmoid\\n output = fc(fc2, _weights['out'], _biases['out'], None)\\n return output\\n\\n # Model Helpers --------------------------------------------------------\\n\\n\\n # Model weights and biases\\n weights = {\\n # 6x6 conv, 3-channel input, 32-channel outputs\\n 'wc1': tf.Variable(tf.truncated_normal([3, 3, channels, 32], stddev=0.01)), #0.01\\n # 5x5 conv, 32-channel inputs, 64-channel outputs\\n 'wc2': tf.Variable(tf.truncated_normal([5, 5, 32, 64], stddev=0.01)), #0.01\\n # 3x3 conv, 64-channel inputs, 128-channel outputs\\n 'wc3': tf.Variable(tf.truncated_normal([3, 3, 64, 128], stddev=0.01)), #0.01\\n # 3x3 conv, 128-channel inputs, 128-channel outputs\\n 'wc4': tf.Variable(tf.truncated_normal([3, 3, 128, 128], stddev=0.1)), #0.1\\n # fully connected, 512 inputs, 2048 outputs\\n # was 4608 for 84x84\\n 'wf1': tf.Variable(tf.truncated_normal([6272, 2048], stddev=0.001)), #0.001\\n # fully coneected 2048 inputs, 2048 outputs\\n 'wf2': tf.Variable(tf.truncated_normal([2048, 2048], stddev=0.001)), #0.001\\n # 2048 inputs, 5 outputs (class prediction)\\n 'out': tf.Variable(tf.truncated_normal([2048, n_classes], stddev=0.01)) #0.01\\n }\\n\\n biases = {\\n 'bc1': tf.Variable(tf.constant(0.1, shape=[32])),\\n 'bc2': tf.Variable(tf.constant(0.1, shape=[64])),\\n 'bc3': tf.Variable(tf.constant(0.1, shape=[128])),\\n 'bc4': tf.Variable(tf.constant(0.1, shape=[128])),\\n 'bf1': tf.Variable(tf.constant(0.01, shape=[2048])),\\n 'bf2': tf.Variable(tf.constant(0.01, shape=[2048])),\\n 'out': tf.Variable(tf.constant(0.1, shape=[n_classes]))\\n }\\n\\n return conv_net(x, weights, biases)\",\n \"def cifar10_5layers(input_image, keep_prob, init_method=tf.truncated_normal_initializer(stddev=1e-2)):\\n with tf.variable_scope(\\\"conv1\\\"):\\n W1 = tf.get_variable(name=\\\"W1\\\", shape=[5,5,3,32], dtype=tf.float32, \\\\\\n initializer=init_method)\\n b1 = tf.get_variable(name=\\\"b1\\\", shape=[32], dtype=tf.float32, \\\\\\n initializer=tf.constant_initializer(0.01))\\n conv1 = conv_pool_relu(input_image, W1, b1)\\n with tf.variable_scope(\\\"conv2\\\"):\\n W2 = tf.get_variable(name=\\\"W2\\\", shape=[5,5,32,64], dtype=tf.float32, \\\\\\n initializer=init_method)\\n b2 = tf.get_variable(name=\\\"b2\\\", shape=[64], dtype=tf.float32, \\\\\\n initializer=tf.constant_initializer(0.01))\\n conv2 = conv_pool_relu(conv1, W2, b2)\\n\\tconv2 = tf.nn.dropout(conv2, keep_prob)\\n with tf.variable_scope(\\\"conv3\\\"):\\n W3 = tf.get_variable(name=\\\"W3\\\", shape=[5,5,64,128], dtype=tf.float32, \\\\\\n initializer=init_method)\\n b3 = tf.get_variable(name=\\\"b3\\\", shape=[128], dtype=tf.float32, \\\\\\n initializer=tf.constant_initializer(0.01))\\n conv3 = conv_pool_relu(conv2, W3, b3)\\n\\tconv3 = tf.nn.dropout(conv3, keep_prob)\\n with tf.variable_scope(\\\"fc1\\\"):\\n W4 = tf.get_variable(name=\\\"W4\\\", shape=[4*4*128,256], dtype=tf.float32, \\\\\\n initializer=init_method)\\n b4 = tf.get_variable(name=\\\"b4\\\", shape=[256], dtype=tf.float32, \\\\\\n initializer=tf.constant_initializer(0.01))\\n conv3_flat = tf.reshape(conv3, [-1, 4*4*128])\\n fc1 = fc_relu(conv3_flat, W4, b4)\\n\\tfc1 = tf.nn.dropout(fc1, keep_prob)\\n with tf.variable_scope(\\\"output\\\"):\\n W5 = tf.get_variable(name=\\\"W5\\\", shape=[256,10], dtype=tf.float32, \\\\\\n initializer=init_method)\\n b5 = tf.get_variable(name=\\\"b5\\\", shape=[10], dtype=tf.float32, \\\\\\n initializer=tf.constant_initializer(0.01))\\n\\ty_logit = tf.matmul(fc1, W5) + b5\\n return y_logit, tf.nn.softmax(y_logit, name=\\\"softmax\\\")\",\n \"def detection_head_graph(self, feature_map, filters):\\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"stage_1\\\", use_bias=True, padding=\\\"same\\\")(feature_map)\\n x = KL.Activation('relu', name='detection_head_stage_1_activation')(x)\\n x = KL.Conv2D(filters, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"stage_2\\\", use_bias=True, padding=\\\"same\\\")(x)\\n x = KL.Activation('relu', name='detection_head_stage_2_activation')(x)\\n x = KL.Conv2D(3, (1, 1), strides=(1, 1),\\n name=\\\"detection_head_\\\" + \\\"final_stage\\\", use_bias=True, padding=\\\"same\\\")(x)\\n return x\",\n \"def encode(self, img):\\n with tf.variable_scope('encoder'):\\n #conv1 = self.conv_layer(\\n # img, [5, 5], [3, 32], stride=2, initializer_type=1, name='conv1')\\n #conv2 = self.conv_layer(\\n # conv1, [5, 5], [32, 32], stride=2, initializer_type=1, name='conv2')\\n conv3 = self.conv_layer(\\n img, [5, 5], [self.in_channels, 64], stride=2, initializer_type=1, name='conv3')\\n #conv4 = self.conv_bn_layer(\\n conv4 = self.conv_layer(\\n conv3, [5, 5], [64, 128], stride=2, #is_training=self.is_training,\\n initializer_type=1, name='conv4')\\n #conv5 = self.conv_bn_layer(\\n conv5 = self.conv_layer(\\n conv4, [5, 5], [128, 256], stride=2, #is_training=self.is_training,\\n initializer_type=1, name='conv5')\\n shape = conv5.get_shape().as_list()\\n feature_map_size = shape[1]*shape[2]*shape[3]\\n conv5_flat = tf.reshape(\\n conv5, [-1, feature_map_size], 'conv5_flat')\\n #fc6 = self.fc_bn_layer(conv5_flat, 1024, is_training=self.is_training,\\n fc6 = self.fc_layer(conv5_flat, 1024,\\n initializer_type=1, name='fc6')\\n #fc7 = self.fc_layer(fc6, 1024, initializer_type=1, name='fc7')\\n return fc6, shape\",\n \"def VGG(model_type='D', dropout=0.5, num_classes=1000, input_shape=(224, 224, 3)):\\n \\n model_type = model_type.upper()\\n assert model_type in ['A', 'B', 'C', 'D', 'E'], \\\"Invalid value of 'model_type'\\\\n\\\" \\\\\\n \\\"It should be one of {'A', 'B', 'C', 'D', 'E'}\\\"\\n \\n assert (type(input_shape) == tuple), \\\"Invalid value of 'input_shape'\\\\n\\\" \\\\\\n \\\"It should be of form (<image_height>, <image_width>, <channels>)\\\"\\n \\n assert (len(input_shape) == 3), \\\"Invalid value of 'input_shape'\\\\n\\\" \\\\\\n \\\"It should be of form (<image_height>, <image_width>, <channels>)\\\"\\n \\n if(dropout != None):\\n assert ((type(dropout) == float) and (0 <= dropout <= 1)), \\\"Invalid value of 'dropout'.\\\\n\\\" \\\\\\n \\\"It should be a real number between 0 and 1 (inclusive).\\\"\\n\\n # Implementing the model\\n model = Sequential()\\n\\n model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu', input_shape=input_shape))\\n if model_type in ['B', 'C', 'D', 'E']:\\n model.add(Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['B', 'C', 'D', 'E']:\\n model.add(Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['C']:\\n model.add(Conv2D(filters=256, kernel_size=(1, 1), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['D', 'E']:\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['E']:\\n model.add(Conv2D(filters=256, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['C']:\\n model.add(Conv2D(filters=512, kernel_size=(1, 1), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['D', 'E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['C']:\\n model.add(Conv2D(filters=512, kernel_size=(1, 1), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['D', 'E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n if model_type in ['E']:\\n model.add(Conv2D(filters=512, kernel_size=(3, 3), strides=(1, 1), padding='same', \\n activation='relu'))\\n model.add(MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))\\n\\n model.add(Flatten())\\n model.add(Dense(units=4096, activation='relu'))\\n if(dropout != None):\\n model.add(Dropout(dropout))\\n model.add(Dense(units=4096, activation='relu'))\\n if(dropout != None):\\n model.add(Dropout(dropout))\\n model.add(Dense(units=num_classes, activation='softmax'))\\n\\n return model\",\n \"def build_model(img_width,\\n\\timg_height,\\n\\tchannels,\\n\\tnum_classes,\\n\\tlr=1e-5,\\n\\tfreeze=False):\\n\\n\\tvgg_model = VGG16(include_top=False, weights='imagenet', input_shape=(img_width, img_height, channels))\\n\\n\\tvgg_output = vgg_model.output\\n\\tdrop0 = Dropout(0.5)(vgg_output)\\n\\tflat = Flatten()(drop0)\\n\\tdense1 = Dense(512, activation='relu')(flat)\\n\\tdrop1 = Dropout(0.5)(dense1)\\n\\tpredictions = Dense(num_classes, activation='softmax')(drop1)\\n\\n\\tmodel = Model(inputs=vgg_model.input, outputs=predictions)\\n\\t\\n\\tif freeze:\\n\\t\\tfor layer in vgg_model.layers:\\n\\t\\t\\tlayer.trainable = False\\n\\n\\tmodel.summary()\\n\\tadam = Adam(lr=lr, decay=1e-6)\\n\\tmodel.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy'])\\n\\treturn model\",\n \"def build_cnn_layer(embedding_layer, config):\\n layers = []\\n for i in range(len(config['filters'])):\\n cnn_layer = tf.keras.layers.Conv1D(\\n kernel_regularizer=tf.keras.regularizers.l2(0.0001),\\n activation='relu', filters=config['filters'][i],\\n kernel_size=config['kernel_size'][i],\\n name='cnn_layer_{}'.format(i + 1))(embedding_layer)\\n pooling_layer = tf.keras.layers.MaxPool1D(\\n name='max_pool_layer_{}'.format(i + 1))(cnn_layer)\\n flatten_layer = tf.keras.layers.Flatten(\\n name='flatten_{}'.format(i + 1))(pooling_layer)\\n layers.append(flatten_layer)\\n return tf.keras.layers.Concatenate(name='concat_layer')(layers)\",\n \"def init_encoder(self):\\n\\n vgg = models.vgg16(pretrained=True)\\n\\n blocks = [self.layer_1,\\n self.layer_2,\\n self.layer_3,\\n self.layer_4,\\n self.layer_5]\\n\\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\\n features = list(vgg.features.children())\\n\\n vgg_layers = []\\n for _layer in features:\\n if isinstance(_layer, nn.Conv2d):\\n vgg_layers.append(_layer)\\n\\n merged_layers = []\\n for idx, conv_block in enumerate(blocks):\\n if idx < 2:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit]\\n else:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit,\\n conv_block.conv3.cbr_unit]\\n for _unit in units:\\n for _layer in _unit:\\n if isinstance(_layer, nn.Conv2d):\\n merged_layers.append(_layer)\\n\\n assert len(vgg_layers) == len(merged_layers)\\n\\n for l1, l2 in zip(vgg_layers, merged_layers):\\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\\n assert l1.weight.size() == l2.weight.size()\\n assert l1.bias.size() == l2.bias.size()\\n l2.weight.data = l1.weight.data\\n l2.bias.data = l1.bias.data\\n\\n blocks = [self.layer_11,\\n self.layer_12,\\n self.layer_13,\\n self.layer_14,\\n self.layer_15]\\n\\n ranges = [[0, 4], [5, 9], [10, 16], [17, 23], [24, 29]]\\n features = list(vgg.features.children())\\n\\n vgg_layers = []\\n for _layer in features:\\n if isinstance(_layer, nn.Conv2d):\\n vgg_layers.append(_layer)\\n\\n merged_layers = []\\n for idx, conv_block in enumerate(blocks):\\n if idx < 2:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit]\\n else:\\n units = [conv_block.conv1.cbr_unit,\\n conv_block.conv2.cbr_unit,\\n conv_block.conv3.cbr_unit]\\n for _unit in units:\\n for _layer in _unit:\\n if isinstance(_layer, nn.Conv2d):\\n merged_layers.append(_layer)\\n\\n assert len(vgg_layers) == len(merged_layers)\\n\\n for l1, l2 in zip(vgg_layers, merged_layers):\\n if isinstance(l1, nn.Conv2d) and isinstance(l2, nn.Conv2d):\\n assert l1.weight.size() == l2.weight.size()\\n assert l1.bias.size() == l2.bias.size()\\n l2.weight.data = l1.weight.data\\n l2.bias.data = l1.bias.data\",\n \"def build(imageWidth, imageHeight, imageDepth, classesNumber, finalAct=\\\"sigmoid\\\"):\\n\\n # inizializzo il modello come sequenziale\\n model = Sequential()\\n inputShape = (imageHeight, imageWidth, imageDepth)\\n chanDim = -1\\n\\n # Primo blocco Conv2D, Relu, Normalization, MaxPool\\n # Utilizzo 32 filtri 3*3\\n model.add(Conv2D(filters=32, kernel_size=(3, 3), padding=\\\"same\\\", input_shape=inputShape))\\n # con attivazione Rectified Linear Unit\\n model.add(Activation(\\\"relu\\\"))\\n # applico una batch normalization\\n model.add(BatchNormalization(axis=chanDim))\\n # un MaxPooling 3*3\\n model.add(MaxPooling2D(pool_size=(3, 3)))\\n # ed un 25% di dropout per ridurre overfitting\\n model.add(Dropout(0.25))\\n\\n # Secondo blocco\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(64, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Terzo blocco\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(Conv2D(128, (3, 3), padding=\\\"same\\\"))\\n model.add(Activation(\\\"relu\\\"))\\n model.add(BatchNormalization(axis=chanDim))\\n model.add(MaxPooling2D(pool_size=(2, 2)))\\n model.add(Dropout(0.25))\\n\\n # Passo ai Fully Connected Layers\\n # Trasformo il modello in un vettore\\n model.add(Flatten())\\n model.add(Dense(1024))\\n model.add(Activation(\\\"sigmoid\\\"))\\n model.add(BatchNormalization())\\n model.add(Dropout(0.5))\\n\\n # Infine utilizzo l'attivazione per la rete\\n model.add(Dense(classesNumber))\\n model.add(Activation(finalAct))\\n\\n return model\",\n \"def keras_add_layers(model, num_classes, keep_prob):\\n # DONE: Implement function\\n\\n # See also lesson \\\"FCN-8 Decoder\\\" for structure, and Long_Shelhamer paper\\n\\n # Walkthrough video started with 1x1 convolution like this, but notes explained\\n # that was already done for us (loaded model is not ordinary VGG but already\\n # adapted for FCN). In fact the VGG network provided looks very much like\\n # the one generated by the Single-Shot Detector caffe code, so I guess they\\n # share some common heritage.\\n #conv_1x1 = tf.layers.conv2d(vgg_layer7_out, # at/near end of VGG\\n # num_classes, # just road/nonroad for us\\n # 1, # as 1x1 conv\\n # padding='same',\\n # kernel_regularizer = tf.contrib.layers.l2_regularizer(1e-3))\\n\\n # Using Tensorboard to visualise the structure of the Udacity VGG model provided, and\\n # tf.trainable_variables() to list the dimensions and sizes of the weights and biases\\n # for each layer, I arrive at this summary of what shape the output of each layer\\n # is (knowing that we started with a 160 height x 576 width x 3 colour channel image).\\n # All of the convolution layers have SAME padding and [1,1,1,1] strides so they\\n # don't reduce the x-y pixel size. All the pooling layers have [1,2,2,1] strides so\\n # they halve the pixel size. I'm ignoring the first dimension (across images), as\\n # everything works on one image at a time.\\n #\\n # Layer name Details Output dimensions\\n # <input> raw image 160x576x3\\n # conv1_1 conv2d 3x3x3x64, Relu 160x576x64\\n # conv1_2 conv2d 3x3x64x64, Relu 160x576x64\\n # pool1 pool [1,2,2,1] 80x288x64\\n # conv2_1 conv2d 3x3x64x128, Relu 80x288x128\\n # conv2_2 conv2d 3x3x128x128, Relu 80x288x128\\n # pool2 pool [1,2,2,1] 40x144x128\\n # conv3_1 conv2d 3x3x128x256, Relu 40x144x256\\n # conv3_2 conv2d 3x3x256x256, Relu 40x144x256\\n # conv3_3 conv2d 3x3x256x256, Relu 40x144x256\\n # pool3 pool [1,2,2,1] 20x72x256 --> layer3_out\\n # conv4_1 conv2d 3x3x256x512, Relu 20x72x512\\n # conv4_2 conv2d 3x3x512x512, Relu 20x72x512\\n # conv4_3 conv2d 3x3x512x512, Relu 20x72x512\\n # pool4 pool [1,2,2,1] 10x36x512 --> layer4_out\\n # conv5_1 conv2d 3x3x512x512, Relu 10x36x512\\n # conv5_2 conv2d 3x3x512x512, Relu 10x36x512\\n # conv5_3 conv2d 3x3x512x512, Relu 10x36x512\\n # pool5 pool [1,2,2,1] 5x18x512\\n # fc6 conv2d 7x7x512x4096, Relu 5x18x4096\\n # dropout dropout(keep_prob) 5x18x4096\\n # fc7 conv2d 1x1x4096x4096, Relu 5x18x4096\\n # dropout_1 dropout(keep_prob) 5x18x4096 --> layer7_out\\n # layer8 conv2d_t 10x36\\n\\n layer3_out = model.get_layer('block3_pool').output\\n layer4_out = model.get_layer('block4_pool').output\\n\\n # Problem here: TF2 library model doesn't have image-shaped layers 6 & 7 like\\n # model provided originally with TF1, but instead is flattened amporphous classifier.\\n # So we're working with more 'raw' layer as input. TODO should add back\\n # two conv2d layers before this to be like the original\\n drop_prob = 1.0 - keep_prob\\n\\n layer5 = model.get_layer('block5_pool')\\n\\n layer6_conv = tf.keras.layers.Conv2D(4096,\\n 7, # 7x7 patch from original Udacity model\\n strides=(1,1),\\n padding='same',\\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)), # guess same as others\\n name='layer6_conv')\\n\\n layer6_dropout = tf.keras.layers.Dropout(drop_prob, name=\\\"layer6_dropout\\\")\\n\\n layer7_conv = tf.keras.layers.Conv2D(4096,\\n 1, # 1x1 patch from original Udacity model\\n strides=(1,1),\\n padding='same',\\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)), # guess\\n name='layer7_conv')\\n\\n layer7_dropout = tf.keras.layers.Dropout(drop_prob, name=\\\"layer7_dropout\\\")\\n\\n # Connect up the new layers\\n x = layer6_conv(layer5.output)\\n x = layer6_dropout(x)\\n x = layer7_conv(x)\\n layer7 = layer7_dropout(x)\\n\\n # Create a new model\\n mod_model = tf.keras.Model(inputs=model.input, outputs=layer7)\\n\\n # We should now have the same structure as the original Udacity version of VGG16,\\n # but still need to add the decoder and skip connections as before\\n\\n # Upsample by 2. We need to work our way down from a kernel depth of 4096\\n # to just our number of classes (i.e. 2). Should we do this all in one go?\\n # Or keep more depth in as we work upwards? For now doing it all in one hit.\\n layer8 = tf.keras.layers.Conv2DTranspose(num_classes, #filters, \\n 4, # kernel size taken from classroom example, might experiment\\n strides=2, # stride causes upsampling\\n padding='same',\\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\\n name='layer8')\\n\\n # Now we're at 10x36x2 so we have same pixel resolution as layer4_out. Can't directly add\\n # in layer4_out because it has filter depth of 512. (Though we could have had our transpose\\n # convolution only downsample to 512 for compatibility... might try that later)\\n\\n # Squash layer4 output with 1x1 convolution so that it has compatible filter depth (i.e. num_classes)\\n layer4_squashed = tf.keras.layers.Conv2D(num_classes, # new number of filters,\\n 1, # 1x1 convolution so kernel size 1\\n padding='same',\\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\\n name='layer4_squashed')\\n # upsample by 2\\n layer9 = tf.keras.layers.Conv2DTranspose(num_classes, # filters\\n 4, # kernel size taken from classroom example\\n strides=(2,2), # stride causes upsampling\\n padding='same',\\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\\n name='layer9')\\n\\n # Now we're at 20x72x2 so same pixel resolution as layer3_out, but need to squash that from\\n # 256 filters to 2 (num_classes) before we can add it in as skip connection\\n layer3_squashed = tf.keras.layers.Conv2D(num_classes, # new number of filters\\n 1, # 1x1 convolution so kernel size 1\\n padding='same',\\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\\n name='layer3_squashed')\\n\\n # upsample by 8 to get back to original image size\\n layer10 = tf.keras.layers.Conv2DTranspose(num_classes,\\n 32, # Finding quite large kernel works nicely\\n strides=(8,8), # stride causes upsampling\\n padding='same',\\n kernel_regularizer = tf.keras.regularizers.l2(0.5 * (1e-3)),\\n name='layer10')\\n\\n # so now we should be at 160x576x2, same as original image size, 2 classes\\n\\n # Connect the layers\\n x1 = layer8(layer7)\\n x2 = layer4_squashed(layer4_out)\\n\\n # now we can add skip layer of this dimension taken from corresponding encoder layer\\n layer8_plus_layer4 = tf.keras.layers.add([x1, x2], name='layer8_plus_layer4')\\n #layer8_plus_layer4 = tf.add(layer8, layer4_squashed, name='layer8_plus_layer4')\\n\\n x1 = layer9(layer8_plus_layer4)\\n x2 = layer3_squashed(layer3_out)\\n\\n # now we can add skip layer of this dimension taken from corresponding encoder layer\\n layer9_plus_layer3 = tf.keras.layers.add([x1, x2], name='layer9_plus_layer3')\\n #layer9_plus_layer3 = tf.add(layer9, layer3_squashed, name='layer9_plus_layer3')\\n\\n predictors = layer10(layer9_plus_layer3) # layer 10 should be same size as image\\n\\n # Create a new model\\n mod_model = tf.keras.Model(inputs=model.input, outputs=predictors)\\n print(\\\"Model after adding decoder layers:\\\")\\n mod_model.summary()\\n\\n return mod_model\",\n \"def keras_functional_conv_net():\\n inputs = tf.keras.layers.Input(shape=(28, 28, 3))\\n x = tf.keras.layers.Conv2D(4, kernel_size=3, activation=None)(inputs)\\n x = tf.keras.layers.BatchNormalization()(x)\\n x = tf.keras.layers.Activation(\\\"relu\\\")(x)\\n x = tf.keras.layers.Conv2D(16, kernel_size=3, activation=None)(x)\\n x = tf.keras.layers.BatchNormalization()(x)\\n x = tf.keras.layers.PReLU()(x)\\n x = tf.keras.layers.Conv2D(16, kernel_size=3, activation=None)(x)\\n outputs = tf.keras.layers.Conv2D(32, kernel_size=3, activation=\\\"relu\\\")(x)\\n model = tf.keras.Model(inputs=inputs, outputs=outputs)\\n\\n return model\",\n \"def __init__(self):\\r\\n torch.nn.Module.__init__(self)\\r\\n # Convolution and pooling layers of VGG-16.\\r\\n self.features = torchvision.models.vgg19_bn(pretrained=False).features\\r\\n self.features = torch.nn.Sequential(*list(self.features.children())\\r\\n [:-1]) # Remove pool5.\\r\\n # Linear classifier.\\r\\n self.fc = torch.nn.Linear(512**2, 11)\",\n \"def __init__(self, options):\\r\\n nn.Module.__init__(self)\\r\\n # Convolution and pooling layers of VGG-16.\\r\\n self.basemodel = torchvision.models.resnet18(pretrained=True)\\r\\n self.options = options\\r\\n\\r\\n #label\\r\\n self.label_primary = nn.Linear(options['primary_dim'], options['proj_dim'])\\r\\n self.label_dual = nn.Linear(options['dual_dim'], options['proj_dim'])\\r\\n\\r\\n #classifer/regressor\\r\\n self.fc_primary = nn.Linear(512 + options['proj_dim'], options['primary_dim'])\\r\\n self.fc_dual = nn.Linear(512 + options['proj_dim'], options['dual_dim'])\\r\\n\\r\\n\\r\\n if self.options['fc'] == True:\\r\\n # Freeze all previous layers.\\r\\n for param in self.basemodel.parameters():\\r\\n param.requires_grad = False\\r\\n # Initialize the fc layers.\\r\\n nn.init.kaiming_normal_(self.fc_primary.weight.data)\\r\\n if self.fc_primary.bias is not None:\\r\\n nn.init.constant_(self.fc_primary.bias.data, val=0)\\r\\n\\r\\n nn.init.kaiming_normal_(self.fc_dual.weight.data)\\r\\n if self.fc_dual.bias is not None:\\r\\n nn.init.constant_(self.fc_dual.bias.data, val=0)\\r\\n\\r\\n nn.init.kaiming_normal_(self.label_primary.weight.data)\\r\\n if self.label_primary.bias is not None:\\r\\n nn.init.constant_(self.label_primary.bias.data, val=0)\\r\\n\\r\\n nn.init.kaiming_normal_(self.label_dual.weight.data)\\r\\n if self.label_dual.bias is not None:\\r\\n nn.init.constant_(self.label_dual.bias.data, val=0)\\r\\n\\r\\n\\r\\n else:\\r\\n for param in self.basemodel.conv1.parameters():\\r\\n param.requires_grad = False\\r\\n for param in self.basemodel.bn1.parameters():\\r\\n param.requires_grad = False\\r\\n for param in self.basemodel.layer1.parameters():\\r\\n param.requires_grad = False\\r\\n #for param in self.basemodel.layer2.parameters():\\r\\n # param.requires_grad = False\\r\\n #for param in self.basemodel.layer3.parameters():\\r\\n # param.requires_grad = False\\r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7441737","0.7329161","0.6902189","0.6832145","0.6800463","0.6664944","0.66505325","0.6622111","0.66121346","0.6557664","0.6509413","0.6507075","0.6500263","0.6457403","0.6448143","0.64436185","0.63982594","0.63637847","0.6361868","0.6351918","0.63231635","0.6312071","0.6308179","0.6300375","0.6292683","0.6268657","0.6261957","0.6257955","0.61618257","0.61575425","0.61519444","0.61424094","0.61420083","0.613279","0.61233884","0.6121265","0.6114862","0.6095126","0.6090032","0.6050108","0.6041173","0.60232735","0.6023015","0.6018335","0.60144866","0.60063905","0.5998461","0.5989758","0.59866303","0.5975711","0.5964234","0.5961319","0.5949383","0.5942972","0.5938511","0.59280837","0.5908122","0.59040797","0.5898722","0.5894342","0.58931994","0.58908755","0.5887949","0.5878947","0.5877685","0.58775187","0.58771694","0.5873496","0.58674026","0.5864918","0.5864437","0.58534133","0.58419013","0.5840927","0.5830197","0.58200896","0.58182615","0.58181536","0.5812363","0.58056414","0.5805597","0.58028865","0.58023816","0.58014","0.5797357","0.57901657","0.5786531","0.5781041","0.578047","0.5779705","0.5772775","0.5769006","0.57642347","0.5763097","0.57562244","0.575381","0.57529944","0.5751666","0.5745783","0.5744431"],"string":"[\n \"0.7441737\",\n \"0.7329161\",\n \"0.6902189\",\n \"0.6832145\",\n \"0.6800463\",\n \"0.6664944\",\n \"0.66505325\",\n \"0.6622111\",\n \"0.66121346\",\n \"0.6557664\",\n \"0.6509413\",\n \"0.6507075\",\n \"0.6500263\",\n \"0.6457403\",\n \"0.6448143\",\n \"0.64436185\",\n \"0.63982594\",\n \"0.63637847\",\n \"0.6361868\",\n \"0.6351918\",\n \"0.63231635\",\n \"0.6312071\",\n \"0.6308179\",\n \"0.6300375\",\n \"0.6292683\",\n \"0.6268657\",\n \"0.6261957\",\n \"0.6257955\",\n \"0.61618257\",\n \"0.61575425\",\n \"0.61519444\",\n \"0.61424094\",\n \"0.61420083\",\n \"0.613279\",\n \"0.61233884\",\n \"0.6121265\",\n \"0.6114862\",\n \"0.6095126\",\n \"0.6090032\",\n \"0.6050108\",\n \"0.6041173\",\n \"0.60232735\",\n \"0.6023015\",\n \"0.6018335\",\n \"0.60144866\",\n \"0.60063905\",\n \"0.5998461\",\n \"0.5989758\",\n \"0.59866303\",\n \"0.5975711\",\n \"0.5964234\",\n \"0.5961319\",\n \"0.5949383\",\n \"0.5942972\",\n \"0.5938511\",\n \"0.59280837\",\n \"0.5908122\",\n \"0.59040797\",\n \"0.5898722\",\n \"0.5894342\",\n \"0.58931994\",\n \"0.58908755\",\n \"0.5887949\",\n \"0.5878947\",\n \"0.5877685\",\n \"0.58775187\",\n \"0.58771694\",\n \"0.5873496\",\n \"0.58674026\",\n \"0.5864918\",\n \"0.5864437\",\n \"0.58534133\",\n \"0.58419013\",\n \"0.5840927\",\n \"0.5830197\",\n \"0.58200896\",\n \"0.58182615\",\n \"0.58181536\",\n \"0.5812363\",\n \"0.58056414\",\n \"0.5805597\",\n \"0.58028865\",\n \"0.58023816\",\n \"0.58014\",\n \"0.5797357\",\n \"0.57901657\",\n \"0.5786531\",\n \"0.5781041\",\n \"0.578047\",\n \"0.5779705\",\n \"0.5772775\",\n \"0.5769006\",\n \"0.57642347\",\n \"0.5763097\",\n \"0.57562244\",\n \"0.575381\",\n \"0.57529944\",\n \"0.5751666\",\n \"0.5745783\",\n \"0.5744431\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.679927"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":76197,"cells":{"query":{"kind":"string","value":"Return JSONserializable representation of the object."},"document":{"kind":"string","value":"def to_dict(self):\n\n out = super().to_dict()\n out[\"connections\"] = self.connections\n return out"},"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 serialize(self, obj):\n return json.dumps(obj)","def toJSON(self):\n return json.dumps(self, default=lambda o: o.__dict__)","def serialize(self):\n return json.dumps(self.as_dict())","def toJSON(cls, obj):\n return json.dumps(obj)","def serialize(self) -> str:\n return json.dumps(self.__dict__)","def json(self):\n return json.dumps(self, default=lambda o: o.__dict__,\n sort_keys=True, indent=4)","def _toJSON(self):\n\n return json.encode(self.__toJSON())","def to_string(self):\n return json.dumps(self.to_json(), cls=ObjectEncoder)","def to_json(self):\n return json.dumps(self.serialize())","def jsonify(self):\n jsonObject = self.getJsonObject()\n return json.dumps(jsonObject)","def json (self):\n\n return jsonpickle.encode(self, unpicklable=False)","def json (self):\n\n return jsonpickle.encode(self, unpicklable=False)","def serialize(self) -> bytes:\n return json_dumps(self._to_dict()).encode()","def serialize(self) -> bytes:\n return json_dumps(self._to_dict()).encode()","def serialize(self) -> bytes:\n return json_dumps(self._to_dict()).encode()","def to_json(self):\n return json.dumps(self.__dict__)","def tojson(self):\n return json.dumps(self.jsonable())","def to_json(self):\n return json.dumps(self.for_json())","def to_json(self, *args, **kwargs):\n return json.dumps(self.serialize(primitive=True), *args, **kwargs)","def to_json(self, *args, **kwargs):\n return json.dumps(self.serialize(), *args, **kwargs)","def json_serialize(self):\n raise NotImplementedError('json_serialize must be overriden')","def to_json(self):\n return json.dumps(self, default=lambda i: i.__dict__)","def as_json(self):\n return json.dumps(self.as_dict())","def as_json(self):\n return json.dumps(self.as_dict())","def as_json(self):\n return json.dumps(self.as_dict())","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)","def toJSON(self):\n raise NotImplementedError()","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\n indent=4)","def to_json(self):\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\n indent=4)","def to_json(self) -> str:\n return json.dumps(asdict(self))","def to_json(self):\n return json.dumps(self._asdict())","def to_json(self):\n return json.dumps(self.to_dict())","def to_json(self):\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def to_json(self) -> str:\n return json.dumps(self.to_dict())","def cls2json(self):\n return json.dumps(self.__dict__)","def cls2json(self):\n return json.dumps(self.__dict__)","def json(self):\n class ExtendedJSONEncoder(json.JSONEncoder):\n def default(self, obj):\n if isinstance(obj, datetime.date) or isinstance(obj, datetime.time):\n encoded_object = obj.isoformat()\n else:\n encoded_object = json.JSONEncoder.default(self, obj)\n return encoded_object\n\n obj = {\n 'operation': self.operation,\n 'version': self.version,\n 'language': self.language,\n 'identifiers': self.identifiers,\n 'store_execute': self.store_execute,\n 'status': self.status,\n 'lineage': self.lineage,\n 'inputs': dict((i, [inpt.json for inpt in self.inputs[i]]) for i in self.inputs),\n 'outputs': self.outputs,\n 'raw': self.raw\n }\n\n return json.dumps(obj, allow_nan=False, cls=ExtendedJSONEncoder)","def toJson(self):\n return json.dumps(self.toDict(), default=str)","def to_json(self, **kwargs):\n return dumps(self, **kwargs)","def to_json(self, *args, **kwargs):\n data = self.to_dict()\n\n return json_util.dumps(data)","def serialize(self):\n\n if util.config['redfish']['indent_json']:\n indent = 4\n else:\n indent = None\n return json.dumps(\n self.redfish,\n default=lambda o: o.__dict__,\n sort_keys=False,\n indent=indent)","def to_json(self) :\n return jsonpickle.encode(self)","def serialize(cls, obj):\n return json.dumps(obj, cls=CustomTypeEncoder)","def toJson(self):\n return json.dumps(self.toDict())","def toJson(self):\n return json.dumps(self.toDict())","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(sanitize_for_serialization(self.to_dict()))","def to_json(self):\n return json.dumps(self.dict)","def toJson(self):\r\n return self.__dict__","def toJSON(object):\n\treturn json.dumps(object, ensure_ascii=False)","def to_json(self):\n return json.dumps(self, default=json_converter, indent=2)","def to_json(self) -> str:\n return json.dumps(model_to_dict(self))","def tojson(self) -> ty.Text:\n return json.dumps(self.todict())","def to_json(self):\n return self.__dict__","def to_json(self):\n return self.__dict__","def to_json(self):\n return self.__dict__","def to_json(self):\n return self.__dict__","def __str__(self):\n return json.dumps(self.obj)","def asJsonString(self):\n return json.dumps(self.asDict(), sort_keys=True)","def serialize(self):\r\n return json.dumps({\r\n 'display_name': self.display_name,\r\n 'data': self.data,\r\n 'metadata': self.metadata,\r\n 'graderType': self.grader_type,\r\n 'publish': self.publish\r\n })","def as_json_string(self):\n return json.dumps(self.as_dict(), sort_keys=True)","def to_json(self):\n\n return self.__dict__","def toJSON(self) -> str:\r\n try:\r\n _ = json.dumps(self.value)\r\n value = self.value\r\n except (TypeError, OverflowError):\r\n value = {}\r\n value['object_type'] = self.value.__class__.__name__\r\n if isinstance(self.value, RawData):\r\n type_str = '_{}__'.format(value['object_type'])\r\n for key, data in self.value.__dict__.items():\r\n value[key.replace(type_str, '')] = data\r\n else:\r\n type_str = '_{}'.format(value['object_type'])\r\n for key, data in self.value.__dict__.items():\r\n value[key.replace(type_str, '')] = data\r\n\r\n return json.dumps({'object_type' : 'RawData', 'version' : self.version,\r\n 'timestamp' : self.timestamp, 'label' : self.label,\r\n 'value' : value})","def toJSON(self):\n\t\treturn json.dumps(self.root, default=lambda o: o.__dict__)","def serialize(self) -> typing.Any:\n return self._serialize(self.__dict__)","def SerializeObject(self, data):\n\n if isinstance(data,dict):\n serializad_data = json.dumps(data)\n else:\n serializad_data = json.dumps(data.__dict__)\n\n return serializad_data","def to_json_string(self) -> None:\n return json.dumps(dataclasses.asdict(self)) + \"\\n\"","def __repr__(self):\n return json.dumps(self.__dict__)","def to_json(self) -> str:\n return JSONEncoder().encode(vars(self))","def toJSONString(self):\n JSONObject = self.toDict()\n\n return json.dumps(JSONObject, ensure_ascii=False)","def AsJsonString(self):\n return json.dumps(self.AsDict(), sort_keys=True)","def as_json(self) -> str:\n return json.dumps(self, cls=_ProgrammeJSONEncoder)","def to_json(self):\n pass","def to_string(self) -> str:\n return json.dumps(self.to_json())","def to_string(self) -> str:\n return json.dumps(self.to_json())","def to_json(self) -> JSON:\n pass","def convert_to_json(self):\n return self.__dict__","def json(self):\n return self.__json","def serialize(self, obj):\n return obj","def to_json(self):\n obj_dict = self.__dict__\n obj_dict[\"_class_\"] = self.__class__.__name__\n return obj_dict","def to_json_string(self):\n\t\treturn json.dumps(dataclasses.asdict(self), indent=2, sort_keys=True) + \"\\n\"","def __toJSON(self):\n context = jsonpickle.pickler.Pickler(unpicklable=True, warn=True, keys=True)\n json_state = context.flatten(self, reset=True)\n\n jsonpickle.set_encoder_options('json', sort_keys=True, indent=4)\n\n # Add version and hash of dictionary json_state\n json_state[\"__version__\"] = self.__version__\n json_state[\"__sha256__\"] = hash_sha256(json.encode(json_state))\n\n # Add user and datetime information afterwards\n json_state[\"__user__\"] = getpass.getuser()\n dt = datetime.now()\n json_state[\"__datetime__\"] = dt.strftime(\"%A, %d. %B %Y %I:%M%p\")\n\n return json_state","def stringify(self, *args, **kwargs):\n return json.dumps(self.serialize(*args, **kwargs), default=SerialClass.string_repr)"],"string":"[\n \"def serialize(self, obj):\\n return json.dumps(obj)\",\n \"def toJSON(self):\\n return json.dumps(self, default=lambda o: o.__dict__)\",\n \"def serialize(self):\\n return json.dumps(self.as_dict())\",\n \"def toJSON(cls, obj):\\n return json.dumps(obj)\",\n \"def serialize(self) -> str:\\n return json.dumps(self.__dict__)\",\n \"def json(self):\\n return json.dumps(self, default=lambda o: o.__dict__,\\n sort_keys=True, indent=4)\",\n \"def _toJSON(self):\\n\\n return json.encode(self.__toJSON())\",\n \"def to_string(self):\\n return json.dumps(self.to_json(), cls=ObjectEncoder)\",\n \"def to_json(self):\\n return json.dumps(self.serialize())\",\n \"def jsonify(self):\\n jsonObject = self.getJsonObject()\\n return json.dumps(jsonObject)\",\n \"def json (self):\\n\\n return jsonpickle.encode(self, unpicklable=False)\",\n \"def json (self):\\n\\n return jsonpickle.encode(self, unpicklable=False)\",\n \"def serialize(self) -> bytes:\\n return json_dumps(self._to_dict()).encode()\",\n \"def serialize(self) -> bytes:\\n return json_dumps(self._to_dict()).encode()\",\n \"def serialize(self) -> bytes:\\n return json_dumps(self._to_dict()).encode()\",\n \"def to_json(self):\\n return json.dumps(self.__dict__)\",\n \"def tojson(self):\\n return json.dumps(self.jsonable())\",\n \"def to_json(self):\\n return json.dumps(self.for_json())\",\n \"def to_json(self, *args, **kwargs):\\n return json.dumps(self.serialize(primitive=True), *args, **kwargs)\",\n \"def to_json(self, *args, **kwargs):\\n return json.dumps(self.serialize(), *args, **kwargs)\",\n \"def json_serialize(self):\\n raise NotImplementedError('json_serialize must be overriden')\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda i: i.__dict__)\",\n \"def as_json(self):\\n return json.dumps(self.as_dict())\",\n \"def as_json(self):\\n return json.dumps(self.as_dict())\",\n \"def as_json(self):\\n return json.dumps(self.as_dict())\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)\",\n \"def toJSON(self):\\n raise NotImplementedError()\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\\n indent=4)\",\n \"def to_json(self):\\n return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True,\\n indent=4)\",\n \"def to_json(self) -> str:\\n return json.dumps(asdict(self))\",\n \"def to_json(self):\\n return json.dumps(self._asdict())\",\n \"def to_json(self):\\n return json.dumps(self.to_dict())\",\n \"def to_json(self):\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def to_json(self) -> str:\\n return json.dumps(self.to_dict())\",\n \"def cls2json(self):\\n return json.dumps(self.__dict__)\",\n \"def cls2json(self):\\n return json.dumps(self.__dict__)\",\n \"def json(self):\\n class ExtendedJSONEncoder(json.JSONEncoder):\\n def default(self, obj):\\n if isinstance(obj, datetime.date) or isinstance(obj, datetime.time):\\n encoded_object = obj.isoformat()\\n else:\\n encoded_object = json.JSONEncoder.default(self, obj)\\n return encoded_object\\n\\n obj = {\\n 'operation': self.operation,\\n 'version': self.version,\\n 'language': self.language,\\n 'identifiers': self.identifiers,\\n 'store_execute': self.store_execute,\\n 'status': self.status,\\n 'lineage': self.lineage,\\n 'inputs': dict((i, [inpt.json for inpt in self.inputs[i]]) for i in self.inputs),\\n 'outputs': self.outputs,\\n 'raw': self.raw\\n }\\n\\n return json.dumps(obj, allow_nan=False, cls=ExtendedJSONEncoder)\",\n \"def toJson(self):\\n return json.dumps(self.toDict(), default=str)\",\n \"def to_json(self, **kwargs):\\n return dumps(self, **kwargs)\",\n \"def to_json(self, *args, **kwargs):\\n data = self.to_dict()\\n\\n return json_util.dumps(data)\",\n \"def serialize(self):\\n\\n if util.config['redfish']['indent_json']:\\n indent = 4\\n else:\\n indent = None\\n return json.dumps(\\n self.redfish,\\n default=lambda o: o.__dict__,\\n sort_keys=False,\\n indent=indent)\",\n \"def to_json(self) :\\n return jsonpickle.encode(self)\",\n \"def serialize(cls, obj):\\n return json.dumps(obj, cls=CustomTypeEncoder)\",\n \"def toJson(self):\\n return json.dumps(self.toDict())\",\n \"def toJson(self):\\n return json.dumps(self.toDict())\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(sanitize_for_serialization(self.to_dict()))\",\n \"def to_json(self):\\n return json.dumps(self.dict)\",\n \"def toJson(self):\\r\\n return self.__dict__\",\n \"def toJSON(object):\\n\\treturn json.dumps(object, ensure_ascii=False)\",\n \"def to_json(self):\\n return json.dumps(self, default=json_converter, indent=2)\",\n \"def to_json(self) -> str:\\n return json.dumps(model_to_dict(self))\",\n \"def tojson(self) -> ty.Text:\\n return json.dumps(self.todict())\",\n \"def to_json(self):\\n return self.__dict__\",\n \"def to_json(self):\\n return self.__dict__\",\n \"def to_json(self):\\n return self.__dict__\",\n \"def to_json(self):\\n return self.__dict__\",\n \"def __str__(self):\\n return json.dumps(self.obj)\",\n \"def asJsonString(self):\\n return json.dumps(self.asDict(), sort_keys=True)\",\n \"def serialize(self):\\r\\n return json.dumps({\\r\\n 'display_name': self.display_name,\\r\\n 'data': self.data,\\r\\n 'metadata': self.metadata,\\r\\n 'graderType': self.grader_type,\\r\\n 'publish': self.publish\\r\\n })\",\n \"def as_json_string(self):\\n return json.dumps(self.as_dict(), sort_keys=True)\",\n \"def to_json(self):\\n\\n return self.__dict__\",\n \"def toJSON(self) -> str:\\r\\n try:\\r\\n _ = json.dumps(self.value)\\r\\n value = self.value\\r\\n except (TypeError, OverflowError):\\r\\n value = {}\\r\\n value['object_type'] = self.value.__class__.__name__\\r\\n if isinstance(self.value, RawData):\\r\\n type_str = '_{}__'.format(value['object_type'])\\r\\n for key, data in self.value.__dict__.items():\\r\\n value[key.replace(type_str, '')] = data\\r\\n else:\\r\\n type_str = '_{}'.format(value['object_type'])\\r\\n for key, data in self.value.__dict__.items():\\r\\n value[key.replace(type_str, '')] = data\\r\\n\\r\\n return json.dumps({'object_type' : 'RawData', 'version' : self.version,\\r\\n 'timestamp' : self.timestamp, 'label' : self.label,\\r\\n 'value' : value})\",\n \"def toJSON(self):\\n\\t\\treturn json.dumps(self.root, default=lambda o: o.__dict__)\",\n \"def serialize(self) -> typing.Any:\\n return self._serialize(self.__dict__)\",\n \"def SerializeObject(self, data):\\n\\n if isinstance(data,dict):\\n serializad_data = json.dumps(data)\\n else:\\n serializad_data = json.dumps(data.__dict__)\\n\\n return serializad_data\",\n \"def to_json_string(self) -> None:\\n return json.dumps(dataclasses.asdict(self)) + \\\"\\\\n\\\"\",\n \"def __repr__(self):\\n return json.dumps(self.__dict__)\",\n \"def to_json(self) -> str:\\n return JSONEncoder().encode(vars(self))\",\n \"def toJSONString(self):\\n JSONObject = self.toDict()\\n\\n return json.dumps(JSONObject, ensure_ascii=False)\",\n \"def AsJsonString(self):\\n return json.dumps(self.AsDict(), sort_keys=True)\",\n \"def as_json(self) -> str:\\n return json.dumps(self, cls=_ProgrammeJSONEncoder)\",\n \"def to_json(self):\\n pass\",\n \"def to_string(self) -> str:\\n return json.dumps(self.to_json())\",\n \"def to_string(self) -> str:\\n return json.dumps(self.to_json())\",\n \"def to_json(self) -> JSON:\\n pass\",\n \"def convert_to_json(self):\\n return self.__dict__\",\n \"def json(self):\\n return self.__json\",\n \"def serialize(self, obj):\\n return obj\",\n \"def to_json(self):\\n obj_dict = self.__dict__\\n obj_dict[\\\"_class_\\\"] = self.__class__.__name__\\n return obj_dict\",\n \"def to_json_string(self):\\n\\t\\treturn json.dumps(dataclasses.asdict(self), indent=2, sort_keys=True) + \\\"\\\\n\\\"\",\n \"def __toJSON(self):\\n context = jsonpickle.pickler.Pickler(unpicklable=True, warn=True, keys=True)\\n json_state = context.flatten(self, reset=True)\\n\\n jsonpickle.set_encoder_options('json', sort_keys=True, indent=4)\\n\\n # Add version and hash of dictionary json_state\\n json_state[\\\"__version__\\\"] = self.__version__\\n json_state[\\\"__sha256__\\\"] = hash_sha256(json.encode(json_state))\\n\\n # Add user and datetime information afterwards\\n json_state[\\\"__user__\\\"] = getpass.getuser()\\n dt = datetime.now()\\n json_state[\\\"__datetime__\\\"] = dt.strftime(\\\"%A, %d. %B %Y %I:%M%p\\\")\\n\\n return json_state\",\n \"def stringify(self, *args, **kwargs):\\n return json.dumps(self.serialize(*args, **kwargs), default=SerialClass.string_repr)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8475618","0.84085596","0.83957154","0.838217","0.83239555","0.8288305","0.8275888","0.8227394","0.81710005","0.81556803","0.8117269","0.8117269","0.81065536","0.81065536","0.81065536","0.80988455","0.80659264","0.8029448","0.7999212","0.799741","0.79870963","0.797142","0.7941959","0.7941959","0.7941959","0.7941652","0.7941652","0.7941652","0.79340965","0.79121095","0.79121095","0.7903038","0.78709847","0.7867825","0.7867825","0.7850982","0.7850982","0.7850982","0.7850982","0.7850982","0.7850982","0.7850982","0.7850982","0.7850982","0.783844","0.783844","0.7837332","0.78363943","0.7834975","0.78343713","0.78065056","0.7794","0.77903575","0.7787237","0.7787237","0.7784064","0.7784064","0.7784064","0.7784064","0.7784064","0.7784064","0.7784064","0.7784064","0.7784064","0.7784064","0.7759944","0.775539","0.7704309","0.7697943","0.7691777","0.7689685","0.7671306","0.7671306","0.7671306","0.7671306","0.765024","0.7637397","0.76098675","0.758708","0.75862324","0.7583238","0.75807375","0.7579968","0.7577776","0.7576992","0.7570204","0.75670713","0.75490505","0.7543369","0.75357395","0.7534308","0.75115967","0.75115967","0.7510672","0.74934787","0.7480337","0.7462089","0.74355114","0.7433692","0.7423795","0.74080426"],"string":"[\n \"0.8475618\",\n \"0.84085596\",\n \"0.83957154\",\n \"0.838217\",\n \"0.83239555\",\n \"0.8288305\",\n \"0.8275888\",\n \"0.8227394\",\n \"0.81710005\",\n \"0.81556803\",\n \"0.8117269\",\n \"0.8117269\",\n \"0.81065536\",\n \"0.81065536\",\n \"0.81065536\",\n \"0.80988455\",\n \"0.80659264\",\n \"0.8029448\",\n \"0.7999212\",\n \"0.799741\",\n \"0.79870963\",\n \"0.797142\",\n \"0.7941959\",\n \"0.7941959\",\n \"0.7941959\",\n \"0.7941652\",\n \"0.7941652\",\n \"0.7941652\",\n \"0.79340965\",\n \"0.79121095\",\n \"0.79121095\",\n \"0.7903038\",\n \"0.78709847\",\n \"0.7867825\",\n \"0.7867825\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.7850982\",\n \"0.783844\",\n \"0.783844\",\n \"0.7837332\",\n \"0.78363943\",\n \"0.7834975\",\n \"0.78343713\",\n \"0.78065056\",\n \"0.7794\",\n \"0.77903575\",\n \"0.7787237\",\n \"0.7787237\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7784064\",\n \"0.7759944\",\n \"0.775539\",\n \"0.7704309\",\n \"0.7697943\",\n \"0.7691777\",\n \"0.7689685\",\n \"0.7671306\",\n \"0.7671306\",\n \"0.7671306\",\n \"0.7671306\",\n \"0.765024\",\n \"0.7637397\",\n \"0.76098675\",\n \"0.758708\",\n \"0.75862324\",\n \"0.7583238\",\n \"0.75807375\",\n \"0.7579968\",\n \"0.7577776\",\n \"0.7576992\",\n \"0.7570204\",\n \"0.75670713\",\n \"0.75490505\",\n \"0.7543369\",\n \"0.75357395\",\n \"0.7534308\",\n \"0.75115967\",\n \"0.75115967\",\n \"0.7510672\",\n \"0.74934787\",\n \"0.7480337\",\n \"0.7462089\",\n \"0.74355114\",\n \"0.7433692\",\n \"0.7423795\",\n \"0.74080426\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":76198,"cells":{"query":{"kind":"string","value":"converts 1Dnumpy array to string readable py plotly.js"},"document":{"kind":"string","value":"def numpy_to_plotlystring(numpy_array, precision=4):\n np.set_printoptions(threshold=np.nan) # enables full printing\n n_data = np.shape(numpy_array)[0]\n # prevent array2string to cut string by ofsestting maximal width\n max_line_width=n_data*(8) # Output Format [#.####, ...], thus 7 chars per entry, added 100 for safekeeping\n string_array = np.array2string(numpy_array, separator=',', max_line_width=n_data*(8), precision=precision, formatter={'float_kind':lambda x: \"%.4f\" % x})\n np.set_printoptions(linewidth=75, threshold=1000) # restores default\n return string_array"},"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 np2str(a: np.ndarray) -> str:\n return json.dumps(a.tolist())","def z_as_plotly(self):\n xs = np.asarray(self.position)[:,2]\n return numpy_to_plotlystring(xs)","def x_as_plotly(self):\n xs = np.asarray(self.position)[:,0]\n return numpy_to_plotlystring(xs)","def y_as_plotly(self):\n xs = np.asarray(self.position)[:,1]\n return numpy_to_plotlystring(xs)","def array_to_plotly(arr, with_alpha=False):\n if with_alpha is True:\n return np.array(['rgba(%s, %s, %s, %s)' % (r, g, b, a)\n for r, g, b, a in arr])\n else:\n return np.array(['rgb(%s, %s, %s)' % (r, g, b) for r, g, b, _ in arr])","def transfer_2d_array_to_str(array):\n str_list = []\n for r in array:\n str_list.append(\",\".join([str(e) for e in r]))\n return \" \".join(str_list)","def array2anyscript(arr):\n def tostr(v):\n if np.isreal(v):\n return '{:.12g}'.format(v)\n elif isinstance(v, (string_types, np.str_)):\n return '\"{}\"'.format(v)\n\n def createsubarr(arr):\n outstr = \"\"\n if isinstance(arr, np.ndarray):\n if len(arr) == 1 and not isinstance(arr[0], np.ndarray):\n return '{'+tostr(arr[0]) + '},'\n outstr += '{'\n for row in arr:\n outstr += createsubarr(row)\n outstr = outstr.strip(',') + '},'\n return outstr\n else:\n return outstr + tostr(arr)+','\n if isinstance(arr, np.ndarray) and not arr.shape:\n return tostr(arr.tolist())\n elif isinstance(arr, np.ndarray) :\n return createsubarr(arr).strip(',')\n elif isinstance( arr, float):\n return tostr(arr)\n else:\n return str(arr)","def json_serialize_numpy_array(array):\n return json.dumps(json_ready_numpy_array(array))","def json_serialize_numpy_array(array):\n return json.dumps(json_ready_numpy_array(array))","def __str__(self):\n return np.array2string(self.graph.toarray())","def __str__(self):\n return str(self.array)","def __str__(self):\n return str(self.arr)","def float_array_string(arr: Iterable[float]) -> str:\n return \"[\" + \", \".join([\"{:.4f}\".format(el) for el in arr]) + \"]\"","def as_str(self):\n return soho.arrayToString('\"%s\" [ ' % self.type_name, self.value, \" ]\")","def _numpy_text(tensor):\n if dtype_util.is_numpy_compatible(tensor.dtype):\n value = np.array(tensor)\n if value.shape:\n text = repr(value)\n else:\n text = str(value)\n else:\n text = '<unprintable>'\n if '\\n' in text:\n text = '\\n' + text\n return text","def array_to_plot(points, resolution=(0.01872, 0.01872, 0.005), point_size=1.2, outfile_name=\"\"):\n # Type in the path to your csv file here\n \n thedata = points\n# print(thedata)\n\n # Set tupleResolution to resolution input parameter\n tupleResolution = resolution;\n\n # EG: for Aut1367, the spacing is (0.01872, 0.01872, 0.005).\n xResolution = tupleResolution[0]\n yResolution = tupleResolution[1]\n zResolution = tupleResolution[2]\n # Now, to get the mm image size, we can multiply all x, y, z\n # to get the proper mm size when plotting.\n \n# print('asdf')\n# x = [x * xResolution for x in thedata[:, 0]]\n# print(x)\n\n trace1 = graphobjs.Scatter3d(\n x = [x * xResolution for x in thedata[:, 0]],\n y = [x * yResolution for x in thedata[:, 1]],\n z = [x * zResolution for x in thedata[:, 2]],\n mode='markers',\n marker=dict(\n size=point_size,\n color='cyan', # set color to an array/list of desired values\n colorscale='Viridis', # choose a colorscale\n opacity=0.15\n )\n )\n\n data = [trace1]\n layout = graphobjs.Layout(\n margin=dict(\n l=0,\n r=0,\n b=0,\n t=0\n ),\n paper_bgcolor='rgb(0,0,0)',\n plot_bgcolor='rgb(0,0,0)'\n )\n\n fig = graphobjs.Figure(data=data, layout=layout)\n# print(self._token + \"plotly\")\n\n make_sure_path_exists('plots')\n \n if outfile_name == \"\":\n plotly.offline.plot(fig, filename= 'plots/' + token + \"_plot.html\")\n else:\n plotly.offline.plot(fig, filename= 'plots/' + outfile_name + \"_plot.html\")","def as_str(self) -> str:\n return dumps(self.as_dict(), cls=NumpyEncoder)","def create_fig_2d(self, data_array_2d, output_fn='', xlabel='', ylabel='', title=''):","def toString(arr2d):\n return (\"\\n\".join(\"\\t\".join(row) for row in arr2d))","def cast_numpy_to_txt(arr, output_file):\n shape = arr.shape\n arr = arr.reshape([shape[0] * shape[1], shape[2]])\n\n np.savetxt(fname=output_file, X=arr, delimiter=' ', fmt='%.18e', newline='\\n', )","def array_to_png(arr,\n path=None,\n show=True,\n vmin=None,\n vmax=None,\n scale=None,\n labels=None):\n scaled, image_mode = autoscale_colors_for_png(arr, vmin=vmin, vmax=vmax)\n save_to_png(\n scaled,\n path=path,\n show=show,\n image_mode=image_mode,\n labels=labels,\n scale=scale)","def _serialize_array(self, array):\n buffer = io.BytesIO()\n np.save(buffer, array)\n return buffer.getvalue()","def save_mat_fig(trace_array, gtype=\"traceplot\"):\n # fig = Figure()\n if gtype == \"traceplot\":\n print(\"ENTER save_traceplot\")\n pm.traceplot(trace_array, figsize=(12,12))\n print(\"PLT.GCF()\")\n fig = plt.gcf()\n print(\"FIGURE\")\n buf = io.BytesIO()\n print(\"BUFF\")\n fig.savefig(buf, format=\"png\")\n data = base64.b64encode(buf.getbuffer()).decode(\"utf8\")\n elif gtype == \"posterior\":\n print(\"ENTER plot_posterior\")\n pm.plot_posterior(trace_array, figsize=(12,12))\n fig = plt.gcf()\n buf = io.BytesIO()\n fig.savefig(buf, format=\"png\")\n data = base64.b64encode(buf.getbuffer()).decode(\"utf8\")\n else:\n data = []\n return \"data:image/png;base64,{}\".format(data)","def __str__(self):\n output = \"\"\n for i in self.values:\n st = []\n output += \"[\"\n for j in i:\n st.append(str(j))\n output += \",\".join(st)+\"]\"\n return str(self.m)+\"x\"+str(self.n)+\" [\" + output + \"]\"","def arraystr(a, max_line_width=None, precision=None, suppress_small=None):\n return np.array2string(a, max_line_width,\n precision, suppress_small,\n separator=', ', prefix=\"\", style=str)\\\n .replace('..., ', '..., ' if PY3 else 'Ellipsis, ')","def pov_array(arr):\n return \"array[{}] {{{}}}\".format(len(arr), \", \".join(str(x) for x in arr))","def __repr__(self):\n\t\treturn repr([self.series[0],self.series[1],self.series[2],\"...\"])","def __str__(self):\n my_str=\"[\"\n for elem in range(self.size):\n x=cArray.cModule.get_element(self.arrayRef,ctypes.c_int(elem))\n my_str+=str(x)+\" \"\n my_str+=\"]\"\n return my_str","def __repr__(self):\r\n\r\n # If the input is a single int/float (with no shape) return a 'scalar'\r\n # time-point:\r\n if self.shape == ():\r\n return \"%r %s\" % (int(self) / float(self._conversion_factor),\r\n self.time_unit)\r\n # Otherwise, return the TimeArray representation:\r\n else:\r\n return np.ndarray.__repr__(self / float(self._conversion_factor)\r\n )[:-1] + \", time_unit='%s')\" % self.time_unit","def __repr__(self) -> str:\n\n thresh = np.get_printoptions()[\"threshold\"]\n np.set_printoptions(threshold=20)\n extra_chars = len(self.__class__.__name__)\n arr_str = \"data=\" + str(self.data).replace(\"\\n\", \"\\n\" + \" \" * (extra_chars + 6))\n shape_str = (\n \" \" * extra_chars\n + \" shape=\"\n + str(self.shape).replace(\"\\n\", \"\\n\" + \" \" * (extra_chars + 7))\n )\n dtype_str = \" \" * extra_chars + \" dtype=\" + str(self.dtype)\n np.set_printoptions(threshold=thresh)\n return \"{klass}({data},\\n{shape},\\n{dtype})\".format(\n klass=self.__class__.__name__,\n data=arr_str,\n shape=shape_str,\n dtype=dtype_str,\n )","def array_2d_str(array, fmt='{:.2f}', sep=', ', row_sep='\\n', with_boundary=True):\n ret = row_sep.join([array_str(x, fmt=fmt, sep=sep, with_boundary=with_boundary) for x in array])\n if with_boundary:\n ret = '[' + ret + ']'\n return ret","def str_array(arr, sides=(3, 3), delim=\", \", format=None, log=False, label_log=True):\n arr = np.asarray(arr)\n if log:\n arr = np.log10(arr)\n\n len_arr = arr.size\n beg, end = _str_array_get_beg_end(sides, len_arr)\n\n if format is None:\n format = _guess_str_format_from_range(arr)\n\n # Create the style specification\n form = \"{{{}}}\".format(format)\n\n arr_str = _str_array_1d(arr, beg, end, form, delim)\n if log and label_log:\n arr_str += \" (log values)\"\n\n return arr_str","def dataAsString(self):\n\n # Force generation of .array\n d = self.asArray()\n slist = []\n for l in self.array:\n s = \"%s %s\" % (self.name, self.rowAsString(l))\n slist.append(s)\n return '\\n'.join(slist)","def array_str(array, fmt='{:.2f}', sep=', ', with_boundary=True):\n ret = sep.join([fmt.format(float(x)) for x in array])\n if with_boundary:\n ret = '[' + ret + ']'\n return ret","def shape2str(x):\n return \"[\" + \" x \".join([str(x) for x in x.shape]) + \"]\"","def serialize(self):\r\n values = ','.join(i.serialize() for i in self.curves)\r\n return \"[{}]\".format(values)","def __str__(self):\n s =\"\"\n if self.data is 0:\n return \"[]\"\n else:\n for i in range(len(self.data)):\n s += str(self.data[i])\n if i != len(self.data)-1:\n s += \", \"\n return \"[\" + s + \"]\"","def to_string(\n self, freqs: \"np.array\", *, formatter: Optional[ModelFormatter] = None\n ) -> str:\n formatter = formatter if formatter is not None else ModelJSONFormatter()\n return formatter.format(self, freqs)","def _encodeArray(self, array):\n\n # Actually, we want dtype,naxis,axNlen,base64(array)\n return base64.b64encode(array.tostring())","def __str__(self):\n return '[' + ', '.join([str(x) for x in self.elem]) + ']'","def pretty_print(image_example):\n print numpy.array_str(image_example, precision=1, max_line_width=142)","def __str__(self):\n ans = \"\"\n for i in range(self.row):\n for j in range(self.col):\n ans+=str(self.array[i][j])+\" \"\n ans+=\"\\n\"\n return ans","def to_json(self) -> str:\n data_dict = self._to_list_dict()\n return json.dumps(data_dict, indent=4, cls=NumpyEncoder)","def array_to_concatenated_string(array):\r\n return \",\".join(str(x) for x in array)","def SimpleArrayPlotHelper(self,filename):\n #levels = np.linspace(-100.0, 9900.0, 100, endpoint=True)\n plt.figure()\n #plt.contourf(orography_field,levels)\n plt.colorbar()\n pts.invert_y_axis()","def basic_array_ejection():\n arr: pa.Array = pa.array([1, 2, 3, 4, 5], type=pa.int8())\n\n srs: pd.Series = arr.to_pandas() # NOTE: Requires pandas installation\n nparr: np.ndarray = arr.to_numpy()\n list_: List[dict] = arr.to_pylist()\n str_: str = arr.to_string()\n\n results = {\n 'to_pandas > to_list': srs.to_list(),\n 'to_numpy > tolist': nparr.tolist(),\n 'to_pylist': list_,\n 'to_string': str_,\n }\n\n pretty_print_result_map(results)","def plotMatrix(matrix:np.ndarray,if_log=False,title=\"Matrix\",plotType=\"static\",range_color=None,\n axis2genome=False,genome_coord1=None,genome_coord2=None,resolution = None):\n import plotly.express as px \n from IPython.display import Image\n\n if(if_log == True): \n matrix = np.log10(matrix)\n\n fig = px.imshow(matrix,color_continuous_scale=px.colors.sequential.Viridis,range_color=range_color)\n fig = fig.update_layout(template='simple_white').update_layout(width=650,height=600)\n\n if (axis2genome):\n import re\n #manually change axis\n posx = re.split(\"[:-]\",genome_coord2)\n xvals = np.percentile([np.round(i) for i in range(0,matrix.shape[1])],(0,25,50,75,100),interpolation='midpoint')\n xtexts = xvals*resolution + int(posx[1].replace(\",\",\"\")) + resolution/2\n xtexts = [genomecoord2human(i) for i in xtexts]\n\n posy = re.split(\"[:-]\",genome_coord1)\n yvals = np.percentile([np.round(i) for i in range(0,matrix.shape[0])],(0,25,50,75,100),interpolation='midpoint')\n ytexts = yvals*resolution + int(posy[1].replace(\",\",\"\")) + resolution/2\n ytexts = [genomecoord2human(i) for i in ytexts]\n\n fig = fig.update_xaxes(ticktext = xtexts,tickvals = xvals).update_yaxes(ticktext = ytexts,tickvals = yvals)\n\n if(plotType == \"interaction\"):\n return fig\n else : return Image(fig.to_image(format=\"png\", engine=\"kaleido\"))","def ncvar_to_str(data, variable_name, unit_factor=1., separator=','):\n return np.array2string(unit_factor*data[variable_name][:],\n separator=separator, precision=3,\n max_line_width=80)[1:-1] + '\\n'","def plot_data(self):","def _dump_plotly(objs, images, func):\n l = len(objs)\n #print(l)\n titles = []\n for i,x in enumerate(objs):\n if 'id' in x:\n titles.append('shape id %d' % x.id)\n else:\n titles.append('item %d' % i)\n fig = tools.make_subplots(rows=l, cols=1, subplot_titles = titles,print_grid=False )\n #print('figure attmpt: ')\n #fig['layout']['xaxis1'].update(title='monkeybar')\n #for x in fig['layout']['xaxis1']:\n #print(x)\n fig.layout.showlegend = False\n for i,x in enumerate(objs):\n traces,annotations,title = func(x,images[i])\n im = {\n \"source\": 'data:image/png;base64, ' + getbase64(images[i]),\n \"x\": 1,\n \"y\": 1 - i/(l-.5),\n \"sizex\": .5,\n \"sizey\": .5,\n }\n fig.layout.images.append(im)\n for t in traces:\n fig.append_trace(t,i+1,1)\n if title is not None:\n fig.layout['xaxis%d' % (i+1)].update(title=title)\n if annotations is not None:\n for a in annotations:\n a['xref'] = 'x%d' % (i+1)\n a['yref'] = 'y%d' % (i+1)\n fig.layout.annotations += annotations\n\n fig['layout'].update(height=400*l, width=1100, margin={\n 'l':80,\n 'r':330,\n 't':100,\n 'b':80,\n 'pad':0,\n 'autoexpand':True,\n },title='plots')\n\n return fig","def resToStr(self, res):\n for i in range(self.npeaks):\n # Remove meaningless parameter values\n if not self.peakTyp[i].startswith('A'):\n res[i][3] = 0.0\n if not(self.peakTyp[i] == 'P' or self.peakTyp[i] == 'AP'):\n res[i][4] = 0.0\n strres = np.array2string(res, precision=3, separator=',',\n sign='+', suppress_small=True)\n return strres","def _get_plotlyjs() -> str:\n js = get_plotlyjs()\n base_symbols = ['circle', 'diamond', 'square', 'hexagram']\n ds_ids = [37, 38, 39, 40, 34, 33, 35, 36]\n for base in base_symbols:\n for ds in ds_ids:\n old, new = _draw_mash(base_symbol=base, ds_symbol=ds)\n if len(re.findall(old, js)) != 1:\n raise ImportError(\"Warning: Incompatible version of Plotly Detected. Please use v5.7.0\")\n js = re.sub(old, new, js)\n return js","def __repr__(self):\r\n\r\n #If the input is a single int/float (with no shape) return a 'scalar'\r\n #time-point:\r\n if self.shape == ():\r\n return \"%r %s\" % (int(self) / float(self._conversion_factor),\r\n self.time_unit)\r\n\r\n #Otherwise, return the UniformTime representation:\r\n else:\r\n return np.ndarray.__repr__(self / float(self._conversion_factor)\r\n )[:-1] + \", time_unit='%s')\" % self.time_unit","def array_to_concatenated_string(array):\n return \",\".join(str(x) for x in array)","def fig2data ( fig ):\n # draw the renderer\n fig.canvas.draw ( )\n buf = np.array(fig.canvas.renderer._renderer)\n return buf","def pov_2d_array(array_list):\n return \"array[{}][{}] {{{}}}\".format(\n len(array_list),\n len(array_list[0]),\n \", \".join(\"{{{}}}\".format(\", \".join(str(x) for x in arr)) for arr in array_list)\n )","def trajectory_to_json(trajectory: Trajectory) -> str:\n # numpy arrays need to be converted to normal tuples\n return json.dumps(trajectory, cls=NumpyEncoder)","def __str__(self):\n return str(self.asMatrix())","def image2str(arr: np.ndarray, char='X', *, columns=28) -> str:\n if isinstance(arr, np.ndarray):\n dims = len(arr.shape)\n else:\n dims, a = 0, arr\n while True:\n try:\n a = a[0]\n except TypeError:\n break\n dims += 1\n if dims == 1:\n arr = [arr[i:i+columns] for i in range(0, len(arr), columns)]\n # for i in arr: print(' '.join(f'{x:>3}' for x in i)) # to print nicely as numbers\n elif dims != 2:\n raise ValueError(\"Can not convert many-dimensional array to string\")\n return '\\n'.join(''.join(char if i else ' ' for i in row) for row in arr)","def tostring(self, transformer=None):\n\t\tresult = ''\n\t\tif not transformer:\n\t\t\ttransformer = str\n\t\tfor start in range(0, len(self.data), self.dims[0]):\n\t\t\tfor c in self.data[start:start+self.dims[0]]:\n\t\t\t\tresult += transformer(c)\n\t\t\tresult += '\\n'\n\t\treturn result","def obs_to_string(observations):\n str_obs = []\n for obs in observations:\n str_obs.append(obs.reshape(-1).tostring())\n return str_obs","def __str__(self):\n lst = [str(i) for i in self.data]\n if self.column:\n return '[' + ', '.join(lst) + ']\\''\n else:\n return '[' + ', '.join(lst) + ']'","def create_data(self) -> str:\r\n s = self.scale\r\n mini, maxi = self.get_min_max()\r\n diff = maxi - mini\r\n\r\n output = \"const data = {\\n\"\r\n\r\n # Create the data for the scatters\r\n # TODO: If it's not interactive, labels shouldn't be exported.\r\n for name, data in self.scatters_data.items():\r\n mapping = self.scatters[name][\"mapping\"]\r\n colormaps = self.scatters[name][\"colormap\"]\r\n cmaps = [None] * len(colormaps)\r\n\r\n for i, colormap in enumerate(colormaps):\r\n if isinstance(colormap, str):\r\n cmaps[i] = plt.cm.get_cmap(colormap)\r\n else:\r\n cmaps[i] = colormap\r\n\r\n output += name + \": {\\n\"\r\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\"x\"]]]\r\n output += \"x: [\" + \",\".join(map(str, x_norm)) + \"],\\n\"\r\n\r\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\"y\"]]]\r\n output += \"y: [\" + \",\".join(map(str, y_norm)) + \"],\\n\"\r\n\r\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\"z\"]]]\r\n output += \"z: [\" + \",\".join(map(str, z_norm)) + \"],\\n\"\r\n\r\n if mapping[\"labels\"] in data:\r\n fmt_labels = [\"'{0}'\".format(s) for s in data[mapping[\"labels\"]]]\r\n output += \"labels: [\" + \",\".join(fmt_labels) + \"],\\n\"\r\n\r\n if mapping[\"s\"] in data:\r\n output += \"s: [\"\r\n\r\n for series in range(len(data[mapping[\"s\"]])):\r\n output += (\r\n \"[\"\r\n + \",\".join(map(str, np.round(data[mapping[\"s\"]][series], 3)))\r\n + \"],\\n\"\r\n )\r\n\r\n output += \"],\\n\"\r\n\r\n output += \"colors: [\\n\"\r\n for series in range(len(data[mapping[\"c\"]])):\r\n output += \"{\\n\"\r\n if mapping[\"cs\"] in data:\r\n colors = np.array(\r\n [cmaps[series](x) for x in data[mapping[\"c\"]][series]]\r\n )\r\n\r\n for i, c in enumerate(colors):\r\n hsl = np.array(colour.rgb2hsl(c[:3]))\r\n hsl[1] = hsl[1] - hsl[1] * data[mapping[\"cs\"]][series][i]\r\n colors[i] = np.append(np.array(colour.hsl2rgb(hsl)), 1.0)\r\n\r\n colors = np.round(colors * 255.0)\r\n\r\n output += (\r\n \"r: [\" + \",\".join(map(str, map(int, colors[:, 0]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"g: [\" + \",\".join(map(str, map(int, colors[:, 1]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"b: [\" + \",\".join(map(str, map(int, colors[:, 2]))) + \"],\\n\"\r\n )\r\n elif mapping[\"c\"] in data:\r\n colors = np.array(\r\n [cmaps[series](x) for x in data[mapping[\"c\"]][series]]\r\n )\r\n colors = np.round(colors * 255.0)\r\n output += (\r\n \"r: [\" + \",\".join(map(str, map(int, colors[:, 0]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"g: [\" + \",\".join(map(str, map(int, colors[:, 1]))) + \"],\\n\"\r\n )\r\n output += (\r\n \"b: [\" + \",\".join(map(str, map(int, colors[:, 2]))) + \"],\\n\"\r\n )\r\n output += \"},\\n\"\r\n\r\n output += \"]\"\r\n output += \"},\\n\"\r\n\r\n for name, data in self.trees_data.items():\r\n mapping = self.trees[name][\"mapping\"]\r\n point_helper = self.trees[name][\"point_helper\"]\r\n\r\n output += name + \": {\\n\"\r\n\r\n if point_helper is not None and point_helper in self.scatters_data:\r\n scatter = self.scatters_data[point_helper]\r\n scatter_mapping = self.scatters[point_helper][\"mapping\"]\r\n\r\n x_t = []\r\n y_t = []\r\n z_t = []\r\n\r\n for i in range(len(data[mapping[\"from\"]])):\r\n x_t.append(scatter[scatter_mapping[\"x\"]][data[mapping[\"from\"]][i]])\r\n x_t.append(scatter[scatter_mapping[\"x\"]][data[mapping[\"to\"]][i]])\r\n y_t.append(scatter[scatter_mapping[\"y\"]][data[mapping[\"from\"]][i]])\r\n y_t.append(scatter[scatter_mapping[\"y\"]][data[mapping[\"to\"]][i]])\r\n z_t.append(scatter[scatter_mapping[\"z\"]][data[mapping[\"from\"]][i]])\r\n z_t.append(scatter[scatter_mapping[\"z\"]][data[mapping[\"to\"]][i]])\r\n\r\n x_norm = [round(s * (x - mini) / diff, 3) for x in x_t]\r\n output += f\"x: [\" + \",\".join(map(str, x_norm)) + \"],\\n\"\r\n\r\n y_norm = [round(s * (y - mini) / diff, 3) for y in y_t]\r\n output += \"y: [\" + \",\".join(map(str, y_norm)) + \"],\\n\"\r\n\r\n z_norm = [round(s * (z - mini) / diff, 3) for z in z_t]\r\n output += \"z: [\" + \",\".join(map(str, z_norm)) + \"],\\n\"\r\n else:\r\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\"x\"]]]\r\n output += \"x: [\" + \",\".join(map(str, x_norm)) + \"],\\n\"\r\n\r\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\"y\"]]]\r\n output += \"y: [\" + \",\".join(map(str, y_norm)) + \"],\\n\"\r\n\r\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\"z\"]]]\r\n\r\n output += \"z: [\" + \",\".join(map(str, z_norm)) + \"],\\n\"\r\n\r\n if mapping[\"c\"] in data:\r\n colormap = self.trees[name][\"colormap\"]\r\n cmap = None\r\n if isinstance(colormap, str):\r\n cmap = plt.cm.get_cmap(colormap)\r\n else:\r\n cmap = colormap\r\n\r\n colors = np.array([cmap(x) for x in data[mapping[\"c\"]]])\r\n colors = np.round(colors * 255.0)\r\n output += \"r: [\" + \",\".join(map(str, colors[:, 0])) + \"],\\n\"\r\n output += \"g: [\" + \",\".join(map(str, colors[:, 1])) + \"],\\n\"\r\n output += \"b: [\" + \",\".join(map(str, colors[:, 2])) + \"],\\n\"\r\n\r\n output += \"},\\n\"\r\n\r\n output += \"};\\n\"\r\n\r\n return output","def to_str(array, encoding='utf8'):\n\n if not isinstance(array, np.ndarray):\n raise ValueError('input should be a NumPy array.')\n\n return np.char.decode(array, encoding)","def display(array):\n plt.figure()\n plt.imshow(array)\n plt.show()","def polytope2str(p, name):\n k = p.A.shape[0]\n l = p.A.shape[1]\n # pik=k\n s = \"idxint \"+name+\"k = \"+str(k)+\";\\n\"\n # pil=l\n s = s+\"idxint \"+name+\"l = \"+str(l)+\";\\n\"\n # piA = [A11,A21,...,Ak1,A12,...,Ak2,...,A1l,...,Akl];\n s = s+\"pfloat \"+name+\"A[] = {\"+matrix2str(-1*p.A)+\"};\\n\"\n # pib = [b1,b2,...,bk];\n s = s+\"pfloat \"+name+\"b[] = {\"+matrix2str(-1*p.b)+\"};\\n\"\n # picenter = [p.chebXc1,...,p.chebXcl];\n s = s+\"pfloat \"+name+\"center[] = {\"+matrix2str(p.chebXc)+\"};\\n\"\n return s","def pyplot_to_tensor(pyplot_figure):\n x = pyplot_to_numpy(pyplot_figure=pyplot_figure)\n return x","def arr2str(arr, sep=\", \", fmt=\"{}\"):\n return sep.join([fmt.format(v) for v in arr])","def __str__(self):\n return \"\"\"TimeSeries(%s)\"\"\" % \",\".join([str(entry) for entry in self._timeseriesData])","def _repr_html_(self):\n\n import numpy as np\n import matplotlib.pyplot as plt\n from .._tier9 import imshow\n\n\n size_in_pixels = np.prod(self.shape)\n size_in_bytes = size_in_pixels * self.dtype.itemsize\n\n labels = (self.dtype == np.uint32)\n\n # In case the image is 2D, 3D and larger than 100 pixels, turn on fancy view\n if len(self.shape) in (2, 3) and size_in_pixels >= 100:\n import matplotlib.pyplot as plt\n imshow(self,\n labels=labels,\n continue_drawing=True,\n colorbar=not labels)\n image = self._png_to_html(self._plt_to_png())\n else:\n return \"<pre>cle.array(\" + str(np.asarray(self)) + \", dtype=\" + str(self.dtype) + \")</pre>\"\n\n\n if size_in_bytes > 1024:\n size_in_bytes = size_in_bytes / 1024\n if size_in_bytes > 1024:\n size_in_bytes = size_in_bytes / 1024\n if size_in_bytes > 1024:\n size_in_bytes = size_in_bytes / 1024\n size = \"{:.1f}\".format(size_in_bytes) + \" GB\"\n else:\n size = \"{:.1f}\".format(size_in_bytes) + \" MB\"\n else:\n size = \"{:.1f}\".format(size_in_bytes) + \" kB\"\n else:\n size = \"{:.1f}\".format(size_in_bytes) + \" B\"\n\n histogram = \"\"\n\n if size_in_bytes < 100 * 1024 * 1024:\n if not labels:\n\n import numpy as np\n from .._tier2 import minimum_of_all_pixels, maximum_of_all_pixels\n from .._tier3 import histogram\n\n num_bins = 32\n\n h = np.asarray(histogram(self, num_bins=num_bins))\n\n plt.figure(figsize=(1.8, 1.2))\n plt.bar(range(0, len(h)), h)\n\n # hide axis text\n # https://stackoverflow.com/questions/2176424/hiding-axis-text-in-matplotlib-plots\n # https://pythonguides.com/matplotlib-remove-tick-labels\n frame1 = plt.gca()\n frame1.axes.xaxis.set_ticklabels([])\n frame1.axes.yaxis.set_ticklabels([])\n plt.tick_params(left=False, bottom=False)\n\n histogram = self._png_to_html(self._plt_to_png())\n\n min_max = \"<tr><td>min</td><td>\" + str(self.min()) + \"</td></tr>\" + \\\n \"<tr><td>max</td><td>\" + str(self.max()) + \"</td></tr>\"\n\n else:\n\n min_max = \"\"\n\n all = [\n \"<table>\",\n \"<tr>\",\n \"<td>\",\n image,\n \"</td>\",\n \"<td style=\\\"text-align: center; vertical-align: top;\\\">\",\n \"<b><a href=\\\"https://github.com/clEsperanto/pyclesperanto_prototype\\\" target=\\\"_blank\\\">cle._</a> image</b><br/>\",\n \"<table>\",\n \"<tr><td>shape</td><td>\" + str(self.shape).replace(\" \", \" \") + \"</td></tr>\",\n \"<tr><td>dtype</td><td>\" + str(self.dtype) + \"</td></tr>\",\n \"<tr><td>size</td><td>\" + size + \"</td></tr>\",\n min_max,\n \"</table>\",\n histogram,\n \"</td>\",\n \"</tr>\",\n \"</table>\",\n ]\n\n return \"\\n\".join(all)","def usd_format(self,number_array):\n return np.char.array(np.around(number_array,decimals=3),itemsize=5)","def format_array(self, name, value):\n\n if value is not None and isinstance(value, list):\n array = '%s = [\\n%s]\\n' % (name, self.parse_array(value, 1))\n else:\n array = '%s = None\\n' % name\n return array","def format_graph(axis):\r\n if isinstance(axis, np.ndarray):\r\n return [format_axis(ax) for ax in axis.flat]\r\n else:\r\n return format_axis(axis)","def __str__(self):\n return \"shape[]\"","def save(self, _=None, filename=\"SME.html\", **kwargs):\n # Here we \"hack\" plotly to use base64 encoded data\n # since we have a lot of data to look at\n # this reduces the file size by about a factor 3\n # zipping it would provide another factor 2\n if filename.endswith(\".html\"):\n self.fig.layout.dragmode = \"zoom\"\n fig = self.fig.to_plotly_json()\n # Convert the data to base64\n for i in range(len(fig[\"data\"])):\n for ax in [\"x\", \"y\"]:\n data = np.asarray(fig[\"data\"][i][ax]).astype(\"float32\")\n b64data = b64encode(data).decode(\"utf8\")\n fig[\"data\"][i][ax] = {\"data\": b64data, \"dtype\": \"float32\"}\n\n data = json.dumps(fig[\"data\"])\n layout = json.dumps(fig[\"layout\"])\n # This is the entire html as generated by self.fig.to_html\n # except we replace the data and layout manually\n # and transform it from base64 to TypedArrays\n html = (\n r\"\"\"<html><head><meta charset=\"utf-8\" /></head><body><div>\"\"\"\n r\"\"\"<script type=\"text/javascript\">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>\"\"\"\n r\"\"\"<script src=\"https://cdn.plot.ly/plotly-latest.min.js\"></script>\"\"\"\n r\"\"\"<div id=\"56dedbe2-a786-4b0b-8232-b68dfd7b9eb5\" class=\"plotly-graph-div\" style=\"height:100%; width:100%;\"></div>\"\"\"\n r\"\"\"<script type=\"text/javascript\">\"\"\"\n r\"\"\"window.PLOTLYENV=window.PLOTLYENV || {};\"\"\"\n r\"\"\"if (document.getElementById(\"56dedbe2-a786-4b0b-8232-b68dfd7b9eb5\")) {\"\"\"\n f\"data = {data};\"\n f\"layout = {layout};\"\n r\"\"\"const FromBase64 = function (str) {return new Uint8Array(atob(str).split('').map(function (c) { return c.charCodeAt(0); }));};\"\"\"\n r\"\"\"for (let i = 0; i < data.length; i++){\"\"\"\n r\"\"\"let data_x = data[i].x.data;\"\"\"\n r\"\"\"let data_y = data[i].y.data;\"\"\"\n r\"\"\"data[i].x = new Float32Array(FromBase64(data_x).buffer);\"\"\"\n r\"\"\"data[i].y = new Float32Array(FromBase64(data_y).buffer);\"\"\"\n r\"\"\"}\"\"\"\n r\"\"\"Plotly.newPlot(\"56dedbe2-a786-4b0b-8232-b68dfd7b9eb5\", data, layout, {\"responsive\": true})};\"\"\"\n r\"\"\"</script></div></body></html>\"\"\"\n )\n # Finally try to minimize if possible\n if htmlmin is not None:\n html = htmlmin.minify(html, remove_empty_space=True)\n with open(filename, \"w\") as f:\n f.write(html)\n\n else:\n write_image(self.fig, filename)","def show(arr2d):\n print (\"\\n\".join(\"\\t\".join(row) for row in arr2d))","def plotlyfig2json(fig, fpath=None):\n\n redata = json.loads(json.dumps(fig.data, cls=PlotlyJSONEncoder))\n relayout = json.loads(json.dumps(fig.layout, cls=PlotlyJSONEncoder))\n\n fig_json=json.dumps({'data': redata,'layout': relayout})\n\n if fpath:\n with open(fpath, 'w') as f:\n f.write(fig_json)\n else:\n return fig_json","def __str__(self):\n lst = [str(k) for k in self._navidx[self._index]]\n lst.insert(self._axis, ':')\n return '(' + ', '.join(lst) + ')'","def pyplot_to_numpy(pyplot_figure):\n pyplot_figure.canvas.draw()\n x = np.fromstring(pyplot_figure.canvas.tostring_rgb(), dtype=np.uint8, sep='')\n x = x.reshape(pyplot_figure.canvas.get_width_height()[::-1] + (3,))\n return x","def __str__(self) -> str:\n out = \"STACK: \" + str(self.da.length()) + \" elements. [\"\n out += ', '.join([str(self.da.get_at_index(_))\n for _ in range(self.da.length())])\n return out + ']'","def to_txt(self, fpath):\n np.savetxt(fpath, self._arr.T)","def serialize(self, data):\n if isinstance(data, dict):\n return json.dumps(\n {\n key: value.tolist() if isinstance(value, np.ndarray) else value\n for key, value in data.items()\n }\n )\n\n if hasattr(data, \"read\"):\n return data.read()\n\n if isinstance(data, np.ndarray):\n return json.dumps(data.tolist())\n\n return json.dumps(data)","def format_graph(axis):\n if isinstance(axis, numpy.ndarray):\n return [format_axis(ax) for ax in axis.flat]\n else:\n return format_axis(axis)","def display(self, colorArray):\n pass","def info(cls):\n return 'Xray plots'","def show(self, data):\n if isinstance(data, (numpy.ndarray, h5py.Dataset)):\n isAtomic = len(data.shape) == 0\n isCurve = len(data.shape) == 1 and numpy.issubdtype(data.dtype, numpy.number)\n isImage = len(data.shape) == 2 and numpy.issubdtype(data.dtype, numpy.number)\n if isAtomic:\n self.showAsString(data)\n elif isCurve:\n self.show1d(data)\n elif isImage:\n self.show2d(data)\n else:\n self.showAsString(data)\n else:\n self.showAsString(data)","def _repr_(self):\n return \"Ring of coordinate functions on {}\".format(self._chart)","def __str__(self):\n\n string = \"values:\\n\\t\"\n string += \" x \".join(map(str, self.shape))\n\n string += \" {} ({})\\n\".format(type(self.values).__name__, self.values.dtype)\n\n if self.print_values is True:\n string += str(self.values) + \"\\n\"\n\n string += \"dims:\\n\\t\"\n\n string += \"{}\\n\".format(self.dims)\n\n string += \"coords:\\n\\t\"\n string += \"\\n\\t\".join(map(repr, self.coords))\n\n string += \"\\n\"\n\n string += \"attrs:\\n\"\n\n for ix, key in enumerate(self.attrs.keys()):\n if ix == self.max_print_attrs:\n string += \"\\t+%i attrs\" % (len(self.attrs) - self.max_print_attrs)\n break\n string += \"\\t{!r}: {!r}\\n\".format(key, self.attrs[key])\n\n return string","def __str__(self):\n data_str = [str(i) for i in self._data]\n return \"STACK: { \" + \", \".join(data_str) + \" }\"","def __str__(self):\n data_str = [str(i) for i in self._data]\n return \"STACK: { \" + \", \".join(data_str) + \" }\"","def tostr (x):\n if isinstance (x, tuple):\n return tuple ( map (tostr, x))\n if isinstance(x, (float, numpy.float32,numpy.float64)):\n return float_to_str(x)\n return str(x)","def set_ndarray(name, arr):\n set_to_db(key=name, str_value=arr.ravel().tostring())","def showPlotlyScatter(self, DataFrame, x_axis, y_axis, saving_directory):\r\n fig = px.scatter(DataFrame, x = x_axis, y=y_axis, hover_name= DataFrame.index, color= 'Lib_Tag_contour_ratio',\r\n hover_data= ['Contour_soma_ratio_Lib', 'Lib_Tag_contour_ratio', 'ImgNameInfor_Lib'], width=1050, height=950)\r\n# fig.update_layout(hovermode=\"x\")\r\n fig.write_html(saving_directory, auto_open=True)","def __str__(self):\n shape = self.dataarray.shape\n return 'CouplingAnalysisPurePython: %i variables, %i timesteps.' % (\n shape[0], shape[1])","def plot_array(self):\n locations = np.array([getattr(pulsar, 'location') for pulsar in self.pulsars])\n fig = plt.figure()\n ax = plt.subplot(111, projection=\"hammer\")\n for location in locations:\n plt.plot(location.ra, location.dec, '.', color='b')\n return fig","def matrix2str(A):\n s = \"\"\n for x in numpy.nditer(A, order='F'):\n s = s + str(x) + \",\"\n\n return s","def print_str(self):\n return soho.printArray('\"%s\" [ ' % self.type_name, self.value, \" ]\")","def floatArrayToString(fvalues, prec=3, delem=\",\"):\n\tsvalues = list(map(lambda v : formatFloat(prec, v), fvalues))\n\tdelem = \" \" if delem is None else delem\n\treturn delem.join(svalues)","def __str__(self):\n DataND_str = \"\"\n # Get the properties inherited from Data\n DataND_str += super(DataND, self).__str__() + linesep\n if len(self.axes) == 0:\n DataND_str += \"axes = []\"\n for ii in range(len(self.axes)):\n DataND_str += (\n \"axes[\"\n + str(ii)\n + \"] = \"\n + str(self.axes[ii].as_dict())\n + \"\\n\"\n + linesep\n + linesep\n )\n DataND_str += \"normalizations = \" + str(self.normalizations) + linesep\n DataND_str += \"FTparameters = \" + str(self.FTparameters) + linesep\n DataND_str += \"values = \" + linesep + str(self.values)\n return DataND_str","def _convert_list_to_json(array):\n return json.dumps(array, skipkeys=False, allow_nan=False, indent=None, separators=(\",\", \":\"))"],"string":"[\n \"def np2str(a: np.ndarray) -> str:\\n return json.dumps(a.tolist())\",\n \"def z_as_plotly(self):\\n xs = np.asarray(self.position)[:,2]\\n return numpy_to_plotlystring(xs)\",\n \"def x_as_plotly(self):\\n xs = np.asarray(self.position)[:,0]\\n return numpy_to_plotlystring(xs)\",\n \"def y_as_plotly(self):\\n xs = np.asarray(self.position)[:,1]\\n return numpy_to_plotlystring(xs)\",\n \"def array_to_plotly(arr, with_alpha=False):\\n if with_alpha is True:\\n return np.array(['rgba(%s, %s, %s, %s)' % (r, g, b, a)\\n for r, g, b, a in arr])\\n else:\\n return np.array(['rgb(%s, %s, %s)' % (r, g, b) for r, g, b, _ in arr])\",\n \"def transfer_2d_array_to_str(array):\\n str_list = []\\n for r in array:\\n str_list.append(\\\",\\\".join([str(e) for e in r]))\\n return \\\" \\\".join(str_list)\",\n \"def array2anyscript(arr):\\n def tostr(v):\\n if np.isreal(v):\\n return '{:.12g}'.format(v)\\n elif isinstance(v, (string_types, np.str_)):\\n return '\\\"{}\\\"'.format(v)\\n\\n def createsubarr(arr):\\n outstr = \\\"\\\"\\n if isinstance(arr, np.ndarray):\\n if len(arr) == 1 and not isinstance(arr[0], np.ndarray):\\n return '{'+tostr(arr[0]) + '},'\\n outstr += '{'\\n for row in arr:\\n outstr += createsubarr(row)\\n outstr = outstr.strip(',') + '},'\\n return outstr\\n else:\\n return outstr + tostr(arr)+','\\n if isinstance(arr, np.ndarray) and not arr.shape:\\n return tostr(arr.tolist())\\n elif isinstance(arr, np.ndarray) :\\n return createsubarr(arr).strip(',')\\n elif isinstance( arr, float):\\n return tostr(arr)\\n else:\\n return str(arr)\",\n \"def json_serialize_numpy_array(array):\\n return json.dumps(json_ready_numpy_array(array))\",\n \"def json_serialize_numpy_array(array):\\n return json.dumps(json_ready_numpy_array(array))\",\n \"def __str__(self):\\n return np.array2string(self.graph.toarray())\",\n \"def __str__(self):\\n return str(self.array)\",\n \"def __str__(self):\\n return str(self.arr)\",\n \"def float_array_string(arr: Iterable[float]) -> str:\\n return \\\"[\\\" + \\\", \\\".join([\\\"{:.4f}\\\".format(el) for el in arr]) + \\\"]\\\"\",\n \"def as_str(self):\\n return soho.arrayToString('\\\"%s\\\" [ ' % self.type_name, self.value, \\\" ]\\\")\",\n \"def _numpy_text(tensor):\\n if dtype_util.is_numpy_compatible(tensor.dtype):\\n value = np.array(tensor)\\n if value.shape:\\n text = repr(value)\\n else:\\n text = str(value)\\n else:\\n text = '<unprintable>'\\n if '\\\\n' in text:\\n text = '\\\\n' + text\\n return text\",\n \"def array_to_plot(points, resolution=(0.01872, 0.01872, 0.005), point_size=1.2, outfile_name=\\\"\\\"):\\n # Type in the path to your csv file here\\n \\n thedata = points\\n# print(thedata)\\n\\n # Set tupleResolution to resolution input parameter\\n tupleResolution = resolution;\\n\\n # EG: for Aut1367, the spacing is (0.01872, 0.01872, 0.005).\\n xResolution = tupleResolution[0]\\n yResolution = tupleResolution[1]\\n zResolution = tupleResolution[2]\\n # Now, to get the mm image size, we can multiply all x, y, z\\n # to get the proper mm size when plotting.\\n \\n# print('asdf')\\n# x = [x * xResolution for x in thedata[:, 0]]\\n# print(x)\\n\\n trace1 = graphobjs.Scatter3d(\\n x = [x * xResolution for x in thedata[:, 0]],\\n y = [x * yResolution for x in thedata[:, 1]],\\n z = [x * zResolution for x in thedata[:, 2]],\\n mode='markers',\\n marker=dict(\\n size=point_size,\\n color='cyan', # set color to an array/list of desired values\\n colorscale='Viridis', # choose a colorscale\\n opacity=0.15\\n )\\n )\\n\\n data = [trace1]\\n layout = graphobjs.Layout(\\n margin=dict(\\n l=0,\\n r=0,\\n b=0,\\n t=0\\n ),\\n paper_bgcolor='rgb(0,0,0)',\\n plot_bgcolor='rgb(0,0,0)'\\n )\\n\\n fig = graphobjs.Figure(data=data, layout=layout)\\n# print(self._token + \\\"plotly\\\")\\n\\n make_sure_path_exists('plots')\\n \\n if outfile_name == \\\"\\\":\\n plotly.offline.plot(fig, filename= 'plots/' + token + \\\"_plot.html\\\")\\n else:\\n plotly.offline.plot(fig, filename= 'plots/' + outfile_name + \\\"_plot.html\\\")\",\n \"def as_str(self) -> str:\\n return dumps(self.as_dict(), cls=NumpyEncoder)\",\n \"def create_fig_2d(self, data_array_2d, output_fn='', xlabel='', ylabel='', title=''):\",\n \"def toString(arr2d):\\n return (\\\"\\\\n\\\".join(\\\"\\\\t\\\".join(row) for row in arr2d))\",\n \"def cast_numpy_to_txt(arr, output_file):\\n shape = arr.shape\\n arr = arr.reshape([shape[0] * shape[1], shape[2]])\\n\\n np.savetxt(fname=output_file, X=arr, delimiter=' ', fmt='%.18e', newline='\\\\n', )\",\n \"def array_to_png(arr,\\n path=None,\\n show=True,\\n vmin=None,\\n vmax=None,\\n scale=None,\\n labels=None):\\n scaled, image_mode = autoscale_colors_for_png(arr, vmin=vmin, vmax=vmax)\\n save_to_png(\\n scaled,\\n path=path,\\n show=show,\\n image_mode=image_mode,\\n labels=labels,\\n scale=scale)\",\n \"def _serialize_array(self, array):\\n buffer = io.BytesIO()\\n np.save(buffer, array)\\n return buffer.getvalue()\",\n \"def save_mat_fig(trace_array, gtype=\\\"traceplot\\\"):\\n # fig = Figure()\\n if gtype == \\\"traceplot\\\":\\n print(\\\"ENTER save_traceplot\\\")\\n pm.traceplot(trace_array, figsize=(12,12))\\n print(\\\"PLT.GCF()\\\")\\n fig = plt.gcf()\\n print(\\\"FIGURE\\\")\\n buf = io.BytesIO()\\n print(\\\"BUFF\\\")\\n fig.savefig(buf, format=\\\"png\\\")\\n data = base64.b64encode(buf.getbuffer()).decode(\\\"utf8\\\")\\n elif gtype == \\\"posterior\\\":\\n print(\\\"ENTER plot_posterior\\\")\\n pm.plot_posterior(trace_array, figsize=(12,12))\\n fig = plt.gcf()\\n buf = io.BytesIO()\\n fig.savefig(buf, format=\\\"png\\\")\\n data = base64.b64encode(buf.getbuffer()).decode(\\\"utf8\\\")\\n else:\\n data = []\\n return \\\"data:image/png;base64,{}\\\".format(data)\",\n \"def __str__(self):\\n output = \\\"\\\"\\n for i in self.values:\\n st = []\\n output += \\\"[\\\"\\n for j in i:\\n st.append(str(j))\\n output += \\\",\\\".join(st)+\\\"]\\\"\\n return str(self.m)+\\\"x\\\"+str(self.n)+\\\" [\\\" + output + \\\"]\\\"\",\n \"def arraystr(a, max_line_width=None, precision=None, suppress_small=None):\\n return np.array2string(a, max_line_width,\\n precision, suppress_small,\\n separator=', ', prefix=\\\"\\\", style=str)\\\\\\n .replace('..., ', '..., ' if PY3 else 'Ellipsis, ')\",\n \"def pov_array(arr):\\n return \\\"array[{}] {{{}}}\\\".format(len(arr), \\\", \\\".join(str(x) for x in arr))\",\n \"def __repr__(self):\\n\\t\\treturn repr([self.series[0],self.series[1],self.series[2],\\\"...\\\"])\",\n \"def __str__(self):\\n my_str=\\\"[\\\"\\n for elem in range(self.size):\\n x=cArray.cModule.get_element(self.arrayRef,ctypes.c_int(elem))\\n my_str+=str(x)+\\\" \\\"\\n my_str+=\\\"]\\\"\\n return my_str\",\n \"def __repr__(self):\\r\\n\\r\\n # If the input is a single int/float (with no shape) return a 'scalar'\\r\\n # time-point:\\r\\n if self.shape == ():\\r\\n return \\\"%r %s\\\" % (int(self) / float(self._conversion_factor),\\r\\n self.time_unit)\\r\\n # Otherwise, return the TimeArray representation:\\r\\n else:\\r\\n return np.ndarray.__repr__(self / float(self._conversion_factor)\\r\\n )[:-1] + \\\", time_unit='%s')\\\" % self.time_unit\",\n \"def __repr__(self) -> str:\\n\\n thresh = np.get_printoptions()[\\\"threshold\\\"]\\n np.set_printoptions(threshold=20)\\n extra_chars = len(self.__class__.__name__)\\n arr_str = \\\"data=\\\" + str(self.data).replace(\\\"\\\\n\\\", \\\"\\\\n\\\" + \\\" \\\" * (extra_chars + 6))\\n shape_str = (\\n \\\" \\\" * extra_chars\\n + \\\" shape=\\\"\\n + str(self.shape).replace(\\\"\\\\n\\\", \\\"\\\\n\\\" + \\\" \\\" * (extra_chars + 7))\\n )\\n dtype_str = \\\" \\\" * extra_chars + \\\" dtype=\\\" + str(self.dtype)\\n np.set_printoptions(threshold=thresh)\\n return \\\"{klass}({data},\\\\n{shape},\\\\n{dtype})\\\".format(\\n klass=self.__class__.__name__,\\n data=arr_str,\\n shape=shape_str,\\n dtype=dtype_str,\\n )\",\n \"def array_2d_str(array, fmt='{:.2f}', sep=', ', row_sep='\\\\n', with_boundary=True):\\n ret = row_sep.join([array_str(x, fmt=fmt, sep=sep, with_boundary=with_boundary) for x in array])\\n if with_boundary:\\n ret = '[' + ret + ']'\\n return ret\",\n \"def str_array(arr, sides=(3, 3), delim=\\\", \\\", format=None, log=False, label_log=True):\\n arr = np.asarray(arr)\\n if log:\\n arr = np.log10(arr)\\n\\n len_arr = arr.size\\n beg, end = _str_array_get_beg_end(sides, len_arr)\\n\\n if format is None:\\n format = _guess_str_format_from_range(arr)\\n\\n # Create the style specification\\n form = \\\"{{{}}}\\\".format(format)\\n\\n arr_str = _str_array_1d(arr, beg, end, form, delim)\\n if log and label_log:\\n arr_str += \\\" (log values)\\\"\\n\\n return arr_str\",\n \"def dataAsString(self):\\n\\n # Force generation of .array\\n d = self.asArray()\\n slist = []\\n for l in self.array:\\n s = \\\"%s %s\\\" % (self.name, self.rowAsString(l))\\n slist.append(s)\\n return '\\\\n'.join(slist)\",\n \"def array_str(array, fmt='{:.2f}', sep=', ', with_boundary=True):\\n ret = sep.join([fmt.format(float(x)) for x in array])\\n if with_boundary:\\n ret = '[' + ret + ']'\\n return ret\",\n \"def shape2str(x):\\n return \\\"[\\\" + \\\" x \\\".join([str(x) for x in x.shape]) + \\\"]\\\"\",\n \"def serialize(self):\\r\\n values = ','.join(i.serialize() for i in self.curves)\\r\\n return \\\"[{}]\\\".format(values)\",\n \"def __str__(self):\\n s =\\\"\\\"\\n if self.data is 0:\\n return \\\"[]\\\"\\n else:\\n for i in range(len(self.data)):\\n s += str(self.data[i])\\n if i != len(self.data)-1:\\n s += \\\", \\\"\\n return \\\"[\\\" + s + \\\"]\\\"\",\n \"def to_string(\\n self, freqs: \\\"np.array\\\", *, formatter: Optional[ModelFormatter] = None\\n ) -> str:\\n formatter = formatter if formatter is not None else ModelJSONFormatter()\\n return formatter.format(self, freqs)\",\n \"def _encodeArray(self, array):\\n\\n # Actually, we want dtype,naxis,axNlen,base64(array)\\n return base64.b64encode(array.tostring())\",\n \"def __str__(self):\\n return '[' + ', '.join([str(x) for x in self.elem]) + ']'\",\n \"def pretty_print(image_example):\\n print numpy.array_str(image_example, precision=1, max_line_width=142)\",\n \"def __str__(self):\\n ans = \\\"\\\"\\n for i in range(self.row):\\n for j in range(self.col):\\n ans+=str(self.array[i][j])+\\\" \\\"\\n ans+=\\\"\\\\n\\\"\\n return ans\",\n \"def to_json(self) -> str:\\n data_dict = self._to_list_dict()\\n return json.dumps(data_dict, indent=4, cls=NumpyEncoder)\",\n \"def array_to_concatenated_string(array):\\r\\n return \\\",\\\".join(str(x) for x in array)\",\n \"def SimpleArrayPlotHelper(self,filename):\\n #levels = np.linspace(-100.0, 9900.0, 100, endpoint=True)\\n plt.figure()\\n #plt.contourf(orography_field,levels)\\n plt.colorbar()\\n pts.invert_y_axis()\",\n \"def basic_array_ejection():\\n arr: pa.Array = pa.array([1, 2, 3, 4, 5], type=pa.int8())\\n\\n srs: pd.Series = arr.to_pandas() # NOTE: Requires pandas installation\\n nparr: np.ndarray = arr.to_numpy()\\n list_: List[dict] = arr.to_pylist()\\n str_: str = arr.to_string()\\n\\n results = {\\n 'to_pandas > to_list': srs.to_list(),\\n 'to_numpy > tolist': nparr.tolist(),\\n 'to_pylist': list_,\\n 'to_string': str_,\\n }\\n\\n pretty_print_result_map(results)\",\n \"def plotMatrix(matrix:np.ndarray,if_log=False,title=\\\"Matrix\\\",plotType=\\\"static\\\",range_color=None,\\n axis2genome=False,genome_coord1=None,genome_coord2=None,resolution = None):\\n import plotly.express as px \\n from IPython.display import Image\\n\\n if(if_log == True): \\n matrix = np.log10(matrix)\\n\\n fig = px.imshow(matrix,color_continuous_scale=px.colors.sequential.Viridis,range_color=range_color)\\n fig = fig.update_layout(template='simple_white').update_layout(width=650,height=600)\\n\\n if (axis2genome):\\n import re\\n #manually change axis\\n posx = re.split(\\\"[:-]\\\",genome_coord2)\\n xvals = np.percentile([np.round(i) for i in range(0,matrix.shape[1])],(0,25,50,75,100),interpolation='midpoint')\\n xtexts = xvals*resolution + int(posx[1].replace(\\\",\\\",\\\"\\\")) + resolution/2\\n xtexts = [genomecoord2human(i) for i in xtexts]\\n\\n posy = re.split(\\\"[:-]\\\",genome_coord1)\\n yvals = np.percentile([np.round(i) for i in range(0,matrix.shape[0])],(0,25,50,75,100),interpolation='midpoint')\\n ytexts = yvals*resolution + int(posy[1].replace(\\\",\\\",\\\"\\\")) + resolution/2\\n ytexts = [genomecoord2human(i) for i in ytexts]\\n\\n fig = fig.update_xaxes(ticktext = xtexts,tickvals = xvals).update_yaxes(ticktext = ytexts,tickvals = yvals)\\n\\n if(plotType == \\\"interaction\\\"):\\n return fig\\n else : return Image(fig.to_image(format=\\\"png\\\", engine=\\\"kaleido\\\"))\",\n \"def ncvar_to_str(data, variable_name, unit_factor=1., separator=','):\\n return np.array2string(unit_factor*data[variable_name][:],\\n separator=separator, precision=3,\\n max_line_width=80)[1:-1] + '\\\\n'\",\n \"def plot_data(self):\",\n \"def _dump_plotly(objs, images, func):\\n l = len(objs)\\n #print(l)\\n titles = []\\n for i,x in enumerate(objs):\\n if 'id' in x:\\n titles.append('shape id %d' % x.id)\\n else:\\n titles.append('item %d' % i)\\n fig = tools.make_subplots(rows=l, cols=1, subplot_titles = titles,print_grid=False )\\n #print('figure attmpt: ')\\n #fig['layout']['xaxis1'].update(title='monkeybar')\\n #for x in fig['layout']['xaxis1']:\\n #print(x)\\n fig.layout.showlegend = False\\n for i,x in enumerate(objs):\\n traces,annotations,title = func(x,images[i])\\n im = {\\n \\\"source\\\": 'data:image/png;base64, ' + getbase64(images[i]),\\n \\\"x\\\": 1,\\n \\\"y\\\": 1 - i/(l-.5),\\n \\\"sizex\\\": .5,\\n \\\"sizey\\\": .5,\\n }\\n fig.layout.images.append(im)\\n for t in traces:\\n fig.append_trace(t,i+1,1)\\n if title is not None:\\n fig.layout['xaxis%d' % (i+1)].update(title=title)\\n if annotations is not None:\\n for a in annotations:\\n a['xref'] = 'x%d' % (i+1)\\n a['yref'] = 'y%d' % (i+1)\\n fig.layout.annotations += annotations\\n\\n fig['layout'].update(height=400*l, width=1100, margin={\\n 'l':80,\\n 'r':330,\\n 't':100,\\n 'b':80,\\n 'pad':0,\\n 'autoexpand':True,\\n },title='plots')\\n\\n return fig\",\n \"def resToStr(self, res):\\n for i in range(self.npeaks):\\n # Remove meaningless parameter values\\n if not self.peakTyp[i].startswith('A'):\\n res[i][3] = 0.0\\n if not(self.peakTyp[i] == 'P' or self.peakTyp[i] == 'AP'):\\n res[i][4] = 0.0\\n strres = np.array2string(res, precision=3, separator=',',\\n sign='+', suppress_small=True)\\n return strres\",\n \"def _get_plotlyjs() -> str:\\n js = get_plotlyjs()\\n base_symbols = ['circle', 'diamond', 'square', 'hexagram']\\n ds_ids = [37, 38, 39, 40, 34, 33, 35, 36]\\n for base in base_symbols:\\n for ds in ds_ids:\\n old, new = _draw_mash(base_symbol=base, ds_symbol=ds)\\n if len(re.findall(old, js)) != 1:\\n raise ImportError(\\\"Warning: Incompatible version of Plotly Detected. Please use v5.7.0\\\")\\n js = re.sub(old, new, js)\\n return js\",\n \"def __repr__(self):\\r\\n\\r\\n #If the input is a single int/float (with no shape) return a 'scalar'\\r\\n #time-point:\\r\\n if self.shape == ():\\r\\n return \\\"%r %s\\\" % (int(self) / float(self._conversion_factor),\\r\\n self.time_unit)\\r\\n\\r\\n #Otherwise, return the UniformTime representation:\\r\\n else:\\r\\n return np.ndarray.__repr__(self / float(self._conversion_factor)\\r\\n )[:-1] + \\\", time_unit='%s')\\\" % self.time_unit\",\n \"def array_to_concatenated_string(array):\\n return \\\",\\\".join(str(x) for x in array)\",\n \"def fig2data ( fig ):\\n # draw the renderer\\n fig.canvas.draw ( )\\n buf = np.array(fig.canvas.renderer._renderer)\\n return buf\",\n \"def pov_2d_array(array_list):\\n return \\\"array[{}][{}] {{{}}}\\\".format(\\n len(array_list),\\n len(array_list[0]),\\n \\\", \\\".join(\\\"{{{}}}\\\".format(\\\", \\\".join(str(x) for x in arr)) for arr in array_list)\\n )\",\n \"def trajectory_to_json(trajectory: Trajectory) -> str:\\n # numpy arrays need to be converted to normal tuples\\n return json.dumps(trajectory, cls=NumpyEncoder)\",\n \"def __str__(self):\\n return str(self.asMatrix())\",\n \"def image2str(arr: np.ndarray, char='X', *, columns=28) -> str:\\n if isinstance(arr, np.ndarray):\\n dims = len(arr.shape)\\n else:\\n dims, a = 0, arr\\n while True:\\n try:\\n a = a[0]\\n except TypeError:\\n break\\n dims += 1\\n if dims == 1:\\n arr = [arr[i:i+columns] for i in range(0, len(arr), columns)]\\n # for i in arr: print(' '.join(f'{x:>3}' for x in i)) # to print nicely as numbers\\n elif dims != 2:\\n raise ValueError(\\\"Can not convert many-dimensional array to string\\\")\\n return '\\\\n'.join(''.join(char if i else ' ' for i in row) for row in arr)\",\n \"def tostring(self, transformer=None):\\n\\t\\tresult = ''\\n\\t\\tif not transformer:\\n\\t\\t\\ttransformer = str\\n\\t\\tfor start in range(0, len(self.data), self.dims[0]):\\n\\t\\t\\tfor c in self.data[start:start+self.dims[0]]:\\n\\t\\t\\t\\tresult += transformer(c)\\n\\t\\t\\tresult += '\\\\n'\\n\\t\\treturn result\",\n \"def obs_to_string(observations):\\n str_obs = []\\n for obs in observations:\\n str_obs.append(obs.reshape(-1).tostring())\\n return str_obs\",\n \"def __str__(self):\\n lst = [str(i) for i in self.data]\\n if self.column:\\n return '[' + ', '.join(lst) + ']\\\\''\\n else:\\n return '[' + ', '.join(lst) + ']'\",\n \"def create_data(self) -> str:\\r\\n s = self.scale\\r\\n mini, maxi = self.get_min_max()\\r\\n diff = maxi - mini\\r\\n\\r\\n output = \\\"const data = {\\\\n\\\"\\r\\n\\r\\n # Create the data for the scatters\\r\\n # TODO: If it's not interactive, labels shouldn't be exported.\\r\\n for name, data in self.scatters_data.items():\\r\\n mapping = self.scatters[name][\\\"mapping\\\"]\\r\\n colormaps = self.scatters[name][\\\"colormap\\\"]\\r\\n cmaps = [None] * len(colormaps)\\r\\n\\r\\n for i, colormap in enumerate(colormaps):\\r\\n if isinstance(colormap, str):\\r\\n cmaps[i] = plt.cm.get_cmap(colormap)\\r\\n else:\\r\\n cmaps[i] = colormap\\r\\n\\r\\n output += name + \\\": {\\\\n\\\"\\r\\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\\\"x\\\"]]]\\r\\n output += \\\"x: [\\\" + \\\",\\\".join(map(str, x_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\\\"y\\\"]]]\\r\\n output += \\\"y: [\\\" + \\\",\\\".join(map(str, y_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\\\"z\\\"]]]\\r\\n output += \\\"z: [\\\" + \\\",\\\".join(map(str, z_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n if mapping[\\\"labels\\\"] in data:\\r\\n fmt_labels = [\\\"'{0}'\\\".format(s) for s in data[mapping[\\\"labels\\\"]]]\\r\\n output += \\\"labels: [\\\" + \\\",\\\".join(fmt_labels) + \\\"],\\\\n\\\"\\r\\n\\r\\n if mapping[\\\"s\\\"] in data:\\r\\n output += \\\"s: [\\\"\\r\\n\\r\\n for series in range(len(data[mapping[\\\"s\\\"]])):\\r\\n output += (\\r\\n \\\"[\\\"\\r\\n + \\\",\\\".join(map(str, np.round(data[mapping[\\\"s\\\"]][series], 3)))\\r\\n + \\\"],\\\\n\\\"\\r\\n )\\r\\n\\r\\n output += \\\"],\\\\n\\\"\\r\\n\\r\\n output += \\\"colors: [\\\\n\\\"\\r\\n for series in range(len(data[mapping[\\\"c\\\"]])):\\r\\n output += \\\"{\\\\n\\\"\\r\\n if mapping[\\\"cs\\\"] in data:\\r\\n colors = np.array(\\r\\n [cmaps[series](x) for x in data[mapping[\\\"c\\\"]][series]]\\r\\n )\\r\\n\\r\\n for i, c in enumerate(colors):\\r\\n hsl = np.array(colour.rgb2hsl(c[:3]))\\r\\n hsl[1] = hsl[1] - hsl[1] * data[mapping[\\\"cs\\\"]][series][i]\\r\\n colors[i] = np.append(np.array(colour.hsl2rgb(hsl)), 1.0)\\r\\n\\r\\n colors = np.round(colors * 255.0)\\r\\n\\r\\n output += (\\r\\n \\\"r: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 0]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"g: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 1]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"b: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 2]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n elif mapping[\\\"c\\\"] in data:\\r\\n colors = np.array(\\r\\n [cmaps[series](x) for x in data[mapping[\\\"c\\\"]][series]]\\r\\n )\\r\\n colors = np.round(colors * 255.0)\\r\\n output += (\\r\\n \\\"r: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 0]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"g: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 1]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += (\\r\\n \\\"b: [\\\" + \\\",\\\".join(map(str, map(int, colors[:, 2]))) + \\\"],\\\\n\\\"\\r\\n )\\r\\n output += \\\"},\\\\n\\\"\\r\\n\\r\\n output += \\\"]\\\"\\r\\n output += \\\"},\\\\n\\\"\\r\\n\\r\\n for name, data in self.trees_data.items():\\r\\n mapping = self.trees[name][\\\"mapping\\\"]\\r\\n point_helper = self.trees[name][\\\"point_helper\\\"]\\r\\n\\r\\n output += name + \\\": {\\\\n\\\"\\r\\n\\r\\n if point_helper is not None and point_helper in self.scatters_data:\\r\\n scatter = self.scatters_data[point_helper]\\r\\n scatter_mapping = self.scatters[point_helper][\\\"mapping\\\"]\\r\\n\\r\\n x_t = []\\r\\n y_t = []\\r\\n z_t = []\\r\\n\\r\\n for i in range(len(data[mapping[\\\"from\\\"]])):\\r\\n x_t.append(scatter[scatter_mapping[\\\"x\\\"]][data[mapping[\\\"from\\\"]][i]])\\r\\n x_t.append(scatter[scatter_mapping[\\\"x\\\"]][data[mapping[\\\"to\\\"]][i]])\\r\\n y_t.append(scatter[scatter_mapping[\\\"y\\\"]][data[mapping[\\\"from\\\"]][i]])\\r\\n y_t.append(scatter[scatter_mapping[\\\"y\\\"]][data[mapping[\\\"to\\\"]][i]])\\r\\n z_t.append(scatter[scatter_mapping[\\\"z\\\"]][data[mapping[\\\"from\\\"]][i]])\\r\\n z_t.append(scatter[scatter_mapping[\\\"z\\\"]][data[mapping[\\\"to\\\"]][i]])\\r\\n\\r\\n x_norm = [round(s * (x - mini) / diff, 3) for x in x_t]\\r\\n output += f\\\"x: [\\\" + \\\",\\\".join(map(str, x_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n y_norm = [round(s * (y - mini) / diff, 3) for y in y_t]\\r\\n output += \\\"y: [\\\" + \\\",\\\".join(map(str, y_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n z_norm = [round(s * (z - mini) / diff, 3) for z in z_t]\\r\\n output += \\\"z: [\\\" + \\\",\\\".join(map(str, z_norm)) + \\\"],\\\\n\\\"\\r\\n else:\\r\\n x_norm = [round(s * (x - mini) / diff, 3) for x in data[mapping[\\\"x\\\"]]]\\r\\n output += \\\"x: [\\\" + \\\",\\\".join(map(str, x_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n y_norm = [round(s * (y - mini) / diff, 3) for y in data[mapping[\\\"y\\\"]]]\\r\\n output += \\\"y: [\\\" + \\\",\\\".join(map(str, y_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n z_norm = [round(s * (z - mini) / diff, 3) for z in data[mapping[\\\"z\\\"]]]\\r\\n\\r\\n output += \\\"z: [\\\" + \\\",\\\".join(map(str, z_norm)) + \\\"],\\\\n\\\"\\r\\n\\r\\n if mapping[\\\"c\\\"] in data:\\r\\n colormap = self.trees[name][\\\"colormap\\\"]\\r\\n cmap = None\\r\\n if isinstance(colormap, str):\\r\\n cmap = plt.cm.get_cmap(colormap)\\r\\n else:\\r\\n cmap = colormap\\r\\n\\r\\n colors = np.array([cmap(x) for x in data[mapping[\\\"c\\\"]]])\\r\\n colors = np.round(colors * 255.0)\\r\\n output += \\\"r: [\\\" + \\\",\\\".join(map(str, colors[:, 0])) + \\\"],\\\\n\\\"\\r\\n output += \\\"g: [\\\" + \\\",\\\".join(map(str, colors[:, 1])) + \\\"],\\\\n\\\"\\r\\n output += \\\"b: [\\\" + \\\",\\\".join(map(str, colors[:, 2])) + \\\"],\\\\n\\\"\\r\\n\\r\\n output += \\\"},\\\\n\\\"\\r\\n\\r\\n output += \\\"};\\\\n\\\"\\r\\n\\r\\n return output\",\n \"def to_str(array, encoding='utf8'):\\n\\n if not isinstance(array, np.ndarray):\\n raise ValueError('input should be a NumPy array.')\\n\\n return np.char.decode(array, encoding)\",\n \"def display(array):\\n plt.figure()\\n plt.imshow(array)\\n plt.show()\",\n \"def polytope2str(p, name):\\n k = p.A.shape[0]\\n l = p.A.shape[1]\\n # pik=k\\n s = \\\"idxint \\\"+name+\\\"k = \\\"+str(k)+\\\";\\\\n\\\"\\n # pil=l\\n s = s+\\\"idxint \\\"+name+\\\"l = \\\"+str(l)+\\\";\\\\n\\\"\\n # piA = [A11,A21,...,Ak1,A12,...,Ak2,...,A1l,...,Akl];\\n s = s+\\\"pfloat \\\"+name+\\\"A[] = {\\\"+matrix2str(-1*p.A)+\\\"};\\\\n\\\"\\n # pib = [b1,b2,...,bk];\\n s = s+\\\"pfloat \\\"+name+\\\"b[] = {\\\"+matrix2str(-1*p.b)+\\\"};\\\\n\\\"\\n # picenter = [p.chebXc1,...,p.chebXcl];\\n s = s+\\\"pfloat \\\"+name+\\\"center[] = {\\\"+matrix2str(p.chebXc)+\\\"};\\\\n\\\"\\n return s\",\n \"def pyplot_to_tensor(pyplot_figure):\\n x = pyplot_to_numpy(pyplot_figure=pyplot_figure)\\n return x\",\n \"def arr2str(arr, sep=\\\", \\\", fmt=\\\"{}\\\"):\\n return sep.join([fmt.format(v) for v in arr])\",\n \"def __str__(self):\\n return \\\"\\\"\\\"TimeSeries(%s)\\\"\\\"\\\" % \\\",\\\".join([str(entry) for entry in self._timeseriesData])\",\n \"def _repr_html_(self):\\n\\n import numpy as np\\n import matplotlib.pyplot as plt\\n from .._tier9 import imshow\\n\\n\\n size_in_pixels = np.prod(self.shape)\\n size_in_bytes = size_in_pixels * self.dtype.itemsize\\n\\n labels = (self.dtype == np.uint32)\\n\\n # In case the image is 2D, 3D and larger than 100 pixels, turn on fancy view\\n if len(self.shape) in (2, 3) and size_in_pixels >= 100:\\n import matplotlib.pyplot as plt\\n imshow(self,\\n labels=labels,\\n continue_drawing=True,\\n colorbar=not labels)\\n image = self._png_to_html(self._plt_to_png())\\n else:\\n return \\\"<pre>cle.array(\\\" + str(np.asarray(self)) + \\\", dtype=\\\" + str(self.dtype) + \\\")</pre>\\\"\\n\\n\\n if size_in_bytes > 1024:\\n size_in_bytes = size_in_bytes / 1024\\n if size_in_bytes > 1024:\\n size_in_bytes = size_in_bytes / 1024\\n if size_in_bytes > 1024:\\n size_in_bytes = size_in_bytes / 1024\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" GB\\\"\\n else:\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" MB\\\"\\n else:\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" kB\\\"\\n else:\\n size = \\\"{:.1f}\\\".format(size_in_bytes) + \\\" B\\\"\\n\\n histogram = \\\"\\\"\\n\\n if size_in_bytes < 100 * 1024 * 1024:\\n if not labels:\\n\\n import numpy as np\\n from .._tier2 import minimum_of_all_pixels, maximum_of_all_pixels\\n from .._tier3 import histogram\\n\\n num_bins = 32\\n\\n h = np.asarray(histogram(self, num_bins=num_bins))\\n\\n plt.figure(figsize=(1.8, 1.2))\\n plt.bar(range(0, len(h)), h)\\n\\n # hide axis text\\n # https://stackoverflow.com/questions/2176424/hiding-axis-text-in-matplotlib-plots\\n # https://pythonguides.com/matplotlib-remove-tick-labels\\n frame1 = plt.gca()\\n frame1.axes.xaxis.set_ticklabels([])\\n frame1.axes.yaxis.set_ticklabels([])\\n plt.tick_params(left=False, bottom=False)\\n\\n histogram = self._png_to_html(self._plt_to_png())\\n\\n min_max = \\\"<tr><td>min</td><td>\\\" + str(self.min()) + \\\"</td></tr>\\\" + \\\\\\n \\\"<tr><td>max</td><td>\\\" + str(self.max()) + \\\"</td></tr>\\\"\\n\\n else:\\n\\n min_max = \\\"\\\"\\n\\n all = [\\n \\\"<table>\\\",\\n \\\"<tr>\\\",\\n \\\"<td>\\\",\\n image,\\n \\\"</td>\\\",\\n \\\"<td style=\\\\\\\"text-align: center; vertical-align: top;\\\\\\\">\\\",\\n \\\"<b><a href=\\\\\\\"https://github.com/clEsperanto/pyclesperanto_prototype\\\\\\\" target=\\\\\\\"_blank\\\\\\\">cle._</a> image</b><br/>\\\",\\n \\\"<table>\\\",\\n \\\"<tr><td>shape</td><td>\\\" + str(self.shape).replace(\\\" \\\", \\\" \\\") + \\\"</td></tr>\\\",\\n \\\"<tr><td>dtype</td><td>\\\" + str(self.dtype) + \\\"</td></tr>\\\",\\n \\\"<tr><td>size</td><td>\\\" + size + \\\"</td></tr>\\\",\\n min_max,\\n \\\"</table>\\\",\\n histogram,\\n \\\"</td>\\\",\\n \\\"</tr>\\\",\\n \\\"</table>\\\",\\n ]\\n\\n return \\\"\\\\n\\\".join(all)\",\n \"def usd_format(self,number_array):\\n return np.char.array(np.around(number_array,decimals=3),itemsize=5)\",\n \"def format_array(self, name, value):\\n\\n if value is not None and isinstance(value, list):\\n array = '%s = [\\\\n%s]\\\\n' % (name, self.parse_array(value, 1))\\n else:\\n array = '%s = None\\\\n' % name\\n return array\",\n \"def format_graph(axis):\\r\\n if isinstance(axis, np.ndarray):\\r\\n return [format_axis(ax) for ax in axis.flat]\\r\\n else:\\r\\n return format_axis(axis)\",\n \"def __str__(self):\\n return \\\"shape[]\\\"\",\n \"def save(self, _=None, filename=\\\"SME.html\\\", **kwargs):\\n # Here we \\\"hack\\\" plotly to use base64 encoded data\\n # since we have a lot of data to look at\\n # this reduces the file size by about a factor 3\\n # zipping it would provide another factor 2\\n if filename.endswith(\\\".html\\\"):\\n self.fig.layout.dragmode = \\\"zoom\\\"\\n fig = self.fig.to_plotly_json()\\n # Convert the data to base64\\n for i in range(len(fig[\\\"data\\\"])):\\n for ax in [\\\"x\\\", \\\"y\\\"]:\\n data = np.asarray(fig[\\\"data\\\"][i][ax]).astype(\\\"float32\\\")\\n b64data = b64encode(data).decode(\\\"utf8\\\")\\n fig[\\\"data\\\"][i][ax] = {\\\"data\\\": b64data, \\\"dtype\\\": \\\"float32\\\"}\\n\\n data = json.dumps(fig[\\\"data\\\"])\\n layout = json.dumps(fig[\\\"layout\\\"])\\n # This is the entire html as generated by self.fig.to_html\\n # except we replace the data and layout manually\\n # and transform it from base64 to TypedArrays\\n html = (\\n r\\\"\\\"\\\"<html><head><meta charset=\\\"utf-8\\\" /></head><body><div>\\\"\\\"\\\"\\n r\\\"\\\"\\\"<script type=\\\"text/javascript\\\">window.PlotlyConfig = {MathJaxConfig: 'local'};</script>\\\"\\\"\\\"\\n r\\\"\\\"\\\"<script src=\\\"https://cdn.plot.ly/plotly-latest.min.js\\\"></script>\\\"\\\"\\\"\\n r\\\"\\\"\\\"<div id=\\\"56dedbe2-a786-4b0b-8232-b68dfd7b9eb5\\\" class=\\\"plotly-graph-div\\\" style=\\\"height:100%; width:100%;\\\"></div>\\\"\\\"\\\"\\n r\\\"\\\"\\\"<script type=\\\"text/javascript\\\">\\\"\\\"\\\"\\n r\\\"\\\"\\\"window.PLOTLYENV=window.PLOTLYENV || {};\\\"\\\"\\\"\\n r\\\"\\\"\\\"if (document.getElementById(\\\"56dedbe2-a786-4b0b-8232-b68dfd7b9eb5\\\")) {\\\"\\\"\\\"\\n f\\\"data = {data};\\\"\\n f\\\"layout = {layout};\\\"\\n r\\\"\\\"\\\"const FromBase64 = function (str) {return new Uint8Array(atob(str).split('').map(function (c) { return c.charCodeAt(0); }));};\\\"\\\"\\\"\\n r\\\"\\\"\\\"for (let i = 0; i < data.length; i++){\\\"\\\"\\\"\\n r\\\"\\\"\\\"let data_x = data[i].x.data;\\\"\\\"\\\"\\n r\\\"\\\"\\\"let data_y = data[i].y.data;\\\"\\\"\\\"\\n r\\\"\\\"\\\"data[i].x = new Float32Array(FromBase64(data_x).buffer);\\\"\\\"\\\"\\n r\\\"\\\"\\\"data[i].y = new Float32Array(FromBase64(data_y).buffer);\\\"\\\"\\\"\\n r\\\"\\\"\\\"}\\\"\\\"\\\"\\n r\\\"\\\"\\\"Plotly.newPlot(\\\"56dedbe2-a786-4b0b-8232-b68dfd7b9eb5\\\", data, layout, {\\\"responsive\\\": true})};\\\"\\\"\\\"\\n r\\\"\\\"\\\"</script></div></body></html>\\\"\\\"\\\"\\n )\\n # Finally try to minimize if possible\\n if htmlmin is not None:\\n html = htmlmin.minify(html, remove_empty_space=True)\\n with open(filename, \\\"w\\\") as f:\\n f.write(html)\\n\\n else:\\n write_image(self.fig, filename)\",\n \"def show(arr2d):\\n print (\\\"\\\\n\\\".join(\\\"\\\\t\\\".join(row) for row in arr2d))\",\n \"def plotlyfig2json(fig, fpath=None):\\n\\n redata = json.loads(json.dumps(fig.data, cls=PlotlyJSONEncoder))\\n relayout = json.loads(json.dumps(fig.layout, cls=PlotlyJSONEncoder))\\n\\n fig_json=json.dumps({'data': redata,'layout': relayout})\\n\\n if fpath:\\n with open(fpath, 'w') as f:\\n f.write(fig_json)\\n else:\\n return fig_json\",\n \"def __str__(self):\\n lst = [str(k) for k in self._navidx[self._index]]\\n lst.insert(self._axis, ':')\\n return '(' + ', '.join(lst) + ')'\",\n \"def pyplot_to_numpy(pyplot_figure):\\n pyplot_figure.canvas.draw()\\n x = np.fromstring(pyplot_figure.canvas.tostring_rgb(), dtype=np.uint8, sep='')\\n x = x.reshape(pyplot_figure.canvas.get_width_height()[::-1] + (3,))\\n return x\",\n \"def __str__(self) -> str:\\n out = \\\"STACK: \\\" + str(self.da.length()) + \\\" elements. [\\\"\\n out += ', '.join([str(self.da.get_at_index(_))\\n for _ in range(self.da.length())])\\n return out + ']'\",\n \"def to_txt(self, fpath):\\n np.savetxt(fpath, self._arr.T)\",\n \"def serialize(self, data):\\n if isinstance(data, dict):\\n return json.dumps(\\n {\\n key: value.tolist() if isinstance(value, np.ndarray) else value\\n for key, value in data.items()\\n }\\n )\\n\\n if hasattr(data, \\\"read\\\"):\\n return data.read()\\n\\n if isinstance(data, np.ndarray):\\n return json.dumps(data.tolist())\\n\\n return json.dumps(data)\",\n \"def format_graph(axis):\\n if isinstance(axis, numpy.ndarray):\\n return [format_axis(ax) for ax in axis.flat]\\n else:\\n return format_axis(axis)\",\n \"def display(self, colorArray):\\n pass\",\n \"def info(cls):\\n return 'Xray plots'\",\n \"def show(self, data):\\n if isinstance(data, (numpy.ndarray, h5py.Dataset)):\\n isAtomic = len(data.shape) == 0\\n isCurve = len(data.shape) == 1 and numpy.issubdtype(data.dtype, numpy.number)\\n isImage = len(data.shape) == 2 and numpy.issubdtype(data.dtype, numpy.number)\\n if isAtomic:\\n self.showAsString(data)\\n elif isCurve:\\n self.show1d(data)\\n elif isImage:\\n self.show2d(data)\\n else:\\n self.showAsString(data)\\n else:\\n self.showAsString(data)\",\n \"def _repr_(self):\\n return \\\"Ring of coordinate functions on {}\\\".format(self._chart)\",\n \"def __str__(self):\\n\\n string = \\\"values:\\\\n\\\\t\\\"\\n string += \\\" x \\\".join(map(str, self.shape))\\n\\n string += \\\" {} ({})\\\\n\\\".format(type(self.values).__name__, self.values.dtype)\\n\\n if self.print_values is True:\\n string += str(self.values) + \\\"\\\\n\\\"\\n\\n string += \\\"dims:\\\\n\\\\t\\\"\\n\\n string += \\\"{}\\\\n\\\".format(self.dims)\\n\\n string += \\\"coords:\\\\n\\\\t\\\"\\n string += \\\"\\\\n\\\\t\\\".join(map(repr, self.coords))\\n\\n string += \\\"\\\\n\\\"\\n\\n string += \\\"attrs:\\\\n\\\"\\n\\n for ix, key in enumerate(self.attrs.keys()):\\n if ix == self.max_print_attrs:\\n string += \\\"\\\\t+%i attrs\\\" % (len(self.attrs) - self.max_print_attrs)\\n break\\n string += \\\"\\\\t{!r}: {!r}\\\\n\\\".format(key, self.attrs[key])\\n\\n return string\",\n \"def __str__(self):\\n data_str = [str(i) for i in self._data]\\n return \\\"STACK: { \\\" + \\\", \\\".join(data_str) + \\\" }\\\"\",\n \"def __str__(self):\\n data_str = [str(i) for i in self._data]\\n return \\\"STACK: { \\\" + \\\", \\\".join(data_str) + \\\" }\\\"\",\n \"def tostr (x):\\n if isinstance (x, tuple):\\n return tuple ( map (tostr, x))\\n if isinstance(x, (float, numpy.float32,numpy.float64)):\\n return float_to_str(x)\\n return str(x)\",\n \"def set_ndarray(name, arr):\\n set_to_db(key=name, str_value=arr.ravel().tostring())\",\n \"def showPlotlyScatter(self, DataFrame, x_axis, y_axis, saving_directory):\\r\\n fig = px.scatter(DataFrame, x = x_axis, y=y_axis, hover_name= DataFrame.index, color= 'Lib_Tag_contour_ratio',\\r\\n hover_data= ['Contour_soma_ratio_Lib', 'Lib_Tag_contour_ratio', 'ImgNameInfor_Lib'], width=1050, height=950)\\r\\n# fig.update_layout(hovermode=\\\"x\\\")\\r\\n fig.write_html(saving_directory, auto_open=True)\",\n \"def __str__(self):\\n shape = self.dataarray.shape\\n return 'CouplingAnalysisPurePython: %i variables, %i timesteps.' % (\\n shape[0], shape[1])\",\n \"def plot_array(self):\\n locations = np.array([getattr(pulsar, 'location') for pulsar in self.pulsars])\\n fig = plt.figure()\\n ax = plt.subplot(111, projection=\\\"hammer\\\")\\n for location in locations:\\n plt.plot(location.ra, location.dec, '.', color='b')\\n return fig\",\n \"def matrix2str(A):\\n s = \\\"\\\"\\n for x in numpy.nditer(A, order='F'):\\n s = s + str(x) + \\\",\\\"\\n\\n return s\",\n \"def print_str(self):\\n return soho.printArray('\\\"%s\\\" [ ' % self.type_name, self.value, \\\" ]\\\")\",\n \"def floatArrayToString(fvalues, prec=3, delem=\\\",\\\"):\\n\\tsvalues = list(map(lambda v : formatFloat(prec, v), fvalues))\\n\\tdelem = \\\" \\\" if delem is None else delem\\n\\treturn delem.join(svalues)\",\n \"def __str__(self):\\n DataND_str = \\\"\\\"\\n # Get the properties inherited from Data\\n DataND_str += super(DataND, self).__str__() + linesep\\n if len(self.axes) == 0:\\n DataND_str += \\\"axes = []\\\"\\n for ii in range(len(self.axes)):\\n DataND_str += (\\n \\\"axes[\\\"\\n + str(ii)\\n + \\\"] = \\\"\\n + str(self.axes[ii].as_dict())\\n + \\\"\\\\n\\\"\\n + linesep\\n + linesep\\n )\\n DataND_str += \\\"normalizations = \\\" + str(self.normalizations) + linesep\\n DataND_str += \\\"FTparameters = \\\" + str(self.FTparameters) + linesep\\n DataND_str += \\\"values = \\\" + linesep + str(self.values)\\n return DataND_str\",\n \"def _convert_list_to_json(array):\\n return json.dumps(array, skipkeys=False, allow_nan=False, indent=None, separators=(\\\",\\\", \\\":\\\"))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7462204","0.73186773","0.71991277","0.692029","0.65574473","0.6528165","0.64883965","0.64638263","0.64638263","0.63993347","0.6335","0.6298709","0.6124041","0.6007191","0.59757954","0.5960761","0.5929254","0.588368","0.58670706","0.58461416","0.5804916","0.58008885","0.5776578","0.5733173","0.57302505","0.57210433","0.5719011","0.5701813","0.56870437","0.56865394","0.56757957","0.5629323","0.5599684","0.5597031","0.55927587","0.55733943","0.5570738","0.5539032","0.55189794","0.55175334","0.5473294","0.5471763","0.5453611","0.54327184","0.53961873","0.5381068","0.5374481","0.53730965","0.53678715","0.5359267","0.5358339","0.53581196","0.53511053","0.534629","0.53274536","0.5323697","0.5317195","0.53076196","0.5306975","0.5299738","0.52969563","0.529531","0.52922004","0.5287175","0.5286878","0.52571183","0.5255418","0.52427644","0.5237456","0.52353746","0.5232462","0.5228981","0.5227376","0.519592","0.51949775","0.51933914","0.5191549","0.5174528","0.51716673","0.5163861","0.51419985","0.5137503","0.5136615","0.5116943","0.5114454","0.51053894","0.5100508","0.5098947","0.5095403","0.5095403","0.5095176","0.50883025","0.5084701","0.508281","0.5073653","0.5070764","0.5065898","0.5058593","0.50556916","0.50540406"],"string":"[\n \"0.7462204\",\n \"0.73186773\",\n \"0.71991277\",\n \"0.692029\",\n \"0.65574473\",\n \"0.6528165\",\n \"0.64883965\",\n \"0.64638263\",\n \"0.64638263\",\n \"0.63993347\",\n \"0.6335\",\n \"0.6298709\",\n \"0.6124041\",\n \"0.6007191\",\n \"0.59757954\",\n \"0.5960761\",\n \"0.5929254\",\n \"0.588368\",\n \"0.58670706\",\n \"0.58461416\",\n \"0.5804916\",\n \"0.58008885\",\n \"0.5776578\",\n \"0.5733173\",\n \"0.57302505\",\n \"0.57210433\",\n \"0.5719011\",\n \"0.5701813\",\n \"0.56870437\",\n \"0.56865394\",\n \"0.56757957\",\n \"0.5629323\",\n \"0.5599684\",\n \"0.5597031\",\n \"0.55927587\",\n \"0.55733943\",\n \"0.5570738\",\n \"0.5539032\",\n \"0.55189794\",\n \"0.55175334\",\n \"0.5473294\",\n \"0.5471763\",\n \"0.5453611\",\n \"0.54327184\",\n \"0.53961873\",\n \"0.5381068\",\n \"0.5374481\",\n \"0.53730965\",\n \"0.53678715\",\n \"0.5359267\",\n \"0.5358339\",\n \"0.53581196\",\n \"0.53511053\",\n \"0.534629\",\n \"0.53274536\",\n \"0.5323697\",\n \"0.5317195\",\n \"0.53076196\",\n \"0.5306975\",\n \"0.5299738\",\n \"0.52969563\",\n \"0.529531\",\n \"0.52922004\",\n \"0.5287175\",\n \"0.5286878\",\n \"0.52571183\",\n \"0.5255418\",\n \"0.52427644\",\n \"0.5237456\",\n \"0.52353746\",\n \"0.5232462\",\n \"0.5228981\",\n \"0.5227376\",\n \"0.519592\",\n \"0.51949775\",\n \"0.51933914\",\n \"0.5191549\",\n \"0.5174528\",\n \"0.51716673\",\n \"0.5163861\",\n \"0.51419985\",\n \"0.5137503\",\n \"0.5136615\",\n \"0.5116943\",\n \"0.5114454\",\n \"0.51053894\",\n \"0.5100508\",\n \"0.5098947\",\n \"0.5095403\",\n \"0.5095403\",\n \"0.5095176\",\n \"0.50883025\",\n \"0.5084701\",\n \"0.508281\",\n \"0.5073653\",\n \"0.5070764\",\n \"0.5065898\",\n \"0.5058593\",\n \"0.50556916\",\n \"0.50540406\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78322643"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":76199,"cells":{"query":{"kind":"string","value":"Right hand side of ODE"},"document":{"kind":"string","value":"def rhs(self, q, m):\n # Number of bodies\n N = self.n_planets\n # Empty np.arrays for computed data\n dp = np.zeros_like(q)\n\n for k in range(N):\n dp_k = np.zeros(self.D)\n for i in range(N):\n if k != i:\n qi_qk = q[i*self.D:(i+1)*self.D] - q[k*self.D:(k+1)*self.D]\n qi_qk /= linalg.norm(qi_qk)**3\n dp_k += m[i]*qi_qk\n dp_k *= self.G\n dp[k*self.D:(k+1)*self.D] = dp_k\n return dp"},"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 ode(self, **kwargs):\n pass","def rightSideOfODE(self, Y, t):\n\t\ttemperature = Y[-1]\n\t\tamounts = Y[:-1]\n\t\tself.amounts = amounts\n\t\t# first get the species amount changes (as an array)\n\t\tdNdt = -1 * self.getMolarFluxes(temperature)\n\t\t# then get the temperature change, and append it to the array\n\t\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\n\t\tdUdt = dUdt + self.getHeatFlux(temperature)\n\t\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\n\t\treturn numpy.append(dNdt,dTdt)","def ode(self, w: np.ndarray) -> np.ndarray:\n _assert_iterables(w, 'Angular velocity')\n if w.ndim != 1 or w.shape[0] != 3:\n raise ValueError(f\"Expected `w` to have shape (3,), got {w.shape}\")\n F = np.array([\n [0.0, -w[0], -w[1], -w[2]],\n [w[0], 0.0, -w[2], w[1]],\n [w[1], w[2], 0.0, -w[0]],\n [w[2], -w[1], w[0], 0.0]])\n return 0.5*F@self.A","def forward_ode(self, t, y):\n\n shape = y.shape\n y = np.reshape(y, (-1, 1)) # make y 2D if it is not already\n\n velocity = y[0, :]\n # position = y[1, :]\n\n omega_motor = velocity / self.wheel_radius * self.gear_ratio # rad/s\n\n # TODO: include motor impedance effects\n motor_current = self._motor_current(omega_motor, 0)\n if self.current_limit:\n motor_current = min((motor_current, self.current_limit))\n\n force = motor_current * self.motor.torque_const * self.gear_ratio \\\n / self.wheel_radius\n if self._slip_force is not None:\n force = min((force, self._slip_force))\n\n return np.reshape(np.vstack((force / self.mass, velocity)), shape)","def get_ode(self, d):\n C1 = np.array([[-1./self.Q, -1.], [1., 0.]])\n C2 = np.array([[1.], [0.]])\n \n def ode(t, x): \n F = self.Fint(x)\n dxdt = np.matmul(C1, x) + np.matmul(C2, (d+(self.A0/self.Q)*np.cos(self.Om*t)+F/self.k))\n return dxdt\n return ode","def ode(self, w: np.ndarray) -> np.ndarray:\n return self.A@skew(w)","def call_odeint(particle_object,dt,omega):\n \n# print \n# print '##########################'\n# \n r = particle_object.position\n v = particle_object.velocity \n beta = particle_object.beta \n# \n# print 'Initial parameters'\n# print 'r', r\n# print 'v', v\n# print 'beta',beta\n# print \n# beta = 0.15\n #particle_radius = particle_object.radius\n \n# ### updating the acceleration due to planet history with the position value before it is moved so that it is the acceleration due to the planet at the position that led to this nett acceleration. \n# particle_object.update_planet_acceleration_history(AccelerationDueToPlanet(r))\n \n u0 = np.array([r[0],r[1],r[2],v[0],v[1],v[2]])\n \n \n sol = odeint(acceleration_for_odeint, u0, np.array([0,dt]), args=(beta, omega,planet_pos)) ## The solution in the from [rx,ry,rz,vx,vy,vz]\n \n r_new = np.array([sol[1,0],sol[1,1],sol[1,2]])\n v_new = np.array([sol[1,3],sol[1,4],sol[1,5]]) \n \n# print 'New parameters'\n# print 'r', r_new\n# print 'v', v_new\n#\n# print \n \n #particle_object.update_position(r_new) \n #particle_object.update_velocity(v_new)\n \n ### add one to the particle's age \n particle_object.update_age() \n particle_object.update_timestep_history(timestep)\n \n #last_uvect = sol[1,:]\n \n #return last_uvect\n \n #return 0,0\n return r_new,v_new","def ODEStep(u, um, t, dt, F):\n up = 2*u - um + dt*dt*F(u, t)\n return up","def electrical_ode(self, state, u_in, omega, *_):\n raise NotImplementedError","def ODEfun(y,t,params):\n Im = y[0]\n Is = y[1]\n Ic = y[2]\n R = y[3]\n \n\n try:\n\n r = params['r']\n p = params['p']\n N = params['N']\n R0 = params['R0']\n k = params['k']\n m = params['m']\n n = params['n']\n m1 = params['m1']\n A = params['A']\n t0 = params['t0']\n ps = 0.1\n except:\n print('error')\n\n S = (1-R/N)\n M = hcode.mitigation(t,m,A,n,m1,t0)\n # the model equations\n f0 = (1-ps)*R0*(k+(1-k)*M)*S*(Im + p*Is) - Im\n f1 = ps*R0*(k+(1-k)*M)*S*(Im + p*Is) - Is\n f2 = r*(1-ps)*R0*(k+(1-k)*M)*S*(Im + p*Is) + ps*R0*(k+(1-k)*M)*S*(Im + p*Is) #r*Im/10 + ps*R0*(k+(1-k)*M)*S*(Im + p*Is)#\n f3 = R0*(k+(1-k)*M)*S*(Im + p*Is)\n\n return [f0, f1, f2, f3]","def ODE(XV,t,M,shape):\n dimensions = shape[1]/2\n XV = XV.reshape(shape)\n F = Net_force_1( XV[:,:dimensions], M)\n\n R = np.append( XV[:,dimensions:], F, axis=0 )\n\n return R.flatten()","def d_beta_d_EDOT(self):\n eTheta = self.eTheta()\n a1 = (self.a1()).decompose()\n sinOmg = np.sin(self.omega())\n cosOmg = np.cos(self.omega())\n return a1/c.c*((-eTheta)/np.sqrt(1-eTheta**2)*cosOmg*self.tt0- \\\n (1-eTheta**2)**0.5*sinOmg*self.d_omega_d_par('EDOT'))","def calculate_data_ode_right_hand_side(data_ops, power_system):\r\n states_results = data_ops['states_results']\r\n A, B, C, D, F, G, u_0, x_0 = create_system_matrices(power_system=power_system)\r\n\r\n u_disturbance = data_ops['power'] @ G.T\r\n u = u_0.T + u_disturbance\r\n\r\n solver_func = functools.partial(ode_right_hand_side_solve, A=A, B=B, C=C, D=D, F=F)\r\n\r\n solver_results = map(solver_func,\r\n data_ops['time'],\r\n states_results,\r\n u)\r\n\r\n list_solver_results = list(solver_results)\r\n\r\n states_t_results = np.concatenate([single_solver_result.reshape((1, -1)) for single_solver_result in\r\n list_solver_results],\r\n axis=0)\r\n\r\n data_ops.update(states_t_results=states_t_results)\r\n\r\n return data_ops","def test_tan_2ndord_2vars():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.tan(x/y)\n df_dxdy = lambda x, y: -(y/np.cos(x/y)**2 + 2*x*np.tan(x/y)/np.cos(x/y)**2) / y**3\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2),\n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n df_dxdy(1.5, 2.5))","def euler_richardson_method_2system_ode2(f, g, dt, x, y, xp, yp, range):\n # f = x'' and g = y''\n # both requires (t, x, y, x', y')\n # get initial conditions and setup arrays\n t = min(range)\n t_space = [t]\n x_space = [x]\n y_space = [y]\n xp_space = [xp]\n yp_space = [yp]\n \n while t <= max(range):\n # find get midpoints\n t_mid = t + (1/2)*dt\n xp_mid = xp + 1/2*f(t, x, y, xp, yp)*dt\n yp_mid = yp + 1/2*g(t, x, y, xp, yp)*dt\n x_mid = x + (1/2)*xp*dt\n y_mid = y + (1/2)*yp*dt\n \n # get slopes\n xp_s = f(t_mid, x_mid, y_mid, xp_mid, yp_mid)\n yp_s = g(t_mid, x_mid, y_mid, xp_mid, yp_mid)\n x_s = xp_mid\n y_s = yp_mid\n \n # update values\n t += dt\n x += x_s*dt\n y += y_s*dt\n xp += xp_s*dt\n yp += yp_s*dt\n\n # append values\n t_space.append(t)\n x_space.append(x)\n xp_space.append(xp)\n y_space.append(y)\n yp_space.append(yp)\n \n \n return (t_space, x_space, y_space, xp_space, yp_space)","def ode(D, radial=False, catch_errors=False):\n\n try:\n k = _k[radial]\n except KeyError:\n raise ValueError(f\"radial must be one of {{{', '.join(repr(key) for key in _k)}}}\") from None\n\n\n def fun(o, y):\n\n theta, dtheta_do = y\n\n try:\n D1 = D(theta, 1)\n except (ValueError, ArithmeticError):\n if catch_errors:\n return np.array((dtheta_do, np.nan*o), float)\n else:\n raise\n\n D_, dD_dtheta = D1\n\n k_o = k/o if k else 0\n\n N = (o/2 + dD_dtheta*dtheta_do)\n\n try:\n R = N/D_\n except ZeroDivisionError:\n if catch_errors:\n R = N*np.inf\n else:\n raise\n\n d2theta_do2 = -(R + k_o)*dtheta_do\n\n try:\n return np.array((dtheta_do, d2theta_do2), float)\n except TypeError:\n if catch_errors:\n return np.array((dtheta_do, np.nan*o), float)\n else:\n raise\n\n\n def jac(o, y):\n\n theta, dtheta_do = y\n\n J = np.empty((2,2)+np.shape(o))\n J[0,0] = 0\n J[0,1] = 1\n\n try:\n D2 = D(theta, 2)\n except (ValueError, ArithmeticError):\n if catch_errors:\n try:\n # This second call to D will not be counted by solvers.\n # However, this is a very unlikely edge case.\n D1 = D(theta, 1)\n except (ValueError, ArithmeticError):\n J[1,:] = np.nan\n return J\n else:\n D_, dD_dtheta = D1\n d2D_dtheta2 = np.nan\n else:\n raise\n else:\n D_, dD_dtheta, d2D_dtheta2 = D2\n\n k_o = k/o if k else 0\n\n # Jacobian expressions were obtained symbolically\n # Source: ../symbolic/ode_jac.py\n try:\n x0 = 1/D_\n except ZeroDivisionError:\n if catch_errors:\n x0 = np.inf\n else:\n raise\n x1 = dD_dtheta*dtheta_do\n x2 = x0*(o + 2*x1)/2\n try:\n J[1,0] = -dtheta_do*x0*(d2D_dtheta2*dtheta_do - dD_dtheta*x2)\n except TypeError:\n if catch_errors:\n J[1,0] = np.nan\n else:\n raise\n try:\n J[1,1] = -k_o - x0*x1 - x2\n except TypeError:\n if catch_errors:\n J[1,1] = np.nan\n else:\n raise\n\n return J\n\n return fun, jac","def electrical_ode(self, state, u_salphabeta, omega, *args):\n u_ralphabeta = np.zeros_like(u_salphabeta)\n u_sr_aphabeta = np.array([u_salphabeta, u_ralphabeta])\n\n return super().electrical_ode(state, u_sr_aphabeta, omega, *args)","def d2(self):\r\n return self.d1() - self.sigma*self.t**0.5","def ode_solver(fun, t_span, y0, t_eval):\n sol = integrate.solve_ivp(fun = fun, t_span = t_span, y0 = y0, t_eval=t_eval, method=\"Radau\")\n return sol","def build_derivative_total(mu):\n\n def ode_right_hand_side(t, y):\n return -mu(t) * y\n\n return ode_right_hand_side","def monkey_ode_int(self, function, y, time, args, Dfun, tfirst, **kwargs):\n assert all(y == self._state), 'unexpected state before integration'\n assert time == [0, self._tau], 'unexpected time steps for integration'\n assert args == (self.args,), 'unexpected arguments'\n assert tfirst\n return np.array([[0, 2], self._state])","def _phi_ode(self, t, z):\n # prep states and phi_matrix\n state = z[0:len(self.istate)]\n ad_state = make_ad(state)\n phi_flat = clear_ad(z[len(self.istate):])\n phi = np.reshape(phi_flat, (len(self.istate),\n len(self.istate)))\n\n # find the accelerations and jacobian\n state_deriv = self.force_model.ode(0, ad_state)\n a_matrix = jacobian(self.force_model.ode(0, ad_state),\n ad_state)\n\n # compute the derivative of the STM and repackage\n phid = np.matmul(a_matrix, phi)\n phid_flat = phid.flatten()\n z_out = np.concatenate((state_deriv, phid_flat))\n\n return z_out","def euler_integrator(self, t, y, tau):\n\n return self.plant.rhs(t, y, tau)","def test_tan_2ndord():\n # one variable\n x = fwd.Variable()\n f = fwd.tan(2.0*x - 3.0)\n assert equals( f.derivative_at(x, {x: 1.5}, order=2), \n 8.0*np.tan(2.0*1.5-3.0)/(np.cos(2.0*1.5-3.0))**2 )\n # two variables\n x, y = fwd.Variable(), fwd.Variable()\n g = fwd.tan(2.0*x / y)\n assert equals(g.derivative_at(x, {x: 1.5, y: 2.5}, order=2), \n 8.0*np.tan(2.0*1.5/2.5) / (np.cos(2.0*1.5/2.5)**2 * (2.5**2)) )\n # test error raising\n with pytest.raises(NotImplementedError):\n g.derivative_at(x, {x:1.0, y: 2.0}, order=3)","def right_rotation(self, ang_vel):\n vel = self.om_left_max * self.R + ang_vel * self.L\n om_right = (vel + ang_vel * self.L) / self.R \n return vel, om_right","def state_ode(self, t, x, p):\n # assign p (parameters) and x (states)\n self.states.loc[:, \"value\"] = x\n v = self.fluxes(t, x, p)\n dxdt = np.dot(self.stoich_matrix, v)\n return dxdt","def build_derivative_full(iota, rho, chi, omega):\n\n def ode_right_hand_side(t, y):\n sprime = -(iota(t) + omega(t)) * y[0, :] + rho(t) * y[1, :]\n cprime = iota(t) * y[0, :] - (rho(t) + omega(t) + chi(t)) * y[1, :]\n return np.vstack([sprime, cprime])\n\n return ode_right_hand_side","def diff_op(self, args: List, time: float) -> List:\n ode_args: Dict = dict(zip(self.ode_list, args))\n dvdt: float = self.dvdt(args=ode_args)\n ode: List[float] = [dvdt]\n\n if self.channel_bool['nav']:\n dhNadt: float = self.nav.dhdt(v=ode_args['v'], h=ode_args['h_nav'])\n ode.append(dhNadt) \n if self.channel_bool['kvhh']:\n dnKdt: float = self.kvhh.dndt(v=ode_args['v'], n=ode_args['n_kvhh'])\n ode.append(dnKdt)\n if self.channel_bool['kva']:\n dhAdt: float = self.kva.dhdt(v=ode_args['v'], h=ode_args['h_kva'])\n ode.append(dhAdt)\n if self.channel_bool['kvsi']:\n dmKSdt: float = self.kvsi.dmdt(v=ode_args['v'], m=ode_args['m_kvsi'])\n ode.append(dmKSdt)\n if self.channel_bool['ampar']:\n dsAMPAdt: float = self.ampar.dsdt(v=ode_args['v'], s=ode_args['s_ampar'])\n ode.append(dsAMPAdt)\n if self.channel_bool['nmdar']:\n dxNMDAdt: float = self.nmdar.dxdt(v=ode_args['v'], x=ode_args['x_nmdar'])\n dsNMDAdt: float = self.nmdar.dsdt(v=ode_args['v'], s=ode_args['s_nmdar'], x=ode_args['x_nmdar'])\n ode.append(dxNMDAdt)\n ode.append(dsNMDAdt)\n if self.channel_bool['gabar']:\n dsGABAdt: float = self.gabar.dsdt(v=ode_args['v'], s=ode_args['s_gabar'])\n ode.append(dsGABAdt)\n if self.channel_bool['cav'] or self.channel_bool['nmdar'] or self.channel_bool['ca']:\n ca_args: Dict = {\n 'v' : ode_args.get('v', None),\n 's_nmdar' : ode_args.get('s_nmdar', None),\n 'ca' : ode_args.get('ca', None),\n }\n dCadt: float = self.dCadt(ca_args)\n ode.append(dCadt)\n \n return ode","def right (x):\n\n return Sinary(side(x.v,0))","def ode_func(t, X, delays, force_from_heat, damping, spring_consts, masses, L,\n pbar=None, state=None):\n if pbar is not None:\n # set everything for the tqdm progressbar\n last_t, dt = state\n n = (t - last_t)/dt\n if n >= 1:\n pbar.update(1)\n pbar.set_description('Delay = {:.3f} ps'.format(t*1e12))\n state[0] = t\n elif n < 0:\n state[0] = t\n\n # start with the actual ode function\n x = X[0:L]\n v = X[L:]\n\n # the output must be a column vector\n X_prime = np.zeros([2*L])\n\n # accelerations = derivative of velocities\n X_prime[L:] = (\n PhononNum.calc_force_from_damping(v, damping, masses)\n + PhononNum.calc_force_from_spring(\n np.r_[np.diff(x), 0],\n np.r_[0, np.diff(x)],\n spring_consts)\n + force_from_heat[:, finderb(t, delays)].squeeze()\n )/masses\n\n # velocities = derivative of positions\n X_prime[0:L] = v\n\n return X_prime","def dual_inf_ODE(t, y, params):\n # Unpack states ------------------------------------------------------------------------------------\n # The states are as follows. All quantities are absolute numbers, not concentrations, so no volume scaling is made\n # during transport between the upper respiratory tract (URT) and the lower respiratory tract (LRT)\n # 0. T1 - target cells in URT\n # 1. E1WT - eclipse-stage cells in URT w/ wildtype virion (infected but not producing virions)\n # 2. I1WT - wildtype infected cells producing virions (URT)\n # 3. VTWT - wildtype virions SAMPLED by a pharyngeal throat swab in URT\n # 4. T1TIP - target cells in URT infected w/ TIP\n # 5. E1D - eclipse-stage cells in URT w/ coinfection by wildtype virus and TIP (infected but not producing virion)\n # 6. I1D - coinfected cells producing both wildtype virion and TIP (URT)\n # 7. VTTIP - TIP virions SAMPLED by a pharyngeal throat swab in URT {assume a hypothetical equivalent test to WT}\n # 8. T2 - target cells in LRT\n # 9. E2WT - eclipse-stage cells in LRT w/ wildtype virion (infected but not producing virions)\n # 10. I2WT - wildtype infected cells producing virions (LRT)\n # 11. VSWT - wildtype virions SAMPLED by a sputum sample from LRT\n # 12. T2TIP - target cells in LRT infected w/ TIP\n # 13. E2D - eclipse-stage cells in LRT w/ coinfection by wildtype virus and TIP (infected but not producing virion)\n # 14. I2D - coinfected cells producing both wildtype virion and TIP (LRT)\n # 15. VSTIP - TIP virions SAMPLEd by a sputum sample from LRT\n T1, E1WT, I1WT, VTWT, T1TIP, E1D, I1D, VTTIP, T2, E2WT, I2WT, VSWT, T2TIP, E2D, I2D, VSTIP = y\n\n # Unpack parameters ------------------------------------------------------------------------------------\n # beta_T = target cell infection rate constant in URT, divided by sampling fraction f1 (beta_T = beta1/f1)\n # k1 = eclipse phase rate constant, for transition from nonproductive infected cell to productive.\n # pi_T = virion production rate by infected cells in URT, multiplied by sampling fraction f1 (pi_T = f1*p1)\n # delta1 = clearance rate of virion-producing infected cells\n # beta_S, analogous to beta_T but for LRT (beta_S = beta2/f2)\n # k2, analogous to k1 but for LRT\n # pi_S, analogous to pi_T but for LRT (pi_S = f2*p2)\n # delta2, analogous to delta1 but for LRT\n # c = clearance rate constant for virions in both URT and LRT\n # w = exponential growth rate for the clearance of virion-producing infected cells (i.e. adaptive immunity)\n # gamma = scaled rate of virion transfer from URT to LRT, calculates production of VS from VT (gamma = f2/f1*g12)\n # rho = relative TIP virion production rate from coinfected cells (vs. wildtype virion production from coinf. cells)\n # psi = relative wildtype virion production rate from coinfected cells (vs. wildtype virion production from singly infected cells)\n # xi = relative target cell infection rate for TIP versus virion.\n # See Ruian Ke et al. medRxiv 10.1101/2020.09.25.20201772v1 for further definitions, parameter names match.\n beta_T, k1, pi_T, delta1, beta_S, k2, pi_S, delta2, c, w, gamma, rho, psi, xi, delta_TIP = params\n\n n_entries = 16\n dydt = np.zeros(n_entries)\n\n # Calculate effect of adaptive immune response\n if t >= 14:\n delta1 = delta1*np.exp(w*(t-14))\n delta2 = delta2*np.exp(w*(t-14))\n else:\n delta1 = delta1\n delta2 = delta2\n\n # dT1/dt\n dydt[0] = -beta_T*VTWT*T1 - xi*beta_T*VTTIP*T1\n\n # dE1WT/dt\n dydt[1] = +beta_T*VTWT*T1 - k1*E1WT\n\n # dI1WT/dt\n dydt[2] = k1*E1WT - delta1*I1WT\n\n # dVTWT/dt\n dydt[3] = pi_T*I1WT - c*VTWT + psi*pi_T*I1D\n\n # dT1TIP/dt\n dydt[4] = xi*beta_T*VTTIP*T1 - beta_T*VTWT*T1TIP\n\n # dE1D/dt\n dydt[5] = beta_T*VTWT*T1TIP - k1*E1D\n\n # dI1D/dt\n #dydt[6] = k1*E1D - delta1*I1D\n # Note that delta_TIP=1.\n # Non-unity values explore differential effect on immune clearance of TIP-carrying infected cells.\n dydt[6] = k1*E1D - delta1*delta_TIP*I1D\n\n # dVTTIP/dt\n dydt[7] = rho*pi_T*I1D - c*VTTIP\n\n # dT2/dt\n dydt[8] = -beta_S*VSWT*T2 - xi*beta_S*VSTIP*T2\n\n # dE2WT/dt\n dydt[9] = beta_S*VSWT*T2 - k2*E2WT\n\n # dI2WT/dt\n dydt[10] = k2*E2WT - delta2*I2WT\n\n # dVSWT/dt\n dydt[11] = pi_S*I2WT - c*VSWT + psi*pi_S*I2D + gamma*VTWT\n\n # dT2TIP/dt\n dydt[12] = xi*beta_S*VSTIP*T2 - beta_S*VSWT*T2TIP\n\n # dE2D/dt\n dydt[13] = beta_S*VSWT*T2TIP - k2*E2D\n\n # dI2D/dt\n dydt[14] = k2*E2D - delta2*delta_TIP*I2D\n\n # dVSTIP/dt\n dydt[15] = rho*pi_S*I2D - c*VSTIP + gamma*VTTIP\n\n return dydt","def _dK_ode_dtheta(self, target):\r\n t_ode = self._t[self._index>0]\r\n dL_dK_ode = self._dL_dK[self._index>0, :]\r\n index_ode = self._index[self._index>0]-1\r\n if self._t2 is None:\r\n if t_ode.size==0:\r\n return \r\n t2_ode = t_ode\r\n dL_dK_ode = dL_dK_ode[:, self._index>0]\r\n index2_ode = index_ode\r\n else:\r\n t2_ode = self._t2[self._index2>0]\r\n dL_dK_ode = dL_dK_ode[:, self._index2>0]\r\n if t_ode.size==0 or t2_ode.size==0:\r\n return\r\n index2_ode = self._index2[self._index2>0]-1\r\n\r\n h1 = self._compute_H(t_ode, index_ode, t2_ode, index2_ode, stationary=self.is_stationary, update_derivatives=True)\r\n #self._dK_ddelay = self._dh_ddelay\r\n self._dK_dsigma = self._dh_dsigma\r\n\r\n if self._t2 is None:\r\n h2 = h1\r\n else:\r\n h2 = self._compute_H(t2_ode, index2_ode, t_ode, index_ode, stationary=self.is_stationary, update_derivatives=True)\r\n\r\n #self._dK_ddelay += self._dh_ddelay.T\r\n self._dK_dsigma += self._dh_dsigma.T\r\n # C1 = self.sensitivity\r\n # C2 = self.sensitivity\r\n\r\n # K = 0.5 * (h1 + h2.T)\r\n # var2 = C1*C2\r\n # if self.is_normalized:\r\n # dk_dD1 = (sum(sum(dL_dK.*dh1_dD1)) + sum(sum(dL_dK.*dh2_dD1.T)))*0.5*var2\r\n # dk_dD2 = (sum(sum(dL_dK.*dh1_dD2)) + sum(sum(dL_dK.*dh2_dD2.T)))*0.5*var2\r\n # dk_dsigma = 0.5 * var2 * sum(sum(dL_dK.*dK_dsigma))\r\n # dk_dC1 = C2 * sum(sum(dL_dK.*K))\r\n # dk_dC2 = C1 * sum(sum(dL_dK.*K))\r\n # else:\r\n # K = np.sqrt(np.pi) * K\r\n # dk_dD1 = (sum(sum(dL_dK.*dh1_dD1)) + * sum(sum(dL_dK.*K))\r\n # dk_dC2 = self.sigma * C1 * sum(sum(dL_dK.*K))\r\n\r\n\r\n # dk_dSim1Variance = dk_dC1\r\n # Last element is the length scale.\r\n (dL_dK_ode[:, :, None]*self._dh_ddelay[:, None, :]).sum(2)\r\n\r\n target[-1] += (dL_dK_ode*self._dK_dsigma/np.sqrt(2)).sum()\r\n\r\n\r\n # # only pass the gradient with respect to the inverse width to one\r\n # # of the gradient vectors ... otherwise it is counted twice.\r\n # g1 = real([dk_dD1 dk_dinvWidth dk_dSim1Variance])\r\n # g2 = real([dk_dD2 0 dk_dSim2Variance])\r\n # return g1, g2\"\"\"\r","def g(t, x0, paras):\n x = odeint(f, x0, t, args=(paras,))\n return x","def _generic_ode_solve(r, psi0, tlist, e_ops, opt, progress_bar, dims=None):\n #\n # prepare output array\n #\n n_tsteps = len(tlist)\n output = Result()\n output.solver = \"sesolve\"\n output.times = tlist\n\n n_modes = len(psi0.dims[0])\n\n if psi0.isunitary:\n oper_evo = True\n oper_n = dims[0][0]\n norm_dim_factor = np.sqrt(oper_n)\n else:\n oper_evo = False\n norm_dim_factor = 1.0\n\n if opt.store_states:\n output.states = []\n\n if isinstance(e_ops, types.FunctionType):\n n_expt_op = 0\n expt_callback = True\n\n elif isinstance(e_ops, list):\n n_expt_op = len(e_ops)\n expt_callback = False\n\n if n_expt_op == 0:\n # fallback on storing states\n output.states = []\n opt.store_states = True\n else:\n output.expect = []\n output.num_expect = n_expt_op\n for op in e_ops:\n if op.isherm:\n output.expect.append(np.zeros(n_tsteps))\n else:\n output.expect.append(np.zeros(n_tsteps, dtype=complex))\n else:\n raise TypeError(\"Expectation parameter must be a list or a function\")\n\n def get_curr_state_data():\n if oper_evo:\n return r.y.reshape([oper_n, oper_n]).T\n else:\n if opt.moving_basis:\n return r.y[0:-n_modes]\n else:\n return r.y\n\n #\n # start evolution\n #\n progress_bar.start(n_tsteps)\n\n output.displacements = np.zeros([n_modes, len(tlist)], dtype=complex)\n\n dt = np.diff(tlist)\n for t_idx, t in enumerate(tlist):\n progress_bar.update(t_idx)\n\n if not r.successful():\n raise Exception(\"ODE integration error: Try to increase \"\n \"the allowed number of substeps by increasing \"\n \"the nsteps parameter in the Options class.\")\n\n # get the current state / oper data if needed\n cdata = None\n if opt.store_states or opt.normalize_output or n_expt_op > 0:\n cdata = get_curr_state_data()\n\n if opt.normalize_output:\n # cdata *= _get_norm_factor(cdata, oper_evo)\n cdata *= norm_dim_factor / la_norm(cdata)\n if oper_evo:\n r.set_initial_value(cdata.ravel(), r.t)\n else:\n r.set_initial_value(cdata, r.t)\n\n if opt.store_states:\n output.states.append(Qobj(cdata, dims=dims))\n\n if opt.moving_basis:\n output.displacements[:, t_idx] = r.y[-n_modes:]\n\n if expt_callback:\n # use callback method\n e_ops(t, Qobj(cdata, dims=dims))\n\n for m in range(n_expt_op):\n output.expect[m][t_idx] = cy_expect_psi(e_ops[m].data, cdata, e_ops[m].isherm)\n\n if t_idx < n_tsteps - 1:\n r.integrate(r.t + dt[t_idx])\n\n progress_bar.finished()\n\n if not opt.rhs_reuse and config.tdname is not None:\n try:\n os.remove(config.tdname + \".pyx\")\n except:\n pass\n\n if opt.store_final_state:\n cdata = get_curr_state_data()\n if opt.normalize_output:\n cdata *= norm_dim_factor / la_norm(cdata)\n output.final_state = Qobj(cdata, dims=dims)\n\n return output","def deterministic_integration(self):\n y0 = self.initial_conditions\n t = self.t\n sol = odeint(self.a, y0, t)\n return sol","def PDE_RHS_FKPP(t,y,q,x,description=None):\n \n \n D_mat = create_Uxx_mat(x)\n\n return (q[0]*D_mat.dot(y) + \n q[1]*y*(1-y))","def exterior_der(self):\n from utilities import format_unop_txt, format_unop_latex\n if self._exterior_derivative is None:\n vmodule = self._vmodule # shortcut\n rname = format_unop_txt('d', self._name)\n rlname = format_unop_latex(r'\\mathrm{d}', self._latex_name)\n resu = vmodule.alternating_form(self._tensor_rank+1, name=rname, \n latex_name=rlname)\n for dom, rst in self._restrictions.iteritems():\n resu._restrictions[dom] = rst.exterior_der()\n self._exterior_derivative = resu\n return self._exterior_derivative","def rhs(y, t, l, m, g):\n # Unpack the states so you can use the variable names in the\n # sympy.physics.mechanics equations\n q1 = y[0]\n q2 = y[1]\n u1 = y[2]\n u2 = y[3]\n # or you can make use of python's tuple unpacking for a one liner\n # q1, q2, u1, u2 = y\n\n # Initialize a vector for the derivatives.\n dydt = zeros((len(y)))\n\n # Compute the derivatives, these are pasted in from the\n # sympy.physics.mechanics results.\n dydt[0] = u1\n dydt[1] = u2\n dydt[2] = (-g*sin(q1)*sin(q2)**2 + 2*g*sin(q1) -\n g*sin(q2)*cos(q1)*cos(q2) + 2*l*u1**2*sin(q1)*cos(q1)*cos(q2)**2 -\n l*u1**2*sin(q1)*cos(q1) - 2*l*u1**2*sin(q2)*cos(q1)**2*cos(q2) +\n l*u1**2*sin(q2)*cos(q2) + l*u2**2*sin(q1)*cos(q2) -\n l*u2**2*sin(q2)*cos(q1))/(l*(sin(q1)**2*sin(q2)**2 +\n 2*sin(q1)*sin(q2)*cos(q1)*cos(q2) + cos(q1)**2*cos(q2)**2 - 2))\n dydt[3] = (-sin(q1)*sin(q2)/2 - cos(q1)*cos(q2)/2)*(2*g*l*m*sin(q1) -\n l**2*m*(-sin(q1)*cos(q2) +\n sin(q2)*cos(q1))*u2**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2)) -\n l**2*m) + (g*l*m*sin(q2) - l**2*m*(sin(q1)*cos(q2) -\n sin(q2)*cos(q1))*u1**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2))\n - l**2*m)\n\n # Return the derivatives.\n return dydt","def driftRHS(field,drift_velocity,t,x):\n f = field.getValue(x)\n fs = np.linalg.norm(f)\n f = f/fs\n return -f*drift_velocity(fs)","def RK45_method(RHS, theta_0, omega_0, t_1, dt):\n initialValues = [theta_0,omega_0]\n\n timeSpan = [0,t_1 + dt]\n\n timeArr = np.arange(0,t_1+dt,dt)\n \n solution = DestoryerOfOrdinaryDifferentialEquations(RHS,timeSpan,initialValues,method=\"RK45\",t_eval=timeArr)\n \n theta = solution.y[0, : ]\n omega = solution.y[1, : ]\n times = solution.t\n \n \n return theta, omega, times","def DyEvo(x, t, T0, r1, r2, K_co, K_ch, alpha, n):\n y=np.zeros([np.size(x)])\n D=np.zeros([2]) \n #define fitnss\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \n #degradation\n deg=fmax*x[1]/(x[1]+Kd) \n #ODE of eco-evo dynamics\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r1*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\n y[2]=x[2]*(r2*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\n \n return y","def _dlnfdRe(self,R,vR,vT,E=None,xE=None,OE=None,LCE=None):\n #Calculate a bunch of stuff that we need\n if E is None or xE is None or OE is None or LCE is None:\n if self._beta == 0.:\n E= vR**2./2.+vT**2./2.+sc.log(R)\n xE= sc.exp(E-.5)\n OE= xE**-1.\n LCE= xE\n else: #non-flat rotation curve\n E= vR**2./2.+vT**2./2.+1./2./self._beta*R**(2.*self._beta)\n xE= (2.*E/(1.+1./self._beta))**(1./2./self._beta)\n OE= xE**(self._beta-1.)\n LCE= xE**(self._beta+1.)\n L= R*vT\n sigma2xE= self._surfaceSigmaProfile.sigma2(xE,log=False)\n return (self._surfaceSigmaProfile.surfacemassDerivative(xE,log=True)\\\n -(1.+OE*(L-LCE)/sigma2xE)*self._surfaceSigmaProfile.sigma2Derivative(xE,log=True)\\\n +(L-LCE)/sigma2xE*(self._beta-1.)*xE**(self._beta-2.)\\\n -OE*(self._beta+1.)/sigma2xE*xE**self._beta)","def d2(self):\n d1 = self.d1()\n return d1 - self.sigma * (self.t **(0.5))","def define_ode(self, F, DFDY):\n self._F = F\n self._DFDY = DFDY","def ODEStep1(u, t, dt, F):\n up = u + 0.5*dt*dt*F(u, t)\n return up","def fangle_degr(self):\r\n\r\n return self._versor_1.angle_degr(self._versor_2)","def f( self , x , u , t ):\n \n dx = np.zeros(self.n) # State derivative vector\n \n ################################################\n # Place holder: put the equations of motion here\n raise NotImplementedError\n ################################################\n \n return dx","def closed_loop_dynamics(self, K):\n\n return self.F - dot(self.G, K)","def den_evolve(self, delt, txp, src):\n self.ne += (-txp.dfluxe + src.se)*delt\n self.ni += (-txp.dfluxi + src.si)*delt","def ODEs(y, t, B, MdiscI, RdiscI, epsilon, delta, n=1.0, alpha=0.1, cs7=1.0,\n k=0.9):\n # Initial conditions\n Mdisc, omega = y\n \n # Constants\n Rdisc = RdiscI * 1.0e5 # Disc radius - cm\n tvisc = Rdisc / (alpha * cs7 * 1.0e7) # Viscous timescale - s\n mu = 1.0e15 * B * (R ** 3.0) # Magnetic Dipole Moment\n M0 = delta * MdiscI * Msol # Global Fallback Mass Budget - g\n tfb = epsilon * tvisc # Fallback timescale - s\n \n # Radii - Alfven, Corotation, Light Cylinder\n Rm = ((mu ** (4.0 / 7.0)) * (GM ** (-1.0 / 7.0)) * ((Mdisc / tvisc) **\n (-2.0 / 7.0)))\n Rc = (GM / (omega ** 2.0)) ** (2.0 / 3.0)\n Rlc = c / omega\n # Cap the Alfven radius\n if Rm >= k * Rlc:\n Rm = k * Rlc\n \n w = (Rm / Rc) ** (3.0 / 2.0) # Fastness parameter\n \n bigT = 0.5 * I * (omega ** 2.0) # Rotational energy\n modW = (0.6 * M * (c ** 2.0) * ((GM / (R * (c ** 2.0))) / (1.0 - 0.5 * (GM\n / (R * (c ** 2.0)))))) # Binding energy\n rot_param = bigT / modW # Rotation parameter\n \n # Dipole torque\n Ndip = (-1.0 * (mu ** 2.0) * (omega ** 3.0)) / (6.0 * (c ** 3.0))\n \n # Mass flow rates and efficiencies\n eta2 = 0.5 * (1.0 + np.tanh(n * (w - 1.0)))\n eta1 = 1.0 - eta2\n Mdotprop = eta2 * (Mdisc / tvisc) # Propelled\n Mdotacc = eta1 * (Mdisc / tvisc) # Accreted\n Mdotfb = (M0 / tfb) * (((t + tfb) / tfb) ** (-5.0 / 3.0)) # Fallback rate\n Mdotdisc = Mdotfb - Mdotprop - Mdotacc # Mass flow through the disc\n \n if rot_param > 0.27:\n Nacc = 0.0 # Prevents magnetar break-up\n else:\n # Accretion torque\n if Rm >= R:\n Nacc = ((GM * Rm) ** 0.5) * (Mdotacc - Mdotprop)\n else:\n Nacc = ((GM * R) ** 0.5) * (Mdotacc - Mdotprop)\n \n omegadot = (Nacc + Ndip) / I # Angular frequency time derivative\n \n return np.array([Mdotdisc, omegadot])","def rightmost_element(self):\n\n\n #Element limits\n L = 1 - 2*self.h\n R = 1\n\n psiN = (self.x-1+self.h)*(self.x-1+2*self.h)/(2*self.h**2)\n psiNm1 = -(self.x-1)*(self.x-1+2*self.h)/(self.h**2)\n psiNm2 = (self.x-1+self.h)*(self.x-1)/(2*self.h**2)\n\n self.psi[-1] = psiN\n self.psi[-2] = psiNm1\n self.psi[-3] = psiNm2\n\n d_psiNm2 = sym.diff(psiNm2,self.x)\n d_psiNm1 = sym.diff(psiNm1,self.x)\n d_psiN = sym.diff(psiN,self.x)\n\n psi_Nm1Nm1 = d_psiNm1*d_psiNm1\n psi_Nm2Nm2 = d_psiNm2*d_psiNm2\n psi_Nm1Nm2 = d_psiNm1*d_psiNm2\n\n A_Nm1Nm1 = sym.integrate(psi_Nm1Nm1, (self.x, L, R))\n A_Nm2Nm2 = sym.integrate(psi_Nm2Nm2, (self.x, L, R))\n A_Nm1Nm2 = sym.integrate(psi_Nm1Nm2, (self.x, L, R))\n\n rhs_Nm2 = sym.integrate(self.f(self.x)*psiNm2,(self.x,L,R)) - sym.integrate(self.D*d_psiN*d_psiNm2,(self.x,L,R))\n rhs_Nm1 = sym.integrate(self.f(self.x)*psiNm1,(self.x,L,R)) - sym.integrate(self.D*d_psiN*d_psiNm1,(self.x,L,R))\n\n a1 = [A_Nm2Nm2,A_Nm1Nm2]\n a2 = [A_Nm1Nm2, A_Nm1Nm1]\n\n A = np.array([a1, a2]).reshape(2,2)\n b = np.array([rhs_Nm2, rhs_Nm1])\n\n for i in range(2*self.Ne-2,2*self.Ne):\n self.global_vector[i] = b[i-(2*self.Ne-2)]\n for j in range(2*self.Ne-2,2*self.Ne):\n self.global_matrix[i,j] = A[i-(2*self.Ne-2), j-(2*self.Ne-2)]","def casadi_ode(self, t, x, u, w):\n v = u[0]\n thetadot = u[1]\n theta = x[2]\n f = cs.vertcat(v * cs.cos(theta), v * cs.sin(theta), thetadot)\n if self.use_nonlinear_noise_model:\n w_vec = cs.vertcat(self.scale[0]*(cs.cos(theta) * w[0] - cs.sin(theta) * w[1]),\n self.scale[1]*(cs.sin(theta) * w[0] + cs.cos(theta) * w[1]),\n self.scale[2]*(v * w[2]))\n else:\n w_vec = w\n return f + w_vec","def calculate_ode_functions(self, f, L):\n\n pass","def _K_compute_ode_eq(self, transpose=False):\r\n\r\n if self._t2 is not None:\r\n if transpose:\r\n t_eq = self._t[self._index==0]\r\n t_ode = self._t2[self._index2>0]\r\n index_ode = self._index2[self._index2>0]-1\r\n else:\r\n t_eq = self._t2[self._index2==0]\r\n t_ode = self._t[self._index>0]\r\n index_ode = self._index[self._index>0]-1\r\n else:\r\n t_eq = self._t[self._index==0]\r\n t_ode = self._t[self._index>0]\r\n index_ode = self._index[self._index>0]-1\r\n\r\n if t_ode.size==0 or t_eq.size==0:\r\n if transpose:\r\n self._K_eq_ode = np.zeros((t_eq.shape[0], t_ode.shape[0]))\r\n else:\r\n self._K_ode_eq = np.zeros((t_ode.shape[0], t_eq.shape[0]))\r\n return\r\n\r\n t_ode_mat = t_ode[:, None]\r\n t_eq_mat = t_eq[None, :]\r\n if self.delay is not None:\r\n t_ode_mat -= self.delay[index_ode, None]\r\n diff_t = (t_ode_mat - t_eq_mat)\r\n\r\n inv_sigma_diff_t = 1./self.sigma*diff_t\r\n decay_vals = self.decay[index_ode][:, None]\r\n half_sigma_d_i = 0.5*self.sigma*decay_vals\r\n\r\n if self.is_stationary:\r\n ln_part, signs = ln_diff_erfs(inf, half_sigma_d_i - inv_sigma_diff_t, return_sign=True)\r\n else:\r\n ln_part, signs = ln_diff_erfs(half_sigma_d_i + t_eq_mat/self.sigma, half_sigma_d_i - inv_sigma_diff_t, return_sign=True)\r\n sK = signs*np.exp(half_sigma_d_i*half_sigma_d_i - decay_vals*diff_t + ln_part)\r\n\r\n sK *= 0.5\r\n\r\n if not self.is_normalized:\r\n sK *= np.sqrt(np.pi)*self.sigma\r\n\r\n\r\n if transpose:\r\n self._K_eq_ode = sK.T\r\n else:\r\n self._K_ode_eq = sK","def ode_for(regime, variable):\n odes = [eq for eq in regime.time_derivatives if eq.dependent_variable == variable.name]\n if len(odes) == 0:\n odes.append(al.TimeDerivative(dependent_variable = variable, rhs = \"0.0\"))\n return expect_single(odes)","def Drepp(self):\n sinE = np.sin(self.E())\n cosE = np.cos(self.E())\n return -self.alpha()*cosE-(self.beta()+self.GAMMA)*sinE","def _dy(self, T):\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])","def e_ortogonal(self, other):\n if self.pi(other) == 0:\n return True\n else:\n return False","def van_der_pol_oscillator_deriv(x, t):\n \n x1 = x[1]\n y = -nu * (x[0] ** 2.0 - 1.0) * x[1] - x[0]\n result = np.array([x1, y])\n return result","def compODEdydt(self, t, y, args=None):\r\n return comp.Comp.compODEdydt_diffu(self, t, y, args)","def exterior_der(self):\n from sage.calculus.functional import diff\n from utilities import format_unop_txt, format_unop_latex\n from sage.tensor.modules.comp import CompFullyAntiSym\n from vectorframe import CoordFrame\n if self._exterior_derivative is None:\n # A new computation is necessary:\n fmodule = self._fmodule # shortcut\n rname = format_unop_txt('d', self._name)\n rlname = format_unop_latex(r'\\mathrm{d}', self._latex_name)\n self._exterior_derivative = DiffFormParal(fmodule, \n self._tensor_rank+1, \n name=rname, \n latex_name=rlname)\n # 1/ List of all coordinate frames in which the components of self\n # are known\n coord_frames = []\n for frame in self._components:\n if isinstance(frame, CoordFrame):\n coord_frames.append(frame)\n if coord_frames == []:\n # A coordinate frame is searched, at the price of a change of\n # frame, priveleging the frame of the domain's default chart\n dom = self._domain\n def_coordf = dom._def_chart._frame\n for frame in self._components:\n if (frame, def_coordf) in dom._frame_changes:\n self.comp(def_coordf, from_basis=frame)\n coord_frames = [def_coordf]\n break\n if coord_frames == []:\n for chart in dom._atlas:\n if chart != dom._def_chart: # the case def_chart is treated above\n coordf = chart._frame\n for frame in self._components:\n if (frame, coordf) in dom._frame_changes:\n self.comp(coordf, from_basis=frame)\n coord_frames[coordf]\n break\n if coord_frames != []:\n break \n # 2/ The computation:\n for frame in coord_frames:\n chart = frame._chart\n sc = self._components[frame]\n dc = CompFullyAntiSym(fmodule._ring, frame, \n self._tensor_rank+1, \n start_index=fmodule._sindex,\n output_formatter=fmodule._output_formatter)\n for ind, val in sc._comp.iteritems():\n for i in fmodule.irange():\n ind_d = (i,) + ind\n if len(ind_d) == len(set(ind_d)): \n # all indices are different\n dc[[ind_d]] += \\\n val.function_chart(chart).diff(i).scalar_field()\n self._exterior_derivative._components[frame] = dc\n return self._exterior_derivative","def ode_solve(z0, t0, t1, f):\n h_max = 0.05\n n_steps = math.ceil((abs(t1 - t0) / h_max).max().item())\n\n h = (t1 - t0) / n_steps\n t = t0\n z = z0\n\n for i_step in range(n_steps):\n z = z + h * f(z, t)\n t = t + h\n return z","def linear_ode_origin(t,y0=5,case=1):\n return y0*np.exp(integrate.quad(origin_fun, 0, t,args=(case))[0])","def _numerical_derivative_two_sided (func:typing.Callable[[float],float], x_0:float) -> typing.Tuple[float,float]:\n epsilon = 1.0e-9\n func_x_0 = func(x_0)\n deriv_neg = (func_x_0 - func(x_0-epsilon)) / epsilon\n deriv_pos = (func(x_0+epsilon) - func_x_0) / epsilon\n return deriv_neg, deriv_pos","def rhs_fenics(y,t):\n #print \"time: \",t\n uprev.vector()[:]=y\n f.t = t #dolfin needs to know the current time for cos(t)\n uprime_solver.solve()\n return uprime_solution.vector().array()","def omtrek(self):\n x = pi*self.r**2\n return x","def solve_ode(self, n_evals, atol = 1e-6, rtol = 1e-4, print_time = False,max_step = np.inf):\n st = time.time()\n t_eval = np.linspace(0,self.t_ode,int(n_evals * self.t_ode) + 1 ).ravel()\n solution = solve_ivp(self.f, self.t_span,self.s0[:3*self.N], t_eval = t_eval, rtol = rtol, atol = atol, max_step = max_step )\n end = time.time()\n if print_time:\n print(\"Solution of ODE with n_evals: \" + str(n_evals) +\", t_ode: \" + str(self.t_ode) \n + \", took: \" + str(end-st) + \" s.\")\n return solution.y.T","def R_term(\n enst, # enstrophy field\n omega1, # vorticity-1 component\n omega2, # vorticity-2 component\n omega3, # vorticity-3 component\n s11, # strain rate-11 component\n s12, # strain rate-12 component\n s13, # strain rate-13 component\n s22, # strain rate-22 component\n s23, # strain rate-23 component\n s33, # strain rate-33 component\n diff = False): # differentiation flag\n #---------------------------------------------------------------------#\n # Defining domain variables #\n #---------------------------------------------------------------------#\n pi = np.pi # pi\n dx = (2.0*pi)/64.0 # spatial step\n nu = 0.000185 # default viscosity\n #---------------------------------------------------------------------#\n # Spectral differentiation variables #\n #---------------------------------------------------------------------#\n dim = 64\n kspec = np.fft.fftfreq(dim) * dim\n Kfield = np.array(np.meshgrid(kspec, kspec, kspec, indexing='ij'))\n #---------------------------------------------------------------------#\n # Spectral differentiation variables #\n #---------------------------------------------------------------------#\n term1 = np.zeros((dim, dim, dim))\n term2 = np.zeros((dim, dim, dim))\n term3 = np.zeros((dim, dim, dim))\n #---------------------------------------------------------------------#\n # Numerator (numpy gradient tool) #\n #---------------------------------------------------------------------#\n if diff is not False:\n term1 = np.gradient(enst,dx, edge_order=2)[0]\n term2 = np.gradient(enst,dx, edge_order=2)[1]\n term3 = np.gradient(enst,dx, edge_order=2)[2]\n #---------------------------------------------------------------------#\n # Numerator (spectral differentiation) #\n #---------------------------------------------------------------------#\n else:\n term1 = 0.5*np.fft.ifftn(1j*Kfield[0]*np.fft.fftn(enst) +\\\n 1j*Kfield[0]*np.fft.fftn(enst)).real\n term2 = 0.5*np.fft.ifftn(1j*Kfield[1]*np.fft.fftn(enst) +\\\n 1j*Kfield[1]*np.fft.fftn(enst)).real\n term3 = 0.5*np.fft.ifftn(1j*Kfield[2]*np.fft.fftn(enst) +\\\n 1j*Kfield[2]*np.fft.fftn(enst)).real\n #---------------------------------------------------------------------#\n # Numerator #\n #---------------------------------------------------------------------#\n num = nu*(term1**2.0+ term2**2.0 + term3**2.0)\n #---------------------------------------------------------------------#\n # Denominator #\n #---------------------------------------------------------------------#\n den = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\n #---------------------------------------------------------------------#\n # R calculation #\n #---------------------------------------------------------------------#\n R = num/den\n\n return R","def main():\n solve_ode_sys()\n\n return GOOD_RET # success","def dynstall_oye_dxdt(t,fs,u,p):\n alpha = u['alpha'](t)\n f_st = p['F_st'](alpha)\n return 1/p['tau'] * (f_st - fs)","def RK2(self, T=2.5, dt=0.00001):\n t_space = np.linspace(0, T, 1 + T/dt)\n U = self.U0.copy()\n half_dt_L = (dt / 2) * self.L\n dt_L = dt * self.L\n\n for i, t in enumerate(t_space[1:]):\n U_hlf = U + half_dt_L @ U\n U += dt_L @ U_hlf\n return U","def test_rhs(self):\n\n _, _, generator = setup_lmde_frames_and_generator(self.basic_model, solver_frame=self.X)\n\n t = 13.1231\n y = np.eye(2, dtype=complex)\n\n output = generator(t, y, in_frame_basis=True).data\n\n X = np.array(self.X.data)\n X_diag, U = np.linalg.eigh(X)\n Uadj = U.conj().transpose()\n gen = (\n -1j\n * 2\n * np.pi\n * (self.w * np.array(self.Z.data) / 2 + self.r * np.cos(2 * np.pi * self.w * t) * X / 2)\n )\n expected = (\n Uadj @ expm(1j * t * X) @ gen @ expm(-1j * t * X) @ U + 1j * np.diag(X_diag)\n ) @ y\n\n self.assertTrue(np.allclose(expected, output))","def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\n return so3.deskew(dR)","def electrical_ode(self, state, u_sr_alphabeta, omega, *args):\n return np.matmul(self._model_constants, np.array([\n # omega, i_alpha, i_beta, psi_ralpha, psi_rbeta, omega * psi_ralpha, omega * psi_rbeta, u_salpha, u_sbeta, u_ralpha, u_rbeta,\n omega,\n state[self.I_SALPHA_IDX],\n state[self.I_SBETA_IDX],\n state[self.PSI_RALPHA_IDX],\n state[self.PSI_RBETA_IDX],\n omega * state[self.PSI_RALPHA_IDX],\n omega * state[self.PSI_RBETA_IDX],\n u_sr_alphabeta[0, 0],\n u_sr_alphabeta[0, 1],\n u_sr_alphabeta[1, 0],\n u_sr_alphabeta[1, 1],\n ]))","def test_VODE():\n mech = 'h2o2.xml'\n gas = cantera.Solution(mech)\n\n T0 = 1500 # [K]\n p0 = cantera.one_atm # [Pa]\n gas.TPX = T0, p0, \"H2:2, O2:1, AR:0.1\"\n\n length = 1.5e-7 # *approximate* PFR length [m]\n u0 = 0.006 # inflow velocity [m/s]\n Ac = 1.0e-4 # cross-sectional area [m**2]\n Nx = 2000 # number of grid\n dx = length / Nx\n\n mass_flow_rate = u0 * gas.density * Ac\n N = gas.n_species # number of gas species\n vecp = numpy.zeros((N+1, 1))\n\n def rhseqn(t, vec):\n Y = vec[0:N]\n T = vec[-1]\n\n rho = gas.density\n u = mass_flow_rate / (rho * Ac)\n h_g = gas.partial_molar_enthalpies\n\n gas.set_unnormalized_mass_fractions(Y)\n gas.TP = T, p0\n\n wdot_g = gas.net_production_rates\n W_g = gas.molecular_weights\n\n for k in range(N):\n vecp[k] = wdot_g[k] * W_g[k] / (rho * u)\n\n vecp[-1] = -numpy.sum(wdot_g * h_g) / (rho * u * gas.cp)\n return vecp\n\n x = 0.0\n count = 0\n Y0 = numpy.hstack((gas.Y, T0))\n\n solver = ode(rhseqn)\n solver.set_integrator('vode', method='bdf')\n solver.set_initial_value(Y0, x)\n\n while x <= length:\n solver.integrate(solver.t + dx)\n\n if not solver.successful():\n print(f'Failed at x = {solver.t}')\n\n if not count % 100:\n print(f'x = {solver.t:.3e}\\tT = {solver.y[-1]:.3f}')\n\n x = solver.t\n count += 1\n\n print(f'x = {solver.t:.3e}\\tT = {solver.y[-1]:.3f}')","def pynamic_test():\n\n sol_times = np.linspace(0, 3, 25)\n\n #the true solution to the ODE\n sol_ys = 3*np.exp(-2*sol_times)\n\n #the parameters for pynamic_ode\n def test_func(_, y_vals):\n return -2*y_vals\n\n start_time = 0\n max_time = 2\n initial_val = [3]\n param_to_monitor = 0\n max_param_delta = 0.1\n base_time_step = 0.5\n min_step_time = 0.01\n\n def end_condition(_, y_vals):\n if y_vals[0] < 0.1:\n return 1\n return 0\n\n start = time.time()\n times, y_vals, status = pynamic_ode(test_func, start_time, max_time, \n initial_val, param_to_monitor, \n max_param_delta, base_time_step, \n min_step_time, end_condition, \n use_rk4=False)\n end = time.time()\n print(\"time to run with RK1: %2.3e\"%(end-start))\n\n start = time.time()\n t_rk4, y_rk4s, st_rk4 = pynamic_ode(test_func, start_time, max_time, \n initial_val, param_to_monitor, \n max_param_delta, base_time_step, \n min_step_time, end_condition, \n use_rk4=True)\n end = time.time()\n print(\"time to run with RK4: %2.3e\"%(end-start))\n\n sol_times = np.linspace(0, max_time, max_time*15)\n\n #the true solution to the ODE\n sol_ys = 3*np.exp(-2*sol_times)\n\n\n print(\"status of solver: %d, status with RK4: %d\"%(status, st_rk4))\n plt.plot(sol_times, sol_ys, 'k', label=\"True Sol.\")\n\n plt.plot(times, y_vals, 'r+', label=\"RK1\")\n plt.plot(times, y_vals, 'r:')\n plt.plot(t_rk4, y_rk4s, 'bx', label=\"RK4\")\n plt.plot(t_rk4, y_rk4s, 'b:')\n\n plt.legend()\n\n plt.savefig(\"test_results.png\")\n\n return 0","def dynamics(self,eta,nu,u_actual,u_control,sampleTime): \n \n # Current velocities\n u_c = self.V_c * math.cos(self.beta_c - eta[5]) # current surge velocity\n v_c = self.V_c * math.sin(self.beta_c - eta[5]) # current sway velocity \n \n nu_c = np.array([u_c,v_c,0,0,0,0],float) # current velocity vector\n nu_r = nu - nu_c # relative velocity vector\n \n U_r = math.sqrt( nu_r[0]**2 + nu_r[1]**2 ) # relative speed\n \n # Rudder command and actual rudder angle\n delta_c = u_control[0]\n delta = u_actual[0]\n \n # Rudder forces and moment (Fossen 2021, Chapter 9.5.1)\n b = 0.7 * self.T # rudder height\n AR = b**2 / self.Lambda # aspect ratio: Lamdba = b**2/AR \n CN = 6.13 * self.Lambda / ( self.Lambda + 2.25 ) # normal coefficient\n t_R = 1 - 0.28 * self.Cb - 0.55\n a_H = 0.4\n x_R = -0.45 * self.L\n x_H = -1.0 * self.L\n\n Xdd = -0.5 * ( 1 - t_R ) * self.rho * U_r**2 * AR * CN\n Yd = -0.25 * ( 1 + a_H ) * self.rho * U_r**2 * AR * CN \n Nd = -0.25 * ( x_R + a_H * x_H ) * self.rho * U_r**2 * AR * CN \n \n # Control forces and moment\n delta_R = -delta # physical rudder angle (rad)\n T = self.tau_X # thrust (N)\n t_deduction = 0.1 # thrust deduction number\n tau1 = ( 1 - t_deduction ) * T - Xdd * math.sin( delta_R )**2 \n tau2 = -Yd * math.sin( 2 * delta_R ) \n tau6 = -Nd * math.sin( 2 * delta_R ) \n tau = np.array( [ tau1, tau2, tau6 ],float) \n \n # Linear maneuvering model\n T_surge = self.L # approx. time constant in surge (s)\n xg = 0 # approx. x-coordinate, CG (m) \n \n # 3-DOF ship model\n [M,N] = clarke83(U_r,self.L, self.B, self.T,self.Cb,self.R66,xg,T_surge)\n Minv = np.linalg.inv(M)\n nu3 = np.array( [ nu_r[0], nu_r[1], nu_r[5] ]) \n nu3_dot = np.matmul( Minv, tau - np.matmul(N,nu3) ) \n \n # 6-DOF ship model\n nu_dot = np.array( [ nu3_dot[0],nu3_dot[1],0,0,0,nu3_dot[2] ]) \n\n # Rudder angle saturation\n if ( abs(delta) >= self.deltaMax * math.pi / 180 ):\n delta = np.sign(delta) * self.deltaMax * math.pi / 180\n \n # Rudder dynamics\n delta_dot = (delta_c - delta) / self.T_delta \n\n # Forward Euler integration [k+1]\n nu = nu + sampleTime * nu_dot\n delta = delta + sampleTime * delta_dot\n\n u_actual = np.array([delta],float) \n\n return nu, u_actual","def test_sin_2ndord_2vars():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.sin(x/y)\n df_dxdy = lambda x, y: -(y*np.cos(x/y) - x*np.sin(x/y))/y**3\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2), \n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n df_dxdy(1.5, 2.5))","def work_dos():\n #potential = 2x**2+x**2y+y**2\n x1,y1 = (2, -3)\n x2,y2 = (-1, 2)\n p1 = (2*(x1**2)) + ((x1**2)*y1) + (y1**2)\n p2 = (2*(x2**2)) + ((x2**2)*y2) + (y2**2)\n sol = p1 - p2\n sol = abs(sol)\n print(f'The vector field F=(4x+2xy,x2+2y) \\n'\n 'along the curve C parametrized by r(t)=(3t−1,−5t+2) \\n '\n f'for 0 ≤ t ≤ 1 is: {sol}')","def kuramoto_ODE(self, t, y, arg):\n w, k = arg\n yt = y[:,None]\n dy = y-yt\n\n phase = w.astype(self.dtype)\n if self.noise != None:\n n = self.noise().astype(self.dtype)\n dy += n\n \n for m, _k in enumerate(k):\n phase += np.sum(_k*np.sin((m+1)*dy),axis=1)\n \n return phase","def one_step(func, y0, rng):\n return scipy.integrate.odeint(func, y0, rng)[-1]","def deriv_angvel(self, t: float,endBehavior: str = 'halt') -> Vector3:\n cw = GeodesicTrajectory.deriv(self,t,endBehavior)\n return so3.deskew(cw)","def rhs(t, Y, q, omega_d, b):\n f = np.zeros_like(Y)\n\n f[0] = Y[1]\n f[1] = -q*Y[1] - np.sin(Y[0]) + b*np.cos(omega_d*t)\n\n return f","def test_exp_2ndord_2vars():\n x, y = fwd.Variable(), fwd.Variable()\n f = fwd.exp(x/y)\n df_dxdy = lambda x, y: -(x*np.exp(x/y) + y*np.exp(x/y)) / y**3\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2),\n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \n df_dxdy(1.5, 2.5))","def omega(self):\n return self._data.train_X @ self._thetas","def getOmega(dels):\n N = dels.delta_d.shape[1]\n delta_t = dels.delta_t\n delta_d = dels.delta_d\n \n a_t = np.diff(delta_t)\n a_t = a_t[:,0:-1]\n \n a_d = np.diff(delta_t[:,::-1])\n a_d = a_d[:,::-1]\n a_d = a_d[:,1::]\n \n b_t = np.diff(delta_d)\n b_t = b_t[:,0:-1]\n \n b_d = np.diff(delta_d[:,::-1])\n b_d = b_d[:,::-1]\n b_d = b_d[:,1::] \n \n c_t = 0.25*(np.abs(a_t)+np.abs(b_t))*np.sign(a_t)*np.sign(b_t)*(np.sign(a_t)*np.sign(b_t)-1)\n c_d = 0.25*(np.abs(a_d)+np.abs(b_d))*np.sign(a_d)*np.sign(b_d)*(np.sign(a_d)*np.sign(b_d)-1)\n Omega = 1.0/(2*N)*(c_t.mean(axis=0) + c_d.mean(axis=0))\n\n return Omega","def hydro_solver(self):\n u_dx = self.central_x(self.u)\n w_dy = self.central_y(self.w)\n P_dx = self.central_x(self.P)\n P_dy = self.central_y(self.P)\n\n rho_dx_upwind = self.upwind_x(self.rho, self.u)\n rho_dy_upwwind = self.upwind_y(self.rho, self.w)\n rho_udx_upwind = self.upwind_x(self.rho * self.u, self.u)\n rho_udy_upwind = self.upwind_y(self.rho * self.u, self.w)\n rho_wdx_upwind = self.upwind_x(self.rho * self.w, self.u)\n rho_wdy_upwind = self.upwind_y(self.rho * self.w, self.w)\n u_dx_uu = self.upwind_x(self.u, self.u)\n u_dx_uw = self.upwind_x(self.u, self.w)\n w_dy_uu = self.upwind_y(self.w, self.u)\n w_dy_uw = self.upwind_y(self.w, self.w)\n e_dx = self.upwind_x(self.e, self.u)\n e_dy = self.upwind_y(self.e, self.w)\n\n self.rho_dt = (\n -self.rho * (u_dx + w_dy)\n - self.u * rho_dx_upwind\n - self.w * rho_dy_upwwind\n )\n self.e_dt = (\n -(self.e + self.P) * (u_dx + w_dy) - self.u * e_dx - self.w * e_dy\n )\n self.rho_udt = (\n -self.rho * self.u * (u_dx_uu + w_dy_uu)\n - self.u * rho_udx_upwind\n - self.w * rho_udy_upwind\n - P_dx\n )\n self.rho_wdt = (\n -self.rho * self.w * (u_dx_uw + w_dy_uw)\n - self.u * rho_wdx_upwind\n - self.w * rho_wdy_upwind\n - P_dy\n + self.rho * self.g\n )\n\n self.time_step()\n rho_previous = np.zeros_like(self.rho)\n rho_previous[:, :] = self.rho\n self.rho[:, :] = self.rho + self.rho_dt * self.dt\n self.e[:, :] = self.e + self.e_dt * self.dt\n self.u[:, :] = (\n rho_previous * self.u + self.rho_udt * self.dt\n ) / self.rho\n self.w[:, :] = (\n rho_previous * self.w + self.rho_wdt * self.dt\n ) / self.rho\n\n self.boundary_conditions()\n self.T[:, :] = (\n (self.Y - 1) * self.e * self.mu * self.m_u / (self.kb * self.rho)\n )\n self.P[:, :] = (self.Y - 1) * self.e\n uw = (self.u, self.w)\n v = np.linalg.norm(uw)\n dt = self.dt\n\n return dt","def deriv(self, t: float, endBehavior: str = 'halt') -> Vector:\n return self.deriv_state(t,endBehavior)","def epflux_eddyterms():\n pass","def DirectSolve(self, y):\n if y >= -self.R:\n a1 = self.apath[y+1]\n if y == -2:\n a2 = 0\n else:\n a2 = self.apath[y+2] \n def constraints(a):\n c0 = (1+self.r)*a + self.b - a1\n c1 = (1+self.r)*a1 + self.b - a2\n return self.uc(c0,0)-self.beta*self.uc(c1,0)*(1+self.r)\n a, n = fsolve(constraints, a1), 0\n c = (1+self.r)*a + self.b - a1\n else:\n a1 = self.apath[y+1]\n a2 = self.apath[y+2]\n if y == -(self.R+1):\n n1 = 0\n c1 = (1+self.r)*a1 + self.b - a2\n else:\n n1 = self.npath[y+1]\n c1 = (1+self.r)*a1 + (1-self.tau)*self.w*n1 - a2\n def constraints((a0,n0)):\n c0 = (1+self.r)*a0 + (1-self.tau)*self.w*n0 - a1\n return self.uc(c0,n0) - self.beta*self.uc(c1,n1)*(1+self.r),\\\n (1-self.tau)*self.w*self.uc(c0,n0) + self.un(c0,n0)\n a, n = fsolve(constraints,(a1,n1))\n c = (1+self.r)*a + (1-self.tau)*self.w*n - a1\n return a, n, c","def Dre(self):\n er = self.er()\n sinE = np.sin(self.E())\n cosE = np.cos(self.E())\n return self.alpha()*(cosE- er)+ \\\n (self.beta()+self.GAMMA)*sinE","def edge_velocity(self):\n #reflext x values at x edges\n self.u[1,:,0] = -self.u[1,:,1]\n self.u[1,:,-1] = -self.u[1,:,-2]\n #mirror x values at y edges \n self.u[1,0,:] = self.u[1,1,:]\n self.u[1,-1,:] = self.u[1,-2,:]\n #mirror y values at x edges\n self.u[0,:,0] = self.u[0,:,1]\n self.u[0,:,-1] = self.u[0,:,-2]\n #mirror y values at y edges \n self.u[0,0,:] = -self.u[0,1,:]\n self.u[0,-1,:] = -self.u[0,-2,:]","def rstobaryright(x, y):\n\n from math import sqrt\n\n L = np.zeros((3, x.size))\n\n xv = (-1.0, 1.0, -1.0)\n yv = (-1.0, -1.0, 1.0)\n\n detT = (yv[1]-yv[2])*(xv[0]-xv[2])+(xv[2]-xv[1])*(yv[0]-yv[2])\n L[0] = ((yv[1]-yv[2])*(x -xv[2])+(xv[2]-xv[1])*(y -yv[2])) / detT\n L[1] = ((yv[2]-yv[0])*(x -xv[2])+(xv[0]-xv[2])*(y -yv[2])) / detT\n L[2] = 1.0 - L[0] - L[1]\n return L.T","def solve(self, t):\n dt = t[1]-t[0]\n if self.dt != dt and self.noise_type != 'custom':\n self.dt = dt\n self.update_noise_params(dt)\n\n kODE = ode(self.kuramoto_ODE, jac=self.kuramoto_ODE_jac)\n kODE.set_integrator(\"dopri5\")\n\n # Set parameters into model\n kODE.set_initial_value(self.init_phase, t[0])\n kODE.set_f_params((self.W, self.K))\n kODE.set_jac_params((self.W, self.K))\n\n if self._noise != None:\n self.update_noise_params(dt)\n\n phase = np.empty((self.n_osc, len(t)))\n \n # Run ODE integrator\n for idx, _t in enumerate(t[1:]):\n phase[:,idx] = kODE.y\n kODE.integrate(_t)\n\n phase[:,-1] = kODE.y\n \n return phase","def Vdiode(Icell, Vcell, Rs):\n return Vcell + Icell * Rs","def _redfield(R, rho0, evecs=None, Nt=1, dt=0.005, t0=0, e_ops=[], return_result=True):\n\n N = rho0.shape[0]\n # initialize the density matrix\n if e_ops is None:\n e_ops = []\n\n # basis transformation\n if evecs is not None:\n rho0 = transform(rho0, evecs)\n e_ops = [transform(e, evecs) for e in e_ops]\n\n rho = rho0.copy()\n rho = dm2vec(rho).astype(complex)\n\n # tf = t0 + dt * Nt\n # result = solve_ivp(rhs, t_span=(t0, tf), y0=rho0, vectorized=True, args=(R, ))\n\n t = t0\n\n if return_result == False:\n\n f_obs = open('obs.dat', 'w')\n fmt = '{} '* (len(e_ops) + 1) + '\\n'\n\n for k in range(Nt):\n\n # compute observables\n # observables = np.zeros(len(e_ops), dtype=complex)\n # for i, obs_op in enumerate(e_ops):\n\n observables = [obs_dm(rho, e) for e in e_ops]\n\n t += dt\n rho = rk4(rho, rhs, dt, R)\n\n # dipole-dipole auto-corrlation function\n #cor = np.trace(np.matmul(d, rho))\n\n # take a partial trace to obtain the rho_el\n\n\n f_obs.write(fmt.format(t, *observables))\n\n\n f_obs.close()\n # f_dm.close()\n\n return rho\n\n else:\n\n rholist = [] # store density matries\n\n result = Result(dt=dt, Nt=Nt, rho0=rho0)\n\n observables = np.zeros((Nt, len(e_ops)), dtype=complex)\n\n for k in range(Nt):\n\n t += dt\n rho = rk4(rho, rhs, dt, R)\n\n tmp = np.reshape(rho, (N, N))\n rholist.append(transform(tmp, dag(evecs)))\n\n\n observables[k, :] = [obs_dm(tmp, e) for e in e_ops]\n\n\n result.observables = observables\n result.rholist = rholist\n\n return result","def runge_integrator(self, t, y, dt, tau):\n\n k1 = self.plant.rhs(t, y, tau)\n k2 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k1, tau)\n k3 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k2, tau)\n k4 = self.plant.rhs(t + dt, y + dt * k3, tau)\n return (k1 + 2 * (k2 + k3) + k4) / 6.0","def dVdx(self, sys):\n dx = sys.positions - self.x0\n k = self.omega*self.omega*sys.mass\n return self.A*k*dx","def c( self , y , r , t = 0 ):\n \n u = np.zeros(self.m) # State derivative vector\n \n raise NotImplementedError\n \n return u","def euler_sde(self, x, rv_n):\n n = self.mp.params[0]; k = self.mp.params[1];\n gamma = self.mp.params[2]; dt = self.mp.params[3];\n\n if x.get_shape()[1] > 1:\n evolve_fun = self.evolve_system\n else:\n evolve_fun = self.evolve\n\n dx = dt * self.evolve(x, n, k, gamma)\n x = x + dx + tf.sqrt(dt)*x*rv_n\n return tf.cast(x, tf.float32)","def VerletHope2(r, v, beta,dt,R_dust,M_dust):\n # Deceptively simple (read about Velocity Verlet on wikipedia)\n r_new = r + v*dt + calculate_acceleration2(r,v,beta,omega,R_dust,M_dust)*dt**2/2\n v_new = v + (calculate_acceleration2(r,v,beta,omega,R_dust,M_dust) + calculate_acceleration2(r_new,v,beta,omega,R_dust,M_dust))/2 * dt\n \n return (r_new, v_new)"],"string":"[\n \"def ode(self, **kwargs):\\n pass\",\n \"def rightSideOfODE(self, Y, t):\\n\\t\\ttemperature = Y[-1]\\n\\t\\tamounts = Y[:-1]\\n\\t\\tself.amounts = amounts\\n\\t\\t# first get the species amount changes (as an array)\\n\\t\\tdNdt = -1 * self.getMolarFluxes(temperature)\\n\\t\\t# then get the temperature change, and append it to the array\\n\\t\\tdUdt = sum( dNdt * self.getEnthalpiesOfVaporization(temperature) )\\n\\t\\tdUdt = dUdt + self.getHeatFlux(temperature)\\n\\t\\tdTdt = dUdt / sum( self.amounts * self.molar_heat_capacities )\\n\\t\\treturn numpy.append(dNdt,dTdt)\",\n \"def ode(self, w: np.ndarray) -> np.ndarray:\\n _assert_iterables(w, 'Angular velocity')\\n if w.ndim != 1 or w.shape[0] != 3:\\n raise ValueError(f\\\"Expected `w` to have shape (3,), got {w.shape}\\\")\\n F = np.array([\\n [0.0, -w[0], -w[1], -w[2]],\\n [w[0], 0.0, -w[2], w[1]],\\n [w[1], w[2], 0.0, -w[0]],\\n [w[2], -w[1], w[0], 0.0]])\\n return 0.5*F@self.A\",\n \"def forward_ode(self, t, y):\\n\\n shape = y.shape\\n y = np.reshape(y, (-1, 1)) # make y 2D if it is not already\\n\\n velocity = y[0, :]\\n # position = y[1, :]\\n\\n omega_motor = velocity / self.wheel_radius * self.gear_ratio # rad/s\\n\\n # TODO: include motor impedance effects\\n motor_current = self._motor_current(omega_motor, 0)\\n if self.current_limit:\\n motor_current = min((motor_current, self.current_limit))\\n\\n force = motor_current * self.motor.torque_const * self.gear_ratio \\\\\\n / self.wheel_radius\\n if self._slip_force is not None:\\n force = min((force, self._slip_force))\\n\\n return np.reshape(np.vstack((force / self.mass, velocity)), shape)\",\n \"def get_ode(self, d):\\n C1 = np.array([[-1./self.Q, -1.], [1., 0.]])\\n C2 = np.array([[1.], [0.]])\\n \\n def ode(t, x): \\n F = self.Fint(x)\\n dxdt = np.matmul(C1, x) + np.matmul(C2, (d+(self.A0/self.Q)*np.cos(self.Om*t)+F/self.k))\\n return dxdt\\n return ode\",\n \"def ode(self, w: np.ndarray) -> np.ndarray:\\n return self.A@skew(w)\",\n \"def call_odeint(particle_object,dt,omega):\\n \\n# print \\n# print '##########################'\\n# \\n r = particle_object.position\\n v = particle_object.velocity \\n beta = particle_object.beta \\n# \\n# print 'Initial parameters'\\n# print 'r', r\\n# print 'v', v\\n# print 'beta',beta\\n# print \\n# beta = 0.15\\n #particle_radius = particle_object.radius\\n \\n# ### updating the acceleration due to planet history with the position value before it is moved so that it is the acceleration due to the planet at the position that led to this nett acceleration. \\n# particle_object.update_planet_acceleration_history(AccelerationDueToPlanet(r))\\n \\n u0 = np.array([r[0],r[1],r[2],v[0],v[1],v[2]])\\n \\n \\n sol = odeint(acceleration_for_odeint, u0, np.array([0,dt]), args=(beta, omega,planet_pos)) ## The solution in the from [rx,ry,rz,vx,vy,vz]\\n \\n r_new = np.array([sol[1,0],sol[1,1],sol[1,2]])\\n v_new = np.array([sol[1,3],sol[1,4],sol[1,5]]) \\n \\n# print 'New parameters'\\n# print 'r', r_new\\n# print 'v', v_new\\n#\\n# print \\n \\n #particle_object.update_position(r_new) \\n #particle_object.update_velocity(v_new)\\n \\n ### add one to the particle's age \\n particle_object.update_age() \\n particle_object.update_timestep_history(timestep)\\n \\n #last_uvect = sol[1,:]\\n \\n #return last_uvect\\n \\n #return 0,0\\n return r_new,v_new\",\n \"def ODEStep(u, um, t, dt, F):\\n up = 2*u - um + dt*dt*F(u, t)\\n return up\",\n \"def electrical_ode(self, state, u_in, omega, *_):\\n raise NotImplementedError\",\n \"def ODEfun(y,t,params):\\n Im = y[0]\\n Is = y[1]\\n Ic = y[2]\\n R = y[3]\\n \\n\\n try:\\n\\n r = params['r']\\n p = params['p']\\n N = params['N']\\n R0 = params['R0']\\n k = params['k']\\n m = params['m']\\n n = params['n']\\n m1 = params['m1']\\n A = params['A']\\n t0 = params['t0']\\n ps = 0.1\\n except:\\n print('error')\\n\\n S = (1-R/N)\\n M = hcode.mitigation(t,m,A,n,m1,t0)\\n # the model equations\\n f0 = (1-ps)*R0*(k+(1-k)*M)*S*(Im + p*Is) - Im\\n f1 = ps*R0*(k+(1-k)*M)*S*(Im + p*Is) - Is\\n f2 = r*(1-ps)*R0*(k+(1-k)*M)*S*(Im + p*Is) + ps*R0*(k+(1-k)*M)*S*(Im + p*Is) #r*Im/10 + ps*R0*(k+(1-k)*M)*S*(Im + p*Is)#\\n f3 = R0*(k+(1-k)*M)*S*(Im + p*Is)\\n\\n return [f0, f1, f2, f3]\",\n \"def ODE(XV,t,M,shape):\\n dimensions = shape[1]/2\\n XV = XV.reshape(shape)\\n F = Net_force_1( XV[:,:dimensions], M)\\n\\n R = np.append( XV[:,dimensions:], F, axis=0 )\\n\\n return R.flatten()\",\n \"def d_beta_d_EDOT(self):\\n eTheta = self.eTheta()\\n a1 = (self.a1()).decompose()\\n sinOmg = np.sin(self.omega())\\n cosOmg = np.cos(self.omega())\\n return a1/c.c*((-eTheta)/np.sqrt(1-eTheta**2)*cosOmg*self.tt0- \\\\\\n (1-eTheta**2)**0.5*sinOmg*self.d_omega_d_par('EDOT'))\",\n \"def calculate_data_ode_right_hand_side(data_ops, power_system):\\r\\n states_results = data_ops['states_results']\\r\\n A, B, C, D, F, G, u_0, x_0 = create_system_matrices(power_system=power_system)\\r\\n\\r\\n u_disturbance = data_ops['power'] @ G.T\\r\\n u = u_0.T + u_disturbance\\r\\n\\r\\n solver_func = functools.partial(ode_right_hand_side_solve, A=A, B=B, C=C, D=D, F=F)\\r\\n\\r\\n solver_results = map(solver_func,\\r\\n data_ops['time'],\\r\\n states_results,\\r\\n u)\\r\\n\\r\\n list_solver_results = list(solver_results)\\r\\n\\r\\n states_t_results = np.concatenate([single_solver_result.reshape((1, -1)) for single_solver_result in\\r\\n list_solver_results],\\r\\n axis=0)\\r\\n\\r\\n data_ops.update(states_t_results=states_t_results)\\r\\n\\r\\n return data_ops\",\n \"def test_tan_2ndord_2vars():\\n x, y = fwd.Variable(), fwd.Variable()\\n f = fwd.tan(x/y)\\n df_dxdy = lambda x, y: -(y/np.cos(x/y)**2 + 2*x*np.tan(x/y)/np.cos(x/y)**2) / y**3\\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2),\\n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n df_dxdy(1.5, 2.5))\",\n \"def euler_richardson_method_2system_ode2(f, g, dt, x, y, xp, yp, range):\\n # f = x'' and g = y''\\n # both requires (t, x, y, x', y')\\n # get initial conditions and setup arrays\\n t = min(range)\\n t_space = [t]\\n x_space = [x]\\n y_space = [y]\\n xp_space = [xp]\\n yp_space = [yp]\\n \\n while t <= max(range):\\n # find get midpoints\\n t_mid = t + (1/2)*dt\\n xp_mid = xp + 1/2*f(t, x, y, xp, yp)*dt\\n yp_mid = yp + 1/2*g(t, x, y, xp, yp)*dt\\n x_mid = x + (1/2)*xp*dt\\n y_mid = y + (1/2)*yp*dt\\n \\n # get slopes\\n xp_s = f(t_mid, x_mid, y_mid, xp_mid, yp_mid)\\n yp_s = g(t_mid, x_mid, y_mid, xp_mid, yp_mid)\\n x_s = xp_mid\\n y_s = yp_mid\\n \\n # update values\\n t += dt\\n x += x_s*dt\\n y += y_s*dt\\n xp += xp_s*dt\\n yp += yp_s*dt\\n\\n # append values\\n t_space.append(t)\\n x_space.append(x)\\n xp_space.append(xp)\\n y_space.append(y)\\n yp_space.append(yp)\\n \\n \\n return (t_space, x_space, y_space, xp_space, yp_space)\",\n \"def ode(D, radial=False, catch_errors=False):\\n\\n try:\\n k = _k[radial]\\n except KeyError:\\n raise ValueError(f\\\"radial must be one of {{{', '.join(repr(key) for key in _k)}}}\\\") from None\\n\\n\\n def fun(o, y):\\n\\n theta, dtheta_do = y\\n\\n try:\\n D1 = D(theta, 1)\\n except (ValueError, ArithmeticError):\\n if catch_errors:\\n return np.array((dtheta_do, np.nan*o), float)\\n else:\\n raise\\n\\n D_, dD_dtheta = D1\\n\\n k_o = k/o if k else 0\\n\\n N = (o/2 + dD_dtheta*dtheta_do)\\n\\n try:\\n R = N/D_\\n except ZeroDivisionError:\\n if catch_errors:\\n R = N*np.inf\\n else:\\n raise\\n\\n d2theta_do2 = -(R + k_o)*dtheta_do\\n\\n try:\\n return np.array((dtheta_do, d2theta_do2), float)\\n except TypeError:\\n if catch_errors:\\n return np.array((dtheta_do, np.nan*o), float)\\n else:\\n raise\\n\\n\\n def jac(o, y):\\n\\n theta, dtheta_do = y\\n\\n J = np.empty((2,2)+np.shape(o))\\n J[0,0] = 0\\n J[0,1] = 1\\n\\n try:\\n D2 = D(theta, 2)\\n except (ValueError, ArithmeticError):\\n if catch_errors:\\n try:\\n # This second call to D will not be counted by solvers.\\n # However, this is a very unlikely edge case.\\n D1 = D(theta, 1)\\n except (ValueError, ArithmeticError):\\n J[1,:] = np.nan\\n return J\\n else:\\n D_, dD_dtheta = D1\\n d2D_dtheta2 = np.nan\\n else:\\n raise\\n else:\\n D_, dD_dtheta, d2D_dtheta2 = D2\\n\\n k_o = k/o if k else 0\\n\\n # Jacobian expressions were obtained symbolically\\n # Source: ../symbolic/ode_jac.py\\n try:\\n x0 = 1/D_\\n except ZeroDivisionError:\\n if catch_errors:\\n x0 = np.inf\\n else:\\n raise\\n x1 = dD_dtheta*dtheta_do\\n x2 = x0*(o + 2*x1)/2\\n try:\\n J[1,0] = -dtheta_do*x0*(d2D_dtheta2*dtheta_do - dD_dtheta*x2)\\n except TypeError:\\n if catch_errors:\\n J[1,0] = np.nan\\n else:\\n raise\\n try:\\n J[1,1] = -k_o - x0*x1 - x2\\n except TypeError:\\n if catch_errors:\\n J[1,1] = np.nan\\n else:\\n raise\\n\\n return J\\n\\n return fun, jac\",\n \"def electrical_ode(self, state, u_salphabeta, omega, *args):\\n u_ralphabeta = np.zeros_like(u_salphabeta)\\n u_sr_aphabeta = np.array([u_salphabeta, u_ralphabeta])\\n\\n return super().electrical_ode(state, u_sr_aphabeta, omega, *args)\",\n \"def d2(self):\\r\\n return self.d1() - self.sigma*self.t**0.5\",\n \"def ode_solver(fun, t_span, y0, t_eval):\\n sol = integrate.solve_ivp(fun = fun, t_span = t_span, y0 = y0, t_eval=t_eval, method=\\\"Radau\\\")\\n return sol\",\n \"def build_derivative_total(mu):\\n\\n def ode_right_hand_side(t, y):\\n return -mu(t) * y\\n\\n return ode_right_hand_side\",\n \"def monkey_ode_int(self, function, y, time, args, Dfun, tfirst, **kwargs):\\n assert all(y == self._state), 'unexpected state before integration'\\n assert time == [0, self._tau], 'unexpected time steps for integration'\\n assert args == (self.args,), 'unexpected arguments'\\n assert tfirst\\n return np.array([[0, 2], self._state])\",\n \"def _phi_ode(self, t, z):\\n # prep states and phi_matrix\\n state = z[0:len(self.istate)]\\n ad_state = make_ad(state)\\n phi_flat = clear_ad(z[len(self.istate):])\\n phi = np.reshape(phi_flat, (len(self.istate),\\n len(self.istate)))\\n\\n # find the accelerations and jacobian\\n state_deriv = self.force_model.ode(0, ad_state)\\n a_matrix = jacobian(self.force_model.ode(0, ad_state),\\n ad_state)\\n\\n # compute the derivative of the STM and repackage\\n phid = np.matmul(a_matrix, phi)\\n phid_flat = phid.flatten()\\n z_out = np.concatenate((state_deriv, phid_flat))\\n\\n return z_out\",\n \"def euler_integrator(self, t, y, tau):\\n\\n return self.plant.rhs(t, y, tau)\",\n \"def test_tan_2ndord():\\n # one variable\\n x = fwd.Variable()\\n f = fwd.tan(2.0*x - 3.0)\\n assert equals( f.derivative_at(x, {x: 1.5}, order=2), \\n 8.0*np.tan(2.0*1.5-3.0)/(np.cos(2.0*1.5-3.0))**2 )\\n # two variables\\n x, y = fwd.Variable(), fwd.Variable()\\n g = fwd.tan(2.0*x / y)\\n assert equals(g.derivative_at(x, {x: 1.5, y: 2.5}, order=2), \\n 8.0*np.tan(2.0*1.5/2.5) / (np.cos(2.0*1.5/2.5)**2 * (2.5**2)) )\\n # test error raising\\n with pytest.raises(NotImplementedError):\\n g.derivative_at(x, {x:1.0, y: 2.0}, order=3)\",\n \"def right_rotation(self, ang_vel):\\n vel = self.om_left_max * self.R + ang_vel * self.L\\n om_right = (vel + ang_vel * self.L) / self.R \\n return vel, om_right\",\n \"def state_ode(self, t, x, p):\\n # assign p (parameters) and x (states)\\n self.states.loc[:, \\\"value\\\"] = x\\n v = self.fluxes(t, x, p)\\n dxdt = np.dot(self.stoich_matrix, v)\\n return dxdt\",\n \"def build_derivative_full(iota, rho, chi, omega):\\n\\n def ode_right_hand_side(t, y):\\n sprime = -(iota(t) + omega(t)) * y[0, :] + rho(t) * y[1, :]\\n cprime = iota(t) * y[0, :] - (rho(t) + omega(t) + chi(t)) * y[1, :]\\n return np.vstack([sprime, cprime])\\n\\n return ode_right_hand_side\",\n \"def diff_op(self, args: List, time: float) -> List:\\n ode_args: Dict = dict(zip(self.ode_list, args))\\n dvdt: float = self.dvdt(args=ode_args)\\n ode: List[float] = [dvdt]\\n\\n if self.channel_bool['nav']:\\n dhNadt: float = self.nav.dhdt(v=ode_args['v'], h=ode_args['h_nav'])\\n ode.append(dhNadt) \\n if self.channel_bool['kvhh']:\\n dnKdt: float = self.kvhh.dndt(v=ode_args['v'], n=ode_args['n_kvhh'])\\n ode.append(dnKdt)\\n if self.channel_bool['kva']:\\n dhAdt: float = self.kva.dhdt(v=ode_args['v'], h=ode_args['h_kva'])\\n ode.append(dhAdt)\\n if self.channel_bool['kvsi']:\\n dmKSdt: float = self.kvsi.dmdt(v=ode_args['v'], m=ode_args['m_kvsi'])\\n ode.append(dmKSdt)\\n if self.channel_bool['ampar']:\\n dsAMPAdt: float = self.ampar.dsdt(v=ode_args['v'], s=ode_args['s_ampar'])\\n ode.append(dsAMPAdt)\\n if self.channel_bool['nmdar']:\\n dxNMDAdt: float = self.nmdar.dxdt(v=ode_args['v'], x=ode_args['x_nmdar'])\\n dsNMDAdt: float = self.nmdar.dsdt(v=ode_args['v'], s=ode_args['s_nmdar'], x=ode_args['x_nmdar'])\\n ode.append(dxNMDAdt)\\n ode.append(dsNMDAdt)\\n if self.channel_bool['gabar']:\\n dsGABAdt: float = self.gabar.dsdt(v=ode_args['v'], s=ode_args['s_gabar'])\\n ode.append(dsGABAdt)\\n if self.channel_bool['cav'] or self.channel_bool['nmdar'] or self.channel_bool['ca']:\\n ca_args: Dict = {\\n 'v' : ode_args.get('v', None),\\n 's_nmdar' : ode_args.get('s_nmdar', None),\\n 'ca' : ode_args.get('ca', None),\\n }\\n dCadt: float = self.dCadt(ca_args)\\n ode.append(dCadt)\\n \\n return ode\",\n \"def right (x):\\n\\n return Sinary(side(x.v,0))\",\n \"def ode_func(t, X, delays, force_from_heat, damping, spring_consts, masses, L,\\n pbar=None, state=None):\\n if pbar is not None:\\n # set everything for the tqdm progressbar\\n last_t, dt = state\\n n = (t - last_t)/dt\\n if n >= 1:\\n pbar.update(1)\\n pbar.set_description('Delay = {:.3f} ps'.format(t*1e12))\\n state[0] = t\\n elif n < 0:\\n state[0] = t\\n\\n # start with the actual ode function\\n x = X[0:L]\\n v = X[L:]\\n\\n # the output must be a column vector\\n X_prime = np.zeros([2*L])\\n\\n # accelerations = derivative of velocities\\n X_prime[L:] = (\\n PhononNum.calc_force_from_damping(v, damping, masses)\\n + PhononNum.calc_force_from_spring(\\n np.r_[np.diff(x), 0],\\n np.r_[0, np.diff(x)],\\n spring_consts)\\n + force_from_heat[:, finderb(t, delays)].squeeze()\\n )/masses\\n\\n # velocities = derivative of positions\\n X_prime[0:L] = v\\n\\n return X_prime\",\n \"def dual_inf_ODE(t, y, params):\\n # Unpack states ------------------------------------------------------------------------------------\\n # The states are as follows. All quantities are absolute numbers, not concentrations, so no volume scaling is made\\n # during transport between the upper respiratory tract (URT) and the lower respiratory tract (LRT)\\n # 0. T1 - target cells in URT\\n # 1. E1WT - eclipse-stage cells in URT w/ wildtype virion (infected but not producing virions)\\n # 2. I1WT - wildtype infected cells producing virions (URT)\\n # 3. VTWT - wildtype virions SAMPLED by a pharyngeal throat swab in URT\\n # 4. T1TIP - target cells in URT infected w/ TIP\\n # 5. E1D - eclipse-stage cells in URT w/ coinfection by wildtype virus and TIP (infected but not producing virion)\\n # 6. I1D - coinfected cells producing both wildtype virion and TIP (URT)\\n # 7. VTTIP - TIP virions SAMPLED by a pharyngeal throat swab in URT {assume a hypothetical equivalent test to WT}\\n # 8. T2 - target cells in LRT\\n # 9. E2WT - eclipse-stage cells in LRT w/ wildtype virion (infected but not producing virions)\\n # 10. I2WT - wildtype infected cells producing virions (LRT)\\n # 11. VSWT - wildtype virions SAMPLED by a sputum sample from LRT\\n # 12. T2TIP - target cells in LRT infected w/ TIP\\n # 13. E2D - eclipse-stage cells in LRT w/ coinfection by wildtype virus and TIP (infected but not producing virion)\\n # 14. I2D - coinfected cells producing both wildtype virion and TIP (LRT)\\n # 15. VSTIP - TIP virions SAMPLEd by a sputum sample from LRT\\n T1, E1WT, I1WT, VTWT, T1TIP, E1D, I1D, VTTIP, T2, E2WT, I2WT, VSWT, T2TIP, E2D, I2D, VSTIP = y\\n\\n # Unpack parameters ------------------------------------------------------------------------------------\\n # beta_T = target cell infection rate constant in URT, divided by sampling fraction f1 (beta_T = beta1/f1)\\n # k1 = eclipse phase rate constant, for transition from nonproductive infected cell to productive.\\n # pi_T = virion production rate by infected cells in URT, multiplied by sampling fraction f1 (pi_T = f1*p1)\\n # delta1 = clearance rate of virion-producing infected cells\\n # beta_S, analogous to beta_T but for LRT (beta_S = beta2/f2)\\n # k2, analogous to k1 but for LRT\\n # pi_S, analogous to pi_T but for LRT (pi_S = f2*p2)\\n # delta2, analogous to delta1 but for LRT\\n # c = clearance rate constant for virions in both URT and LRT\\n # w = exponential growth rate for the clearance of virion-producing infected cells (i.e. adaptive immunity)\\n # gamma = scaled rate of virion transfer from URT to LRT, calculates production of VS from VT (gamma = f2/f1*g12)\\n # rho = relative TIP virion production rate from coinfected cells (vs. wildtype virion production from coinf. cells)\\n # psi = relative wildtype virion production rate from coinfected cells (vs. wildtype virion production from singly infected cells)\\n # xi = relative target cell infection rate for TIP versus virion.\\n # See Ruian Ke et al. medRxiv 10.1101/2020.09.25.20201772v1 for further definitions, parameter names match.\\n beta_T, k1, pi_T, delta1, beta_S, k2, pi_S, delta2, c, w, gamma, rho, psi, xi, delta_TIP = params\\n\\n n_entries = 16\\n dydt = np.zeros(n_entries)\\n\\n # Calculate effect of adaptive immune response\\n if t >= 14:\\n delta1 = delta1*np.exp(w*(t-14))\\n delta2 = delta2*np.exp(w*(t-14))\\n else:\\n delta1 = delta1\\n delta2 = delta2\\n\\n # dT1/dt\\n dydt[0] = -beta_T*VTWT*T1 - xi*beta_T*VTTIP*T1\\n\\n # dE1WT/dt\\n dydt[1] = +beta_T*VTWT*T1 - k1*E1WT\\n\\n # dI1WT/dt\\n dydt[2] = k1*E1WT - delta1*I1WT\\n\\n # dVTWT/dt\\n dydt[3] = pi_T*I1WT - c*VTWT + psi*pi_T*I1D\\n\\n # dT1TIP/dt\\n dydt[4] = xi*beta_T*VTTIP*T1 - beta_T*VTWT*T1TIP\\n\\n # dE1D/dt\\n dydt[5] = beta_T*VTWT*T1TIP - k1*E1D\\n\\n # dI1D/dt\\n #dydt[6] = k1*E1D - delta1*I1D\\n # Note that delta_TIP=1.\\n # Non-unity values explore differential effect on immune clearance of TIP-carrying infected cells.\\n dydt[6] = k1*E1D - delta1*delta_TIP*I1D\\n\\n # dVTTIP/dt\\n dydt[7] = rho*pi_T*I1D - c*VTTIP\\n\\n # dT2/dt\\n dydt[8] = -beta_S*VSWT*T2 - xi*beta_S*VSTIP*T2\\n\\n # dE2WT/dt\\n dydt[9] = beta_S*VSWT*T2 - k2*E2WT\\n\\n # dI2WT/dt\\n dydt[10] = k2*E2WT - delta2*I2WT\\n\\n # dVSWT/dt\\n dydt[11] = pi_S*I2WT - c*VSWT + psi*pi_S*I2D + gamma*VTWT\\n\\n # dT2TIP/dt\\n dydt[12] = xi*beta_S*VSTIP*T2 - beta_S*VSWT*T2TIP\\n\\n # dE2D/dt\\n dydt[13] = beta_S*VSWT*T2TIP - k2*E2D\\n\\n # dI2D/dt\\n dydt[14] = k2*E2D - delta2*delta_TIP*I2D\\n\\n # dVSTIP/dt\\n dydt[15] = rho*pi_S*I2D - c*VSTIP + gamma*VTTIP\\n\\n return dydt\",\n \"def _dK_ode_dtheta(self, target):\\r\\n t_ode = self._t[self._index>0]\\r\\n dL_dK_ode = self._dL_dK[self._index>0, :]\\r\\n index_ode = self._index[self._index>0]-1\\r\\n if self._t2 is None:\\r\\n if t_ode.size==0:\\r\\n return \\r\\n t2_ode = t_ode\\r\\n dL_dK_ode = dL_dK_ode[:, self._index>0]\\r\\n index2_ode = index_ode\\r\\n else:\\r\\n t2_ode = self._t2[self._index2>0]\\r\\n dL_dK_ode = dL_dK_ode[:, self._index2>0]\\r\\n if t_ode.size==0 or t2_ode.size==0:\\r\\n return\\r\\n index2_ode = self._index2[self._index2>0]-1\\r\\n\\r\\n h1 = self._compute_H(t_ode, index_ode, t2_ode, index2_ode, stationary=self.is_stationary, update_derivatives=True)\\r\\n #self._dK_ddelay = self._dh_ddelay\\r\\n self._dK_dsigma = self._dh_dsigma\\r\\n\\r\\n if self._t2 is None:\\r\\n h2 = h1\\r\\n else:\\r\\n h2 = self._compute_H(t2_ode, index2_ode, t_ode, index_ode, stationary=self.is_stationary, update_derivatives=True)\\r\\n\\r\\n #self._dK_ddelay += self._dh_ddelay.T\\r\\n self._dK_dsigma += self._dh_dsigma.T\\r\\n # C1 = self.sensitivity\\r\\n # C2 = self.sensitivity\\r\\n\\r\\n # K = 0.5 * (h1 + h2.T)\\r\\n # var2 = C1*C2\\r\\n # if self.is_normalized:\\r\\n # dk_dD1 = (sum(sum(dL_dK.*dh1_dD1)) + sum(sum(dL_dK.*dh2_dD1.T)))*0.5*var2\\r\\n # dk_dD2 = (sum(sum(dL_dK.*dh1_dD2)) + sum(sum(dL_dK.*dh2_dD2.T)))*0.5*var2\\r\\n # dk_dsigma = 0.5 * var2 * sum(sum(dL_dK.*dK_dsigma))\\r\\n # dk_dC1 = C2 * sum(sum(dL_dK.*K))\\r\\n # dk_dC2 = C1 * sum(sum(dL_dK.*K))\\r\\n # else:\\r\\n # K = np.sqrt(np.pi) * K\\r\\n # dk_dD1 = (sum(sum(dL_dK.*dh1_dD1)) + * sum(sum(dL_dK.*K))\\r\\n # dk_dC2 = self.sigma * C1 * sum(sum(dL_dK.*K))\\r\\n\\r\\n\\r\\n # dk_dSim1Variance = dk_dC1\\r\\n # Last element is the length scale.\\r\\n (dL_dK_ode[:, :, None]*self._dh_ddelay[:, None, :]).sum(2)\\r\\n\\r\\n target[-1] += (dL_dK_ode*self._dK_dsigma/np.sqrt(2)).sum()\\r\\n\\r\\n\\r\\n # # only pass the gradient with respect to the inverse width to one\\r\\n # # of the gradient vectors ... otherwise it is counted twice.\\r\\n # g1 = real([dk_dD1 dk_dinvWidth dk_dSim1Variance])\\r\\n # g2 = real([dk_dD2 0 dk_dSim2Variance])\\r\\n # return g1, g2\\\"\\\"\\\"\\r\",\n \"def g(t, x0, paras):\\n x = odeint(f, x0, t, args=(paras,))\\n return x\",\n \"def _generic_ode_solve(r, psi0, tlist, e_ops, opt, progress_bar, dims=None):\\n #\\n # prepare output array\\n #\\n n_tsteps = len(tlist)\\n output = Result()\\n output.solver = \\\"sesolve\\\"\\n output.times = tlist\\n\\n n_modes = len(psi0.dims[0])\\n\\n if psi0.isunitary:\\n oper_evo = True\\n oper_n = dims[0][0]\\n norm_dim_factor = np.sqrt(oper_n)\\n else:\\n oper_evo = False\\n norm_dim_factor = 1.0\\n\\n if opt.store_states:\\n output.states = []\\n\\n if isinstance(e_ops, types.FunctionType):\\n n_expt_op = 0\\n expt_callback = True\\n\\n elif isinstance(e_ops, list):\\n n_expt_op = len(e_ops)\\n expt_callback = False\\n\\n if n_expt_op == 0:\\n # fallback on storing states\\n output.states = []\\n opt.store_states = True\\n else:\\n output.expect = []\\n output.num_expect = n_expt_op\\n for op in e_ops:\\n if op.isherm:\\n output.expect.append(np.zeros(n_tsteps))\\n else:\\n output.expect.append(np.zeros(n_tsteps, dtype=complex))\\n else:\\n raise TypeError(\\\"Expectation parameter must be a list or a function\\\")\\n\\n def get_curr_state_data():\\n if oper_evo:\\n return r.y.reshape([oper_n, oper_n]).T\\n else:\\n if opt.moving_basis:\\n return r.y[0:-n_modes]\\n else:\\n return r.y\\n\\n #\\n # start evolution\\n #\\n progress_bar.start(n_tsteps)\\n\\n output.displacements = np.zeros([n_modes, len(tlist)], dtype=complex)\\n\\n dt = np.diff(tlist)\\n for t_idx, t in enumerate(tlist):\\n progress_bar.update(t_idx)\\n\\n if not r.successful():\\n raise Exception(\\\"ODE integration error: Try to increase \\\"\\n \\\"the allowed number of substeps by increasing \\\"\\n \\\"the nsteps parameter in the Options class.\\\")\\n\\n # get the current state / oper data if needed\\n cdata = None\\n if opt.store_states or opt.normalize_output or n_expt_op > 0:\\n cdata = get_curr_state_data()\\n\\n if opt.normalize_output:\\n # cdata *= _get_norm_factor(cdata, oper_evo)\\n cdata *= norm_dim_factor / la_norm(cdata)\\n if oper_evo:\\n r.set_initial_value(cdata.ravel(), r.t)\\n else:\\n r.set_initial_value(cdata, r.t)\\n\\n if opt.store_states:\\n output.states.append(Qobj(cdata, dims=dims))\\n\\n if opt.moving_basis:\\n output.displacements[:, t_idx] = r.y[-n_modes:]\\n\\n if expt_callback:\\n # use callback method\\n e_ops(t, Qobj(cdata, dims=dims))\\n\\n for m in range(n_expt_op):\\n output.expect[m][t_idx] = cy_expect_psi(e_ops[m].data, cdata, e_ops[m].isherm)\\n\\n if t_idx < n_tsteps - 1:\\n r.integrate(r.t + dt[t_idx])\\n\\n progress_bar.finished()\\n\\n if not opt.rhs_reuse and config.tdname is not None:\\n try:\\n os.remove(config.tdname + \\\".pyx\\\")\\n except:\\n pass\\n\\n if opt.store_final_state:\\n cdata = get_curr_state_data()\\n if opt.normalize_output:\\n cdata *= norm_dim_factor / la_norm(cdata)\\n output.final_state = Qobj(cdata, dims=dims)\\n\\n return output\",\n \"def deterministic_integration(self):\\n y0 = self.initial_conditions\\n t = self.t\\n sol = odeint(self.a, y0, t)\\n return sol\",\n \"def PDE_RHS_FKPP(t,y,q,x,description=None):\\n \\n \\n D_mat = create_Uxx_mat(x)\\n\\n return (q[0]*D_mat.dot(y) + \\n q[1]*y*(1-y))\",\n \"def exterior_der(self):\\n from utilities import format_unop_txt, format_unop_latex\\n if self._exterior_derivative is None:\\n vmodule = self._vmodule # shortcut\\n rname = format_unop_txt('d', self._name)\\n rlname = format_unop_latex(r'\\\\mathrm{d}', self._latex_name)\\n resu = vmodule.alternating_form(self._tensor_rank+1, name=rname, \\n latex_name=rlname)\\n for dom, rst in self._restrictions.iteritems():\\n resu._restrictions[dom] = rst.exterior_der()\\n self._exterior_derivative = resu\\n return self._exterior_derivative\",\n \"def rhs(y, t, l, m, g):\\n # Unpack the states so you can use the variable names in the\\n # sympy.physics.mechanics equations\\n q1 = y[0]\\n q2 = y[1]\\n u1 = y[2]\\n u2 = y[3]\\n # or you can make use of python's tuple unpacking for a one liner\\n # q1, q2, u1, u2 = y\\n\\n # Initialize a vector for the derivatives.\\n dydt = zeros((len(y)))\\n\\n # Compute the derivatives, these are pasted in from the\\n # sympy.physics.mechanics results.\\n dydt[0] = u1\\n dydt[1] = u2\\n dydt[2] = (-g*sin(q1)*sin(q2)**2 + 2*g*sin(q1) -\\n g*sin(q2)*cos(q1)*cos(q2) + 2*l*u1**2*sin(q1)*cos(q1)*cos(q2)**2 -\\n l*u1**2*sin(q1)*cos(q1) - 2*l*u1**2*sin(q2)*cos(q1)**2*cos(q2) +\\n l*u1**2*sin(q2)*cos(q2) + l*u2**2*sin(q1)*cos(q2) -\\n l*u2**2*sin(q2)*cos(q1))/(l*(sin(q1)**2*sin(q2)**2 +\\n 2*sin(q1)*sin(q2)*cos(q1)*cos(q2) + cos(q1)**2*cos(q2)**2 - 2))\\n dydt[3] = (-sin(q1)*sin(q2)/2 - cos(q1)*cos(q2)/2)*(2*g*l*m*sin(q1) -\\n l**2*m*(-sin(q1)*cos(q2) +\\n sin(q2)*cos(q1))*u2**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2)) -\\n l**2*m) + (g*l*m*sin(q2) - l**2*m*(sin(q1)*cos(q2) -\\n sin(q2)*cos(q1))*u1**2)/(l**2*m*(sin(q1)*sin(q2)/2 +\\n cos(q1)*cos(q2)/2)*(sin(q1)*sin(q2) + cos(q1)*cos(q2))\\n - l**2*m)\\n\\n # Return the derivatives.\\n return dydt\",\n \"def driftRHS(field,drift_velocity,t,x):\\n f = field.getValue(x)\\n fs = np.linalg.norm(f)\\n f = f/fs\\n return -f*drift_velocity(fs)\",\n \"def RK45_method(RHS, theta_0, omega_0, t_1, dt):\\n initialValues = [theta_0,omega_0]\\n\\n timeSpan = [0,t_1 + dt]\\n\\n timeArr = np.arange(0,t_1+dt,dt)\\n \\n solution = DestoryerOfOrdinaryDifferentialEquations(RHS,timeSpan,initialValues,method=\\\"RK45\\\",t_eval=timeArr)\\n \\n theta = solution.y[0, : ]\\n omega = solution.y[1, : ]\\n times = solution.t\\n \\n \\n return theta, omega, times\",\n \"def DyEvo(x, t, T0, r1, r2, K_co, K_ch, alpha, n):\\n y=np.zeros([np.size(x)])\\n D=np.zeros([2]) \\n #define fitnss\\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \\n #degradation\\n deg=fmax*x[1]/(x[1]+Kd) \\n #ODE of eco-evo dynamics\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r1*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\\n y[2]=x[2]*(r2*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\\n \\n return y\",\n \"def _dlnfdRe(self,R,vR,vT,E=None,xE=None,OE=None,LCE=None):\\n #Calculate a bunch of stuff that we need\\n if E is None or xE is None or OE is None or LCE is None:\\n if self._beta == 0.:\\n E= vR**2./2.+vT**2./2.+sc.log(R)\\n xE= sc.exp(E-.5)\\n OE= xE**-1.\\n LCE= xE\\n else: #non-flat rotation curve\\n E= vR**2./2.+vT**2./2.+1./2./self._beta*R**(2.*self._beta)\\n xE= (2.*E/(1.+1./self._beta))**(1./2./self._beta)\\n OE= xE**(self._beta-1.)\\n LCE= xE**(self._beta+1.)\\n L= R*vT\\n sigma2xE= self._surfaceSigmaProfile.sigma2(xE,log=False)\\n return (self._surfaceSigmaProfile.surfacemassDerivative(xE,log=True)\\\\\\n -(1.+OE*(L-LCE)/sigma2xE)*self._surfaceSigmaProfile.sigma2Derivative(xE,log=True)\\\\\\n +(L-LCE)/sigma2xE*(self._beta-1.)*xE**(self._beta-2.)\\\\\\n -OE*(self._beta+1.)/sigma2xE*xE**self._beta)\",\n \"def d2(self):\\n d1 = self.d1()\\n return d1 - self.sigma * (self.t **(0.5))\",\n \"def define_ode(self, F, DFDY):\\n self._F = F\\n self._DFDY = DFDY\",\n \"def ODEStep1(u, t, dt, F):\\n up = u + 0.5*dt*dt*F(u, t)\\n return up\",\n \"def fangle_degr(self):\\r\\n\\r\\n return self._versor_1.angle_degr(self._versor_2)\",\n \"def f( self , x , u , t ):\\n \\n dx = np.zeros(self.n) # State derivative vector\\n \\n ################################################\\n # Place holder: put the equations of motion here\\n raise NotImplementedError\\n ################################################\\n \\n return dx\",\n \"def closed_loop_dynamics(self, K):\\n\\n return self.F - dot(self.G, K)\",\n \"def den_evolve(self, delt, txp, src):\\n self.ne += (-txp.dfluxe + src.se)*delt\\n self.ni += (-txp.dfluxi + src.si)*delt\",\n \"def ODEs(y, t, B, MdiscI, RdiscI, epsilon, delta, n=1.0, alpha=0.1, cs7=1.0,\\n k=0.9):\\n # Initial conditions\\n Mdisc, omega = y\\n \\n # Constants\\n Rdisc = RdiscI * 1.0e5 # Disc radius - cm\\n tvisc = Rdisc / (alpha * cs7 * 1.0e7) # Viscous timescale - s\\n mu = 1.0e15 * B * (R ** 3.0) # Magnetic Dipole Moment\\n M0 = delta * MdiscI * Msol # Global Fallback Mass Budget - g\\n tfb = epsilon * tvisc # Fallback timescale - s\\n \\n # Radii - Alfven, Corotation, Light Cylinder\\n Rm = ((mu ** (4.0 / 7.0)) * (GM ** (-1.0 / 7.0)) * ((Mdisc / tvisc) **\\n (-2.0 / 7.0)))\\n Rc = (GM / (omega ** 2.0)) ** (2.0 / 3.0)\\n Rlc = c / omega\\n # Cap the Alfven radius\\n if Rm >= k * Rlc:\\n Rm = k * Rlc\\n \\n w = (Rm / Rc) ** (3.0 / 2.0) # Fastness parameter\\n \\n bigT = 0.5 * I * (omega ** 2.0) # Rotational energy\\n modW = (0.6 * M * (c ** 2.0) * ((GM / (R * (c ** 2.0))) / (1.0 - 0.5 * (GM\\n / (R * (c ** 2.0)))))) # Binding energy\\n rot_param = bigT / modW # Rotation parameter\\n \\n # Dipole torque\\n Ndip = (-1.0 * (mu ** 2.0) * (omega ** 3.0)) / (6.0 * (c ** 3.0))\\n \\n # Mass flow rates and efficiencies\\n eta2 = 0.5 * (1.0 + np.tanh(n * (w - 1.0)))\\n eta1 = 1.0 - eta2\\n Mdotprop = eta2 * (Mdisc / tvisc) # Propelled\\n Mdotacc = eta1 * (Mdisc / tvisc) # Accreted\\n Mdotfb = (M0 / tfb) * (((t + tfb) / tfb) ** (-5.0 / 3.0)) # Fallback rate\\n Mdotdisc = Mdotfb - Mdotprop - Mdotacc # Mass flow through the disc\\n \\n if rot_param > 0.27:\\n Nacc = 0.0 # Prevents magnetar break-up\\n else:\\n # Accretion torque\\n if Rm >= R:\\n Nacc = ((GM * Rm) ** 0.5) * (Mdotacc - Mdotprop)\\n else:\\n Nacc = ((GM * R) ** 0.5) * (Mdotacc - Mdotprop)\\n \\n omegadot = (Nacc + Ndip) / I # Angular frequency time derivative\\n \\n return np.array([Mdotdisc, omegadot])\",\n \"def rightmost_element(self):\\n\\n\\n #Element limits\\n L = 1 - 2*self.h\\n R = 1\\n\\n psiN = (self.x-1+self.h)*(self.x-1+2*self.h)/(2*self.h**2)\\n psiNm1 = -(self.x-1)*(self.x-1+2*self.h)/(self.h**2)\\n psiNm2 = (self.x-1+self.h)*(self.x-1)/(2*self.h**2)\\n\\n self.psi[-1] = psiN\\n self.psi[-2] = psiNm1\\n self.psi[-3] = psiNm2\\n\\n d_psiNm2 = sym.diff(psiNm2,self.x)\\n d_psiNm1 = sym.diff(psiNm1,self.x)\\n d_psiN = sym.diff(psiN,self.x)\\n\\n psi_Nm1Nm1 = d_psiNm1*d_psiNm1\\n psi_Nm2Nm2 = d_psiNm2*d_psiNm2\\n psi_Nm1Nm2 = d_psiNm1*d_psiNm2\\n\\n A_Nm1Nm1 = sym.integrate(psi_Nm1Nm1, (self.x, L, R))\\n A_Nm2Nm2 = sym.integrate(psi_Nm2Nm2, (self.x, L, R))\\n A_Nm1Nm2 = sym.integrate(psi_Nm1Nm2, (self.x, L, R))\\n\\n rhs_Nm2 = sym.integrate(self.f(self.x)*psiNm2,(self.x,L,R)) - sym.integrate(self.D*d_psiN*d_psiNm2,(self.x,L,R))\\n rhs_Nm1 = sym.integrate(self.f(self.x)*psiNm1,(self.x,L,R)) - sym.integrate(self.D*d_psiN*d_psiNm1,(self.x,L,R))\\n\\n a1 = [A_Nm2Nm2,A_Nm1Nm2]\\n a2 = [A_Nm1Nm2, A_Nm1Nm1]\\n\\n A = np.array([a1, a2]).reshape(2,2)\\n b = np.array([rhs_Nm2, rhs_Nm1])\\n\\n for i in range(2*self.Ne-2,2*self.Ne):\\n self.global_vector[i] = b[i-(2*self.Ne-2)]\\n for j in range(2*self.Ne-2,2*self.Ne):\\n self.global_matrix[i,j] = A[i-(2*self.Ne-2), j-(2*self.Ne-2)]\",\n \"def casadi_ode(self, t, x, u, w):\\n v = u[0]\\n thetadot = u[1]\\n theta = x[2]\\n f = cs.vertcat(v * cs.cos(theta), v * cs.sin(theta), thetadot)\\n if self.use_nonlinear_noise_model:\\n w_vec = cs.vertcat(self.scale[0]*(cs.cos(theta) * w[0] - cs.sin(theta) * w[1]),\\n self.scale[1]*(cs.sin(theta) * w[0] + cs.cos(theta) * w[1]),\\n self.scale[2]*(v * w[2]))\\n else:\\n w_vec = w\\n return f + w_vec\",\n \"def calculate_ode_functions(self, f, L):\\n\\n pass\",\n \"def _K_compute_ode_eq(self, transpose=False):\\r\\n\\r\\n if self._t2 is not None:\\r\\n if transpose:\\r\\n t_eq = self._t[self._index==0]\\r\\n t_ode = self._t2[self._index2>0]\\r\\n index_ode = self._index2[self._index2>0]-1\\r\\n else:\\r\\n t_eq = self._t2[self._index2==0]\\r\\n t_ode = self._t[self._index>0]\\r\\n index_ode = self._index[self._index>0]-1\\r\\n else:\\r\\n t_eq = self._t[self._index==0]\\r\\n t_ode = self._t[self._index>0]\\r\\n index_ode = self._index[self._index>0]-1\\r\\n\\r\\n if t_ode.size==0 or t_eq.size==0:\\r\\n if transpose:\\r\\n self._K_eq_ode = np.zeros((t_eq.shape[0], t_ode.shape[0]))\\r\\n else:\\r\\n self._K_ode_eq = np.zeros((t_ode.shape[0], t_eq.shape[0]))\\r\\n return\\r\\n\\r\\n t_ode_mat = t_ode[:, None]\\r\\n t_eq_mat = t_eq[None, :]\\r\\n if self.delay is not None:\\r\\n t_ode_mat -= self.delay[index_ode, None]\\r\\n diff_t = (t_ode_mat - t_eq_mat)\\r\\n\\r\\n inv_sigma_diff_t = 1./self.sigma*diff_t\\r\\n decay_vals = self.decay[index_ode][:, None]\\r\\n half_sigma_d_i = 0.5*self.sigma*decay_vals\\r\\n\\r\\n if self.is_stationary:\\r\\n ln_part, signs = ln_diff_erfs(inf, half_sigma_d_i - inv_sigma_diff_t, return_sign=True)\\r\\n else:\\r\\n ln_part, signs = ln_diff_erfs(half_sigma_d_i + t_eq_mat/self.sigma, half_sigma_d_i - inv_sigma_diff_t, return_sign=True)\\r\\n sK = signs*np.exp(half_sigma_d_i*half_sigma_d_i - decay_vals*diff_t + ln_part)\\r\\n\\r\\n sK *= 0.5\\r\\n\\r\\n if not self.is_normalized:\\r\\n sK *= np.sqrt(np.pi)*self.sigma\\r\\n\\r\\n\\r\\n if transpose:\\r\\n self._K_eq_ode = sK.T\\r\\n else:\\r\\n self._K_ode_eq = sK\",\n \"def ode_for(regime, variable):\\n odes = [eq for eq in regime.time_derivatives if eq.dependent_variable == variable.name]\\n if len(odes) == 0:\\n odes.append(al.TimeDerivative(dependent_variable = variable, rhs = \\\"0.0\\\"))\\n return expect_single(odes)\",\n \"def Drepp(self):\\n sinE = np.sin(self.E())\\n cosE = np.cos(self.E())\\n return -self.alpha()*cosE-(self.beta()+self.GAMMA)*sinE\",\n \"def _dy(self, T):\\n return self._h(np.diff(T)) * self._a / self._m / self._c * np.diff(T) * np.array([1, -1])\",\n \"def e_ortogonal(self, other):\\n if self.pi(other) == 0:\\n return True\\n else:\\n return False\",\n \"def van_der_pol_oscillator_deriv(x, t):\\n \\n x1 = x[1]\\n y = -nu * (x[0] ** 2.0 - 1.0) * x[1] - x[0]\\n result = np.array([x1, y])\\n return result\",\n \"def compODEdydt(self, t, y, args=None):\\r\\n return comp.Comp.compODEdydt_diffu(self, t, y, args)\",\n \"def exterior_der(self):\\n from sage.calculus.functional import diff\\n from utilities import format_unop_txt, format_unop_latex\\n from sage.tensor.modules.comp import CompFullyAntiSym\\n from vectorframe import CoordFrame\\n if self._exterior_derivative is None:\\n # A new computation is necessary:\\n fmodule = self._fmodule # shortcut\\n rname = format_unop_txt('d', self._name)\\n rlname = format_unop_latex(r'\\\\mathrm{d}', self._latex_name)\\n self._exterior_derivative = DiffFormParal(fmodule, \\n self._tensor_rank+1, \\n name=rname, \\n latex_name=rlname)\\n # 1/ List of all coordinate frames in which the components of self\\n # are known\\n coord_frames = []\\n for frame in self._components:\\n if isinstance(frame, CoordFrame):\\n coord_frames.append(frame)\\n if coord_frames == []:\\n # A coordinate frame is searched, at the price of a change of\\n # frame, priveleging the frame of the domain's default chart\\n dom = self._domain\\n def_coordf = dom._def_chart._frame\\n for frame in self._components:\\n if (frame, def_coordf) in dom._frame_changes:\\n self.comp(def_coordf, from_basis=frame)\\n coord_frames = [def_coordf]\\n break\\n if coord_frames == []:\\n for chart in dom._atlas:\\n if chart != dom._def_chart: # the case def_chart is treated above\\n coordf = chart._frame\\n for frame in self._components:\\n if (frame, coordf) in dom._frame_changes:\\n self.comp(coordf, from_basis=frame)\\n coord_frames[coordf]\\n break\\n if coord_frames != []:\\n break \\n # 2/ The computation:\\n for frame in coord_frames:\\n chart = frame._chart\\n sc = self._components[frame]\\n dc = CompFullyAntiSym(fmodule._ring, frame, \\n self._tensor_rank+1, \\n start_index=fmodule._sindex,\\n output_formatter=fmodule._output_formatter)\\n for ind, val in sc._comp.iteritems():\\n for i in fmodule.irange():\\n ind_d = (i,) + ind\\n if len(ind_d) == len(set(ind_d)): \\n # all indices are different\\n dc[[ind_d]] += \\\\\\n val.function_chart(chart).diff(i).scalar_field()\\n self._exterior_derivative._components[frame] = dc\\n return self._exterior_derivative\",\n \"def ode_solve(z0, t0, t1, f):\\n h_max = 0.05\\n n_steps = math.ceil((abs(t1 - t0) / h_max).max().item())\\n\\n h = (t1 - t0) / n_steps\\n t = t0\\n z = z0\\n\\n for i_step in range(n_steps):\\n z = z + h * f(z, t)\\n t = t + h\\n return z\",\n \"def linear_ode_origin(t,y0=5,case=1):\\n return y0*np.exp(integrate.quad(origin_fun, 0, t,args=(case))[0])\",\n \"def _numerical_derivative_two_sided (func:typing.Callable[[float],float], x_0:float) -> typing.Tuple[float,float]:\\n epsilon = 1.0e-9\\n func_x_0 = func(x_0)\\n deriv_neg = (func_x_0 - func(x_0-epsilon)) / epsilon\\n deriv_pos = (func(x_0+epsilon) - func_x_0) / epsilon\\n return deriv_neg, deriv_pos\",\n \"def rhs_fenics(y,t):\\n #print \\\"time: \\\",t\\n uprev.vector()[:]=y\\n f.t = t #dolfin needs to know the current time for cos(t)\\n uprime_solver.solve()\\n return uprime_solution.vector().array()\",\n \"def omtrek(self):\\n x = pi*self.r**2\\n return x\",\n \"def solve_ode(self, n_evals, atol = 1e-6, rtol = 1e-4, print_time = False,max_step = np.inf):\\n st = time.time()\\n t_eval = np.linspace(0,self.t_ode,int(n_evals * self.t_ode) + 1 ).ravel()\\n solution = solve_ivp(self.f, self.t_span,self.s0[:3*self.N], t_eval = t_eval, rtol = rtol, atol = atol, max_step = max_step )\\n end = time.time()\\n if print_time:\\n print(\\\"Solution of ODE with n_evals: \\\" + str(n_evals) +\\\", t_ode: \\\" + str(self.t_ode) \\n + \\\", took: \\\" + str(end-st) + \\\" s.\\\")\\n return solution.y.T\",\n \"def R_term(\\n enst, # enstrophy field\\n omega1, # vorticity-1 component\\n omega2, # vorticity-2 component\\n omega3, # vorticity-3 component\\n s11, # strain rate-11 component\\n s12, # strain rate-12 component\\n s13, # strain rate-13 component\\n s22, # strain rate-22 component\\n s23, # strain rate-23 component\\n s33, # strain rate-33 component\\n diff = False): # differentiation flag\\n #---------------------------------------------------------------------#\\n # Defining domain variables #\\n #---------------------------------------------------------------------#\\n pi = np.pi # pi\\n dx = (2.0*pi)/64.0 # spatial step\\n nu = 0.000185 # default viscosity\\n #---------------------------------------------------------------------#\\n # Spectral differentiation variables #\\n #---------------------------------------------------------------------#\\n dim = 64\\n kspec = np.fft.fftfreq(dim) * dim\\n Kfield = np.array(np.meshgrid(kspec, kspec, kspec, indexing='ij'))\\n #---------------------------------------------------------------------#\\n # Spectral differentiation variables #\\n #---------------------------------------------------------------------#\\n term1 = np.zeros((dim, dim, dim))\\n term2 = np.zeros((dim, dim, dim))\\n term3 = np.zeros((dim, dim, dim))\\n #---------------------------------------------------------------------#\\n # Numerator (numpy gradient tool) #\\n #---------------------------------------------------------------------#\\n if diff is not False:\\n term1 = np.gradient(enst,dx, edge_order=2)[0]\\n term2 = np.gradient(enst,dx, edge_order=2)[1]\\n term3 = np.gradient(enst,dx, edge_order=2)[2]\\n #---------------------------------------------------------------------#\\n # Numerator (spectral differentiation) #\\n #---------------------------------------------------------------------#\\n else:\\n term1 = 0.5*np.fft.ifftn(1j*Kfield[0]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[0]*np.fft.fftn(enst)).real\\n term2 = 0.5*np.fft.ifftn(1j*Kfield[1]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[1]*np.fft.fftn(enst)).real\\n term3 = 0.5*np.fft.ifftn(1j*Kfield[2]*np.fft.fftn(enst) +\\\\\\n 1j*Kfield[2]*np.fft.fftn(enst)).real\\n #---------------------------------------------------------------------#\\n # Numerator #\\n #---------------------------------------------------------------------#\\n num = nu*(term1**2.0+ term2**2.0 + term3**2.0)\\n #---------------------------------------------------------------------#\\n # Denominator #\\n #---------------------------------------------------------------------#\\n den = omega1*s11*omega1 + omega1*s12*omega2 + omega1*s13*omega3 +\\\\\\n omega2*s12*omega1 + omega2*s22*omega2 + omega2*s23*omega3+\\\\\\n omega3*s13*omega1 + omega3*s23*omega2 + omega3*s33*omega3\\n #---------------------------------------------------------------------#\\n # R calculation #\\n #---------------------------------------------------------------------#\\n R = num/den\\n\\n return R\",\n \"def main():\\n solve_ode_sys()\\n\\n return GOOD_RET # success\",\n \"def dynstall_oye_dxdt(t,fs,u,p):\\n alpha = u['alpha'](t)\\n f_st = p['F_st'](alpha)\\n return 1/p['tau'] * (f_st - fs)\",\n \"def RK2(self, T=2.5, dt=0.00001):\\n t_space = np.linspace(0, T, 1 + T/dt)\\n U = self.U0.copy()\\n half_dt_L = (dt / 2) * self.L\\n dt_L = dt * self.L\\n\\n for i, t in enumerate(t_space[1:]):\\n U_hlf = U + half_dt_L @ U\\n U += dt_L @ U_hlf\\n return U\",\n \"def test_rhs(self):\\n\\n _, _, generator = setup_lmde_frames_and_generator(self.basic_model, solver_frame=self.X)\\n\\n t = 13.1231\\n y = np.eye(2, dtype=complex)\\n\\n output = generator(t, y, in_frame_basis=True).data\\n\\n X = np.array(self.X.data)\\n X_diag, U = np.linalg.eigh(X)\\n Uadj = U.conj().transpose()\\n gen = (\\n -1j\\n * 2\\n * np.pi\\n * (self.w * np.array(self.Z.data) / 2 + self.r * np.cos(2 * np.pi * self.w * t) * X / 2)\\n )\\n expected = (\\n Uadj @ expm(1j * t * X) @ gen @ expm(-1j * t * X) @ U + 1j * np.diag(X_diag)\\n ) @ y\\n\\n self.assertTrue(np.allclose(expected, output))\",\n \"def deriv_angvel(self, t: float, endBehavior: str = 'halt') -> Vector3:\\n dR = GeodesicHermiteTrajectory.eval_velocity(self,t,endBehavior)\\n return so3.deskew(dR)\",\n \"def electrical_ode(self, state, u_sr_alphabeta, omega, *args):\\n return np.matmul(self._model_constants, np.array([\\n # omega, i_alpha, i_beta, psi_ralpha, psi_rbeta, omega * psi_ralpha, omega * psi_rbeta, u_salpha, u_sbeta, u_ralpha, u_rbeta,\\n omega,\\n state[self.I_SALPHA_IDX],\\n state[self.I_SBETA_IDX],\\n state[self.PSI_RALPHA_IDX],\\n state[self.PSI_RBETA_IDX],\\n omega * state[self.PSI_RALPHA_IDX],\\n omega * state[self.PSI_RBETA_IDX],\\n u_sr_alphabeta[0, 0],\\n u_sr_alphabeta[0, 1],\\n u_sr_alphabeta[1, 0],\\n u_sr_alphabeta[1, 1],\\n ]))\",\n \"def test_VODE():\\n mech = 'h2o2.xml'\\n gas = cantera.Solution(mech)\\n\\n T0 = 1500 # [K]\\n p0 = cantera.one_atm # [Pa]\\n gas.TPX = T0, p0, \\\"H2:2, O2:1, AR:0.1\\\"\\n\\n length = 1.5e-7 # *approximate* PFR length [m]\\n u0 = 0.006 # inflow velocity [m/s]\\n Ac = 1.0e-4 # cross-sectional area [m**2]\\n Nx = 2000 # number of grid\\n dx = length / Nx\\n\\n mass_flow_rate = u0 * gas.density * Ac\\n N = gas.n_species # number of gas species\\n vecp = numpy.zeros((N+1, 1))\\n\\n def rhseqn(t, vec):\\n Y = vec[0:N]\\n T = vec[-1]\\n\\n rho = gas.density\\n u = mass_flow_rate / (rho * Ac)\\n h_g = gas.partial_molar_enthalpies\\n\\n gas.set_unnormalized_mass_fractions(Y)\\n gas.TP = T, p0\\n\\n wdot_g = gas.net_production_rates\\n W_g = gas.molecular_weights\\n\\n for k in range(N):\\n vecp[k] = wdot_g[k] * W_g[k] / (rho * u)\\n\\n vecp[-1] = -numpy.sum(wdot_g * h_g) / (rho * u * gas.cp)\\n return vecp\\n\\n x = 0.0\\n count = 0\\n Y0 = numpy.hstack((gas.Y, T0))\\n\\n solver = ode(rhseqn)\\n solver.set_integrator('vode', method='bdf')\\n solver.set_initial_value(Y0, x)\\n\\n while x <= length:\\n solver.integrate(solver.t + dx)\\n\\n if not solver.successful():\\n print(f'Failed at x = {solver.t}')\\n\\n if not count % 100:\\n print(f'x = {solver.t:.3e}\\\\tT = {solver.y[-1]:.3f}')\\n\\n x = solver.t\\n count += 1\\n\\n print(f'x = {solver.t:.3e}\\\\tT = {solver.y[-1]:.3f}')\",\n \"def pynamic_test():\\n\\n sol_times = np.linspace(0, 3, 25)\\n\\n #the true solution to the ODE\\n sol_ys = 3*np.exp(-2*sol_times)\\n\\n #the parameters for pynamic_ode\\n def test_func(_, y_vals):\\n return -2*y_vals\\n\\n start_time = 0\\n max_time = 2\\n initial_val = [3]\\n param_to_monitor = 0\\n max_param_delta = 0.1\\n base_time_step = 0.5\\n min_step_time = 0.01\\n\\n def end_condition(_, y_vals):\\n if y_vals[0] < 0.1:\\n return 1\\n return 0\\n\\n start = time.time()\\n times, y_vals, status = pynamic_ode(test_func, start_time, max_time, \\n initial_val, param_to_monitor, \\n max_param_delta, base_time_step, \\n min_step_time, end_condition, \\n use_rk4=False)\\n end = time.time()\\n print(\\\"time to run with RK1: %2.3e\\\"%(end-start))\\n\\n start = time.time()\\n t_rk4, y_rk4s, st_rk4 = pynamic_ode(test_func, start_time, max_time, \\n initial_val, param_to_monitor, \\n max_param_delta, base_time_step, \\n min_step_time, end_condition, \\n use_rk4=True)\\n end = time.time()\\n print(\\\"time to run with RK4: %2.3e\\\"%(end-start))\\n\\n sol_times = np.linspace(0, max_time, max_time*15)\\n\\n #the true solution to the ODE\\n sol_ys = 3*np.exp(-2*sol_times)\\n\\n\\n print(\\\"status of solver: %d, status with RK4: %d\\\"%(status, st_rk4))\\n plt.plot(sol_times, sol_ys, 'k', label=\\\"True Sol.\\\")\\n\\n plt.plot(times, y_vals, 'r+', label=\\\"RK1\\\")\\n plt.plot(times, y_vals, 'r:')\\n plt.plot(t_rk4, y_rk4s, 'bx', label=\\\"RK4\\\")\\n plt.plot(t_rk4, y_rk4s, 'b:')\\n\\n plt.legend()\\n\\n plt.savefig(\\\"test_results.png\\\")\\n\\n return 0\",\n \"def dynamics(self,eta,nu,u_actual,u_control,sampleTime): \\n \\n # Current velocities\\n u_c = self.V_c * math.cos(self.beta_c - eta[5]) # current surge velocity\\n v_c = self.V_c * math.sin(self.beta_c - eta[5]) # current sway velocity \\n \\n nu_c = np.array([u_c,v_c,0,0,0,0],float) # current velocity vector\\n nu_r = nu - nu_c # relative velocity vector\\n \\n U_r = math.sqrt( nu_r[0]**2 + nu_r[1]**2 ) # relative speed\\n \\n # Rudder command and actual rudder angle\\n delta_c = u_control[0]\\n delta = u_actual[0]\\n \\n # Rudder forces and moment (Fossen 2021, Chapter 9.5.1)\\n b = 0.7 * self.T # rudder height\\n AR = b**2 / self.Lambda # aspect ratio: Lamdba = b**2/AR \\n CN = 6.13 * self.Lambda / ( self.Lambda + 2.25 ) # normal coefficient\\n t_R = 1 - 0.28 * self.Cb - 0.55\\n a_H = 0.4\\n x_R = -0.45 * self.L\\n x_H = -1.0 * self.L\\n\\n Xdd = -0.5 * ( 1 - t_R ) * self.rho * U_r**2 * AR * CN\\n Yd = -0.25 * ( 1 + a_H ) * self.rho * U_r**2 * AR * CN \\n Nd = -0.25 * ( x_R + a_H * x_H ) * self.rho * U_r**2 * AR * CN \\n \\n # Control forces and moment\\n delta_R = -delta # physical rudder angle (rad)\\n T = self.tau_X # thrust (N)\\n t_deduction = 0.1 # thrust deduction number\\n tau1 = ( 1 - t_deduction ) * T - Xdd * math.sin( delta_R )**2 \\n tau2 = -Yd * math.sin( 2 * delta_R ) \\n tau6 = -Nd * math.sin( 2 * delta_R ) \\n tau = np.array( [ tau1, tau2, tau6 ],float) \\n \\n # Linear maneuvering model\\n T_surge = self.L # approx. time constant in surge (s)\\n xg = 0 # approx. x-coordinate, CG (m) \\n \\n # 3-DOF ship model\\n [M,N] = clarke83(U_r,self.L, self.B, self.T,self.Cb,self.R66,xg,T_surge)\\n Minv = np.linalg.inv(M)\\n nu3 = np.array( [ nu_r[0], nu_r[1], nu_r[5] ]) \\n nu3_dot = np.matmul( Minv, tau - np.matmul(N,nu3) ) \\n \\n # 6-DOF ship model\\n nu_dot = np.array( [ nu3_dot[0],nu3_dot[1],0,0,0,nu3_dot[2] ]) \\n\\n # Rudder angle saturation\\n if ( abs(delta) >= self.deltaMax * math.pi / 180 ):\\n delta = np.sign(delta) * self.deltaMax * math.pi / 180\\n \\n # Rudder dynamics\\n delta_dot = (delta_c - delta) / self.T_delta \\n\\n # Forward Euler integration [k+1]\\n nu = nu + sampleTime * nu_dot\\n delta = delta + sampleTime * delta_dot\\n\\n u_actual = np.array([delta],float) \\n\\n return nu, u_actual\",\n \"def test_sin_2ndord_2vars():\\n x, y = fwd.Variable(), fwd.Variable()\\n f = fwd.sin(x/y)\\n df_dxdy = lambda x, y: -(y*np.cos(x/y) - x*np.sin(x/y))/y**3\\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2), \\n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n df_dxdy(1.5, 2.5))\",\n \"def work_dos():\\n #potential = 2x**2+x**2y+y**2\\n x1,y1 = (2, -3)\\n x2,y2 = (-1, 2)\\n p1 = (2*(x1**2)) + ((x1**2)*y1) + (y1**2)\\n p2 = (2*(x2**2)) + ((x2**2)*y2) + (y2**2)\\n sol = p1 - p2\\n sol = abs(sol)\\n print(f'The vector field F=(4x+2xy,x2+2y) \\\\n'\\n 'along the curve C parametrized by r(t)=(3t−1,−5t+2) \\\\n '\\n f'for 0 ≤ t ≤ 1 is: {sol}')\",\n \"def kuramoto_ODE(self, t, y, arg):\\n w, k = arg\\n yt = y[:,None]\\n dy = y-yt\\n\\n phase = w.astype(self.dtype)\\n if self.noise != None:\\n n = self.noise().astype(self.dtype)\\n dy += n\\n \\n for m, _k in enumerate(k):\\n phase += np.sum(_k*np.sin((m+1)*dy),axis=1)\\n \\n return phase\",\n \"def one_step(func, y0, rng):\\n return scipy.integrate.odeint(func, y0, rng)[-1]\",\n \"def deriv_angvel(self, t: float,endBehavior: str = 'halt') -> Vector3:\\n cw = GeodesicTrajectory.deriv(self,t,endBehavior)\\n return so3.deskew(cw)\",\n \"def rhs(t, Y, q, omega_d, b):\\n f = np.zeros_like(Y)\\n\\n f[0] = Y[1]\\n f[1] = -q*Y[1] - np.sin(Y[0]) + b*np.cos(omega_d*t)\\n\\n return f\",\n \"def test_exp_2ndord_2vars():\\n x, y = fwd.Variable(), fwd.Variable()\\n f = fwd.exp(x/y)\\n df_dxdy = lambda x, y: -(x*np.exp(x/y) + y*np.exp(x/y)) / y**3\\n assert equals(f.derivative_at((x, x), {x: 1.5, y:2.5}, order=2),\\n f.derivative_at( x, {x: 1.5, y:2.5}, order=2)) \\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n f.derivative_at((y, x), {x: 1.5, y:2.5}, order=2))\\n assert equals(f.derivative_at((x, y), {x: 1.5, y:2.5}, order=2), \\n df_dxdy(1.5, 2.5))\",\n \"def omega(self):\\n return self._data.train_X @ self._thetas\",\n \"def getOmega(dels):\\n N = dels.delta_d.shape[1]\\n delta_t = dels.delta_t\\n delta_d = dels.delta_d\\n \\n a_t = np.diff(delta_t)\\n a_t = a_t[:,0:-1]\\n \\n a_d = np.diff(delta_t[:,::-1])\\n a_d = a_d[:,::-1]\\n a_d = a_d[:,1::]\\n \\n b_t = np.diff(delta_d)\\n b_t = b_t[:,0:-1]\\n \\n b_d = np.diff(delta_d[:,::-1])\\n b_d = b_d[:,::-1]\\n b_d = b_d[:,1::] \\n \\n c_t = 0.25*(np.abs(a_t)+np.abs(b_t))*np.sign(a_t)*np.sign(b_t)*(np.sign(a_t)*np.sign(b_t)-1)\\n c_d = 0.25*(np.abs(a_d)+np.abs(b_d))*np.sign(a_d)*np.sign(b_d)*(np.sign(a_d)*np.sign(b_d)-1)\\n Omega = 1.0/(2*N)*(c_t.mean(axis=0) + c_d.mean(axis=0))\\n\\n return Omega\",\n \"def hydro_solver(self):\\n u_dx = self.central_x(self.u)\\n w_dy = self.central_y(self.w)\\n P_dx = self.central_x(self.P)\\n P_dy = self.central_y(self.P)\\n\\n rho_dx_upwind = self.upwind_x(self.rho, self.u)\\n rho_dy_upwwind = self.upwind_y(self.rho, self.w)\\n rho_udx_upwind = self.upwind_x(self.rho * self.u, self.u)\\n rho_udy_upwind = self.upwind_y(self.rho * self.u, self.w)\\n rho_wdx_upwind = self.upwind_x(self.rho * self.w, self.u)\\n rho_wdy_upwind = self.upwind_y(self.rho * self.w, self.w)\\n u_dx_uu = self.upwind_x(self.u, self.u)\\n u_dx_uw = self.upwind_x(self.u, self.w)\\n w_dy_uu = self.upwind_y(self.w, self.u)\\n w_dy_uw = self.upwind_y(self.w, self.w)\\n e_dx = self.upwind_x(self.e, self.u)\\n e_dy = self.upwind_y(self.e, self.w)\\n\\n self.rho_dt = (\\n -self.rho * (u_dx + w_dy)\\n - self.u * rho_dx_upwind\\n - self.w * rho_dy_upwwind\\n )\\n self.e_dt = (\\n -(self.e + self.P) * (u_dx + w_dy) - self.u * e_dx - self.w * e_dy\\n )\\n self.rho_udt = (\\n -self.rho * self.u * (u_dx_uu + w_dy_uu)\\n - self.u * rho_udx_upwind\\n - self.w * rho_udy_upwind\\n - P_dx\\n )\\n self.rho_wdt = (\\n -self.rho * self.w * (u_dx_uw + w_dy_uw)\\n - self.u * rho_wdx_upwind\\n - self.w * rho_wdy_upwind\\n - P_dy\\n + self.rho * self.g\\n )\\n\\n self.time_step()\\n rho_previous = np.zeros_like(self.rho)\\n rho_previous[:, :] = self.rho\\n self.rho[:, :] = self.rho + self.rho_dt * self.dt\\n self.e[:, :] = self.e + self.e_dt * self.dt\\n self.u[:, :] = (\\n rho_previous * self.u + self.rho_udt * self.dt\\n ) / self.rho\\n self.w[:, :] = (\\n rho_previous * self.w + self.rho_wdt * self.dt\\n ) / self.rho\\n\\n self.boundary_conditions()\\n self.T[:, :] = (\\n (self.Y - 1) * self.e * self.mu * self.m_u / (self.kb * self.rho)\\n )\\n self.P[:, :] = (self.Y - 1) * self.e\\n uw = (self.u, self.w)\\n v = np.linalg.norm(uw)\\n dt = self.dt\\n\\n return dt\",\n \"def deriv(self, t: float, endBehavior: str = 'halt') -> Vector:\\n return self.deriv_state(t,endBehavior)\",\n \"def epflux_eddyterms():\\n pass\",\n \"def DirectSolve(self, y):\\n if y >= -self.R:\\n a1 = self.apath[y+1]\\n if y == -2:\\n a2 = 0\\n else:\\n a2 = self.apath[y+2] \\n def constraints(a):\\n c0 = (1+self.r)*a + self.b - a1\\n c1 = (1+self.r)*a1 + self.b - a2\\n return self.uc(c0,0)-self.beta*self.uc(c1,0)*(1+self.r)\\n a, n = fsolve(constraints, a1), 0\\n c = (1+self.r)*a + self.b - a1\\n else:\\n a1 = self.apath[y+1]\\n a2 = self.apath[y+2]\\n if y == -(self.R+1):\\n n1 = 0\\n c1 = (1+self.r)*a1 + self.b - a2\\n else:\\n n1 = self.npath[y+1]\\n c1 = (1+self.r)*a1 + (1-self.tau)*self.w*n1 - a2\\n def constraints((a0,n0)):\\n c0 = (1+self.r)*a0 + (1-self.tau)*self.w*n0 - a1\\n return self.uc(c0,n0) - self.beta*self.uc(c1,n1)*(1+self.r),\\\\\\n (1-self.tau)*self.w*self.uc(c0,n0) + self.un(c0,n0)\\n a, n = fsolve(constraints,(a1,n1))\\n c = (1+self.r)*a + (1-self.tau)*self.w*n - a1\\n return a, n, c\",\n \"def Dre(self):\\n er = self.er()\\n sinE = np.sin(self.E())\\n cosE = np.cos(self.E())\\n return self.alpha()*(cosE- er)+ \\\\\\n (self.beta()+self.GAMMA)*sinE\",\n \"def edge_velocity(self):\\n #reflext x values at x edges\\n self.u[1,:,0] = -self.u[1,:,1]\\n self.u[1,:,-1] = -self.u[1,:,-2]\\n #mirror x values at y edges \\n self.u[1,0,:] = self.u[1,1,:]\\n self.u[1,-1,:] = self.u[1,-2,:]\\n #mirror y values at x edges\\n self.u[0,:,0] = self.u[0,:,1]\\n self.u[0,:,-1] = self.u[0,:,-2]\\n #mirror y values at y edges \\n self.u[0,0,:] = -self.u[0,1,:]\\n self.u[0,-1,:] = -self.u[0,-2,:]\",\n \"def rstobaryright(x, y):\\n\\n from math import sqrt\\n\\n L = np.zeros((3, x.size))\\n\\n xv = (-1.0, 1.0, -1.0)\\n yv = (-1.0, -1.0, 1.0)\\n\\n detT = (yv[1]-yv[2])*(xv[0]-xv[2])+(xv[2]-xv[1])*(yv[0]-yv[2])\\n L[0] = ((yv[1]-yv[2])*(x -xv[2])+(xv[2]-xv[1])*(y -yv[2])) / detT\\n L[1] = ((yv[2]-yv[0])*(x -xv[2])+(xv[0]-xv[2])*(y -yv[2])) / detT\\n L[2] = 1.0 - L[0] - L[1]\\n return L.T\",\n \"def solve(self, t):\\n dt = t[1]-t[0]\\n if self.dt != dt and self.noise_type != 'custom':\\n self.dt = dt\\n self.update_noise_params(dt)\\n\\n kODE = ode(self.kuramoto_ODE, jac=self.kuramoto_ODE_jac)\\n kODE.set_integrator(\\\"dopri5\\\")\\n\\n # Set parameters into model\\n kODE.set_initial_value(self.init_phase, t[0])\\n kODE.set_f_params((self.W, self.K))\\n kODE.set_jac_params((self.W, self.K))\\n\\n if self._noise != None:\\n self.update_noise_params(dt)\\n\\n phase = np.empty((self.n_osc, len(t)))\\n \\n # Run ODE integrator\\n for idx, _t in enumerate(t[1:]):\\n phase[:,idx] = kODE.y\\n kODE.integrate(_t)\\n\\n phase[:,-1] = kODE.y\\n \\n return phase\",\n \"def Vdiode(Icell, Vcell, Rs):\\n return Vcell + Icell * Rs\",\n \"def _redfield(R, rho0, evecs=None, Nt=1, dt=0.005, t0=0, e_ops=[], return_result=True):\\n\\n N = rho0.shape[0]\\n # initialize the density matrix\\n if e_ops is None:\\n e_ops = []\\n\\n # basis transformation\\n if evecs is not None:\\n rho0 = transform(rho0, evecs)\\n e_ops = [transform(e, evecs) for e in e_ops]\\n\\n rho = rho0.copy()\\n rho = dm2vec(rho).astype(complex)\\n\\n # tf = t0 + dt * Nt\\n # result = solve_ivp(rhs, t_span=(t0, tf), y0=rho0, vectorized=True, args=(R, ))\\n\\n t = t0\\n\\n if return_result == False:\\n\\n f_obs = open('obs.dat', 'w')\\n fmt = '{} '* (len(e_ops) + 1) + '\\\\n'\\n\\n for k in range(Nt):\\n\\n # compute observables\\n # observables = np.zeros(len(e_ops), dtype=complex)\\n # for i, obs_op in enumerate(e_ops):\\n\\n observables = [obs_dm(rho, e) for e in e_ops]\\n\\n t += dt\\n rho = rk4(rho, rhs, dt, R)\\n\\n # dipole-dipole auto-corrlation function\\n #cor = np.trace(np.matmul(d, rho))\\n\\n # take a partial trace to obtain the rho_el\\n\\n\\n f_obs.write(fmt.format(t, *observables))\\n\\n\\n f_obs.close()\\n # f_dm.close()\\n\\n return rho\\n\\n else:\\n\\n rholist = [] # store density matries\\n\\n result = Result(dt=dt, Nt=Nt, rho0=rho0)\\n\\n observables = np.zeros((Nt, len(e_ops)), dtype=complex)\\n\\n for k in range(Nt):\\n\\n t += dt\\n rho = rk4(rho, rhs, dt, R)\\n\\n tmp = np.reshape(rho, (N, N))\\n rholist.append(transform(tmp, dag(evecs)))\\n\\n\\n observables[k, :] = [obs_dm(tmp, e) for e in e_ops]\\n\\n\\n result.observables = observables\\n result.rholist = rholist\\n\\n return result\",\n \"def runge_integrator(self, t, y, dt, tau):\\n\\n k1 = self.plant.rhs(t, y, tau)\\n k2 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k1, tau)\\n k3 = self.plant.rhs(t + 0.5 * dt, y + 0.5 * dt * k2, tau)\\n k4 = self.plant.rhs(t + dt, y + dt * k3, tau)\\n return (k1 + 2 * (k2 + k3) + k4) / 6.0\",\n \"def dVdx(self, sys):\\n dx = sys.positions - self.x0\\n k = self.omega*self.omega*sys.mass\\n return self.A*k*dx\",\n \"def c( self , y , r , t = 0 ):\\n \\n u = np.zeros(self.m) # State derivative vector\\n \\n raise NotImplementedError\\n \\n return u\",\n \"def euler_sde(self, x, rv_n):\\n n = self.mp.params[0]; k = self.mp.params[1];\\n gamma = self.mp.params[2]; dt = self.mp.params[3];\\n\\n if x.get_shape()[1] > 1:\\n evolve_fun = self.evolve_system\\n else:\\n evolve_fun = self.evolve\\n\\n dx = dt * self.evolve(x, n, k, gamma)\\n x = x + dx + tf.sqrt(dt)*x*rv_n\\n return tf.cast(x, tf.float32)\",\n \"def VerletHope2(r, v, beta,dt,R_dust,M_dust):\\n # Deceptively simple (read about Velocity Verlet on wikipedia)\\n r_new = r + v*dt + calculate_acceleration2(r,v,beta,omega,R_dust,M_dust)*dt**2/2\\n v_new = v + (calculate_acceleration2(r,v,beta,omega,R_dust,M_dust) + calculate_acceleration2(r_new,v,beta,omega,R_dust,M_dust))/2 * dt\\n \\n return (r_new, v_new)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75142777","0.7181643","0.69310933","0.6536001","0.646115","0.6173939","0.6170267","0.6157919","0.6156554","0.6128975","0.6113935","0.60999966","0.60107154","0.5988227","0.59345883","0.59310585","0.583424","0.5826762","0.5802471","0.5792491","0.578822","0.5765777","0.576524","0.5760391","0.57514894","0.5751221","0.5742813","0.57396924","0.57303554","0.5724525","0.5710117","0.56656885","0.5660637","0.565458","0.5640014","0.5636567","0.5628147","0.5620804","0.5620045","0.5609267","0.5602494","0.55939883","0.5587254","0.5587235","0.55841744","0.5582578","0.55755025","0.55733573","0.5568383","0.55620944","0.5556708","0.55472594","0.5532904","0.5532677","0.55178595","0.54810137","0.54794437","0.5463717","0.5462641","0.5456182","0.54543525","0.544727","0.5441097","0.5439625","0.54280293","0.54258054","0.54220337","0.54206717","0.5417035","0.5405692","0.5400108","0.5397694","0.5396162","0.53876626","0.5384247","0.5368275","0.5364096","0.5363029","0.5358486","0.53545713","0.5353279","0.5353081","0.53468996","0.5345049","0.5337319","0.5336325","0.5323802","0.53222346","0.53104675","0.530469","0.53044516","0.52993196","0.5294125","0.52829444","0.52821195","0.52804995","0.52784276","0.5277341","0.5277029","0.5269534","0.52648723"],"string":"[\n \"0.75142777\",\n \"0.7181643\",\n \"0.69310933\",\n \"0.6536001\",\n \"0.646115\",\n \"0.6173939\",\n \"0.6170267\",\n \"0.6157919\",\n \"0.6156554\",\n \"0.6128975\",\n \"0.6113935\",\n \"0.60999966\",\n \"0.60107154\",\n \"0.5988227\",\n \"0.59345883\",\n \"0.59310585\",\n \"0.583424\",\n \"0.5826762\",\n \"0.5802471\",\n \"0.5792491\",\n \"0.578822\",\n \"0.5765777\",\n \"0.576524\",\n \"0.5760391\",\n \"0.57514894\",\n \"0.5751221\",\n \"0.5742813\",\n \"0.57396924\",\n \"0.57303554\",\n \"0.5724525\",\n \"0.5710117\",\n \"0.56656885\",\n \"0.5660637\",\n \"0.565458\",\n \"0.5640014\",\n \"0.5636567\",\n \"0.5628147\",\n \"0.5620804\",\n \"0.5620045\",\n \"0.5609267\",\n \"0.5602494\",\n \"0.55939883\",\n \"0.5587254\",\n \"0.5587235\",\n \"0.55841744\",\n \"0.5582578\",\n \"0.55755025\",\n \"0.55733573\",\n \"0.5568383\",\n \"0.55620944\",\n \"0.5556708\",\n \"0.55472594\",\n \"0.5532904\",\n \"0.5532677\",\n \"0.55178595\",\n \"0.54810137\",\n \"0.54794437\",\n \"0.5463717\",\n \"0.5462641\",\n \"0.5456182\",\n \"0.54543525\",\n \"0.544727\",\n \"0.5441097\",\n \"0.5439625\",\n \"0.54280293\",\n \"0.54258054\",\n \"0.54220337\",\n \"0.54206717\",\n \"0.5417035\",\n \"0.5405692\",\n \"0.5400108\",\n \"0.5397694\",\n \"0.5396162\",\n \"0.53876626\",\n \"0.5384247\",\n \"0.5368275\",\n \"0.5364096\",\n \"0.5363029\",\n \"0.5358486\",\n \"0.53545713\",\n \"0.5353279\",\n \"0.5353081\",\n \"0.53468996\",\n \"0.5345049\",\n \"0.5337319\",\n \"0.5336325\",\n \"0.5323802\",\n \"0.53222346\",\n \"0.53104675\",\n \"0.530469\",\n \"0.53044516\",\n \"0.52993196\",\n \"0.5294125\",\n \"0.52829444\",\n \"0.52821195\",\n \"0.52804995\",\n \"0.52784276\",\n \"0.5277341\",\n \"0.5277029\",\n \"0.5269534\",\n \"0.52648723\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":761,"numItemsPerPage":100,"numTotalItems":95772,"offset":76100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjU3MTQ1MSwianRpIjoiNGRmNDlmYjMtOGM3Zi00NDdhLTgwYTItNjVhODFmY2NiOGJiIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY1NzUwNTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.UItD9YMBEWa0mqnNoRSJIL8R56tgJ7_XmdHSPliCuKdWOPxAh2Yt8OR136aYqSLfxUKkiJtwj_uDbT2D-mwoAg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Build the decision tree | def buildTree(data, level):
node = maxIG(data)
subsets = splitBy(data, node[0])
header = ["Outlook", "Temp", "Humidity", "Wind", "Play"]
if node[1] == 0:
print("\t" * level, level, getColumn(data, node[0])[0], ":", getColumn(data, -1)[0])
elif level < 4:
p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_decision_tree():\n\n decision_tree_root = None\n decision_tree_root = DecisionNode(None,None,lambda feature:feature[0]==1)\n decision_tree_root.left = DecisionNode(None,None,None,1)\n decision_tree_root.right = DecisionNode(None,None,lambda feature:feature[3]==1)\n decision_tree_root.right... | [
"0.7623397",
"0.73653334",
"0.72419083",
"0.7224621",
"0.701551",
"0.69989246",
"0.68689287",
"0.6819133",
"0.6815177",
"0.67908794",
"0.675017",
"0.67482513",
"0.67481315",
"0.6737991",
"0.67176723",
"0.6646255",
"0.65618885",
"0.65146697",
"0.6460597",
"0.6337855",
"0.63327... | 0.0 | -1 |
Returns the definition for unit with name `definition_name`. | def get_definition(self, definition_name, unit_type):
if unit_type == pu.UnitType.alias:
relevant_dict = self.alias_definitions
elif unit_type == pu.UnitType.slot:
relevant_dict = self.slot_definitions
elif unit_type == pu.UnitType.intent:
relevant_dict = self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_definition(self, name):\n if self.is_defined(name):\n return self._definitions[name]\n return None",
"def get_def(self, def_name):\n if not def_name:\n return None\n for defi in self._definitions:\n if defi._name == def_name:\n r... | [
"0.72344184",
"0.63266414",
"0.63032293",
"0.6179592",
"0.6067163",
"0.6035977",
"0.58439296",
"0.5780957",
"0.57687986",
"0.5746453",
"0.5741409",
"0.5714593",
"0.56843793",
"0.5671426",
"0.5670899",
"0.5664608",
"0.5657939",
"0.56444097",
"0.5607851",
"0.5600935",
"0.557700... | 0.7419221 | 0 |
Parses the master file and subsequent files and transforms the information parsed into a dictionary of declaration names > rules. | def parse(self):
print_DBG("Parsing master file: "+self.tokenizer.get_file_information()[0])
for token_line in self.tokenizer.next_tokenized_line():
if not token_line[0].isspace():
if token_line[0] == pu.INCLUDE_FILE_SYM:
self.tokenizer.open_file(token_lin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_master_mapping_file(master_mapping_file, bcos):\n bco_names = []\n\n mapping_dict = {\n }\n\n for bco in bcos:\n bco_names.append(os.path.splitext(os.path.basename(bco))[0])\n mapping_dict[os.path.splitext(os.path.basename(bco))[0]] = {\n \"missing\": {\n\n ... | [
"0.60867506",
"0.578407",
"0.5697687",
"0.5682963",
"0.5680399",
"0.5605115",
"0.55050564",
"0.5500258",
"0.54917365",
"0.54871374",
"0.54120314",
"0.5396366",
"0.53410786",
"0.5339711",
"0.5313843",
"0.5282944",
"0.52651393",
"0.52578163",
"0.52340865",
"0.52198327",
"0.5214... | 0.74442387 | 0 |
Parses a line (as tokens) that contains a declaration initiator. | def _parse_declaration_initiator(self, token_line):
if self._expecting_rule:
self.tokenizer.syntax_error("Expected a generation rule, got a "+
"unit declaration instead.")
unit_type = pu.get_unit_type_from_sym(token_line[0])
declaration_inter... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Declaration(self):\n type = self.Type()\n if self.currtok[1].name == \"IDENT\":\n self.ids[self.currtok[0]] = type\n id = self.primary()\n\n if self.currtok[1].name == \"SEMI\":\n self.currtok = next(self.tg)\n return DeclarationExpr(... | [
"0.60595083",
"0.57688266",
"0.57019955",
"0.5691983",
"0.5684513",
"0.56226003",
"0.552998",
"0.55017716",
"0.5465409",
"0.5453657",
"0.5441814",
"0.52609015",
"0.5220658",
"0.520444",
"0.5193987",
"0.5159767",
"0.5131876",
"0.5129617",
"0.5114839",
"0.51058304",
"0.5096995"... | 0.8207203 | 0 |
Creates a unit of type `unit_type` with name `unit_name` and modifiers `modifiers` inside the relevant dictionary (`alias_definitions`, `slot_definitions` or `intent_definitions`). `modifiers` is a `UnitDeclarationModifiersRepr` and `nb_examples_asked` is a tuple (training, test). | def create_unit(self, unit_type, unit_name, modifiers,
nb_examples_asked=None):
new_unit = None
relevant_dict = None
if unit_type == pu.UnitType.alias:
new_unit = AliasDefinition(unit_name, modifiers)
# new_unit = AliasDefinition(unit_name, [], modifie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_unit(self, unit_type):\n unit = None\n\n if unit_type == 'ElfRider':\n unit = ElfRider()\n elif unit_type == 'Knight':\n unit = Knight()\n elif unit_type == \"DwarfFighter\":\n unit = DwarfFighter()\n elif unit_type == 'OrcRider':\n ... | [
"0.6863574",
"0.62725776",
"0.6256398",
"0.6254103",
"0.60253644",
"0.5939342",
"0.58484507",
"0.57158554",
"0.56877196",
"0.5604188",
"0.5513164",
"0.5367513",
"0.5357851",
"0.53299356",
"0.5321212",
"0.5317357",
"0.52819335",
"0.5246464",
"0.51694965",
"0.5160825",
"0.51535... | 0.8705934 | 0 |
Parses the list of string `tokens` that represents a rule in a template file and add the rule to the declaration currently being parsed. | def _parse_rule(self, tokens):
if self._currently_parsed_declaration is None:
self.tokenizer.syntax_error("Got a rule outside of "+
"a unit declaration.")
self._check_indentation(tokens[0])
sub_rules = self.tokens_to_sub_rules(tokens[1:])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_rules(self, rules: List):\n self.template.extend(rules)",
"def insert_tokens(self, token_list):\n\n assert type(token_list) == list, \"Token list should be a list of tuples of the format (token_name, regex).\"\n\n self.tokens += token_list\n self.__create_regex()",
"def appl... | [
"0.6217032",
"0.5957868",
"0.57224643",
"0.56512535",
"0.5468249",
"0.5428751",
"0.54161507",
"0.5412818",
"0.5250332",
"0.5239056",
"0.5192862",
"0.507564",
"0.50741833",
"0.50386393",
"0.5019195",
"0.4952552",
"0.4938836",
"0.49024025",
"0.4873259",
"0.4867532",
"0.48509473... | 0.58242035 | 2 |
Checks that the str `indentation` is the same as the expected indentation from the last parsed rule. Raises a `SyntaxError` if it isn't. | def _check_indentation(self, indentation):
if self._expected_indentation is None:
self._expected_indentation = indentation
return
if indentation != self._expected_indentation:
self.tokenizer.syntax_error("Inconsistent indentation.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_indentation(code: str, path: pathlib.Path = None):\n if not isinstance(code, str):\n raise TypeError('code must be string but {} given'.format(type(code)))\n assert path is None or isinstance(path, pathlib.Path), type(path)\n\n lines = code.splitlines(keepends=True)\n whitespace = r... | [
"0.6527587",
"0.598616",
"0.598616",
"0.5967331",
"0.57532173",
"0.5659602",
"0.56493586",
"0.5569273",
"0.550822",
"0.53785354",
"0.53224736",
"0.5262904",
"0.52626956",
"0.51944107",
"0.5175933",
"0.5161552",
"0.51611274",
"0.5155272",
"0.51426595",
"0.5091848",
"0.50561875... | 0.78708684 | 0 |
Transforms a list of tokens into a list of subrules | def tokens_to_sub_rules(self, tokens):
# Remove alternative slot rule if necessary
alt_slot_value = None # TODO DummySlotVal absolutely need to be managed differently
if self._currently_parsed_declaration[0] == pu.UnitType.slot:
answer = pu.find_alt_slot_and_index(tokens)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_rules(self, token_parse_list):\r\n return token_parse_list",
"def extract_rules(self, labels=None):\n # Extract flat list of rules in array form\n if isinstance(self.base_estimator, RandomForestClassifier):\n rules = list(it.chain(*[self.__extract_dt_rules__(dt) for dt i... | [
"0.6186922",
"0.60484374",
"0.5945183",
"0.5885389",
"0.5819015",
"0.56935894",
"0.56846756",
"0.5673392",
"0.5631876",
"0.55965734",
"0.55585086",
"0.5541569",
"0.5531376",
"0.5428534",
"0.53792447",
"0.53696585",
"0.53554046",
"0.53478056",
"0.53404236",
"0.534006",
"0.5325... | 0.6196971 | 0 |
Checks that the subrule represented by `interior_tokens` is syntactically valid. | def _check_sub_rule_validity(self, interior_tokens, sub_rule_type):
try:
if sub_rule_type == pu.SubRuleType.word_group:
pu.check_word_group_validity(interior_tokens)
elif sub_rule_type == pu.SubRuleType.choice:
pu.check_choice_validity(interior_tokens)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_composite_tokens(self, name, tokens):\n assert len(tokens) >= 2\n key = tokens[0]\n\n assert key.value.lower() == name\n assert tokens[-1].value.lower() == \"end\"\n\n if len(tokens) == 2:\n body = [] # empty TYPE..END block\n else:\n body ... | [
"0.5497027",
"0.5389574",
"0.5389574",
"0.51875174",
"0.5152841",
"0.5063203",
"0.49809048",
"0.49645007",
"0.49629456",
"0.49387994",
"0.49272373",
"0.49200037",
"0.49097204",
"0.48745412",
"0.48715726",
"0.48682913",
"0.48433882",
"0.48420814",
"0.48327184",
"0.4830428",
"0... | 0.7403252 | 0 |
Renames the unit declaration of type `unit_type` from `old_name` to `new_name` (possibly replacing the unit with that name). Raises a `KeyError` if `old_name` is not a declared unit. | def rename_unit(self, unit_type, old_name, new_name):
if unit_type == pu.UnitType.alias:
relevant_dict = self.alias_definitions
elif unit_type == pu.UnitType.slot:
relevant_dict = self.slot_definitions
elif unit_type == pu.UnitType:
relevant_dict = self.intent... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def renameKey(self, oldKey, newKey, meta=None, units=None):\n\n if meta:\n if oldKey not in meta:\n return\n meta.replaceKey(oldKey, newKey)\n if units:\n if oldKey not in units:\n return\n units.replaceKey(oldKey, newKey)",
... | [
"0.6078044",
"0.60575974",
"0.5870249",
"0.58238894",
"0.57904357",
"0.56272036",
"0.5613752",
"0.551229",
"0.551229",
"0.54903346",
"0.54142356",
"0.541372",
"0.5401158",
"0.53964615",
"0.5391015",
"0.538513",
"0.533361",
"0.5305564",
"0.52826214",
"0.52747434",
"0.5249805",... | 0.8716253 | 0 |
Deletes a unit definition. | def delete(self, unit_type, unit_name, variation_name=None):
if unit_type == pu.UnitType.alias:
relevant_dict = self.alias_definitions
stat_key = "#aliases"
elif unit_type == pu.UnitType.slot:
relevant_dict = self.slot_definitions
stat_key = "#slots"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def removeUnitDefinition(self, *args):\n return _libsbml.Model_removeUnitDefinition(self, *args)",
"def delete(self):\n key = self.request.get('key')\n\n if not self.assert_xsrf_token_or_fail(\n self.request, 'delete-unit', {'key': key}):\n return\n\n if not ... | [
"0.732434",
"0.6751945",
"0.6362059",
"0.6315331",
"0.62406754",
"0.6101216",
"0.6085688",
"0.5932826",
"0.5915547",
"0.58609813",
"0.57939345",
"0.56276876",
"0.5566255",
"0.5560605",
"0.55542415",
"0.5517972",
"0.5458577",
"0.5439751",
"0.5436361",
"0.54343516",
"0.54220444... | 0.6920054 | 1 |
Adds an already built definition to the list of declared units. | def add_definition(self, unit_type, unit_name, definition):
if unit_type == pu.UnitType.alias:
relevant_dict = self.alias_definitions
stat_key = "#aliases"
elif unit_type == pu.UnitType.slot:
relevant_dict = self.slot_definitions
stat_key = "#slots"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addUnitDefinition(self, *args):\n return _libsbml.Model_addUnitDefinition(self, *args)",
"def insert_definition(self, definition):\r\n self.definitions.insert(definition)",
"def add_definition(self, definition):\n self._definitions[definition.name] = definition",
"def addUnit(self, *... | [
"0.6652101",
"0.62057215",
"0.61890745",
"0.5981908",
"0.597683",
"0.59402233",
"0.58646315",
"0.58580893",
"0.5674745",
"0.5613364",
"0.545894",
"0.5456516",
"0.5444362",
"0.53415227",
"0.52771723",
"0.527371",
"0.52607644",
"0.525298",
"0.52528954",
"0.52448136",
"0.5241117... | 0.6550536 | 1 |
Do whatever is needed to have the box Working, like connecting to databases, getting needed parameters, etc | def __init__(self, *args, **kwargs):
self.update(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def os_start_db( self, ):\r\n pass",
"def connect(self):\n pwd = self.passwordEdit.text()\n user = self.usernameEdit.text()\n url = self.backendEdit.text()\n\n if user == \"\":\n user = None\n if pwd == \"\":\n pwd = None\n\n auth = self.con... | [
"0.6297941",
"0.62816715",
"0.62472177",
"0.6076363",
"0.60625684",
"0.60310054",
"0.6024862",
"0.60142833",
"0.6013913",
"0.6013913",
"0.6003923",
"0.5982284",
"0.597791",
"0.59599304",
"0.5925516",
"0.59009486",
"0.58777225",
"0.5855192",
"0.5825399",
"0.5779079",
"0.577830... | 0.0 | -1 |
Let's display our Box content | def __repr__(self, *args, **kwargs):
result ='{'
for (k, v) in self.items(*args, **kwargs):
result += repr(k) + ": " + repr(v) + ","
result = result[:-1] + '}'
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def box(self) -> None:\n self.screen.box()",
"def show(self):\r\n display(self.grid_part)",
"def display(self):\n width = 1 + max(len(self.values[s]) for s in self.boxes)\n line = 'x'.join(['-'*(width*3)]*3)\n for r in self.rows:\n print(''.join(self.values[r+c].ce... | [
"0.6970078",
"0.66412747",
"0.65527636",
"0.654283",
"0.6489814",
"0.6355681",
"0.6348469",
"0.61675423",
"0.61346054",
"0.611562",
"0.6096315",
"0.60569906",
"0.6044113",
"0.60230255",
"0.60131484",
"0.5989969",
"0.5946924",
"0.594632",
"0.59206116",
"0.5901945",
"0.58962774... | 0.0 | -1 |
Return the length of the box, ie the number of keys | def __len__(self, *args, **kwargs):
return len(self._list(*args, **kwargs)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __len__(self):\n return len(self.name_and_box_index)",
"def length(self):\n return pyvista.Box(self.bounds).length",
"def length(self):\n # TODO: Count number of key-value entries in each of the buckets\n return self.size\n # for bucket in self.buckets():",
"def getNumb... | [
"0.7549395",
"0.73779494",
"0.7292861",
"0.7270157",
"0.71937984",
"0.71814114",
"0.7116411",
"0.70783395",
"0.7069969",
"0.7034821",
"0.7034821",
"0.7034821",
"0.70135105",
"0.69604254",
"0.6941469",
"0.69326866",
"0.6927963",
"0.69122046",
"0.689848",
"0.689801",
"0.689801"... | 0.0 | -1 |
Return the File like object associated to a key | def __getitem__(self, key, *args, **kwargs):
# And if it exist
if not self.has_key(key, *args, **kwargs):
raise IndexError
return self._get(key, *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file(self, key):\n result = (None, None)\n path = os.path.join(self.directory, self.subdirectory, key)\n if os.path.isfile(path):\n content_type, _ = mimetypes.guess_type(path)\n with open(path, \"rb\") as file:\n result = content_type, file.read()\... | [
"0.7402981",
"0.7396121",
"0.67223567",
"0.6574202",
"0.6513079",
"0.6461926",
"0.63906527",
"0.6378118",
"0.6342053",
"0.6300237",
"0.6271362",
"0.6247083",
"0.62446433",
"0.6169464",
"0.6167233",
"0.6167233",
"0.6164922",
"0.6126087",
"0.61220825",
"0.6080943",
"0.60761184"... | 0.0 | -1 |
Let's assign the document to a specific place in the Box | def __setitem__(self, key, document, *args, **kwargs):
self._put(key, document, *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def edit_document():",
"def define_box_location(self):\n self.contents['Box_ID'] = np.ones(self.numatom) * self.num_box",
"def _put(self, name, document):\n raise NotImplementedError",
"def document(self, document):\n\n self._document = document",
"def document(self, document):\n\n ... | [
"0.6500657",
"0.6379893",
"0.5859167",
"0.58119535",
"0.58119535",
"0.5648817",
"0.5648132",
"0.5608137",
"0.55838746",
"0.5473571",
"0.54608184",
"0.5435312",
"0.5435312",
"0.5435312",
"0.5435312",
"0.5435312",
"0.5435312",
"0.5435312",
"0.5435312",
"0.5435312",
"0.5435312",... | 0.0 | -1 |
Delete an item from the box | def __delitem__(self, key, *args, **kwargs):
self._del(key, *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, box):\n boom = box.GetSelection()\n if boom == box.GetRootItem():\n return\n\n item_data = box.GetItemData(boom).GetData()\n\n if isinstance(item_data, data_types.ProductData):\n boom = box.GetItemParent(boom)\n item_data = box.GetItemDa... | [
"0.799132",
"0.7552727",
"0.74391794",
"0.7338039",
"0.72282916",
"0.71293783",
"0.70990616",
"0.7088416",
"0.7064737",
"0.70392716",
"0.70376575",
"0.69746894",
"0.69746894",
"0.69288194",
"0.69267917",
"0.6904008",
"0.6899043",
"0.6876089",
"0.6865989",
"0.6847135",
"0.6844... | 0.0 | -1 |
Let's iterate over keys | def __iter__(self, *args, **kwargs):
for key in self.keys(*args, **kwargs):
yield key | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterkeys(self):",
"def iterkeys(self):",
"def iterate_keys(\n self,\n keys: istr = None,\n terms: istr = None,\n prefixes: istr = None,\n labels: istr = None,\n ) -> Iterable[str]:",
"def keysAll():",
"def iterkeys(d):\r\n return iter(getattr(d, _iterkeys)())",
... | [
"0.8028127",
"0.8028127",
"0.75702435",
"0.7447725",
"0.7096699",
"0.7065386",
"0.7054807",
"0.7042659",
"0.70120496",
"0.69577056",
"0.68988377",
"0.6898542",
"0.6833501",
"0.681694",
"0.6812973",
"0.67881155",
"0.67873925",
"0.67873925",
"0.67829543",
"0.67829543",
"0.67823... | 0.71602553 | 4 |
Do we have a key in our Box | def __contains__(self, key, *args, **kwargs):
if key in self._list(*args, **kwargs):
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_keys(self):",
"def __contains__(self, key):\n if not isinstance(key, pm.general.Attribute):\n return super(ChannelBox, self).__contains__(key)\n else:\n for attr in self:\n if key.longName() == attr.longName():\n return True\n ... | [
"0.6986122",
"0.6938919",
"0.6731619",
"0.67175514",
"0.65140647",
"0.649861",
"0.6473597",
"0.6459295",
"0.64445496",
"0.6423036",
"0.6414411",
"0.6403864",
"0.63690263",
"0.63574445",
"0.6352781",
"0.63443744",
"0.6337839",
"0.6337052",
"0.6315151",
"0.62985957",
"0.6284299... | 0.0 | -1 |
Let's iterate over keys | def iterkeys(self, *args, **kwargs):
self.__iter__(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterkeys(self):",
"def iterkeys(self):",
"def iterate_keys(\n self,\n keys: istr = None,\n terms: istr = None,\n prefixes: istr = None,\n labels: istr = None,\n ) -> Iterable[str]:",
"def keysAll():",
"def __iter__(self, *args, **kwargs):\n for key in self.k... | [
"0.8028127",
"0.8028127",
"0.75702435",
"0.7447725",
"0.71602553",
"0.7096699",
"0.7065386",
"0.7042659",
"0.70120496",
"0.69577056",
"0.68988377",
"0.6898542",
"0.6833501",
"0.681694",
"0.6812973",
"0.67881155",
"0.67873925",
"0.67873925",
"0.67829543",
"0.67829543",
"0.6782... | 0.7054807 | 7 |
Let's iterate over values | def itervalues(self, *args, **kwargs):
for key in self.iterkeys():
yield self._get(key, *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n for val in self.value:\n yield val",
"def iter_values(self):\n values = self.values\n if (values is not None):\n yield from values",
"def values():",
"def values(self):\n return iter(util.annotate(v) for _, v in self._pairs())",
"def _... | [
"0.75258666",
"0.7508892",
"0.7246989",
"0.7126353",
"0.70811474",
"0.69964606",
"0.6943839",
"0.6941814",
"0.6876169",
"0.6856465",
"0.6845299",
"0.6784815",
"0.6760413",
"0.6748729",
"0.67412543",
"0.6608278",
"0.66009533",
"0.65879375",
"0.6520216",
"0.6509102",
"0.6483587... | 0.6520901 | 18 |
Returns the ordered file list contained in the box, which are the keys. | def keys(self, *args, **kwargs):
return self._list(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keys(self):\n self._load()\n return list(self._file_openers.keys())",
"def _keys(self):\n for name in listdir(abspath(self._path)):\n key, ext = splitext(name)\n if ext == \".pkl\":\n yield key",
"def get_key_list(self) -> list:\n return self... | [
"0.6447488",
"0.6203259",
"0.59547013",
"0.5950618",
"0.591363",
"0.59093",
"0.58849907",
"0.5868697",
"0.5834718",
"0.58314633",
"0.5818464",
"0.5811564",
"0.57635695",
"0.5761299",
"0.5735301",
"0.5695829",
"0.56861126",
"0.5675353",
"0.5649169",
"0.5625992",
"0.5604739",
... | 0.5268028 | 96 |
Returns the ordered file content in the box, values are File like object. | def values(self, *args, **kwargs):
return [ self._get(doc, *args, **kwargs) for doc in self.keys(*args, **kwargs) ] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file_content(self):\n after = self.file.revisions.filter(\n revision_number__gt=self.revision_number)\n content = self.file.content\n\n for revision in after:\n patch = dmp.patch_fromText(revision.diff)\n content = dmp.patch_apply(patch, content)[0]\n\n... | [
"0.6578323",
"0.6195132",
"0.6158609",
"0.6130001",
"0.60816914",
"0.6070722",
"0.5900003",
"0.58784735",
"0.5852176",
"0.5815309",
"0.5789908",
"0.57732135",
"0.5750775",
"0.57497567",
"0.570029",
"0.5668922",
"0.5662288",
"0.564425",
"0.56397945",
"0.5639734",
"0.5627384",
... | 0.0 | -1 |
Return the tuples (key, value) of the document in the Box | def items(self, *args, **kwargs):
return [ (key, self._get(key, *args, **kwargs),) for key in self.keys(*args, **kwargs) ] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tag_dict_values (self):\r\n\r\n if self.using_database:\r\n value_tuple = (notebookname,)\r\n db_cursor.execute(\"SELECT keyword \"\r\n +\"FROM keys_to_indexes\"\r\n +\" WHERE notebook=?;\",\r\n ... | [
"0.5800763",
"0.5605774",
"0.55930257",
"0.55834126",
"0.5575003",
"0.5566999",
"0.55480194",
"0.55251276",
"0.55248296",
"0.54984486",
"0.54984283",
"0.5479217",
"0.54744464",
"0.5467374",
"0.54591835",
"0.5444327",
"0.5435902",
"0.54260826",
"0.539782",
"0.53727955",
"0.536... | 0.0 | -1 |
Check if a document with name exist in the box. Name must be a UUID. | def has_key(self, name, *args, **kwargs):
if not name in self._list(*args, **kwargs):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _document_exists(self, document_name):\n return len(self.ssm_client.list_document_versions(Name=document_name)['DocumentVersions']) >= 1",
"def document_exists(self, docid):\n raise NotImplementedError",
"async def exists(self, tag_name):\n try:\n if await self.get_id(tag_na... | [
"0.7135397",
"0.6594063",
"0.65436053",
"0.64406437",
"0.6437423",
"0.64143556",
"0.6381167",
"0.62394005",
"0.6217442",
"0.6199171",
"0.6186326",
"0.61659366",
"0.6156692",
"0.61054975",
"0.61047465",
"0.59580827",
"0.59065944",
"0.5855192",
"0.58499634",
"0.5817798",
"0.579... | 0.0 | -1 |
Returns the list of all items in the box. | def _list(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_items(self):\n return self.api.state['items']",
"def get_items(self) -> list:\r\n return self._items",
"def getAllItemsList():\n return Gw2Spidy._request('all-items', 'all')['results']",
"def items(self):\n return list(self.items_generator())",
"def get_all(self):\n ... | [
"0.7333024",
"0.72668177",
"0.72242326",
"0.71624315",
"0.71111107",
"0.70891744",
"0.70159924",
"0.6920204",
"0.691704",
"0.6915142",
"0.6856909",
"0.6847854",
"0.6846284",
"0.6830232",
"0.6828449",
"0.68206275",
"0.6808724",
"0.67803705",
"0.6778643",
"0.674152",
"0.6718216... | 0.0 | -1 |
Get a document from the box, should return a File like object | def _get(self, name):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetDocument(self):\n return self.file",
"def getDocument(cred, documentPath):\n url = cred.base_url + \"documents/\" + documentPath\n\n return makeRequest(cred, url, 'GET')",
"def get_document(self):\n return self.document",
"def retrieve_document(self, format):\n self._validat... | [
"0.76784086",
"0.6944488",
"0.6931573",
"0.6773835",
"0.67368263",
"0.6678726",
"0.6640609",
"0.6607192",
"0.65544736",
"0.65524936",
"0.65454",
"0.65300834",
"0.6474754",
"0.64528465",
"0.6449089",
"0.6386817",
"0.6363929",
"0.6361937",
"0.6354846",
"0.6332822",
"0.6315605",... | 0.0 | -1 |
Put a document in a box. document are, generally, File like objects. If a document with this name exist, it will be overwritten. | def _put(self, name, document):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def edit_document():",
"def add_doc(self, name, boring):\n\n self.documents[name] = boring",
"def create_document(file_name):\n path = INPUT_DIR+file_name # assemble the file descriptor\n file = open(path) # open in read mode\n doc = Document() # create a new document\n # add the title fi... | [
"0.61639756",
"0.6162539",
"0.59793246",
"0.5963256",
"0.590264",
"0.58933574",
"0.58044666",
"0.5765277",
"0.5765277",
"0.5704316",
"0.5627359",
"0.5610905",
"0.55908906",
"0.5577505",
"0.5577505",
"0.5577505",
"0.55759597",
"0.5559141",
"0.55538213",
"0.55373514",
"0.552513... | 0.7024438 | 0 |
Remove a document from the box. | def _del(self, name):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def remove_doc(self, *args, **kwargs):\n pass",
"def delete_document(self):\n pass",
"def remove_document(request, pk, doc_name):\n\n refresh_template = request.session[constants.ACTUAL_TEMPLATE]\n\n docs = request.session[constants.ADD_DOCS]\n document = next(el for el in docs if ... | [
"0.76537997",
"0.73871493",
"0.6808508",
"0.68083537",
"0.667",
"0.64736843",
"0.63695973",
"0.62124866",
"0.61931455",
"0.6146125",
"0.61168104",
"0.61005217",
"0.6050102",
"0.6044907",
"0.60415405",
"0.602878",
"0.59733033",
"0.5963243",
"0.5946144",
"0.58676904",
"0.584129... | 0.0 | -1 |
Initialize the DFTimewolf console output object. | def __init__(self, sender, verbose):
super(DFTimewolfConsoleOutput, self).__init__()
self._sender = sender
self._verbose = verbose | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, console_output, console_stream):\n self.console_output = console_output\n self.console_stream = console_stream",
"def __init__(self):\n self.start = datetime.datetime.now()\n self.linecount = 0\n if sys.stdout.isatty():\n self.term = Terminal()\n ... | [
"0.7273711",
"0.6603541",
"0.63445574",
"0.62620664",
"0.6247948",
"0.6224108",
"0.62141013",
"0.6183469",
"0.6162597",
"0.6135037",
"0.6121743",
"0.6066026",
"0.6051641",
"0.60458225",
"0.6029775",
"0.60186225",
"0.5972186",
"0.59671825",
"0.5889796",
"0.58682",
"0.5840445",... | 0.7100504 | 1 |
Format message with timestamp, script name and sender name. | def _FormatMessage(self, message):
script_name = os.path.basename(sys.argv[0])
timestamp = datetime.now().isoformat()
formatted_message = '[{0:s}] {1:s}: {2:s} - {3:s}\n'.format(
timestamp, script_name, self._sender, message)
return formatted_message | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_message(self, message):\n return \"%s at %s\" % (\n message[0], time.asctime(time.localtime(message[1])))",
"def format(self, message):",
"def _format_msg(self, format_str, *args):\r\n return u\"{0} - - [{1}] {2}\\n\".format(\r\n self.client_address[0],\r\n ... | [
"0.71702343",
"0.63822514",
"0.6338278",
"0.6299789",
"0.6249407",
"0.6240023",
"0.61700153",
"0.61387986",
"0.61233366",
"0.6073101",
"0.60591334",
"0.5941699",
"0.58731693",
"0.5831379",
"0.58288723",
"0.5788805",
"0.57774264",
"0.57669884",
"0.5763617",
"0.5748114",
"0.572... | 0.81965363 | 0 |
Send message to standard out. | def StdOut(self, message):
sys.stdout.write('{0:s}\n'.format(message))
sys.stdout.flush() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send(self, msg):\n if self.verbose:\n print('<- out ' + msg)\n self._socket.send_string(msg)\n return",
"def write(self, msg, *_):\n if self.out is not None:\n self.out.write(msg)\n self.out.flush()",
"def stdout(msg):\n sys.stdout.write(msg)\n sys.stdout.... | [
"0.73845494",
"0.72514176",
"0.71020246",
"0.6914435",
"0.6861263",
"0.6831616",
"0.6803821",
"0.6777944",
"0.6777944",
"0.67456704",
"0.66035986",
"0.6591568",
"0.6567837",
"0.656644",
"0.656644",
"0.6550436",
"0.65137446",
"0.6496491",
"0.6481694",
"0.6435243",
"0.6383848",... | 0.75261456 | 0 |
Send formatted message to standard error. | def StdErr(self, message, die=False):
error_message = self._FormatMessage(message)
if die:
exit_message = error_message.rstrip('\n')
sys.exit(exit_message)
sys.stderr.write(error_message)
sys.stderr.flush() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_error(msg):\n\n print(msg)",
"def error(message):\n print str(message)",
"def error(msg):\n sys.stdout.write('%s[ ERROR ]%s %s\\n' % (colors.RED, colors.RESET, msg))",
"def send_error(self, e):\n self._send({'error': e.payload})",
"def error(cls, message):\n print('[ERRO... | [
"0.7451318",
"0.7334253",
"0.72953176",
"0.71933055",
"0.71841633",
"0.70832545",
"0.70167476",
"0.7006353",
"0.69829154",
"0.6961286",
"0.6953911",
"0.69475806",
"0.69462806",
"0.6946146",
"0.69442457",
"0.68781567",
"0.68722326",
"0.68413025",
"0.68083096",
"0.68083096",
"0... | 0.6524549 | 60 |
Send verbose output to standard error. | def VerboseOut(self, message):
if self._verbose:
self.StdErr(message, die=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error(message):\n print(message, file=sys.stderr)",
"def error(*args, **kwargs):\n print(*args, file=sys.stderr, **kwargs)",
"def err(self, text):\n if not self.is_quiet_err:\n self.__emit(\"ERROR: \" + text, sys.stderr)",
"def _print_error(message):\n sys.stderr.write(str(mess... | [
"0.7068845",
"0.69946826",
"0.69232833",
"0.68590796",
"0.6770286",
"0.6770286",
"0.6770286",
"0.66918993",
"0.6639223",
"0.66315615",
"0.66117066",
"0.65715766",
"0.6510242",
"0.6505283",
"0.64945483",
"0.6488714",
"0.648618",
"0.6482448",
"0.64809734",
"0.6477335",
"0.64744... | 0.73082143 | 0 |
Convenience function to read input from stdin. | def ReadFromStdin():
for line in sys.stdin:
path_name = line.strip('\n').split()
try:
path = path_name[0]
name = path_name[1]
except IndexError:
raise IndexError('Malformed input on stdin')
yield (path, name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_stdin():\n return \"\".join(sys.stdin.readlines()).strip()",
"def read_input(args, parser):\n if args.text == sys.stdin:\n # check if stdin is empty\n stdin_ready, _, _ = select.select([sys.stdin], [], [], 0)\n if stdin_ready:\n return sys.stdin.read().strip()\n\n ... | [
"0.760807",
"0.75703275",
"0.72676516",
"0.721318",
"0.7152076",
"0.69860023",
"0.6639193",
"0.6587536",
"0.64938253",
"0.64057076",
"0.6331568",
"0.6262105",
"0.623257",
"0.6206357",
"0.62016064",
"0.6172127",
"0.6170546",
"0.61641914",
"0.6152224",
"0.61395735",
"0.6136844"... | 0.64873475 | 9 |
Check timezone string against known timezones in the pytz package. | def IsValidTimezone(timezone):
return timezone in pytz.all_timezones | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_timezone(tzstring):\n if not tzstring:\n return get_localzone()\n try:\n return pytz.timezone(tzstring)\n except pytz.UnknownTimeZoneError:\n raise VdtValueError(\"Unknown timezone {}\".format(tzstring))",
"def is_tz_valid(self, tz : str):\n # check tz is a string\n ... | [
"0.7579308",
"0.74548393",
"0.72705984",
"0.6789601",
"0.66779983",
"0.6512265",
"0.64019895",
"0.63673794",
"0.6315279",
"0.62908083",
"0.6286167",
"0.62601435",
"0.62428313",
"0.6206581",
"0.6180309",
"0.6156222",
"0.60593784",
"0.6052749",
"0.6025556",
"0.6025556",
"0.6025... | 0.74890524 | 1 |
Replaces some arguments by those specified by a keyvalue dictionary. This function will be recursively called on a dictionary looking for any value containing a "$" variable. If found, the value will be replaced by the attribute in "args" of the same name. It is used to load arguments from the CLI and any extra configu... | def import_args_from_dict(value, args, config):
if isinstance(value, six.string_types):
for match in TOKEN_REGEX.finditer(str(value)):
token = match.group(1)
if token in args:
actual_param = args[token]
if isinstance(actual_param, six.string_types):
value = value.replace("@"+... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_args(self, args):\n for cfg in args:\n keys, v = cfg.split('=', maxsplit=1)\n keylist = keys.split('.')\n dic = self\n for i, k in enumerate(keylist[:-1]):\n assert k in dir(dic), \"Unknown config key: {}\".format(keys)\n d... | [
"0.68151176",
"0.6694366",
"0.62639254",
"0.6206691",
"0.5526846",
"0.5518324",
"0.54716885",
"0.54171",
"0.54088897",
"0.5379822",
"0.5378015",
"0.53294635",
"0.5300866",
"0.52824336",
"0.5280397",
"0.52757204",
"0.5272755",
"0.52654624",
"0.5264887",
"0.5236045",
"0.5231624... | 0.57869947 | 4 |
Checks if any values in a given dictionary still contain @ parameters. | def check_placeholders(value):
if isinstance(value, six.string_types):
if TOKEN_REGEX.search(value):
raise ValueError('{0:s} must be replaced in dictionary'.format(value))
elif isinstance(value, list):
return [check_placeholders(item) for item in value]
elif isinstance(value, dict):
return {key:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_implied_parameters(self, parameters):\n for key, values, implied_keys in self.IMPLIED_PARAMETERS:\n self.log([u\"Checking implied parameters by '%s'='%s'\", key, values])\n if (key in parameters) and (parameters[key] in values):\n found = False\n ... | [
"0.62755895",
"0.59351057",
"0.58636785",
"0.58431524",
"0.5831259",
"0.5828135",
"0.5820753",
"0.57764626",
"0.57671577",
"0.5734962",
"0.5709924",
"0.5636245",
"0.5611094",
"0.5594863",
"0.5587707",
"0.55796117",
"0.55698526",
"0.5558164",
"0.5509387",
"0.55067164",
"0.5503... | 0.0 | -1 |
Catches Ctrl + C to exit cleanly. | def signal_handler(*unused_argvs):
sys.stderr.write("\nCtrl^C caught, bailing...\n")
sys.exit(0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ctrl_c(signum, frame):\n global shutdown_event\n raise SystemExit('\\nCancelling...')",
"def allowCtrlC():\n signal.signal(signal.SIGINT, signal.SIG_DFL)",
"def signal_handler(self, signal, frame):\r\n print 'You pressed Ctrl+C!'\r\n sys.exit(0)",
"def ctrl_c_trapper(signum: int, s... | [
"0.80725306",
"0.789612",
"0.78671515",
"0.77578425",
"0.7625408",
"0.75891113",
"0.7430562",
"0.7410401",
"0.729414",
"0.7250938",
"0.7194444",
"0.7110748",
"0.70975953",
"0.679413",
"0.67453665",
"0.66968954",
"0.6669376",
"0.66400564",
"0.66031146",
"0.6600431",
"0.6469647... | 0.8342945 | 0 |
Distort one image for training a network. | def preprocess_for_train(
image, height, width, bbox,
do_distort_color=True,
do_flip_horizontal=True,
do_flip_vertical=False,
area_range=(0.2, 1.0),
aspect_ratio_range=(0.75, 1.333),
normalize_method='inception',
fast_mode=True,
scope=None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distort_images(self, images, seed):\n if self.mode == \"train\":\n images = image_processing.distort_image(images, seed)\n\n # Rescale to [-1,1] instead of [0, 1]\n images = tf.subtract(images, 0.5)\n images = tf.multiply(images, 2.0)\n return images",
"def undistort(self,src):\n #... | [
"0.73022383",
"0.6604408",
"0.6493764",
"0.6346601",
"0.63008636",
"0.62407595",
"0.6238941",
"0.61212516",
"0.6048554",
"0.6030431",
"0.6009535",
"0.600286",
"0.597758",
"0.5952197",
"0.5927538",
"0.5903251",
"0.58237195",
"0.58088666",
"0.5779274",
"0.5659034",
"0.5553383",... | 0.61765313 | 7 |
Prepare one image for evaluation. If height and width are specified it would output an image with that size by applying resize_bilinear. If central_fraction is specified it would crop the central fraction of the input image. | def preprocess_for_eval(image, height, width,
central_fraction=0.875, scope=None):
with tf.name_scope(scope, 'eval_image', [image, height, width]):
if image.dtype != tf.float32:
image = tf.image.convert_image_dtype(image, dtype=tf.float32)
# Crop the central region of the image w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(image, height, width,\n central_fraction=0.875, scope=None):\n with tf.name_scope(scope, 'eval_image', [image, height, width]):\n if image.dtype != tf.float32:\n image = tf.image.convert_image_dtype(image, dtype=tf.float32)\n # Crop the central region of the image ... | [
"0.6689361",
"0.65859485",
"0.5938244",
"0.57086855",
"0.56061655",
"0.5604108",
"0.55377597",
"0.5537046",
"0.5517595",
"0.54937977",
"0.54748225",
"0.5371019",
"0.53591627",
"0.535385",
"0.5330709",
"0.5325815",
"0.5318338",
"0.53006196",
"0.52887845",
"0.52764225",
"0.5267... | 0.6445598 | 2 |
Preprocess one image for training or evaluation. | def preprocess_image(
image, height, width,
is_training=False,
bbox=None,
fast_mode=True,
add_image_summaries=True,
**kwargs):
do_distort_color = kwargs.pop('do_distort_color', False)
do_flip_horizontal = kwargs.pop('do_flip_horizontal', True)
do_flip_vertical = kwa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(self, img):\n img_ = image.load_img(img, target_size=(299, 299))\n img_ = image.img_to_array(img_)\n img_ = np.expand_dims(img_, axis=0)\n img_ = preprocess_input(img_)\n return img_",
"def preprocess_image(self, inputs):\n raise NotImplementedError('prepr... | [
"0.74826854",
"0.730003",
"0.72899485",
"0.7244322",
"0.7049938",
"0.69764584",
"0.6940527",
"0.6870593",
"0.684732",
"0.6824978",
"0.68106574",
"0.6790526",
"0.6737742",
"0.67320675",
"0.67121994",
"0.6706478",
"0.6687464",
"0.6673582",
"0.66599274",
"0.6629511",
"0.661788",... | 0.6436267 | 32 |
Adds the two vectors, v and u. | def add_vectors(v, u):
return (v[0] + u[0], v[1] + u[1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_vectors(u, v): #11.22.5\r\n new_vector = []\r\n \"\"\"Because they have same length so we\r\n should take advantage from this one\"\"\"\r\n for i in range(len(u)):\r\n m = u[i] + v[i] # Get their value of i index at the same time!\r\n new_vector.append(m)\r\n return new_vector"... | [
"0.81809795",
"0.81132114",
"0.74564755",
"0.7385315",
"0.7307801",
"0.7250798",
"0.7221409",
"0.72022974",
"0.7178813",
"0.7116212",
"0.71116716",
"0.71053827",
"0.7038589",
"0.702951",
"0.70047545",
"0.68703395",
"0.68566346",
"0.68371874",
"0.6800543",
"0.6782561",
"0.6777... | 0.8510088 | 0 |
Returns the (x,y) tile of room. | def room_xy(room, x, y, value=None):
return room[x][y] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tile(self, x: int, y: int):\n return self.awmap.tile(x, y)",
"def get_tile(self, row, col):\n return self.grid[row][col]",
"def get_tile(self, row, col):\n #print 'The value of tile at position: (',row,',',col,') is: ',self.grid[row][col]\n return self.grid[row][col]",
"def ge... | [
"0.7695231",
"0.7685104",
"0.7619274",
"0.758384",
"0.7560093",
"0.754351",
"0.7527224",
"0.752072",
"0.752072",
"0.752072",
"0.75105745",
"0.750853",
"0.74337506",
"0.743131",
"0.7421612",
"0.74162275",
"0.7416172",
"0.7408059",
"0.7405969",
"0.7388739",
"0.7369988",
"0.73... | 0.7127098 | 29 |
Returns the width and height of room. | def room_wh(room):
if isinstance(room, str):
room = dungeon[room]
return len(room), len(room[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dimensions (self):\n return (self.width, self.height)",
"def size(self):\n return (self.width(), self.height())",
"def size(self):\n return (self.width, self.height)",
"def size(self):\n return self.width, self.height",
"def getDims(self):\n size = self.screenSize\n ... | [
"0.7284312",
"0.72340363",
"0.7229903",
"0.7218242",
"0.71061677",
"0.7099479",
"0.7098856",
"0.70988137",
"0.7063528",
"0.69398564",
"0.69301516",
"0.6902028",
"0.6874542",
"0.68626475",
"0.6828495",
"0.68002677",
"0.6784956",
"0.6776988",
"0.67632365",
"0.67047834",
"0.6679... | 0.62047046 | 79 |
Creates a new room. The rooms is a list of lists, where every list represents a column. Tiles | def create_room(w, h):
# map[0] gives a list which represents the row, or the x. Then map[x][y]
# gives the yth place in the column x.
room = [[' ' for j in range(h)] for i in range(w)]
for x in range(w):
for y in range(h):
if y == 0 or y == (h-1):
room[x][y] = '-'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_rooms(width=10, height=10):\n # create blank rooms\n rooms = [Room(id) for id in range(1, (width * height + 1))]\n\n # make some rooms inaccessible\n for _ in range(0, height*width//10):\n rand_num = randint(0, height*width-1)\n while rooms[rand_num].is_accessible == False:\n ... | [
"0.7591706",
"0.71845305",
"0.71760666",
"0.7051529",
"0.69662994",
"0.66109204",
"0.6405384",
"0.6376221",
"0.63713443",
"0.630056",
"0.6272139",
"0.62588125",
"0.62555104",
"0.6243304",
"0.6191843",
"0.6115295",
"0.6084862",
"0.60528034",
"0.6038224",
"0.6000447",
"0.596918... | 0.7119422 | 3 |
Finds the name of a given room. If the room doesn't exist returns None. | def get_room_name(dungeon, room):
for n in dungeon:
if dungeon[n] == room:
return n
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_room(self, room_name):\r\n try:\r\n return self._rooms[room_name]\r\n except KeyError:\r\n return None",
"def get_room(self, name):\n for i in self.rooms:\n if self.rooms[i].name == name:\n return self.rooms[i]\n raise RuntimeErr... | [
"0.75425893",
"0.7537608",
"0.7521715",
"0.7370273",
"0.7260868",
"0.7102111",
"0.7077929",
"0.69465464",
"0.6901336",
"0.6713058",
"0.6378655",
"0.63167995",
"0.62781125",
"0.62456167",
"0.62415075",
"0.6202007",
"0.6202007",
"0.6162853",
"0.6153098",
"0.61020285",
"0.607822... | 0.801243 | 0 |
Prints out the room. This is the basic graphics function. Clear(), stdout.flush() arn't entirely clear to me. | def print_room(dungeon, room):
if not isinstance(room, str):
name = get_room_name(dungeon, room)
else:
name = room
room = dungeon[name]
w, h = room_wh(room)
room_str = ''
for y in range(h):
row = ''
for x in range(w):
#print room
tile =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self):\n\t\tfor i in range(0, self.size):\n\t\t\tprint('\\n' + \"----\" * self.size)\n\t\t\tfor j in range(0, self.size):\n\t\t\t\tprint(self.grid[i][j] + ' |', end=\" \")\n\t\tprint('\\n'+ \"----\" * self.size + '\\n')",
"def display(self):\n for r in range(len(self.grid)):\n for c in... | [
"0.7538773",
"0.7269248",
"0.72002727",
"0.71958214",
"0.7131456",
"0.70858586",
"0.69819885",
"0.6970632",
"0.6965393",
"0.6960884",
"0.69436365",
"0.69365036",
"0.69221085",
"0.6880478",
"0.6877629",
"0.6868829",
"0.685913",
"0.6822707",
"0.6803275",
"0.67974323",
"0.678989... | 0.6630154 | 37 |
Creates a new dungeon out of the graph rooms. The size of each room depends on it's rank. | def create_dungeon(graph, ranks):
dungeon = {}
w, h = 150, 100
for r in graph:
name, w, h = r, int(w*ranks[r]+10), int(h*ranks[r]+10)
dungeon[name] = create_room(w, h)
return dungeon | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_dungeon(self):\r\n # Total number of rooms\r\n n = self.__nx * self.__ny\r\n room_stack = []\r\n current_room = self.room_at(self.__ix, self.__iy)\r\n # Total number of visited rooms during maze construction\r\n nv = 1\r\n\r\n # iterate over all rooms of du... | [
"0.79936665",
"0.743523",
"0.673504",
"0.6677515",
"0.6576027",
"0.65215296",
"0.64986736",
"0.646819",
"0.64603704",
"0.6405314",
"0.63618886",
"0.6356892",
"0.6314918",
"0.6306273",
"0.6300013",
"0.6290147",
"0.6279687",
"0.6276442",
"0.6262408",
"0.62097096",
"0.62089825",... | 0.7741939 | 1 |
Prints out the whole dungeon... Kind of useless cause I couldn't get it to build all the rooms as a single dungeon with hallways and all. | def print_dungeon(dungeon):
for r in dungeon:
print_room(dungeon[r]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_room(dungeon, room):\n if not isinstance(room, str):\n name = get_room_name(dungeon, room)\n else:\n name = room\n room = dungeon[name]\n w, h = room_wh(room)\n room_str = ''\n for y in range(h):\n row = ''\n for x in range(w):\n #print room\n ... | [
"0.7222498",
"0.7206108",
"0.68528926",
"0.6848333",
"0.66115516",
"0.6574171",
"0.65262556",
"0.6516744",
"0.6489489",
"0.6471107",
"0.6433852",
"0.6400976",
"0.63732857",
"0.63092345",
"0.628924",
"0.62752634",
"0.6267731",
"0.62479174",
"0.6238725",
"0.62261903",
"0.621193... | 0.77093595 | 0 |
The basic crit. Its type can be 'player' or 'crawler'. | def create_crit(dungeon, room, pos, symbol, type, hp=1, dir=None, score=None):
crit = {'dungeon': dungeon,
'room': dungeon[room],
'room_name': room,
'symbol': symbol,
'pos': (pos[0], pos[1]),
'lastpos': (pos[0], pos[1]),
'hp': hp,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def crit_ai(crit):\n if crit['type'] == 'crawler':\n # Crawlers move at random.\n return random.choice(['left','right','up','down'])\n #if crit['type'] == 'bullet':\n # return crit['dir']\n return None",
"def critic(self) -> CriticType:\n if not self._critic:\n rais... | [
"0.7114849",
"0.6818957",
"0.61771935",
"0.6091296",
"0.5658373",
"0.5643586",
"0.5643586",
"0.56431574",
"0.5410564",
"0.5399258",
"0.5377942",
"0.53656733",
"0.52876395",
"0.50784194",
"0.5024129",
"0.49956137",
"0.4870065",
"0.48335576",
"0.48329183",
"0.4807755",
"0.47434... | 0.61057764 | 3 |
Create a new door. A door is a list with a symbol and a destination room. It is saved in the room's list and no where else. | def create_door(dungeon, room, pos, symbol, destination):
dungeon[room][pos[0]][pos[1]] = [symbol, destination] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_door(self, room=None, status=\"open\", tile=None, name=\"door\", color=None, random=False, x=None, y=None):\n\n walls = room.get_walls()\n if random:\n door_seed = randint(0, len(room.get_walls()) - 1)\n\n while walls[door_seed][0] == 1 or walls[door_seed][0] == room.... | [
"0.69796914",
"0.6737017",
"0.6626829",
"0.63650703",
"0.632819",
"0.6296616",
"0.628974",
"0.619405",
"0.6189811",
"0.6084912",
"0.5908753",
"0.5863805",
"0.5863573",
"0.58631283",
"0.5750759",
"0.5719418",
"0.56915903",
"0.56372154",
"0.56128436",
"0.5598879",
"0.5522017",
... | 0.79109216 | 0 |
Blits the obj unto the room it is in. An obj is a dictionary with all the relevent keys. | def blit(obj):
# An object is a dictionary with the keys: 'dungeon', 'room', 'symbol', 'pos', 'lastpos'
x = obj['pos'][0]
y = obj['pos'][1]
lastx= obj['lastpos'][0]
lasty = obj['lastpos'][1]
room = obj['room']
if x < len(room) and y < len(room[0]):
room[lastx][lasty] = ' '
ro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_dict(self, obj):\n\n for attr, value in obj.__dict__.items():\n self.__dict__[attr] = value",
"def _update_loose (self, dict):\n self.__dict__.update(dict)",
"def put(self, obj):\n\n if obj is None:\n return\n\n return obj",
"def _restore_objs_from_I... | [
"0.55141205",
"0.5455272",
"0.5451394",
"0.5428932",
"0.53700477",
"0.5302088",
"0.527134",
"0.5265598",
"0.5256817",
"0.52297986",
"0.5223485",
"0.51562405",
"0.51516265",
"0.5151293",
"0.5136837",
"0.5135862",
"0.507945",
"0.50718594",
"0.50638777",
"0.5061924",
"0.5055992"... | 0.59469885 | 0 |
Moves obj according to the vector v. | def move(dungeon, obj, v, crits):
# An object is a dictionary with the keys: 'dungeon', 'room', 'symbol', 'pos', 'lastpos'
if v == None:
return
room = obj['room']
newpos = add_vectors(obj['pos'], v)
tile = room[newpos[0]][newpos[1]]
if obj['type'] == 'bullet' and (tile == '-' or tile == ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_vertex(self, p, v, x, y, z):\n self._move_vertex(p, v, x, y, z)",
"def move(self, _vec):\n\n\t\t_dest = self._grid[0] + _vec[0], self._grid[1] + _vec[1], self._grid[2] + _vec[2]\n\t\tif _vec[2]: # jeśli ruszamy się w z to znaczy że wchodzimy po schodach\n\t\t\tself._map.getLayer('Fields').get(sel... | [
"0.68294024",
"0.65596116",
"0.6420798",
"0.62307125",
"0.5968462",
"0.5814363",
"0.57445145",
"0.57445145",
"0.56720877",
"0.566532",
"0.5644781",
"0.5639692",
"0.5605438",
"0.55740774",
"0.5565334",
"0.5545422",
"0.5524349",
"0.5501914",
"0.549206",
"0.54794955",
"0.5427554... | 0.630317 | 3 |
Returns an action for the crit to follow. | def crit_ai(crit):
if crit['type'] == 'crawler':
# Crawlers move at random.
return random.choice(['left','right','up','down'])
#if crit['type'] == 'bullet':
# return crit['dir']
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_action_critic(self, x): \n x = x.to(self.dummy_param.device)\n encoder_output, actor_output = self.get_penultimate(x)\n critic_output = self.critic_decoder(encoder_output)\n return actor_output, critic_output",
"def request_action(self):\n\n # Determine the compu... | [
"0.6199234",
"0.6157312",
"0.61139256",
"0.60479057",
"0.60223484",
"0.5996251",
"0.5987789",
"0.58963466",
"0.5876293",
"0.5801321",
"0.5761508",
"0.5742031",
"0.5710618",
"0.5710618",
"0.5710618",
"0.57095194",
"0.56798005",
"0.5675119",
"0.5675119",
"0.5675119",
"0.5675119... | 0.552107 | 34 |
initialize your data structure here. | def __init__(self):
self.stack = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self.data = []\n self.record = {}",
"def __init__(self):\n self.structure = {}",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self... | [
"0.7761043",
"0.76102185",
"0.7555967",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.7549892",
"0.752797",
"0.7446006",
"0.7446006",
"0.7446006",
"0.7446006",
"0.7446006",
"0.743338",
"0.743338",
"0.7408609",
"0.7385719",
"0.737986",
"0.737986",
"0.73... | 0.0 | -1 |
Design the model with Multilevel Perceptrons | def get_model(neurons_in_layer, number_of_layers=2, lr=0.1, activation_function='relu', dropout_rates=0.2):
model = Sequential()
model.add(Dense(neurons_in_layer, activation=activation_function, input_shape=(3072,)))
model.add(Dropout(dropout_rates))
for i in range(number_of_layers-1):
model.ad... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, hidden_layer_sizes, activation='relu', reg=0.001, k_fold=5, random_state=0):\n print(\"Initialize model Multi-layer Perceptron\")\n self.hidden_layer_sizes = hidden_layer_sizes\n self.activation = activation\n self.reg = reg\n self.k_fold = k_fold\n self... | [
"0.7173574",
"0.6657019",
"0.65320843",
"0.6526806",
"0.64745086",
"0.63801926",
"0.6337982",
"0.6330352",
"0.63216627",
"0.62055063",
"0.6185266",
"0.6155439",
"0.614831",
"0.6130537",
"0.6128191",
"0.6096416",
"0.6073686",
"0.606398",
"0.6046298",
"0.6005055",
"0.6001098",
... | 0.0 | -1 |
Preprocess images. convert them into vector. | def get_preprocessed_data(x_train, x_test, y_train, y_test):
x_train = x_train.reshape(50000, 3072)
x_test = x_test.reshape(10000, 3072)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = np_utils.to_categorical(y_train, num_classes)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_process(self, images: Union[np.ndarray, List]) -> np.ndarray:\n images = validate_image(images)\n image_sizes = []\n image_arr = []\n for image in images:\n image_sizes.append(image.shape)\n image = resize(image,\n height=self.in_h... | [
"0.7123236",
"0.71175474",
"0.71103907",
"0.71058273",
"0.7010947",
"0.69705945",
"0.680906",
"0.6789942",
"0.6776293",
"0.676025",
"0.6729897",
"0.672513",
"0.66972786",
"0.6683716",
"0.6600654",
"0.65509903",
"0.65455157",
"0.6541596",
"0.65228456",
"0.65175027",
"0.6517117... | 0.0 | -1 |
Train for one epoch on the training set | def train(train_loader, model, criterion, optimizer, epoch, noise_decay_rate,
noise_param_list, noise_decay, random_noise=False, sparsity=0):
global total_steps, exp_flops, exp_l0, args, writer
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_one_epoch(self):\n raise NotImplementedError",
"def train_one_epoch(self):\n\t\tself.model.train()\n\t\ttrain_loss = 0\n\n\t\tfor batch_idx, data in enumerate(self.data_loader.train_loader):\n\t\t\tInput = data[0].float().to(self.device)\n\t\t\tOutput = data[1].float().to(self.device)\n\n\t\t\ts... | [
"0.85638434",
"0.81158483",
"0.79524827",
"0.7938271",
"0.7938271",
"0.7938271",
"0.7938271",
"0.7749522",
"0.77110666",
"0.76998925",
"0.7698468",
"0.76657456",
"0.7661316",
"0.7612038",
"0.75879216",
"0.75706774",
"0.7550792",
"0.75401384",
"0.74804544",
"0.74505657",
"0.74... | 0.0 | -1 |
Perform validation on the validation set | def validate(val_loader, model, criterion, epoch):
global args, writer
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
# switch to evaluate mode
model.eval()
#if not args.multi_gpu:
# if model.beta_ema > 0:
# old_params = model.get_params()
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self):\n for rule in self.get_rules():\n rule.validate(self.get_val())",
"def validate():",
"def validate(self):",
"def validate(self):",
"def _validate(self):\n pass",
"def validate(self):\n raise NotImplementedError(\"validate function needs to be implemente... | [
"0.7935849",
"0.7611668",
"0.7374195",
"0.7374195",
"0.7308814",
"0.7305275",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.7230471",
"0.722908",
"0.71874404",
"0.7187279",
"0.71682346",
"0.7132424",
"0.70742506",
"0.7050... | 0.0 | -1 |
Perform validation on the validation set | def test(test_loader, model, criterion, epoch):
global args, writer
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
# switch to evaluate mode
model.eval()
#if not args.multi_gpu:
# if model.beta_ema > 0:
# old_params = model.get_params()
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self):\n for rule in self.get_rules():\n rule.validate(self.get_val())",
"def validate():",
"def validate(self):",
"def validate(self):",
"def _validate(self):\n pass",
"def validate(self):\n raise NotImplementedError(\"validate function needs to be implemente... | [
"0.7935849",
"0.7611668",
"0.7374195",
"0.7374195",
"0.7308814",
"0.7305275",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.729531",
"0.7230471",
"0.722908",
"0.71874404",
"0.7187279",
"0.71682346",
"0.7132424",
"0.70742506",
"0.7050... | 0.0 | -1 |
Sort the given list in the way that humans expect. | def natural_sort( l ):
convert = lambda text: int(text) if text.isdigit() else text
alphanum_key = lambda key: [ convert(c) for c in re.split('([0-9]+)', key) ]
l.sort( key=alphanum_key )
return l | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort_list(self,list_):\r\n list_.sort()",
"def sort(self):\r\n self.list.sort(key=lambda x: ''.join(x))",
"def sort(self):\n self.list.sort(key=lambda x: ''.join)",
"def sort_list(list, key):\r\n list.sort(lambda x,y: cmp(key(x), key(y))) # Python < 2.4 hack\r\n return list",
"de... | [
"0.8292916",
"0.76561475",
"0.757362",
"0.7467298",
"0.744403",
"0.7396385",
"0.73923665",
"0.7373652",
"0.73097515",
"0.7273553",
"0.72724366",
"0.7242809",
"0.723442",
"0.7208328",
"0.7205921",
"0.7205823",
"0.7152361",
"0.71513903",
"0.71511674",
"0.71472865",
"0.71407837"... | 0.0 | -1 |
Constructs a QGraphicsItem displaying streams in a timeline | def __init__(self, parent, streams):
super(TimelineItem, self).__init__()
self._parent = parent
# Timeline boundries
self._start_stamp = None # earliest of all stamps
self._end_stamp = None # latest of all stamps
self._stamp_left = None # earliest timestamp currently visible
self._stamp_right = None ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, streams, parent=None):\n\n\t\t# Initialize class\n\t\tQtGui.QWidget.__init__(self, parent)\n\t\tself.main_layout = QtGui.QVBoxLayout(self)\n\t\tself.setLayout(self.main_layout)\n\n\t\t# Retrieve first and last timestamps\n\t\t_streams_ts_float = dict()\n\t\tfor stream_name in streams.keys():\n\t... | [
"0.8026527",
"0.6497834",
"0.5820398",
"0.5699911",
"0.5643354",
"0.55481607",
"0.5530482",
"0.5490387",
"0.5429456",
"0.53892124",
"0.5310036",
"0.528807",
"0.52612",
"0.51812494",
"0.51704144",
"0.5135293",
"0.5133683",
"0.51331383",
"0.51291114",
"0.50970054",
"0.50852877"... | 0.77844894 | 1 |
Recalculates the layout of the timeline to take into account any changes that have occured | def _layout(self):
# Calculate history left and history width
self._scene_width = self.scene().views()[0].size().width()
max_stream_name_width = -1
for stream_name in self.streams:
stream_width = self._qfont_width(stream_name)
if max_stream_name_width <= stream_width:
max_stream_name_width = stream_w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_timeline_view(self):\n self.t2.setGeometry(self.t1.vb.sceneBoundingRect())\n self.t2.linkedViewChanged(self.t1.vb, self.t2.XAxis)",
"def refreshView(self):\n chldn = self.tDisp.get_children()\n for chld in chldn:\n self.tDisp.delete(chld)\n if len(self.con... | [
"0.65964925",
"0.6024597",
"0.58769494",
"0.5846595",
"0.57629436",
"0.5730918",
"0.5716509",
"0.5535949",
"0.55330044",
"0.54991317",
"0.54743934",
"0.5464647",
"0.5434402",
"0.540857",
"0.5375012",
"0.53379875",
"0.53152764",
"0.53030854",
"0.5293149",
"0.52806264",
"0.5271... | 0.6831872 | 0 |
Draw all stream messages | def _draw_stream_histories(self, painter):
for stream in sorted(self._history_boundaries.keys()):
self._draw_stream_history(painter, stream) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _draw_stream_history(self, painter, stream_name):\n\n\t\t# x, y, w, h = self._history_boundaries[stream]\n\t\t_, y, _, h = self._history_boundaries[stream_name]\n\n\t\tmsg_y = y\n\t\tmsg_height = h\n\n\t\t# Get the renderer and the message combine interval\n\t\tmsg_combine_interval = self.map_dx_to_dstamp(self... | [
"0.693785",
"0.6424569",
"0.6293783",
"0.62174135",
"0.6211622",
"0.6183592",
"0.60616964",
"0.6001059",
"0.59859204",
"0.5963548",
"0.59148",
"0.5900497",
"0.58060837",
"0.57852465",
"0.577698",
"0.5775494",
"0.57620776",
"0.5743451",
"0.573396",
"0.5727461",
"0.5727461",
... | 0.6337151 | 2 |
Draw boxes corresponding to message regions on the timeline. | def _draw_stream_history(self, painter, stream_name):
# x, y, w, h = self._history_boundaries[stream]
_, y, _, h = self._history_boundaries[stream_name]
msg_y = y
msg_height = h
# Get the renderer and the message combine interval
msg_combine_interval = self.map_dx_to_dstamp(self._default_msg_combine_px)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_message_box(self):\r\n length = len(self.__lines)\r\n\r\n # Build the Dialogue Box\r\n background = pygame.transform.scale(BACKGROUND_PNG, (WINDOW_WIDTH, WINDOW_HEIGHT // 3))\r\n rect = background.get_rect()\r\n rect.center = (WINDOW_WIDTH // 2, 2 * WINDOW_HEIGHT // 3 + ... | [
"0.68003374",
"0.6561625",
"0.6500125",
"0.6344254",
"0.618181",
"0.6083605",
"0.6078848",
"0.6063363",
"0.6002534",
"0.59684235",
"0.5890529",
"0.5880073",
"0.58771783",
"0.5864927",
"0.5861873",
"0.58615",
"0.5853589",
"0.5806285",
"0.5789888",
"0.5786381",
"0.57839763",
... | 0.5819884 | 17 |
Draw markers to indicate the area covered by all the streams within the current visible area. | def _draw_stream_ends(self, painter):
x_start = self.map_stamp_to_x(self._start_stamp)
x_end = self.map_stamp_to_x(self._end_stamp)
painter.setBrush(QtGui.QBrush(self._history_external_color))
painter.drawRect(self._history_left,
self._history_top,
x_start - self._history_l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_points(self, video, roi_size=None):\n if roi_size is None:\n if hasattr(self, 'roi_size'):\n roi_size = self.roi_size\n\n fig, ax = plt.subplots(figsize=(15, 5))\n ax.imshow(video.mraw[0].astype(float), cmap='gray')\n ax.scatter(video.points[:, 1],\n ... | [
"0.5892175",
"0.5860346",
"0.56598705",
"0.56319463",
"0.5599937",
"0.55717206",
"0.55695695",
"0.55595607",
"0.55528086",
"0.54748017",
"0.5459466",
"0.54485136",
"0.5441773",
"0.5423518",
"0.54149544",
"0.54016405",
"0.53898364",
"0.5385444",
"0.5380194",
"0.53659046",
"0.5... | 0.5139556 | 41 |
Draws boxes to separate the different stream lines | def _draw_stream_dividers(self, painter):
clip_left = self._history_left
clip_right = self._history_left + self._history_width
row = 0
for stream_name in self.streams:
(x, y, w, h) = self._history_boundaries[stream_name]
if row % 2 == 0:
painter.setPen(QtCore.Qt.lightGray)
painter.setBrush(QtGui... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self):\n # 5 is the number of characters per box add one for the header column\n sepreator_line = \"-\" * (len(self.letters) + 1) * 5 + \"-\"\n print(sepreator_line)\n print(\n \"| \" + \"\".join([f\"| {letter} \" for letter in self.letters]) + \"|\")\n pri... | [
"0.68568236",
"0.67817307",
"0.6709467",
"0.660299",
"0.65354925",
"0.6516649",
"0.64493024",
"0.64444536",
"0.643776",
"0.64299077",
"0.6425775",
"0.64102346",
"0.63965875",
"0.63838845",
"0.63773304",
"0.6371379",
"0.6348268",
"0.63384986",
"0.6333496",
"0.632072",
"0.63206... | 0.67708635 | 2 |
Draw a line and 2 triangles to denote the current position being viewed | def _draw_current_pos(self, painter):
if self.current_pos is None:
return
px = self.map_stamp_to_x(self.current_pos)
pw, ph = self._current_pos_pointer_size
# Line
painter.setPen(QtGui.QPen(self._current_pos_color))
painter.setBrush(QtGui.QBrush(self._current_pos_color))
painter.drawLine(px, self._his... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw(self):\n if len(self.__points) >= 2:\n self._total_length = 0\n for i in range(len(self.__points) - 1):\n p1 = self.__points[i]\n p2 = self.__points[i + 1]\n coords = self.__line_segment(p1, p2)\n if not coords is None:\n pyglet.graphics.draw_indexed(4, py... | [
"0.73082083",
"0.72350454",
"0.72212887",
"0.7208003",
"0.71741086",
"0.71650916",
"0.714153",
"0.7035961",
"0.7022858",
"0.6951389",
"0.6932027",
"0.6917848",
"0.6891519",
"0.68568385",
"0.6823802",
"0.67701685",
"0.6716448",
"0.6708265",
"0.6707591",
"0.6677401",
"0.6676562... | 0.6822145 | 15 |
Draw a simple black rectangle frame around the timeline view area | def _draw_history_border(self, painter):
x = self._history_left
y = self._history_top
w = self._history_width
h = self._history_bottom - self._history_top
painter.setBrush(QtCore.Qt.NoBrush)
painter.setPen(QtCore.Qt.black)
painter.drawRect(x, y, w, h)
painter.setBrush(self._default_brush)
painter.set... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render(self, context):\n pygame.draw.rect(context, (255, 0, 0), self.box)",
"def draw_rectangle(t, w, h):\r\n for i in range(2):\r\n t.forward(w)\r\n t.left(90)\r\n t.forward(h)\r\n t.left(90)",
"def draw_rect(t, rect):\n t.pu()\n t.goto(rect.corner.x, rect.corne... | [
"0.6589045",
"0.65832454",
"0.64691156",
"0.62886983",
"0.6278969",
"0.6278481",
"0.625346",
"0.62273216",
"0.6219932",
"0.62083167",
"0.61804396",
"0.6173406",
"0.6169983",
"0.61535484",
"0.6110812",
"0.6101094",
"0.608499",
"0.6075405",
"0.6047118",
"0.6037817",
"0.6027269"... | 0.0 | -1 |
Calculate positions of existing stream names and draw them on the left, one for each row | def _draw_stream_names(self, painter):
streams = self._history_boundaries.keys()
coords = [(self._margin_left, y + (h / 2) + (self._stream_font_height / 2))\
for (_, y, _, h) in self._history_boundaries.values()]
for text, coords in zip([t.lstrip('/') for t in streams], coords):
painter.setBru... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _draw_stream_history(self, painter, stream_name):\n\n\t\t# x, y, w, h = self._history_boundaries[stream]\n\t\t_, y, _, h = self._history_boundaries[stream_name]\n\n\t\tmsg_y = y\n\t\tmsg_height = h\n\n\t\t# Get the renderer and the message combine interval\n\t\tmsg_combine_interval = self.map_dx_to_dstamp(self... | [
"0.6044906",
"0.6034543",
"0.5864108",
"0.57839006",
"0.55741054",
"0.55496025",
"0.5518214",
"0.53334785",
"0.53273594",
"0.5275547",
"0.52673393",
"0.52578425",
"0.52254885",
"0.52020663",
"0.51958114",
"0.5169469",
"0.5148948",
"0.5139718",
"0.5129087",
"0.511747",
"0.5115... | 0.6857854 | 0 |
Draw vertical gridlines showing major and minor time divisions. | def _draw_time_divisions(self, painter):
x_per_sec = self.map_dstamp_to_dx(1.0)
major_divisions = [s for s in self._sec_divisions\
if x_per_sec * s >= self._major_spacing]
if len(major_divisions) == 0:
major_division = max(self._sec_divisions)
else:
major_division = min(major_di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _render_grid_lines(self, w, h, x2, y2, w2, h2):\n # 1. find sample value of top/bottom pixel coordinate\n # 2. calc sample values that need a line and draw them using pixel-coordinates\n # 3. find time values of left/right pixel coordinate\n # 2. calc time values that need a line an... | [
"0.70710504",
"0.67601466",
"0.6702512",
"0.6604961",
"0.64861846",
"0.64794636",
"0.6436664",
"0.6410128",
"0.64027077",
"0.6334597",
"0.6321969",
"0.6250417",
"0.62492687",
"0.619716",
"0.61785114",
"0.6158972",
"0.6153642",
"0.6151999",
"0.61019206",
"0.6064893",
"0.604629... | 0.6433868 | 7 |
Draw black hashed vertical gridlines showing major time divisions. | def _draw_major_divisions(self, painter, stamps, start_stamp, division):
label_y = self._history_top - self._current_pos_pointer_size[1] - 5
for stamp in stamps:
x = self.map_stamp_to_x(stamp, False)
label = self._get_label(division, stamp - start_stamp)
label_x = x + self._major_divisions_label_indent
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_gray_grid(self):\n gray = \"#D3D3D3\"\n # Draw the vertical lines\n for x in range(0, self.width, self.scale):\n self.canvas.create_line(x, 0, x, self.height, fill=gray)\n\n # Draw the horizontal lines\n for y in range(0, self.height, self.scale):\n ... | [
"0.69875175",
"0.68149954",
"0.6810751",
"0.6640372",
"0.6640368",
"0.6514969",
"0.64459324",
"0.6404875",
"0.63303",
"0.6300145",
"0.62667954",
"0.6247951",
"0.6237642",
"0.6236573",
"0.6233812",
"0.62030315",
"0.61506754",
"0.6144414",
"0.61432195",
"0.61411273",
"0.6073863... | 0.5688038 | 50 |
Draw grey hashed vertical gridlines showing minor time divisions. | def _draw_minor_divisions(self, painter, stamps, start_stamp, division):
xs = [self.map_stamp_to_x(stamp) for stamp in stamps]
painter.setPen(self._minor_division_pen)
for x in xs:
painter.drawLine(x, self._history_top, x, self._history_bottom)
painter.setPen(self._minor_division_tick_pen)
for x in xs:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nicegrid():\n pl.grid(b=True, which='major', color='black', linestyle='-')\n\n pl.grid(b=True, which='minor', color='silver', linestyle=':')",
"def draw_gray_grid(self):\n gray = \"#D3D3D3\"\n # Draw the vertical lines\n for x in range(0, self.width, self.scale):\n self.... | [
"0.6914279",
"0.6753478",
"0.67506677",
"0.63327754",
"0.6317481",
"0.6279112",
"0.6270952",
"0.6231856",
"0.62011725",
"0.61593866",
"0.61234695",
"0.60951996",
"0.60335577",
"0.60326385",
"0.5998049",
"0.5859148",
"0.5859122",
"0.58522",
"0.5829957",
"0.58120954",
"0.581029... | 0.6185247 | 9 |
Group timestamps closer from each other than `max_interval` into one region | def _group_close_stamps(self, stamps, max_interval):
region_start, prev_stamp = None, None
for stamp in stamps:
if prev_stamp:
if stamp - prev_stamp > max_interval:
region_end = prev_stamp
yield (region_start, region_end)
region_start = stamp
else:
region_start = stamp
prev_stamp = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MaxToMin(min_lev, max_lev, datetime_maxes):\r\n y_res_mins = []\r\n deltaT_ranges = []\r\n for row in range(len(max_lev)-1):\r\n range_length = (datetime_maxes.iloc[row+1]-datetime_maxes.iloc[row]).seconds/3600 # hours\r\n if ~np.isnan(max_lev.iloc[row]) & (range_length>=3.5) & (range_le... | [
"0.5671331",
"0.563569",
"0.5533073",
"0.5493953",
"0.54180735",
"0.53772825",
"0.536929",
"0.5356859",
"0.53497636",
"0.5327543",
"0.531671",
"0.5242983",
"0.5203973",
"0.51983154",
"0.513029",
"0.5128987",
"0.5108332",
"0.50875574",
"0.50568986",
"0.5040786",
"0.502568",
... | 0.7114516 | 0 |
Generate visible stamps every `stamp_step` | def _get_stamps(self, start_stamp, stamp_step):
if start_stamp >= self._stamp_left:
stamp = start_stamp
else:
stamp = start_stamp\
+ int((self._stamp_left - start_stamp) / stamp_step)\
* stamp_step\
+ stamp_step
while stamp < self._end_stamp:
yield stamp
stamp += st... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _step_plot_closure(self, step_number):\n if self.watermark_hint is not None:\n plot_image_grid(\"watermark_hint_and_mask_{}\".format(step_number),\n [np.clip(self.watermark_hint, 0, 1),\n np.clip(torch_to_np(self.mask_net_output), 0, 1)])... | [
"0.51510036",
"0.5127864",
"0.5116933",
"0.50611883",
"0.50135565",
"0.49733168",
"0.4951268",
"0.49507222",
"0.49395362",
"0.49356547",
"0.49340758",
"0.49257594",
"0.49197146",
"0.4887233",
"0.4885607",
"0.48852775",
"0.4877723",
"0.48731306",
"0.48653987",
"0.48653987",
"0... | 0.6394511 | 0 |
Generates a label representing the elapsed time | def _get_label(self, division, elapsed):
secs = int(elapsed) % 60
mins = int(elapsed) / 60
hrs = mins / 60
days = hrs / 24
weeks = days / 7
if division >= 7 * 24 * 60 * 60: # >1wk divisions: show weeks
return '%dw' % weeks
elif division >= 24 * 60 * 60: # >24h divisions: show days
return '%dd' %... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return str(self.elapsed) + ' sec'",
"def message(self):\n if self.display_time:\n return \"Time: {}\".format(int(self.physics_engine.time_since_start()%self.time_cycle_secs))",
"def time_unit(self):\n self.skip_over_label['text'] = \"Start at (mins:secs): \"... | [
"0.7150838",
"0.6989443",
"0.6914872",
"0.67797524",
"0.6740108",
"0.6696059",
"0.6665888",
"0.66028243",
"0.6594788",
"0.6568519",
"0.6528017",
"0.65170825",
"0.64268756",
"0.6359626",
"0.63095796",
"0.62881374",
"0.6244882",
"0.62107897",
"0.61800116",
"0.61648136",
"0.6146... | 0.68177 | 3 |
Converts a pixel x value to a stamp | def map_x_to_stamp(self, x, clamp_to_visible=True):
fraction = float(x - self._history_left) / self._history_width
if clamp_to_visible:
if fraction <= 0.0:
return self._stamp_left
elif fraction >= 1.0:
return self._stamp_right
return self._stamp_left + fraction * (self._stamp_right - self._stamp_l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_stamp_to_x(self, stamp, clamp_to_visible=True):\n\t\tif self._stamp_left is None:\n\t\t\treturn None\n\t\tfraction = (stamp - self._stamp_left) / (self._stamp_right - self._stamp_left)\n\n\t\tif clamp_to_visible:\n\t\t\tfraction = min(1.0, max(0.0, fraction))\n\n\t\treturn self._history_left + fraction * s... | [
"0.6354424",
"0.60428345",
"0.6025354",
"0.59755665",
"0.5949464",
"0.5905613",
"0.5802552",
"0.574917",
"0.5697909",
"0.5613637",
"0.5608171",
"0.5599196",
"0.5548162",
"0.5536649",
"0.5518662",
"0.54913527",
"0.5478743",
"0.5445028",
"0.5438126",
"0.5430467",
"0.54274035",
... | 0.6221601 | 1 |
Converts a distance in pixel space to a distance in stamp space | def map_dx_to_dstamp(self, dx):
return float(dx) * (self._stamp_right - self._stamp_left) / self._history_width | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distMap(frame1, frame2):\r\n frame1_32 = np.float32(frame1)\r\n frame2_32 = np.float32(frame2)\r\n diff32 = frame1_32 - frame2_32\r\n norm32 = np.sqrt(diff32[:,:,0]**2 + diff32[:,:,1]**2 + diff32[:,:,2]**2)/np.sqrt(255**2 + 255**2 + 255**2)\r\n dist = np.uint8(norm32*255)\r\n return dist",
... | [
"0.6133821",
"0.60676736",
"0.60676736",
"0.6032651",
"0.60021335",
"0.5997194",
"0.58633155",
"0.5827517",
"0.57786804",
"0.57726216",
"0.5743113",
"0.57406116",
"0.5637086",
"0.56176287",
"0.5610416",
"0.55981433",
"0.55748016",
"0.55701214",
"0.55482084",
"0.5545479",
"0.5... | 0.5823158 | 8 |
Converts a timestamp to the x value where that stamp exists in the timeline | def map_stamp_to_x(self, stamp, clamp_to_visible=True):
if self._stamp_left is None:
return None
fraction = (stamp - self._stamp_left) / (self._stamp_right - self._stamp_left)
if clamp_to_visible:
fraction = min(1.0, max(0.0, fraction))
return self._history_left + fraction * self._history_width | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_timestamp(self, timestamp):\n return int(timestamp * 1e6)",
"def map_x_to_stamp(self, x, clamp_to_visible=True):\n\t\tfraction = float(x - self._history_left) / self._history_width\n\n\t\tif clamp_to_visible:\n\t\t\tif fraction <= 0.0:\n\t\t\t\treturn self._stamp_left\n\t\t\telif fraction >= 1.0:... | [
"0.59893584",
"0.595037",
"0.59041595",
"0.5840616",
"0.57994235",
"0.5774577",
"0.5716677",
"0.5689685",
"0.56540406",
"0.5592866",
"0.55166227",
"0.5504513",
"0.53762025",
"0.536753",
"0.5366946",
"0.53652966",
"0.5351976",
"0.53115314",
"0.53014266",
"0.5296015",
"0.529426... | 0.6297501 | 0 |
Converts a distance in pixel space to a distance in stamp space | def map_dstamp_to_dx(self, dstamp):
return (float(dstamp) * self._history_width) / (self._stamp_right - self._stamp_left) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distMap(frame1, frame2):\r\n frame1_32 = np.float32(frame1)\r\n frame2_32 = np.float32(frame2)\r\n diff32 = frame1_32 - frame2_32\r\n norm32 = np.sqrt(diff32[:,:,0]**2 + diff32[:,:,1]**2 + diff32[:,:,2]**2)/np.sqrt(255**2 + 255**2 + 255**2)\r\n dist = np.uint8(norm32*255)\r\n return dist",
... | [
"0.6133821",
"0.60676736",
"0.60676736",
"0.6032651",
"0.5997194",
"0.58633155",
"0.5827517",
"0.5823158",
"0.57786804",
"0.57726216",
"0.5743113",
"0.57406116",
"0.5637086",
"0.56176287",
"0.5610416",
"0.55981433",
"0.55748016",
"0.55701214",
"0.55482084",
"0.5545479",
"0.55... | 0.60021335 | 4 |
Constructs a widget displaying data streams. | def __init__(self, streams, parent=None):
# Initialize class
QtGui.QWidget.__init__(self, parent)
self.main_layout = QtGui.QVBoxLayout(self)
self.setLayout(self.main_layout)
# Retrieve first and last timestamps
_streams_ts_float = dict()
for stream_name in streams.keys():
tuple_ts = streams[stream_na... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, arg=None, maxpoints=None, token=None, **kwargs):\n super(Stream, self).__init__(\"stream\")\n\n # Validate arg\n # ------------\n if arg is None:\n arg = {}\n elif isinstance(arg, self.__class__):\n arg = arg.to_plotly_json()\n elif... | [
"0.60662293",
"0.60183984",
"0.5765122",
"0.57445544",
"0.5743239",
"0.5712016",
"0.5709956",
"0.5702659",
"0.5701964",
"0.5619593",
"0.5604423",
"0.55646557",
"0.55324537",
"0.5525624",
"0.5523583",
"0.54967433",
"0.5460502",
"0.5456427",
"0.5456427",
"0.54321116",
"0.542418... | 0.6148988 | 0 |
Return the latest file activated at a specific timestamp | def getFileAtStamp(self, timestamp):
out = ""
out_ts = (0,0)
for stream_name in self.stamps_by_stream.keys():
ts_index = bisect.bisect_right(self.stamps_by_stream[stream_name], timestamp)-1
if ts_index < 0:
continue
tuple_ts = self.streams[stream_name].keys()
tuple_ts.sort()
if tuple_ts[ts_inde... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRecentFile(*p):\n\tfrom os import stat\n\tfrom os.path import join\n\tfrom glob import glob\n\tresult = \"\"\n\tfiles = glob(join(p[0],*p[1:]))\n\tfor file in files:\n\t\tif result == \"\":\n\t\t\tresult = file\n\t\telse:\n\t\t\tif stat(file).st_mtime > stat(result).st_mtime:\n\t\t\t\tresult = file\n\tretur... | [
"0.6752036",
"0.66719294",
"0.6483359",
"0.64500797",
"0.6422892",
"0.64227515",
"0.6416471",
"0.6395238",
"0.6394504",
"0.62854326",
"0.62306523",
"0.62281126",
"0.61313367",
"0.6093726",
"0.6092767",
"0.60853755",
"0.6073606",
"0.6070921",
"0.60552466",
"0.6004467",
"0.5956... | 0.65377134 | 2 |
Return the list of files active at a specific timestamp | def getFilesAtStamp(self, timestamp):
out = []
for stream_name in self.stamps_by_stream.keys():
ts_index = bisect.bisect_right(self.stamps_by_stream[stream_name], timestamp)-1
if ts_index < 0:
continue
tuple_ts = self.streams[stream_name].keys()
tuple_ts.sort()
out.append(self.streams[stream_name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_superseded_by_timestamp(logfiles, current_timestamp):\n return [\n lf for lf in logfiles\n if current_timestamp - lf.timestamp > ONE_HOUR_PLUS\n ]",
"def list_files(line_id, datetime_, len_):\n the_dir = pathlib.Path(data_dir())/str(line_id)\n format_spec= \"%Y-%m-%d %H:%M\"\... | [
"0.66932845",
"0.66161937",
"0.63355404",
"0.6247447",
"0.62039196",
"0.6180368",
"0.6078104",
"0.6065711",
"0.5992878",
"0.59065336",
"0.5900509",
"0.5812714",
"0.57897043",
"0.5761614",
"0.5710695",
"0.5701943",
"0.5648884",
"0.56379694",
"0.5618448",
"0.55972624",
"0.55963... | 0.6878091 | 0 |
Slides the cursor to the previous frame. Does nothing if there is no frame before the current position | def moveToPreviousFrame(self):
all_ts = [s for t in self.stamps_by_stream.values() for s in t]
all_ts.sort()
first_frame = all_ts[0]
selected_index = bisect.bisect_right(all_ts, self._timeline.current_pos)-1
if selected_index <= 0 or all_ts[selected_index-1] < first_frame:
# There is no data before, or no... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def MoveToPreviousSlide(self, event):\n pass",
"def move_previous():\n self.variables.table.set_joystick(False)\n self.variables.table.set_axis(\n [True, True, True]\n ) # so all axis can be adressed\n errorcode = self.variables.table.move_to(\n ... | [
"0.67286366",
"0.6641986",
"0.66257024",
"0.66009825",
"0.6596117",
"0.649492",
"0.64684224",
"0.6314484",
"0.63081133",
"0.62761515",
"0.6240718",
"0.62358576",
"0.6189635",
"0.618176",
"0.61055577",
"0.60551465",
"0.6049198",
"0.602905",
"0.6027203",
"0.59977496",
"0.598562... | 0.67099565 | 1 |
Slides the cursor to the next frame. Does nothing if there is no frame after the current position | def moveToNextFrame(self):
all_ts = [s for t in self.stamps_by_stream.values() for s in t]
all_ts.sort()
first_frame = all_ts[0]
selected_index = bisect.bisect_right(all_ts, self._timeline.current_pos)-1
if len(all_ts)-1 == selected_index:
# We are already at the last frame
return
# Move forward eno... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Advance(self):\n\t\t\n\t\tself.present_frame += 1\n\t\t\n\t\tif self.present_frame < len(self.frames):\n\t\t\tself.frames[self.present_frame].Draw()\n\t\t\t\n\t\telse if self.loop:\n\t\t\tself.present_frame = 0\n\t\t\tself.frames[self.present_frame].Draw()\n\t\t\n\t\telse:\n\t\t\tself.Stop()",
"def moveFrame... | [
"0.68434274",
"0.6700361",
"0.66485",
"0.66261816",
"0.63143",
"0.62346226",
"0.6141126",
"0.61278856",
"0.60991865",
"0.6071463",
"0.6062554",
"0.6061215",
"0.6060542",
"0.6012689",
"0.60106057",
"0.6004812",
"0.59986347",
"0.59896463",
"0.59786433",
"0.5969532",
"0.5899186"... | 0.66077775 | 4 |
creates the solvent coupling array given the input efields values for a specific time, t w1first selects whether w1 or w2p is the first interacting positive field accounts for CARS interactions | def sOmega(E1, E2, E3, t, wvg, mu_vg, w1first = True):
if w1first==True:
first = E1
else:
first = E3
O = np.zeros((len(t),3,3),dtype=np.complex64)
# from gg
O[:,1,0] = 0.5*mu_vg * E2 * first * rotor(-wvg*t)
O[:,2,0] = 0.5*mu_vg * E2 * first * rotor( wvg*t)
return O | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spikingModel(wEE, wEI, wIE, wII, stim_e, stim_i,\n time=1000, dt=0.1, Vth=1.0, Vre=0.0,\n tau_e=15.0, tau_i=10.0, ref_e=5.0, ref_i=5.0, \n syntau2_e=3.0, syntau2_i=2.0, syntau1=1.0):\n\n T = np.arange(0,time,dt)\n nE = wEE.shape[0]\n nI = wII.shape[0]\n\... | [
"0.54710454",
"0.54353726",
"0.53806365",
"0.5359551",
"0.53592795",
"0.53414726",
"0.526344",
"0.5240726",
"0.52171093",
"0.5178414",
"0.51758915",
"0.5162229",
"0.5154969",
"0.5150186",
"0.5112925",
"0.510639",
"0.50983155",
"0.5083747",
"0.5056256",
"0.50537574",
"0.504135... | 0.0 | -1 |
A list of references to all availability sets in the proximity placement group. | def availability_sets(self) -> Sequence['outputs.SubResourceWithColocationStatusResponse']:
return pulumi.get(self, "availability_sets") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSets():",
"def available_sets(self, data=None, remote=False):\n if data is None:\n data = [SET_LABELS.RELEASE_DATE, SET_LABELS.BLOCK]\n else:\n if SET_LABELS.RELEASE_DATE not in data:\n data.append(SET_LABELS.RELEASE_DATE)\n if SET_LABELS.BLOCK... | [
"0.6209047",
"0.61726505",
"0.6001793",
"0.58266896",
"0.57690054",
"0.5768825",
"0.5753576",
"0.5750528",
"0.5735078",
"0.573019",
"0.57248986",
"0.5633302",
"0.55227154",
"0.5505786",
"0.5500121",
"0.5497109",
"0.54799634",
"0.5475461",
"0.54534113",
"0.5427677",
"0.5427677... | 0.6932559 | 0 |
Describes colocation status of the Proximity Placement Group. | def colocation_status(self) -> Optional['outputs.InstanceViewStatusResponse']:
return pulumi.get(self, "colocation_status") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_proximity_placement_group_output(include_colocation_status: Optional[pulumi.Input[Optional[str]]] = None,\n proximity_placement_group_name: Optional[pulumi.Input[str]] = None,\n resource_group_name: Optional[pulumi.Input[str]] ... | [
"0.60518825",
"0.55944324",
"0.51280826",
"0.5106413",
"0.4960813",
"0.4956404",
"0.48696086",
"0.4845193",
"0.48329565",
"0.48307562",
"0.48002636",
"0.47613734",
"0.47556528",
"0.47326788",
"0.47120273",
"0.46764436",
"0.46637207",
"0.46574867",
"0.46571022",
"0.46519265",
... | 0.6535979 | 0 |
Specifies the user intent of the proximity placement group. | def intent(self) -> Optional['outputs.ProximityPlacementGroupPropertiesResponseIntent']:
return pulumi.get(self, "intent") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def proximity_placement_group_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"proximity_placement_group_id\")",
"def set_target_org_favor(self, target, org, amount, gossip):\n rep, _ = target.Dominion.reputations.get_or_create(organization=org)\n rep.favor = amount\n ... | [
"0.51500684",
"0.5134789",
"0.49458975",
"0.49388775",
"0.49299842",
"0.48332885",
"0.47327837",
"0.4717751",
"0.47022802",
"0.4651362",
"0.46352458",
"0.45787394",
"0.45650944",
"0.45557648",
"0.4527954",
"0.45201847",
"0.4517139",
"0.45151445",
"0.4511541",
"0.45032752",
"0... | 0.66879284 | 0 |
A list of references to all virtual machine scale sets in the proximity placement group. | def virtual_machine_scale_sets(self) -> Sequence['outputs.SubResourceWithColocationStatusResponse']:
return pulumi.get(self, "virtual_machine_scale_sets") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSets():",
"def getscales(self):\n return self.scales",
"def scale_model(self) -> List[ClsSetInfo]:\n # Find layer groups\n connected_graph = ConnectedGraph(self._model)\n ordered_module_list = get_ordered_list_of_conv_modules(connected_graph.starting_ops)\n graph_searc... | [
"0.5751221",
"0.5642852",
"0.5589611",
"0.55564994",
"0.552904",
"0.54642105",
"0.5410798",
"0.5333115",
"0.53124064",
"0.528538",
"0.5217663",
"0.52064294",
"0.5205053",
"0.5187349",
"0.5155125",
"0.5154665",
"0.5090085",
"0.5086139",
"0.5064288",
"0.50516343",
"0.50274223",... | 0.6637517 | 0 |
A list of references to all virtual machines in the proximity placement group. | def virtual_machines(self) -> Sequence['outputs.SubResourceWithColocationStatusResponse']:
return pulumi.get(self, "virtual_machines") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def virtual_machines(self):\n return self._virtual_machines",
"def VirtualMachines(self):\n if not self._vms:\n vms = self._get_objects(vim.VirtualMachine)\n for vm in vms:\n self._vms[vm.name] = VirtualMachine(vm, self.service_instance)\n return self._vm... | [
"0.639447",
"0.60194457",
"0.5924702",
"0.57988507",
"0.57118845",
"0.57008165",
"0.56512684",
"0.55621773",
"0.5538973",
"0.54351383",
"0.5410967",
"0.53850055",
"0.5377102",
"0.5369306",
"0.5311894",
"0.52921194",
"0.5284723",
"0.52809006",
"0.52809006",
"0.5277062",
"0.527... | 0.5576687 | 7 |
Specifies the Availability Zone where virtual machine, virtual machine scale set or availability set associated with the proximity placement group can be created. | def zones(self) -> Optional[Sequence[str]]:
return pulumi.get(self, "zones") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def availability_zone(self) -> str:\n return pulumi.get(self, \"availability_zone\")",
"def availability_zone(self) -> Optional[str]:\n return pulumi.get(self, \"availability_zone\")",
"def availability_zone(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"availability_zone\")",
"... | [
"0.5842643",
"0.5806106",
"0.57767004",
"0.572297",
"0.572297",
"0.5708085",
"0.56195277",
"0.56034905",
"0.55768645",
"0.53280735",
"0.53220266",
"0.53134626",
"0.5304716",
"0.53038365",
"0.53038365",
"0.5241365",
"0.51650095",
"0.51525104",
"0.51333594",
"0.5128593",
"0.511... | 0.0 | -1 |
Retrieves information about a proximity placement group . | def get_proximity_placement_group(include_colocation_status: Optional[str] = None,
proximity_placement_group_name: Optional[str] = None,
resource_group_name: Optional[str] = None,
opts: Optional[pulumi.InvokeOptions] =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_proximity_placement_group_output(include_colocation_status: Optional[pulumi.Input[Optional[str]]] = None,\n proximity_placement_group_name: Optional[pulumi.Input[str]] = None,\n resource_group_name: Optional[pulumi.Input[str]] ... | [
"0.7122391",
"0.6447593",
"0.5987146",
"0.5548576",
"0.5290991",
"0.5241569",
"0.51601255",
"0.5140031",
"0.5072342",
"0.50679076",
"0.5049934",
"0.50372356",
"0.503405",
"0.4999213",
"0.49940577",
"0.49926674",
"0.49398476",
"0.49374238",
"0.4922861",
"0.49130318",
"0.491201... | 0.6372414 | 2 |
Retrieves information about a proximity placement group . | def get_proximity_placement_group_output(include_colocation_status: Optional[pulumi.Input[Optional[str]]] = None,
proximity_placement_group_name: Optional[pulumi.Input[str]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def proximity_placement_group_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"proximity_placement_group_id\")",
"def get_proximity_placement_group(include_colocation_status: Optional[str] = None,\n proximity_placement_group_name: Optional[str] = None,\... | [
"0.6448816",
"0.6372465",
"0.59885687",
"0.5547061",
"0.52896416",
"0.5240235",
"0.5159709",
"0.514106",
"0.50733167",
"0.50714",
"0.50509393",
"0.50364816",
"0.50350046",
"0.5000382",
"0.49950966",
"0.49934098",
"0.49427128",
"0.49386653",
"0.49252462",
"0.4914164",
"0.49125... | 0.71223414 | 0 |
This function constructs VGG_CNN_F and is based on | def VGG_CNN_F(arch_mode='full', weights='imagenet',
input_shape=(224, 224, 3), pooling=None, classes=1000):
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_vgg16(self):\n use_batch_norm = self.use_batch_norm\n\n imgs = tf.placeholder(tf.float32, [self.batch_size]+self.img_shape)\n is_train = tf.placeholder(tf.bool)\n\n conv1_1_feats = convolution(imgs, 3, 3, 64, 1, 1, 'conv1_1')\n conv1_1_feats = nonlinear(conv1_1_feats, '... | [
"0.7441737",
"0.7329161",
"0.6902189",
"0.6832145",
"0.6800463",
"0.6664944",
"0.66505325",
"0.6622111",
"0.66121346",
"0.6557664",
"0.6509413",
"0.6507075",
"0.6500263",
"0.6457403",
"0.6448143",
"0.64436185",
"0.63982594",
"0.63637847",
"0.6361868",
"0.6351918",
"0.63231635... | 0.679927 | 5 |
Return JSONserializable representation of the object. | def to_dict(self):
out = super().to_dict()
out["connections"] = self.connections
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serialize(self, obj):\n return json.dumps(obj)",
"def toJSON(self):\n return json.dumps(self, default=lambda o: o.__dict__)",
"def serialize(self):\n return json.dumps(self.as_dict())",
"def toJSON(cls, obj):\n return json.dumps(obj)",
"def serialize(self) -> str:\n r... | [
"0.8475618",
"0.84085596",
"0.83957154",
"0.838217",
"0.83239555",
"0.8288305",
"0.8275888",
"0.8227394",
"0.81710005",
"0.81556803",
"0.8117269",
"0.8117269",
"0.81065536",
"0.81065536",
"0.81065536",
"0.80988455",
"0.80659264",
"0.8029448",
"0.7999212",
"0.799741",
"0.79870... | 0.0 | -1 |
converts 1Dnumpy array to string readable py plotly.js | def numpy_to_plotlystring(numpy_array, precision=4):
np.set_printoptions(threshold=np.nan) # enables full printing
n_data = np.shape(numpy_array)[0]
# prevent array2string to cut string by ofsestting maximal width
max_line_width=n_data*(8) # Output Format [#.####, ...], thus 7 chars per entry, added 1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def np2str(a: np.ndarray) -> str:\n return json.dumps(a.tolist())",
"def z_as_plotly(self):\n xs = np.asarray(self.position)[:,2]\n return numpy_to_plotlystring(xs)",
"def x_as_plotly(self):\n xs = np.asarray(self.position)[:,0]\n return numpy_to_plotlystring(xs)",
"def y_as_pl... | [
"0.7462204",
"0.73186773",
"0.71991277",
"0.692029",
"0.65574473",
"0.6528165",
"0.64883965",
"0.64638263",
"0.64638263",
"0.63993347",
"0.6335",
"0.6298709",
"0.6124041",
"0.6007191",
"0.59757954",
"0.5960761",
"0.5929254",
"0.588368",
"0.58670706",
"0.58461416",
"0.5804916"... | 0.78322643 | 0 |
Right hand side of ODE | def rhs(self, q, m):
# Number of bodies
N = self.n_planets
# Empty np.arrays for computed data
dp = np.zeros_like(q)
for k in range(N):
dp_k = np.zeros(self.D)
for i in range(N):
if k != i:
qi_qk = q[i*self.D:(i+1)*self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ode(self, **kwargs):\n pass",
"def rightSideOfODE(self, Y, t):\n\t\ttemperature = Y[-1]\n\t\tamounts = Y[:-1]\n\t\tself.amounts = amounts\n\t\t# first get the species amount changes (as an array)\n\t\tdNdt = -1 * self.getMolarFluxes(temperature)\n\t\t# then get the temperature change, and append it to... | [
"0.75142777",
"0.7181643",
"0.69310933",
"0.6536001",
"0.646115",
"0.6173939",
"0.6170267",
"0.6157919",
"0.6156554",
"0.6128975",
"0.6113935",
"0.60999966",
"0.60107154",
"0.5988227",
"0.59345883",
"0.59310585",
"0.583424",
"0.5826762",
"0.5802471",
"0.5792491",
"0.578822",
... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.