version-control/the-stack-ds-lib-100k · Datasets at Hugging Face

repo_name stringlengths 6 130	hexsha list	file_path list	code list	apis list
ms440/bnlearn	[ "229b2bf05b6b6f2aa7dc96e6d55bf972cdbbfe52" ]	[ "bnlearn/helpers/network.py" ]	[ "\"\"\" This function has functionalities for network creation, clustering and plotting.\n\n\tG = network.to_graph(adjmat)\n\tlabx = network.cluster(G)\n\tfig = network.plot(G, labx)\n\n INPUT:\n adjmat: pd.DataFrame(): Edges are any values >0 between intersecting nodes.\n rows = features\n colums = samples\n OPTIONAL\n\n verbose: Integer [0..5] if verbose >= DEBUG: print('debug message')\n 0: (default)\n 1: ERROR\n 2: WARN\n 3: INFO\n 4: DEBUG\n \n\n OUTPUT\n\toutput\n\n DESCRIPTION\n This function has functionalities for network creation, clustering and plotting\n \n REQUIRES\n pip install python-louvain\n pip install --upgrade networkx\n \n\n\"\"\"\n\n#--------------------------------------------------------------------------\n# Name : network.py\n# Author : E.Taskesen\n# Contact : [email protected]\n# Date : July. 2019\n#--------------------------------------------------------------------------\n\n#%% Libraries\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport numpy as np\nimport community\nimport networkx as nx\nfrom sklearn.preprocessing import minmax_scale\nfrom sklearn.preprocessing import MinMaxScaler \nfrom ismember import ismember\nimport bnlearn.helpers.confmatrix as confmatrix\n\n#%% Make graph from adjacency matrix\ndef to_graph(adjmat, verbose=3):\n assert float(nx.__version__)>2, 'This function requires networkx to be v2 or higher. Try to: pip install --upgrade networkx'\n config = dict()\n config['verbose'] = verbose\n\n adjmat = is_DataFrame(adjmat)\n if config['verbose']>=3: print('[NETWORK.to_graph] Making graph')\n G=nx.from_pandas_adjacency(adjmat)\n\n return(G)\n\n#%% Convert Adjmat to graph (G) (also works with lower versions of networkx)\ndef adjmat2graph(adjmat):\n G = nx.DiGraph() # Directed graph\n # Convert adjmat to source target\n df_edges=adjmat.stack().reset_index()\n df_edges.columns=['source', 'target', 'weight']\n df_edges['weight']=df_edges['weight'].astype(float)\n \n # Add directed edge with weigth\n for i in range(df_edges.shape[0]):\n if df_edges['weight'].iloc[i]!=0:\n # Setup color\n if df_edges['weight'].iloc[i]==1:\n color='k'\n elif df_edges['weight'].iloc[i]>1:\n color='r'\n elif df_edges['weight'].iloc[i]<0:\n color='b'\n else:\n color='p'\n \n # Create edge in graph\n G.add_edge(df_edges['source'].iloc[i], df_edges['target'].iloc[i], weight=np.abs(df_edges['weight'].iloc[i]), color=color) \n # Return\n return(G)\n \n#%% Compute similarity matrix\ndef compute_centrality(G, centrality='betweenness', verbose=3):\n if verbose>=3: print('[NETWORK.compute_centrality] Computing centrality %s' %(centrality))\n \n if centrality=='betweenness':\n bb=nx.centrality.betweenness_centrality(G)\n elif centrality=='closeness':\n bb=nx.centrality.closeness_centrality(G)\n elif centrality=='eigenvector':\n bb=nx.centrality.eigenvector_centrality(G)\n elif centrality=='degree':\n bb=nx.centrality.degree_centrality(G)\n elif centrality=='edge':\n bb=nx.centrality.edge_betweenness(G)\n elif centrality=='harmonic':\n bb=nx.centrality.harmonic_centrality(G)\n elif centrality=='katz':\n bb=nx.centrality.katz_centrality(G)\n elif centrality=='local':\n bb=nx.centrality.local_reaching_centrality(G)\n elif centrality=='out_degree':\n bb=nx.centrality.out_degree_centrality(G)\n elif centrality=='percolation':\n bb=nx.centrality.percolation_centrality(G)\n elif centrality=='second_order':\n bb=nx.centrality.second_order_centrality(G)\n elif centrality=='subgraph':\n bb=nx.centrality.subgraph_centrality(G)\n elif centrality=='subgraph_exp':\n bb=nx.centrality.subgraph_centrality_exp(G)\n elif centrality=='information':\n bb=nx.centrality.information_centrality(G)\n else:\n print('[NETWORK] [ERROR] Centrality <%s> does not exist!' %(centrality))\n \n # Set the attributes\n score=np.array([bb.values()])\n nx.set_node_attributes(G, bb, centrality)\n \n return(G, score)\n\n#%% compute clusters\ndef cluster(G, verbose=3):\n if verbose>=3: print('[NETWORK.cluster] Clustering using best partition')\n # Partition\n partition=community.best_partition(G)\n # Set property to node\n nx.set_node_attributes(G, partition, 'clusterlabel')\n # Extract labels\n labx=[partition.get(node) for node in G.nodes()]\n labx=np.array(labx)\n \n return(G, labx)\n\n#%% Compute cluster comparison\ndef cluster_comparison_centralities(G, width=5, height=4, showfig=False, methodtype='default', verbose=3):\n config=dict()\n config['showfig']=showfig\n config['width']=width\n config['height']=height\n config['verbose']=verbose\n\n if verbose>=3: print('[NETWORK] Compute a dozen of centralities and clusterlabels')\n \n # compute labx for each of the centralities\n centralities=['betweenness', 'closeness','eigenvector','degree','edge','harmonic','katz','local','out_degree','percolation','second_order','subgraph','subgraph_exp','information']\n \n # Compute best positions for the network\n pos=nx.spring_layout(G)\n\n # Cluster data nd store label in G\n [G, score] = cluster(G)\n \n # Compute centrality score for each of the centralities and store in G\n for centrality in centralities:\n [G,score]=compute_centrality(G, centrality=centrality)\n \n # Store\n df=pd.DataFrame([G.nodes.values()])\n df.set_index(np.array([G.nodes.keys()]), inplace=True)\n \n # Make plots\n for centrality in centralities:\n if config['showfig']:\n plot(G, node_color=df['clusterlabel'], node_size=df[centrality], pos=pos, cmap='Set1', title=centrality, width=config['width'], height=config['height'], methodtype='default')\n \n return(G, df)\n\n#%% Make plot\ndef plot(G, node_color=None, node_label=None, node_size=100, node_size_scale=[25,200], alpha=0.8, font_size=18, cmap='Set1', width=40, height=30, pos=None, filename=None, title=None, methodtype='default', verbose=3):\n # https://networkx.github.io/documentation/networkx-1.7/reference/generated/networkx.drawing.nx_pylab.draw_networkx.html\n config=dict()\n config['filename']=filename\n config['width']=width\n config['height']=height\n config['verbose']=verbose\n config['node_size_scale']=node_size_scale\n \n if verbose>=3: print('[NETWORK] Creating network plot')\n \n if 'pandas' in str(type(node_size)):\n node_size=node_size.values\n \n #scaling node sizes\n if config['node_size_scale']!=None and 'numpy' in str(type(node_size)):\n if verbose>=3: print('[NETWORK] Scaling node sizes')\n node_size=minmax_scale(node_size, feature_range=(node_size_scale[0], node_size_scale[1]))\n\n # Node positions\n# if isinstance(pos, type(None)):\n# pos=nx.spring_layout(G)\n\n# if isinstance(node_label, type(None)):\n# node_label=[G.nodes])\n\n fig=plt.figure(figsize=(config['width'], config['height']))\n \n # Make the graph\n if methodtype=='circular':\n nx.draw_circular(G, labels=node_label, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size, with_labels=True)\n elif methodtype=='kawai':\n nx.draw_kamada_kawai(G, labels=node_label, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size, with_labels=True)\n else:\n nx.draw_networkx(G, labels=node_label, pos=pos, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size, with_labels=True)\n# nx.draw_networkx(G, pos=pos, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size)\n \n plt.title(title)\n plt.grid(True)\n plt.show()\n \n # Savefig\n if not isinstance(config['filename'], type(None)):\n if verbose>=3: print('[NETWORK.plot] Saving figure')\n plt.savefig(config['filename'])\n \n return(fig)\n\n#%% Normalize in good d3 range\ndef normalize_size(getsizes, minscale=0.1, maxscale=4):\n getsizes = MinMaxScaler(feature_range=(minscale,maxscale)).fit_transform(getsizes).flatten()\n return(getsizes)\n\n#%% Convert dataframe to Graph\ndef df2G(df_nodes, df_edges, verbose=3):\n # Put edge information in G\n# G = nx.from_pandas_edgelist(df_edges, 'source', 'target', ['weight', 'edge_weight','edge_width','source_label','target_label'])\n \n colnames=list(df_edges.columns.values[~np.isin(df_edges.columns.values,['source','target'])])\n G = nx.from_pandas_edgelist(df_edges, 'source', 'target', colnames)\n\n # Put node info in G\n getnodes=[G.nodes]\n for col in df_nodes.columns:\n for i in range(0, df_nodes.shape[0]):\n if np.any(np.isin(getnodes, df_nodes.index.values[i])):\n G.nodes[df_nodes.index.values[i]][col] = str(df_nodes[col].iloc[i])\n \n return(G)\n \n#%% Convert Graph to dataframe\ndef G2df(G, node_color=None, node_label=None, node_size=100, edge_distance_minmax=[1,100], verbose=3):\n # Nodes\n df_node_names=pd.DataFrame([G.nodes], columns=['node_name'])\n df_node_props=pd.DataFrame([G.nodes.values()])\n df_nodes=pd.concat([df_node_names, df_node_props], axis=1)\n\n if not np.any(df_nodes.columns=='node_color'):\n df_nodes['node_color']='#000080'\n if not np.any(df_nodes.columns=='node_color_edge'):\n df_nodes['node_color_edge']='#000000'\n if not np.any(df_nodes.columns=='node_size_edge'):\n df_nodes['node_size_edge']=1\n if not isinstance(node_label, type(None)):\n df_nodes['node_label']=node_label\n \n if np.any(df_nodes.columns=='node_size'):\n df_nodes['node_size']=normalize_size(df_nodes['node_size'].values.reshape(-1,1), 1, 10)\n else:\n df_nodes['node_size']=10\n\n # Edges\n df_edge_links=pd.DataFrame([G.edges], columns=['source_label','target_label'])\n df_edge_props=pd.DataFrame([*G.edges.values()])\n df_edges=pd.concat([df_edge_links, df_edge_props], axis=1)\n \n # Source and target values\n df_nodes['index_value']=None\n df_edges['source']=None\n df_edges['target']=None\n# uinodes=np.unique(np.append(df_edges['source_label'], df_edges['target_label']))\n uinodes=np.unique(df_nodes['node_name'])\n for i in range(0,len(uinodes)):\n I=(uinodes[i]==df_edges['source_label'])\n df_edges['source'].loc[I]=i\n I=(uinodes[i]==df_edges['target_label'])\n df_edges['target'].loc[I]=i\n \n I=df_nodes['node_name']==uinodes[i]\n df_nodes['index_value'].loc[I]=i\n \n df_nodes.set_index(df_nodes['index_value'], inplace=True)\n del df_nodes['index_value']\n \n # Include width and weights\n if not np.any(df_edges.columns=='edge_weight') and np.any(df_edges.columns=='weight'):\n df_edges['edge_weight']=normalize_size(df_edges['weight'].values.reshape(-1,1), edge_distance_minmax[0], edge_distance_minmax[1])\n else:\n df_edges['edge_weight']=2\n if not np.any(df_edges.columns=='edge_width'):\n df_edges['edge_width']=2\n if not np.any(df_edges.columns=='weight'):\n df_edges['weight']=2\n\n # Remove self-loops\n I=df_edges['source']!=df_edges['target']\n df_edges=df_edges.loc[I,:].reset_index(drop=True)\n\n return(df_nodes, df_edges)\n\n#%% Make plot\ndef bokeh(G, node_color=None, node_label=None, node_size=100, node_size_scale=[25,200], alpha=0.8, font_size=18, cmap='Set1', width=40, height=30, pos=None, filename=None, title=None, methodtype='default', verbose=3):\n import networkx as nx\n from bokeh.io import show, output_file\n from bokeh.models import Plot, Range1d, MultiLine, Circle, HoverTool, BoxZoomTool, ResetTool\n from bokeh.models.graphs import from_networkx\n from bokeh.palettes import Spectral4\n \n SAME_CLUB_COLOR, DIFFERENT_CLUB_COLOR = \"black\", \"red\"\n edge_attrs = {}\n \n for start_node, end_node, _ in G.edges(data=True):\n edge_color = SAME_CLUB_COLOR if G.nodes[start_node][\"club\"] == G.nodes[end_node][\"club\"] else DIFFERENT_CLUB_COLOR\n edge_attrs[(start_node, end_node)] = edge_color\n \n nx.set_edge_attributes(G, edge_attrs, \"edge_color\")\n \n # Show with Bokeh\n plot = Plot(plot_width=400, plot_height=400,\n x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))\n plot.title.text = \"Graph Interaction Demonstration\"\n \n node_hover_tool = HoverTool(tooltips=[(\"index\", \"@index\"), (\"club\", \"@club\")])\n plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool())\n \n graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))\n \n graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])\n graph_renderer.edge_renderer.glyph = MultiLine(line_color=\"edge_color\", line_alpha=0.8, line_width=1)\n plot.renderers.append(graph_renderer)\n \n output_file(\"interactive_graphs.html\")\n show(plot)\n\n#%% Comparison of two networks\ndef compare_networks(adjmat_true, adjmat_pred, pos=None, showfig=True, width=15, height=8, verbose=3):\n # Make sure columns and indices to match\n [IArow,IBrow]=ismember(adjmat_true.index.values, adjmat_pred.index.values)\n [IAcol,IBcol]=ismember(adjmat_true.columns.values, adjmat_pred.columns.values)\n adjmat_true = adjmat_true.loc[IArow,IAcol]\n adjmat_pred = adjmat_pred.iloc[IBrow,IBcol]\n \n # Make sure it is boolean adjmat\n adjmat_true = adjmat_true>0\n adjmat_pred = adjmat_pred>0\n\n # Check whether order is correct\n assert np.all(adjmat_true.columns.values==adjmat_pred.columns.values), 'Column order of both input values could not be matched'\n assert np.all(adjmat_true.index.values==adjmat_pred.index.values), 'Row order of both input values could not be matched'\n \n # Get edges\n y_true = adjmat_true.stack().reset_index()[0].values\n y_pred = adjmat_pred.stack().reset_index()[0].values\n \n # Confusion matrix\n scores=confmatrix.twoclass(y_true, y_pred, threshold=0.5, classnames=['Disconnected','Connected'], title='', cmap=plt.cm.Blues, showfig=1, verbose=0)\n #bayes.plot(out_bayes['adjmat'], pos=G['pos'])\n \n # Setup graph\n adjmat_diff = adjmat_true.astype(int)\n adjmat_diff[(adjmat_true.astype(int) - adjmat_pred.astype(int))<0]=2\n adjmat_diff[(adjmat_true.astype(int) - adjmat_pred.astype(int))>0]=-1\n \n if showfig:\n # Setup graph\n # G_true = adjmat2graph(adjmat_true)\n G_diff = adjmat2graph(adjmat_diff)\n # Graph layout\n pos = graphlayout(G_diff, pos=pos, scale=1, layout='fruchterman_reingold')\n # Bootup figure\n plt.figure(figsize=(width,height))\n # nodes\n nx.draw_networkx_nodes(G_diff, pos, node_size=700)\n # edges\n colors = [G_diff[u][v]['color'] for u,v in G_diff.edges()]\n #weights = [G_diff[u][v]['weight'] for u,v in G_diff.edges()]\n nx.draw_networkx_edges(G_diff, pos, arrowstyle='->', edge_color=colors, width=1)\n # Labels\n nx.draw_networkx_labels(G_diff, pos, font_size=20, font_family='sans-serif')\n # Get labels of weights\n #labels = nx.get_edge_attributes(G,'weight')\n # Plot weights\n nx.draw_networkx_edge_labels(G_diff, pos, edge_labels=nx.get_edge_attributes(G_diff,'weight'))\n # Making figure nice\n #plt.legend(['Nodes','TN','FP','test'])\n ax = plt.gca()\n ax.set_axis_off()\n plt.show()\n \n # Return\n return(scores, adjmat_diff)\n\n#%% Make graph layout\ndef graphlayout(model, pos, scale=1, layout='fruchterman_reingold', verbose=3):\n if isinstance(pos, type(None)):\n if layout=='fruchterman_reingold':\n pos = nx.fruchterman_reingold_layout(model, scale=scale, iterations=50)\n else:\n pos = nx.spring_layout(model, scale=scale, iterations=50)\n else:\n if verbose>=3: print('[NETWORK.graphlayout] Existing coordinates from <pos> are used.')\n\n return(pos)\n\n#%% Convert to pandas dataframe\ndef is_DataFrame(data, verbose=0):\n if isinstance(data, list):\n data=pd.DataFrame(data)\n elif isinstance(data, np.ndarray):\n data=pd.DataFrame(data)\n elif isinstance(data, pd.DataFrame):\n pass\n else:\n print('Typing should be pd.DataFrame()!')\n data=None\n \n return(data)\n" ]	[ [ "numpy.isin", "matplotlib.pyplot.gca", "pandas.concat", "numpy.abs", "matplotlib.pyplot.title", "numpy.unique", "pandas.DataFrame", "matplotlib.pyplot.savefig", "numpy.all", "numpy.any", "matplotlib.pyplot.grid", "sklearn.preprocessing.MinMaxScaler", "numpy.array", "sklearn.preprocessing.minmax_scale", "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ] ]
Vpatrik/mech_ros	[ "3119908b25b2c86756c1d88e9da2d60cb426e1cc" ]	[ "src/Compare_Aruco_board_marker_detection.py" ]	[ "#!/usr/bin/env python\n\n# Patrik Vavra 2019\n\n\"\"\"\nCompares estimated pose of ArUco marker and ChArUco board, computes statistical data\nand write them to csv file.\n\"\"\"\n\n\nimport numpy as np\n# import cv2\nimport yaml\n# import time\nimport rospy\nimport cv2\nimport math\nimport csv\n\n\nfrom geometry_msgs.msg import PoseWithCovarianceStamped\nfrom mech_ros_msgs.msg import MarkerList\nfrom mech_ros_msgs.msg import Marker\n\nfilename = \"/home/patrik/catkin_ws/src/mech_ros/localization/Data_natoceni.csv\"\n\n\n# Static transformation from board to marker\nx_tr = 0\ny_tr = 0\nz_tr = 0\n\n## Generate dictionary\ndictionary = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_5X5_50)\ndictionary_b = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_50)\n# dictionary_b = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)\nboard = cv2.aruco.CharucoBoard_create(4,3,0.0633,0.0475,dictionary_b)# Doma\n# board = cv2.aruco.CharucoBoard_create(8,5,.034566,.01725,dictionary_b)\n# board = cv2.aruco.CharucoBoard_create(3,2,0.0895,0.0714,dictionary_b) # mechlab\n\n# Define topics\nmarker_detector_topic = \"/markers\"\nboard_detector_topic = \"/board\"\nframe_id = \"/camera\"\n\n# Define calibration filename\ncalibration_file = \"/home/patrik/catkin_ws/src/mech_ros/Config_ARuco/camera.yaml\"\n\nmarkerLength = 0.088\n\n\n## Define Aruco Detector Params\narucoParams = cv2.aruco.DetectorParameters_create()\n\narucoParams.adaptiveThreshConstant = 7\narucoParams.adaptiveThreshWinSizeMax = 35 # default 23\narucoParams.adaptiveThreshWinSizeMin = 3 # default 3\narucoParams.adaptiveThreshWinSizeStep = 8 # default 10\n\narucoParams.cornerRefinementMethod = 1\narucoParams.cornerRefinementMaxIterations = 30\narucoParams.cornerRefinementMinAccuracy = 0.01\narucoParams.cornerRefinementWinSize = 5\n\narucoParams.errorCorrectionRate = 0.6\narucoParams.minCornerDistanceRate = 0.05 # min distance between marker corners,\n# min. distance[pix] = PerimeterminCornerDistanceRate\narucoParams.minMarkerDistanceRate = 0.05 # min distance between corners of different markers,\n# min. distance[pix] = Perimeter(smaller one)minMarkerDistanceRate\narucoParams.minMarkerPerimeterRate = 0.1 # min_mark_perim[pix]= max. dimension of image [pix]minMark-per-Rate\narucoParams.maxMarkerPerimeterRate = 4.0\narucoParams.minOtsuStdDev = 5.0\narucoParams.perspectiveRemoveIgnoredMarginPerCell = 0.13\narucoParams.perspectiveRemovePixelPerCell = 8\narucoParams.polygonalApproxAccuracyRate = 0.01\narucoParams.markerBorderBits = 1\narucoParams.maxErroneousBitsInBorderRate = 0.04\narucoParams.minDistanceToBorder = 3\n\n\n## Define Aruco board Detector Params\narucoParams_b = cv2.aruco.DetectorParameters_create()\narucoParams_b.adaptiveThreshConstant = 7\narucoParams_b.adaptiveThreshWinSizeMax = 45 # default 23\narucoParams_b.adaptiveThreshWinSizeMin = 3 # default 3\narucoParams_b.adaptiveThreshWinSizeStep = 7 # default 10\narucoParams_b.cornerRefinementMethod = 0\n# arucoParams_b.errorCorrectionRate = 0.6\n# arucoParams_b.minOtsuStdDev = 5.0\n# arucoParams_b.perspectiveRemoveIgnoredMarginPerCell = 0.13\n# arucoParams_b.perspectiveRemovePixelPerCell = 8\n# arucoParams_b.polygonalApproxAccuracyRate = 0.01\narucoParams_b.markerBorderBits = 1\n# arucoParams_b.maxErroneousBitsInBorderRate = 0.04\n# arucoParams_b.minDistanceToBorder = 3\n\n\n\n## Initialization\nmarkerIds = np.array([])\nmarkerCorners = np.array([])\nrejectedImgPoints = np.array([])\naxis = np.float32([[markerLength/2,markerLength/2,0], [-markerLength/2,markerLength/2,0], [-markerLength/2,-markerLength/2,0], [markerLength/2,-markerLength/2,0],\n [markerLength/2,markerLength/2,markerLength],[-markerLength/2,markerLength/2,markerLength],[-markerLength/2,-markerLength/2,markerLength],[markerLength/2,-markerLength/2,markerLength] ])\n\n## Initialization for statistics\nmarker_pose = np.zeros((50,3))\nboard_pose = np.zeros((50,3))\npose_difference = np.zeros((50,3))\nsurface_matrix = np.zeros((50,2))\n\n\n# Matrix for conversion from ROS frame to OpenCV in camera\nR_ROS_O_camera = np.array([[ 0.0, 0.0, 1.0],\n [ -1.0, 0.0, 0.0],\n [ 0.0, -1.0, 0.0]])\n\n # Matrix for conversion from OpenCV frame to ROS in marker\nR_O_ROS_marker = np.array([[ 0.0, 1.0, 0.0],\n [ 0.0, 0.0, 1.0],\n [ 1.0, 0.0, 0.0]])\n\n\n## Load coefficients\ndef load_coefficient(calibration_file):\n with open(calibration_file) as stream:\n try:\n data_loaded = yaml.load(stream)\n c_matrix = np.array(data_loaded[\"camera_matrix\"][\"data\"]).reshape((3,3))\n dist_coeff = np.array(data_loaded[\"distortion_coefficients\"][\"data\"])\n return c_matrix, dist_coeff\n except yaml.YAMLError as exc:\n print(exc)\n # with np.load('/home/patrik/catkin_ws/src/mech_ros/map/camCal2.npz') as X:\n # c_matrix, dist_coeff, _, _ = [X[i] for i in ('mtx', 'dist', 'rvecs', 'tvecs')]\n # return c_matrix, dist_coeff\n\n\n\n_FLOAT_EPS_4 = np.finfo(float).eps 4.0\n\ndef rotationMatrixToEulerAngles(M, cy_thresh=None):\n # cy_thresh : None or scalar, optional\n # threshold below which to give up on straightforward arctan for\n # estimating x rotation. If None (default), estimate from\n # precision of input. Source : http://www.graphicsgems.org/\n\n if cy_thresh is None:\n try:\n cy_thresh = np.finfo(M.dtype).eps * 4\n except ValueError:\n cy_thresh = _FLOAT_EPS_4\n r11, r12, r13, r21, r22, r23, r31, r32, r33 = M.flat\n # cy: sqrt((cos(y)cos(z))2 + (cos(x)cos(y))*2)\n cy = math.sqrt(r33r33 + r23r23)\n if cy > cy_thresh: # cos(y) not close to zero, standard form\n z = math.atan2(-r12, r11) # atan2(cos(y)sin(z), cos(y)cos(z))\n y = math.atan2(r13, cy) # atan2(sin(y), cy)\n x = math.atan2(-r23, r33) # atan2(cos(y)sin(x), cos(x)cos(y))\n else: # cos(y) (close to) zero, so x -> 0.0 (see above)\n # so r21 -> sin(z), r22 -> cos(z) and\n z = math.atan2(r21, r22)\n y = math.atan2(r13, cy) # atan2(sin(y), cy)\n x = 0.0\n return [x, y, z]\n\n\ndef rotationToQuaternion(M):\n trace = M[0,0] + M[1,1] + M[2,2]\n q = [0,0,0,0]\n if trace>0:\n s = math.sqrt(trace+1.0) \n q[3] = s0.5\n s = 0.5/s\n q[0] = (M[2,1]-M[1,2])s\n q[1] = (M[0,2]-M[2,0])s\n q[2] = (M[1,0]-M[0,1])s\n\n else:\n if M[0,0] < M[1,1]:\n if M[1,1] < M[2,2]:\n i = 2\n else:\n i = 1\n else:\n if M[0,0] < M[2,2]:\n i = 2\n else:\n i = 0\n j = (i+1)%3\n k = (i+1)%3\n s = math.sqrt(M[i,i] - M[j,j] - M[k,k] +1.0)\n q[i] = s0.5\n s = 0.5/s\n q[3] = (M[k,j] - M[j,k])s\n q[j] = (M[j,i] - M[i,j])s\n q[k] = (M[k,i] - M[i,k])s\n \n return q\n\ndef draw(img, corners, imgpts):\n imgpts = np.int32(imgpts).reshape(-1,2)\n # draw ground floor in green\n# img = cv2.drawContours(img, [imgpts[:4]],-1,(0,255,0),-3)\n # draw pillars in blue color\n for i,j in zip(range(4),range(4,8)):\n img = cv2.line(img, tuple(imgpts[i]), tuple(imgpts[j]),(255),3)\n # draw top layer in red color\n img = cv2.drawContours(img, [imgpts[4:]],-1,(0,0,255),3)\n return img\n\n\n\n# i = 0\n# time_last = time.time()\n\n############### Capture stream ###############\n\n######## UDP ####################\n#pipe = \"udpsrc port=5777 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! appsink sync=false\"\n\n########## TCP ################\ndef aruco_detect(camera_matrix, dist_coeff):\n cap = cv2.VideoCapture('tcpclientsrc host=mechros1.local port=8080 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! appsink sync=false', cv2.CAP_GSTREAMER)\n # cap = cv2.VideoCapture(0)\n # pipe = 'tcp://10.42.0.85:5001'\n # cap = cv2.VideoCapture(pipe)\n\n\n # cap.set(cv2.CAP_PROP_AUTOFOCUS,0)\n cap.set(cv2.CAP_PROP_FOCUS,0)\n cap.set(cv2.CAP_PROP_FRAME_WIDTH,1280)\n cap.set(cv2.CAP_PROP_FRAME_HEIGHT,720)\n # cap.set(cv2.CAP_PROP_BUFFERSIZE,3)\n # cap.set(cv2.CAP_PROP_SETTINGS,0)\n # cap.set(cv2.CAP_PROP_FOURCC =\n\n k=0\n flag_started = False\n\n while(cap.isOpened()) and not(rospy.is_shutdown()):\n ret, frame = cap.read()\n # frame = cv2.flip(frame,0)\n time = rospy.Time.now()\n marker_yaw = None\n ret_b = 0\n\n if ret==True:\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n markerCorners,markerIds,_ = cv2.aruco.detectMarkers(gray,dictionary,parameters = arucoParams, cameraMatrix = camera_matrix,\n distCoeff = dist_coeff )\n\n markerCorners_b,markerIds_b,_ = cv2.aruco.detectMarkers(gray,dictionary_b,parameters = arucoParams_b, cameraMatrix = camera_matrix,\n distCoeff = dist_coeff )\n\n\n if len(markerCorners) > 0:\n rvec, tvec, _objPoints = cv2.aruco.estimatePoseSingleMarkers(markerCorners, markerLength, camera_matrix, dist_coeff) # For a single marker\n cv2.aruco.drawDetectedMarkers(frame,markerCorners, markerIds)\n aruco_MarkerList = MarkerList()\n aruco_MarkerList.header.stamp = time\n aruco_MarkerList.header.frame_id = frame_id\n\n\n for i in range(markerIds.size):\n frame = cv2.aruco.drawAxis(frame, camera_matrix, dist_coeff, rvec[i], tvec[i], 0.1)\n imgpts, jac = cv2.projectPoints(axis, rvec[i], tvec[i], camera_matrix, dist_coeff)\n frame = draw(frame, markerCorners[i], imgpts)\n\n # Calculate surface area in pixels\n surface = cv2.contourArea(markerCorners[i], False)\n \n # Fill MarkerList with each marker\n aruco_Marker = Marker()\n aruco_Marker.id = str(markerIds[i,0])\n aruco_Marker.surface = surface\n\n # Prevedeni rodrigues vectoru na rotacni matici\n Rmat = np.zeros(shape=(3,3))\n cv2.Rodrigues(rvec[i,0],Rmat)\n\n # Convert from Opencv frame to ROS frame in camera\n R = np.dot(R_ROS_O_camera, Rmat)\n\n # Convert inverted matrix from Opencv frame to ROS frame in marker\n R = np.dot(R, R_O_ROS_marker)\n\n # Convert from Rotation matrix to Euler angles\n Euler = rotationMatrixToEulerAngles(R.T) # rotace z markeru do kamery\n\n # Fill Marker orientation vector\n aruco_Marker.pose.orientation.r = Euler[0]\n aruco_Marker.pose.orientation.p = Euler[1]\n aruco_Marker.pose.orientation.y = Euler[2]\n marker_yaw = Euler[2]\n\n # Coordinate vector of camera position from marker in camera coordinate frame\n aruco_Marker.pose.position.x = -tvec[i,0,2]\n aruco_Marker.pose.position.y = tvec[i,0,0]\n aruco_Marker.pose.position.z = tvec[i,0,1]\n # For comparsion with board\n marker_x = -tvec[i,0,2]\n marker_y = tvec[i,0,0]\n ## For compatibility with gazebo\n aruco_Marker.header.stamp = time\n\n # All coordinates are in marker frame\n aruco_MarkerList.markers.append(aruco_Marker)\n\n marker_publisher.publish(aruco_MarkerList)\n\n\n if len(markerCorners_b) > 0:\n ret, ch_corners, ch_ids = cv2.aruco.interpolateCornersCharuco(markerCorners_b, markerIds_b, gray, board,camera_matrix, dist_coeff)\n cv2.aruco.drawDetectedMarkers(frame,markerCorners_b, markerIds_b)\n if ret > 3:\n ret_b, rvec, tvec = cv2.aruco.estimatePoseCharucoBoard(ch_corners, ch_ids, board, camera_matrix, dist_coeff) # For a single marker\n \n if ret_b:\n # cv2.aruco.drawDetectedMarkers(frame,markerCorners_b, markerIds_b)\n aruco_MarkerList_b = MarkerList()\n aruco_MarkerList_b.header.stamp = time\n aruco_MarkerList_b.header.frame_id = frame_id\n\n # cv2.aruco.drawAxis(frame, camera_matrix, dist_coeff, rvec[i], tvec[i], 0.1)\n # imgpts, jac = cv2.projectPoints(axis, rvec[i], tvec[i], camera_matrix, dist_coeff)\n # frame = draw(frame, markerCorners[i], imgpts)\n\n # Fill MarkerList with each marker\n aruco_Marker_b = Marker()\n # aruco_Marker.id = str(markerIds[0][0])\n # aruco_Marker.surface = surface\n\n # Prevedeni rodrigues vectoru na rotacni matici\n Rmat = np.zeros(shape=(3,3))\n cv2.Rodrigues(rvec,Rmat)\n\n\n\n # Convert from Opencv frame to ROS frame in camera\n R = np.dot(R_ROS_O_camera, Rmat)\n\n # Convert inverted matrix from Opencv frame to ROS frame in marker\n R = np.dot(R, R_O_ROS_marker)\n\n # Convert from Rotation matrix to Euler angles\n Euler_b = rotationMatrixToEulerAngles(R.T) # rotace z markeru do kamery\n\n \n # Fill Marker orientation vector\n aruco_Marker_b.pose.orientation.y = Euler_b[2]\n aruco_Marker_b.pose.orientation.r = Euler_b[0]\n aruco_Marker_b.pose.orientation.p = Euler_b[1]\n\n surface = cv2.contourArea(ch_corners, False)\n aruco_Marker_b.surface = surface\n\n # Coordinate vector of camera position from marker in camera coordinate frame\n aruco_Marker_b.pose.position.x = -tvec[2]\n aruco_Marker_b.pose.position.y = tvec[0]\n aruco_Marker_b.pose.position.z = tvec[1]\n\n ## For compatibility with gazebo\n aruco_Marker_b.header.stamp = time\n\n # All coordinates are in marker frame\n aruco_MarkerList_b.markers.append(aruco_Marker_b)\n\n board_publisher.publish(aruco_MarkerList_b)\n\n key = cv2.waitKey(1) & 0xFF\n if key == ord('s'):\n flag_started = True\n rospy.loginfo(\"Measurement started!\")\n\n if k < 50 and flag_started:\n if len(markerCorners_b) > 0 and ret_b > 0:\n yaw_m = Euler[2] % (2math.pi)\n yaw_b = Euler_b[2] % (2math.pi)\n\n marker_pose[k,:] = aruco_Marker.pose.position.x,aruco_Marker.pose.position.y, yaw_m\n board_pose[k,:] = aruco_Marker_b.pose.position.x,aruco_Marker_b.pose.position.y, yaw_b\n surface_matrix[k,:] = aruco_Marker.surface, aruco_Marker_b.surface\n k +=1\n\n elif k >= 50 and flag_started:\n k = 0\n flag_started = False\n\n avg_pose_m = np.mean(marker_pose, axis= 0)\n avg_pose_b = np.mean(board_pose, axis= 0)\n avg_surface = np.mean(surface_matrix,axis=0)\n pose_difference = marker_pose - avg_pose_b\n measur_cov = np.cov(marker_pose,y = None, rowvar=False)\n # diff_cov = np.cov(pose_difference,y = None, rowvar=False)\n err_cov = np.sum(pose_differencepose_difference, axis=0)/50\n\n \n\n # Write to file\n # x_m, y_m, Yaw_m, x_b, y_b, Yaw_b, var_meas_x, var_meas_y, var_meas_Yaw, var_err_x, var_err_y, var_err_Yaw\n row = [avg_surface[0], avg_surface[1], avg_pose_m[0],avg_pose_m[1], avg_pose_m[2],avg_pose_b[0],avg_pose_b[1], avg_pose_b[2],\n measur_cov[0,0],measur_cov[1,1], measur_cov[2,2], err_cov[0], err_cov[1], err_cov[2]]\n\n with open(filename, 'a') as csvFile:\n writer = csv.writer(csvFile)\n writer.writerow(row)\n csvFile.close()\n\n rospy.loginfo(\"Measurement ended!\") \n\n # frame = cv2.flip(frame,0)\t\n cv2.imshow('frame',frame)\n if key == ord('q'):\n break\n\n # rospy.spin()\n\n # rospy.spin()\n\n csvFile.close()\n cap.release()\n #out.release()\n cv2.destroyAllWindows()\n\n\nif __name__ == '__main__':\n rospy.init_node('aruco_detect', anonymous=True)\n marker_publisher = rospy.Publisher(marker_detector_topic, MarkerList,queue_size=10)\n board_publisher = rospy.Publisher(board_detector_topic, MarkerList,queue_size=10)\n camera_matrix, dist_coeff = load_coefficient(calibration_file)\n aruco_detect(camera_matrix,dist_coeff)\n # rospy.spin()" ]	[ [ "numpy.dot", "numpy.int32", "numpy.finfo", "numpy.cov", "numpy.mean", "numpy.float32", "numpy.array", "numpy.zeros", "numpy.sum" ] ]
farizrahman4u/AdelaiDet	[ "156e60bb0a5dde4aa6e29ebd3623834c5d32b3c1" ]	[ "adet/evaluation/text_evaluation.py" ]	[ "import contextlib\nimport copy\nimport io\nimport itertools\nimport json\nimport logging\nimport numpy as np\nimport os\nimport re\nimport torch\nfrom collections import OrderedDict\n# from fvcore.common.file_io import PathManager\n# from detectron2.utils.file_io import PathManager\nfrom adet.utils.file_io import PathManager\nfrom pycocotools.coco import COCO\n\nfrom detectron2.utils import comm\nfrom detectron2.data import MetadataCatalog\nfrom detectron2.evaluation.evaluator import DatasetEvaluator\n\nimport glob\nimport shutil\nfrom shapely.geometry import Polygon, LinearRing\nfrom adet.evaluation import text_eval_script\nimport zipfile\n\n\nclass TextEvaluator(DatasetEvaluator):\n \"\"\"\n Evaluate text proposals and recognition.\n \"\"\"\n\n def __init__(self, dataset_name, cfg, distributed, output_dir=None):\n self._tasks = (\"polygon\", \"recognition\")\n self._distributed = distributed\n self._output_dir = output_dir\n\n self._cpu_device = torch.device(\"cpu\")\n self._logger = logging.getLogger(__name__)\n\n self._metadata = MetadataCatalog.get(dataset_name)\n if not hasattr(self._metadata, \"json_file\"):\n raise AttributeError(\n f\"json_file was not found in MetaDataCatalog for '{dataset_name}'.\"\n )\n\n json_file = PathManager.get_local_path(self._metadata.json_file)\n with contextlib.redirect_stdout(io.StringIO()):\n self._coco_api = COCO(json_file)\n\n # use dataset_name to decide eval_gt_path\n if \"totaltext\" in dataset_name:\n self._text_eval_gt_path = \"datasets/evaluation/gt_totaltext.zip\"\n self._word_spotting = True\n elif \"ctw1500\" in dataset_name:\n self._text_eval_gt_path = \"datasets/evaluation/gt_ctw1500.zip\"\n self._word_spotting = False\n self._text_eval_confidence = cfg.MODEL.FCOS.INFERENCE_TH_TEST\n\n def reset(self):\n self._predictions = []\n\n def process(self, inputs, outputs):\n for input, output in zip(inputs, outputs):\n prediction = {\"image_id\": input[\"image_id\"]}\n\n instances = output[\"instances\"].to(self._cpu_device)\n prediction[\"instances\"] = instances_to_coco_json(instances, input[\"image_id\"])\n self._predictions.append(prediction)\n\n def to_eval_format(self, file_path, temp_dir=\"temp_det_results\", cf_th=0.5):\n def fis_ascii(s):\n a = (ord(c) < 128 for c in s)\n return all(a)\n\n def de_ascii(s):\n a = [c for c in s if ord(c) < 128]\n outa = ''\n for i in a:\n outa +=i\n return outa\n\n with open(file_path, 'r') as f:\n data = json.load(f)\n with open('temp_all_det_cors.txt', 'w') as f2:\n for ix in range(len(data)):\n if data[ix]['score'] > 0.1:\n outstr = '{}: '.format(data[ix]['image_id'])\n xmin = 1000000\n ymin = 1000000\n xmax = 0 \n ymax = 0\n for i in range(len(data[ix]['polys'])):\n outstr = outstr + str(int(data[ix]['polys'][i][0])) +','+str(int(data[ix]['polys'][i][1])) +','\n ass = de_ascii(data[ix]['rec'])\n if len(ass)>=0: # \n outstr = outstr + str(round(data[ix]['score'], 3)) +',####'+ass+'\\n'\t\n f2.writelines(outstr)\n f2.close()\n dirn = temp_dir\n lsc = [cf_th] \n fres = open('temp_all_det_cors.txt', 'r').readlines()\n for isc in lsc:\t\n if not os.path.isdir(dirn):\n os.mkdir(dirn)\n\n for line in fres:\n line = line.strip()\n s = line.split(': ')\n filename = '{:07d}.txt'.format(int(s[0]))\n outName = os.path.join(dirn, filename)\n with open(outName, 'a') as fout:\n ptr = s[1].strip().split(',####')\n score = ptr[0].split(',')[-1]\n if float(score) < isc:\n continue\n cors = ','.join(e for e in ptr[0].split(',')[:-1])\n fout.writelines(cors+',####'+ptr[1]+'\\n')\n os.remove(\"temp_all_det_cors.txt\")\n\n def sort_detection(self, temp_dir):\n origin_file = temp_dir\n output_file = \"final_\"+temp_dir\n\n if not os.path.isdir(output_file):\n os.mkdir(output_file)\n\n files = glob.glob(origin_file+'.txt')\n files.sort()\n\n for i in files:\n out = i.replace(origin_file, output_file)\n fin = open(i, 'r').readlines()\n fout = open(out, 'w')\n for iline, line in enumerate(fin):\n ptr = line.strip().split(',####')\n rec = ptr[1]\n cors = ptr[0].split(',')\n assert(len(cors) %2 == 0), 'cors invalid.'\n pts = [(int(cors[j]), int(cors[j+1])) for j in range(0,len(cors),2)]\n try:\n pgt = Polygon(pts)\n except Exception as e:\n print(e)\n print('An invalid detection in {} line {} is removed ... '.format(i, iline))\n continue\n \n if not pgt.is_valid:\n print('An invalid detection in {} line {} is removed ... '.format(i, iline))\n continue\n \n pRing = LinearRing(pts)\n if pRing.is_ccw:\n pts.reverse()\n outstr = ''\n for ipt in pts[:-1]:\n outstr += (str(int(ipt[0]))+','+ str(int(ipt[1]))+',')\n outstr += (str(int(pts[-1][0]))+','+ str(int(pts[-1][1])))\n outstr = outstr+',####' + rec\n fout.writelines(outstr+'\\n')\n fout.close()\n os.chdir(output_file)\n\n def zipdir(path, ziph):\n # ziph is zipfile handle\n for root, dirs, files in os.walk(path):\n for file in files:\n ziph.write(os.path.join(root, file))\n\n zipf = zipfile.ZipFile('../det.zip', 'w', zipfile.ZIP_DEFLATED)\n zipdir('./', zipf)\n zipf.close()\n os.chdir(\"../\")\n # clean temp files\n shutil.rmtree(origin_file)\n shutil.rmtree(output_file)\n return \"det.zip\"\n \n def evaluate_with_official_code(self, result_path, gt_path):\n return text_eval_script.text_eval_main(det_file=result_path, gt_file=gt_path, is_word_spotting=self._word_spotting)\n\n def evaluate(self):\n if self._distributed:\n comm.synchronize()\n predictions = comm.gather(self._predictions, dst=0)\n predictions = list(itertools.chain(predictions))\n\n if not comm.is_main_process():\n return {}\n else:\n predictions = self._predictions\n\n if len(predictions) == 0:\n self._logger.warning(\"[COCOEvaluator] Did not receive valid predictions.\")\n return {}\n\n coco_results = list(itertools.chain([x[\"instances\"] for x in predictions]))\n PathManager.mkdirs(self._output_dir)\n\n file_path = os.path.join(self._output_dir, \"text_results.json\")\n self._logger.info(\"Saving results to {}\".format(file_path))\n with PathManager.open(file_path, \"w\") as f:\n f.write(json.dumps(coco_results))\n f.flush()\n\n self._results = OrderedDict()\n \n # eval text\n temp_dir = \"temp_det_results/\"\n self.to_eval_format(file_path, temp_dir, self._text_eval_confidence)\n result_path = self.sort_detection(temp_dir)\n text_result = self.evaluate_with_official_code(result_path, self._text_eval_gt_path)\n os.remove(result_path)\n\n # parse\n template = \"(\\S+): (\\S+): (\\S+), (\\S+): (\\S+), (\\S+): (\\S+)\"\n for task in (\"e2e_method\", \"det_only_method\"):\n result = text_result[task]\n groups = re.match(template, result).groups()\n self._results[groups[0]] = {groups[i2+1]: float(groups[(i+1)2]) for i in range(3)}\n\n return copy.deepcopy(self._results)\n\n\ndef instances_to_coco_json(instances, img_id):\n num_instances = len(instances)\n if num_instances == 0:\n return []\n\n scores = instances.scores.tolist()\n beziers = instances.beziers.numpy()\n recs = instances.recs.numpy()\n\n results = []\n for bezier, rec, score in zip(beziers, recs, scores):\n # convert beziers to polygons\n poly = bezier_to_polygon(bezier)\n s = decode(rec)\n result = {\n \"image_id\": img_id,\n \"category_id\": 1,\n \"polys\": poly,\n \"rec\": s,\n \"score\": score,\n }\n results.append(result)\n return results\n\n\ndef bezier_to_polygon(bezier):\n u = np.linspace(0, 1, 20)\n bezier = bezier.reshape(2, 4, 2).transpose(0, 2, 1).reshape(4, 4)\n points = np.outer((1 - u) * 3, bezier[:, 0]) \\\n + np.outer(3 * u * ((1 - u) ** 2), bezier[:, 1]) \\\n + np.outer(3 * (u ** 2) * (1 - u), bezier[:, 2]) \\\n + np.outer(u ** 3, bezier[:, 3])\n \n # convert points to polygon\n points = np.concatenate((points[:, :2], points[:, 2:]), axis=0)\n return points.tolist()\n\n\nCTLABELS = [' ','!','\"','#','$','%','&','\\'','(',')','*','+',',','-','.','/','0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?','@','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','[','\\\\',']','^','_','`','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','{','\|','}','~']\n\n\ndef ctc_decode(rec):\n # ctc decoding\n last_char = False\n s = ''\n for c in rec:\n c = int(c)\n if c < 95:\n if last_char != c:\n s += CTLABELS[c]\n last_char = c\n elif c == 95:\n s += u'口'\n else:\n last_char = False\n return s\n\n\ndef decode(rec):\n s = ''\n for c in rec:\n c = int(c)\n if c < 95:\n s += CTLABELS[c]\n elif c == 95:\n s += u'口'\n\n return s\n \n" ]	[ [ "numpy.concatenate", "torch.device", "numpy.linspace", "numpy.outer" ] ]
BEAR-algorithm/BEAR	[ "3793ac9a736f99f880ccd3693a9ccd54f5c45f04" ]	[ "SOFTMAX-MISSION-Topk-minibatch.py" ]	[ "import numpy as np\nimport matplotlib.pyplot as plt\nimport random\nimport time\nimport warnings\nimport murmurhash\nimport pickle\nimport heapq\nfrom countminsketch_mmh3_parallel import CountMinSketch\nfrom topkheap import mytopkheap\nwarnings.filterwarnings(\"ignore\")\n\ndef loss_softmax(W, X, y_ind, reg):\n loss = 0\n num_train, dim = X.shape\n scores = X.dot(W) # [N, K]\n predicted_class = np.argmax(scores,axis=1)\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[list(range(num_train)), y_ind] # [N, ]\n scores_exp_sum = np.sum(scores_exp, axis=1) # [N, ]\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= num_train\n loss += 0.5 * reg * np.sum(W * W)\n return loss,predicted_class\n\n\ndef merge_classes(top_k,top_k_value):\n merged_heap = mytopkheap(top_k_value)\n for top_k_heap in top_k:\n merged_heap.push(top_k_heap.output_topk_heap())\n return list(zip(top_k_heap.output_topk_heap()))[1]\n\ndef merge_classes_fast(top_k):\n merged_heap = []\n for top_k_heap in top_k:\n merged_heap.extend(top_k_heap.output_topk_heap())\n\n top_k_value_local = int(len(merged_heap) / len(top_k))\n heapq.heapify( merged_heap )\n return list(zip(heapq.nlargest(top_k_value_local,merged_heap)))[1]\n\n\ndef loss_grad_softmax(W, X, y_ind, reg):\n \"\"\" Compute the loss and gradients using softmax with vectorized version\"\"\"\n loss = 0\n grad = np.zeros_like(W)\n num_train, dim = np.shape(X)\n\n scores = X.dot(W) # [N, K]\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[list(range(num_train)), y_ind] # [N, ]\n scores_exp_sum = np.sum(scores_exp, axis=1) # [N, ]\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= num_train\n loss += 0.5 * reg * np.sum(W * W)\n\n scores_exp_normalized = (scores_exp.T / scores_exp_sum).T\n # deal with the correct class\n scores_exp_normalized[list(range(num_train)), y_ind] -= 1 # [N, K]\n grad = X.T.dot(scores_exp_normalized)\n grad /= num_train\n grad += reg * W\n\n return loss, grad\n\n\nnp.random.seed(0)\nrandom.seed(0)\n\nfilepath = 'RCV1/rcv1_train.binary'\n\ndata_dimension = 47236\nnumber_of_classes = 2\nstep_size = 1\n\ncms = CountMinSketch(1000,5,2)\ntop_k = []\ntop_k_value = 400\ntop_k_value = 2 * top_k_value\nfor c in range(number_of_classes):\n top_k.append(mytopkheap(top_k_value))\n\nepoch = 1\nloss = 1\nmini_batch_size = 2000\n\nindicies_in_minibatch = []\nindicies_in_minibatch_flat = []\nvalues_in_minibatch = []\ndata_label = []\n\ntraining_loss_store = []\ncnt_store = []\ntime_store = []\n\nstart_time = time.time()\nwhile loss > 0.01 and epoch < 2:\n\n line = 'start'\n print('epoch = ', epoch)\n\n cnt = 0\n with open(filepath) as fp:\n while line and cnt< 20242: \n\n line = fp.readline()\n line = line[:-1]\n line_splited = line.split(' ')\n data_label.append(int((int(line_splited[0])+1)/2))\n\n indicies_in_data = []\n values_in_data = []\n for feature_index, feature_value in enumerate(line_splited[1:]):\n feature,value = feature_value.split(':')\n feature = int(feature)-1\n value = float(value)\n indicies_in_data.append(feature)\n indicies_in_minibatch_flat.append(feature)\n values_in_data.append(value)\n\n indicies_in_minibatch.append(indicies_in_data)\n values_in_minibatch.append(values_in_data)\n\n if cnt % mini_batch_size == mini_batch_size - 1:\n\n indicies_in_minibatch_flat = list(set(indicies_in_minibatch_flat))\n indicies_in_minibatch_flat_dict = dict(zip(indicies_in_minibatch_flat,range(len(indicies_in_minibatch_flat))))\n\n data_vector = np.zeros((len(indicies_in_minibatch_flat) ,mini_batch_size))\n for data_ind in range(mini_batch_size):\n for item_ind,item in enumerate(indicies_in_minibatch[data_ind]):\n data_vector[indicies_in_minibatch_flat_dict[item],data_ind] = values_in_minibatch[data_ind][item_ind]\n\n\n X = data_vector.T\n y_ind = np.asarray(data_label)\n\n\n top_k_merged_indicies = set(merge_classes_fast(top_k)) # merge the top_k among classes\n WW = cms.query(list( map(str,indicies_in_minibatch_flat)))\n for indd,item in enumerate(indicies_in_minibatch_flat): # zero out the feautues that are out of top-k\n if item not in top_k_merged_indicies:\n WW[indd,:] = 0\n\n loss, grad = loss_grad_softmax(WW, X, y_ind, reg=0)\n cms.add(list( map(str,indicies_in_minibatch_flat) ),- step_size * grad)\n WW = cms.query(list(map(str,indicies_in_minibatch_flat)))\n for c in range(number_of_classes): # update the top_k heaps for each class\n top_k[c].push(list(zip(np.abs(WW[:,c]),indicies_in_minibatch_flat)))\n\n\n\n indicies_in_minibatch = []\n values_in_minibatch = []\n data_label = []\n indicies_in_minibatch_flat = []\n\n cnt += 1\n\n if cnt % 10000 == 0:\n\n training_loss_store.append(loss)\n cnt_store.append(cnt)\n time_store.append(time.time()-start_time)\n print(cnt)\n print(loss)\n\n epoch += 1\n\nfp.close()\n\n## save the convergence trajectories\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-loss.p\", 'wb')\npickle.dump(training_loss_store, filehandler)\nfilehandler.close()\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-cnt.p\", 'wb')\npickle.dump(cnt_store, filehandler)\nfilehandler.close()\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-time.p\", 'wb')\npickle.dump(time_store, filehandler)\nfilehandler.close()\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-features.p\", 'wb')\npickle.dump(set(top_k_merged_indicies), filehandler)\nfilehandler.close()\nprint(len(set(top_k_merged_indicies)))\n\n# finding the test loss\nindicies_in_minibatch = []\nindicies_in_minibatch_flat = []\nvalues_in_minibatch = []\ntotal_test_loss = []\ndata_label = []\nline = 'start'\ncnt = 0\nfilepath = '/Users/amirali/Desktop/RCV1/rcv1_test.binary'\naccuracy_list = []\npredicted_class_TEST = np.asarray([])\nground_truth_TEST = np.asarray([])\nwith open(filepath) as fp:\n while line and cnt < 120000 : ##677399\n if cnt % 10000 == 0:\n print(cnt)\n\n line = fp.readline()\n line = line[:-1]\n line_splited = line.split(' ')\n data_label.append(int((int(line_splited[0])+1)/2))\n\n indicies_in_data = []\n values_in_data = []\n for feature_index, feature_value in enumerate(line_splited[1:]):\n feature,value = feature_value.split(':')\n feature = int(feature)-1\n value = float(value)\n indicies_in_data.append(feature)\n indicies_in_minibatch_flat.append(feature)\n values_in_data.append(value)\n\n\n indicies_in_minibatch.append(indicies_in_data)\n values_in_minibatch.append(values_in_data)\n\n if cnt % mini_batch_size == mini_batch_size - 1:\n\n indicies_in_minibatch_flat = list(set(indicies_in_minibatch_flat))\n indicies_in_minibatch_flat_dict = dict(zip(indicies_in_minibatch_flat,range(len(indicies_in_minibatch_flat))))\n\n data_vector = np.zeros((len(indicies_in_minibatch_flat) ,mini_batch_size))\n for data_ind in range(mini_batch_size):\n for item_ind,item in enumerate(indicies_in_minibatch[data_ind]):\n data_vector[indicies_in_minibatch_flat_dict[item],data_ind] = values_in_minibatch[data_ind][item_ind]\n\n\n X = data_vector.T\n y_ind = data_label\n\n WW = cms.query(list( map(str,indicies_in_minibatch_flat)))\n for indd,item in enumerate(indicies_in_minibatch_flat): # zero out the feautues that are out of top-k\n if item not in top_k_merged_indicies:\n WW[indd,:] = 0\n\n loss,predicted_class = loss_softmax(WW, X, y_ind, reg=0)\n total_test_loss.append(loss)\n\n predicted_class_TEST = np.append(predicted_class_TEST,predicted_class)\n ground_truth_TEST = np.append(ground_truth_TEST,data_label)\n\n indicies_in_minibatch = []\n values_in_minibatch = []\n data_label = []\n indicies_in_minibatch_flat = []\n\n cnt += 1\n\n\nprint('***')\nprint('average test loss is ')\nprint(np.mean(np.asarray(total_test_loss)))\nprint('accuracy')\nacc_val = (predicted_class_TEST == ground_truth_TEST).sum() / len(ground_truth_TEST)\nprint(acc_val)\n\n## store\nfile = open(\"results/MISSION-b2000-step1-w1000-d5-k400-log.txt\",\"w\")\nfile.write(\"Average test loss %f \\n\" %np.mean(np.asarray(total_test_loss)) )\nfile.write(\"Average test accuracy %f \\n\" % acc_val )\nfile.close()\n\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-test-ground-truth.p\", 'wb')\npickle.dump(ground_truth_TEST, filehandler)\nfilehandler.close()\n\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-test-prediction.p\", 'wb')\npickle.dump(predicted_class_TEST, filehandler)\nfilehandler.close()\n" ]	[ [ "numpy.log", "numpy.abs", "numpy.random.seed", "numpy.asarray", "numpy.max", "numpy.append", "numpy.argmax", "numpy.zeros_like", "numpy.shape", "numpy.exp", "numpy.sum" ] ]
neeradp/incubator-mxnet	[ "b34addeb1ffa4786158636e10724083d8462ed07" ]	[ "python/mxnet/contrib/onnx/onnx2mx/_op_translations.py" ]	[ "# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\n# coding: utf-8\n\"\"\" Module for translating ONNX operators into Mxnet operatoes\"\"\"\n# pylint: disable=unused-argument,protected-access\nimport numpy as np\nfrom . import _translation_utils as translation_utils\nfrom .... import symbol\n# Method definitions for the callable objects mapped in the import_helper module\n\ndef identity(attrs, inputs, proto_obj):\n \"\"\"Returns the identity function of the input.\"\"\"\n return 'identity', attrs, inputs\n\ndef random_uniform(attrs, inputs, proto_obj):\n \"\"\"Draw random samples from a uniform distribtuion.\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n \"Instructions to install - https://github.com/onnx/onnx\")\n new_attrs = translation_utils._remove_attributes(attrs, ['seed'])\n new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attrs.get('dtype', 1))]\n return 'random_uniform', new_attrs, inputs\n\ndef random_normal(attrs, inputs, proto_obj):\n \"\"\"Draw random samples from a Gaussian distribution.\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n \"Instructions to install - https://github.com/onnx/onnx\")\n new_attr = translation_utils._remove_attributes(attrs, ['seed'])\n new_attr = translation_utils._fix_attribute_names(new_attr, {'mean': 'loc'})\n new_attr['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attr.get('dtype', 1))]\n return 'random_normal', new_attr, inputs\n\ndef sample_multinomial(attrs, inputs, proto_obj):\n \"\"\"Draw random samples from a multinomial distribution.\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n + \"Instructions to install - https://github.com/onnx/onnx\")\n new_attrs = translation_utils._remove_attributes(attrs, ['seed'])\n new_attrs = translation_utils._fix_attribute_names(new_attrs, {'sample_size': 'shape'})\n new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(attrs.get('dtype', 6))]\n return 'sample_multinomial', new_attrs, inputs\n\n# Arithmetic Operations\ndef add(attrs, inputs, proto_obj):\n \"\"\"Adding two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_add', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_add', new_attr, inputs\n\ndef subtract(attrs, inputs, proto_obj):\n \"\"\"Subtracting two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_sub', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_sub', new_attr, inputs\n\ndef multiply(attrs, inputs, proto_obj):\n \"\"\"Multiply two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_mul', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_mul', new_attr, inputs\n\ndef divide(attrs, inputs, proto_obj):\n \"\"\"Divide two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_div', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_div', new_attr, inputs\n\ndef mean(attrs, inputs, proto_obj):\n \"\"\"Mean of all the input tensors.\"\"\"\n concat_input = [symbol.expand_dims(op_input, axis=0) for op_input in inputs]\n concat_sym = symbol.concat(concat_input, dim=0)\n mean_sym = symbol.mean(concat_sym, axis=0)\n return mean_sym, attrs, inputs\n\ndef logical_and(attrs, inputs, proto_obj):\n \"\"\"Logical and of two input arrays.\"\"\"\n return 'broadcast_logical_and', attrs, inputs\n\ndef logical_or(attrs, inputs, proto_obj):\n \"\"\"Logical or of two input arrays.\"\"\"\n return 'broadcast_logical_or', attrs, inputs\n\ndef logical_xor(attrs, inputs, proto_obj):\n \"\"\"Logical xor of two input arrays.\"\"\"\n return 'broadcast_logical_xor', attrs, inputs\n\ndef logical_not(attrs, inputs, proto_obj):\n \"\"\"Logical not of two input arrays.\"\"\"\n return 'logical_not', attrs, inputs\n\ndef absolute(attrs, inputs, proto_obj):\n \"\"\"Returns element-wise absolute value of the input.\"\"\"\n return 'abs', attrs, inputs\n\ndef negative(attrs, inputs, proto_obj):\n \"\"\"Negation of every element in a tensor\"\"\"\n return 'negative', attrs, inputs\n\ndef add_n(attrs, inputs, proto_obj):\n \"\"\"Elementwise sum of arrays\"\"\"\n return 'add_n', attrs, inputs\n\n# Sorting and Searching\ndef argmax(attrs, inputs, proto_obj):\n \"\"\"Returns indices of the maximum values along an axis\"\"\"\n axis = attrs.get('axis', 0)\n keepdims = attrs.get('keepdims', 1)\n argmax_op = symbol.argmax(inputs[0], axis=axis, keepdims=keepdims)\n # onnx argmax operator always expects int64 as output type\n cast_attrs = {'dtype': 'int64'}\n return 'cast', cast_attrs, argmax_op\n\ndef argmin(attrs, inputs, proto_obj):\n \"\"\"Returns indices of the minimum values along an axis.\"\"\"\n axis = attrs.get('axis', 0)\n keepdims = attrs.get('keepdims', 1)\n argmin_op = symbol.argmin(inputs[0], axis=axis, keepdims=keepdims)\n # onnx argmax operator always expects int64 as output type\n cast_attrs = {'dtype': 'int64'}\n return 'cast', cast_attrs, argmin_op\n\ndef maximum(attrs, inputs, proto_obj):\n \"\"\"\n Elementwise maximum of arrays.\n MXNet maximum compares only two symbols at a time.\n ONNX can send more than two to compare.\n Breaking into multiple mxnet ops to compare two symbols at a time\n \"\"\"\n if len(inputs) > 1:\n mxnet_op = symbol.maximum(inputs[0], inputs[1])\n for op_input in inputs[2:]:\n mxnet_op = symbol.maximum(mxnet_op, op_input)\n else:\n mxnet_op = symbol.maximum(inputs[0], inputs[0])\n return mxnet_op, attrs, inputs\n\ndef minimum(attrs, inputs, proto_obj):\n \"\"\"Elementwise minimum of arrays.\"\"\"\n # MXNet minimum compares only two symbols at a time.\n # ONNX can send more than two to compare.\n # Breaking into multiple mxnet ops to compare two symbols at a time\n if len(inputs) > 1:\n mxnet_op = symbol.minimum(inputs[0], inputs[1])\n for op_input in inputs[2:]:\n mxnet_op = symbol.minimum(mxnet_op, op_input)\n else:\n mxnet_op = symbol.minimum(inputs[0], inputs[0])\n return mxnet_op, attrs, inputs\n\ndef lesser(attrs, inputs, proto_obj):\n \"\"\"Logical Lesser operator with broadcasting.\"\"\"\n return 'broadcast_lesser', attrs, inputs\n\ndef greater(attrs, inputs, proto_obj):\n \"\"\"Logical Greater operator with broadcasting.\"\"\"\n return 'broadcast_greater', attrs, inputs\n\ndef equal(attrs, inputs, proto_obj):\n \"\"\"Logical Equal operator with broadcasting.\"\"\"\n return 'broadcast_equal', attrs, inputs\n\n#Hyperbolic functions\ndef tanh(attrs, inputs, proto_obj):\n \"\"\"Returns the hyperbolic tangent of the input array.\"\"\"\n return 'tanh', attrs, inputs\n\n# Rounding\ndef ceil(attrs, inputs, proto_obj):\n \"\"\" Calculate ceil value for input \"\"\"\n return 'ceil', attrs, inputs\n\ndef floor(attrs, inputs, proto_obj):\n \"\"\" Calculate floor value for input \"\"\"\n return 'floor', attrs, inputs\n\n# Joining and spliting\ndef concat(attrs, inputs, proto_obj):\n \"\"\" Joins input arrays along a given axis. \"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axis': 'dim'})\n return 'concat', new_attrs, inputs\n\n# Basic neural network functions\ndef softsign(attrs, inputs, proto_obj):\n \"\"\"Computes softsign of x element-wise.\"\"\"\n return 'softsign', attrs, inputs\n\ndef sigmoid(attrs, inputs, proto_obj):\n \"\"\"Computes elementwise sigmoid of the input array\"\"\"\n return 'sigmoid', attrs, inputs\n\ndef hardsigmoid(attrs, inputs, proto_obj):\n \"\"\"Computes elementwise hard sigmoid of the input array\"\"\"\n return 'hard_sigmoid', attrs, inputs\n\ndef relu(attrs, inputs, proto_obj):\n \"\"\"Computes rectified linear function.\"\"\"\n return 'relu', attrs, inputs\n\ndef pad(attrs, inputs, proto_obj):\n \"\"\" Add padding to input tensor\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'pads' : 'pad_width',\n 'value' : 'constant_value'\n })\n new_attrs['pad_width'] = translation_utils._pad_sequence_fix(new_attrs.get('pad_width'))\n return 'pad', new_attrs, inputs\n\ndef matrix_multiplication(attrs, inputs, proto_obj):\n \"\"\"Performs general matrix multiplication\"\"\"\n return 'linalg_gemm2', attrs, inputs\n\ndef batch_norm(attrs, inputs, proto_obj):\n \"\"\"Batch normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon': 'eps',\n 'is_test': 'fix_gamma'})\n new_attrs = translation_utils._remove_attributes(new_attrs,\n ['spatial', 'consumed_inputs'])\n # Disable cuDNN BN only if epsilon from model is < than minimum cuDNN eps (1e-5)\n cudnn_min_eps = 1e-5\n cudnn_off = 0 if attrs.get('epsilon', cudnn_min_eps) >= cudnn_min_eps else 1\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'cudnn_off': cudnn_off})\n\n # in test mode \"fix_gamma\" should be unset.\n new_attrs['fix_gamma'] = not attrs.get('is_test', 1)\n return 'BatchNorm', new_attrs, inputs\n\ndef instance_norm(attrs, inputs, proto_obj):\n \"\"\"Instance Normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon' : 'eps'})\n new_attrs['eps'] = attrs.get('epsilon', 1e-5)\n return 'InstanceNorm', new_attrs, inputs\n\ndef leaky_relu(attrs, inputs, proto_obj):\n \"\"\"Leaky Relu function\"\"\"\n if 'alpha' in attrs:\n new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})\n else:\n new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 0.01})\n return 'LeakyReLU', new_attrs, inputs\n\ndef _elu(attrs, inputs, proto_obj):\n \"\"\"Elu function\"\"\"\n if 'alpha' in attrs:\n new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})\n else:\n new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 1.0})\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'act_type': 'elu'})\n return 'LeakyReLU', new_attrs, inputs\n\ndef _prelu(attrs, inputs, proto_obj):\n \"\"\"PRelu function\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'act_type': 'prelu'})\n return 'LeakyReLU', new_attrs, inputs\n\ndef _selu(attrs, inputs, proto_obj):\n \"\"\"Selu function\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'act_type': 'selu'})\n return 'LeakyReLU', new_attrs, inputs\n\ndef softmax(attrs, inputs, proto_obj):\n \"\"\"Softmax function.\"\"\"\n if 'axis' not in attrs:\n attrs = translation_utils._add_extra_attributes(attrs, {'axis': 1})\n return 'softmax', attrs, inputs\n\ndef log_softmax(attrs, inputs, proto_obj):\n \"\"\"Computes the log softmax of the input. This is equivalent to\n computing softmax followed by log.\"\"\"\n return 'log_softmax', attrs, inputs\n\ndef softplus(attrs, inputs, proto_obj):\n \"\"\"Applies the sofplus activation function element-wise to the input.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'act_type' : 'softrelu'})\n return 'Activation', new_attrs, inputs\n\ndef conv(attrs, inputs, proto_obj):\n \"\"\"Compute N-D convolution on (N+2)-D input.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'kernel_shape' : 'kernel',\n 'strides' : 'stride',\n 'pads': 'pad',\n 'dilations': 'dilate',\n 'group': 'num_group'})\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'num_group' : 1})\n new_attrs = translation_utils._fix_bias('Convolution', new_attrs, len(inputs))\n\n new_attrs = translation_utils._fix_channels('Convolution', new_attrs, inputs, proto_obj)\n kernel = new_attrs['kernel']\n stride = new_attrs['stride'] if 'stride' in new_attrs else []\n padding = new_attrs['pad'] if 'pad' in new_attrs else []\n dilations = new_attrs['dilate'] if 'dilate' in new_attrs else []\n num_filter = new_attrs['num_filter']\n num_group = new_attrs['num_group']\n no_bias = new_attrs['no_bias'] if 'no_bias' in new_attrs else 0\n bias = None if no_bias is True else inputs[2]\n\n # Unlike ONNX, MXNet's convolution operator does not support asymmetric padding, so we first\n # use 'Pad' operator, which supports asymmetric padding. Then use the convolution operator.\n pad_width = (0, 0, 0, 0) + translation_utils._pad_sequence_fix(padding, kernel_dim=len(kernel))\n pad_op = symbol.pad(inputs[0], mode='constant', pad_width=pad_width)\n\n conv_op = symbol.Convolution(pad_op, inputs[1], bias,\n kernel=kernel, stride=stride, dilate=dilations,\n num_filter=num_filter, num_group=num_group, no_bias=no_bias)\n\n return conv_op, new_attrs, inputs\n\ndef deconv(attrs, inputs, proto_obj):\n \"\"\"Computes transposed convolution of the input tensor.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'kernel_shape' : 'kernel',\n 'strides' : 'stride',\n 'pads': 'pad',\n 'dilations': 'dilate',\n 'group': 'num_group',\n 'output_padding': 'adj'})\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'num_group' : 1})\n new_attrs = translation_utils._fix_bias('Deconvolution', new_attrs, len(inputs))\n\n new_attrs = translation_utils._fix_channels('Deconvolution', new_attrs, inputs, proto_obj)\n kernel = new_attrs['kernel']\n stride = new_attrs['stride'] if 'stride' in new_attrs else []\n padding = new_attrs['pad'] if 'pad' in new_attrs else []\n dilations = new_attrs['dilate'] if 'dilate' in new_attrs else []\n num_filter = new_attrs['num_filter']\n num_group = new_attrs['num_group']\n no_bias = new_attrs['no_bias'] if 'no_bias' in new_attrs else False\n bias = None if no_bias is True else inputs[2]\n adj = new_attrs['adj'][:len(kernel)]\n\n # Unlike ONNX, MXNet's deconvolution operator does not support asymmetric padding, so we first\n # use 'Pad' operator, which supports asymmetric padding. Then use the deconvolution operator.\n pad_width = (0, 0, 0, 0) + translation_utils._pad_sequence_fix(padding, kernel_dim=len(kernel))\n pad_op = symbol.pad(inputs[0], mode='constant', pad_width=pad_width)\n\n deconv_op = symbol.Deconvolution(pad_op, inputs[1], bias,\n kernel=kernel, stride=stride, dilate=dilations,\n num_filter=num_filter, num_group=num_group, no_bias=no_bias,\n adj=adj)\n\n return deconv_op, new_attrs, inputs\n\ndef fully_connected(attrs, inputs, proto_obj):\n \"\"\"Applies a linear transformation: Y=XWT+b.\"\"\"\n new_attrs = translation_utils._remove_attributes(attrs, ['axis'])\n\n new_attrs = translation_utils._fix_bias('FullyConnected', new_attrs, len(inputs))\n\n new_attrs = translation_utils._fix_channels('FullyConnected', new_attrs, inputs, proto_obj)\n\n return 'FullyConnected', new_attrs, inputs\n\n\ndef global_maxpooling(attrs, inputs, proto_obj):\n \"\"\"Performs max pooling on the input.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,\n 'kernel': (1, 1),\n 'pool_type': 'max'})\n return 'Pooling', new_attrs, inputs\n\n\ndef global_avgpooling(attrs, inputs, proto_obj):\n \"\"\"Performs avg pooling on the input.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,\n 'kernel': (1, 1),\n 'pool_type': 'avg'})\n return 'Pooling', new_attrs, inputs\n\ndef global_lppooling(attrs, inputs, proto_obj):\n \"\"\"Performs global lp pooling on the input.\"\"\"\n p_value = attrs.get('p', 2)\n new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,\n 'kernel': (1, 1),\n 'pool_type': 'lp',\n 'p_value': p_value})\n new_attrs = translation_utils._remove_attributes(new_attrs, ['p'])\n return 'Pooling', new_attrs, inputs\n\ndef linalg_gemm(attrs, inputs, proto_obj):\n \"\"\"Performs general matrix multiplication and accumulation\"\"\"\n trans_a = 0\n trans_b = 0\n alpha = 1\n beta = 1\n if 'transA' in attrs:\n trans_a = attrs['transA']\n if 'transB' in attrs:\n trans_b = attrs['transB']\n if 'alpha' in attrs:\n alpha = attrs['alpha']\n if 'beta' in attrs:\n beta = attrs['beta']\n flatten_a = symbol.flatten(inputs[0])\n matmul_op = symbol.linalg_gemm2(A=flatten_a, B=inputs[1],\n transpose_a=trans_a, transpose_b=trans_b,\n alpha=alpha)\n gemm_op = symbol.broadcast_add(matmul_op, betainputs[2])\n new_attrs = translation_utils._fix_attribute_names(attrs, {'transA': 'transpose_a',\n 'transB': 'transpose_b'})\n new_attrs = translation_utils._remove_attributes(new_attrs, ['broadcast'])\n return gemm_op, new_attrs, inputs\n\ndef local_response_norm(attrs, inputs, proto_obj):\n \"\"\"Local Response Normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'bias': 'knorm',\n 'size' : 'nsize'})\n return 'LRN', new_attrs, inputs\n\ndef dropout(attrs, inputs, proto_obj):\n \"\"\"Dropout Regularization.\"\"\"\n mode = 'training'\n if 'is_test' in attrs and attrs['is_test'] == 0:\n mode = 'always'\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'ratio': 'p'})\n new_attrs = translation_utils._remove_attributes(new_attrs, ['is_test'])\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'mode': mode})\n return 'Dropout', new_attrs, inputs\n\n# Changing shape and type.\ndef reshape(attrs, inputs, proto_obj):\n \"\"\"Reshape the given array by the shape attribute.\"\"\"\n if len(inputs) == 1:\n return 'reshape', attrs, inputs[0]\n reshape_shape = list(proto_obj._params[inputs[1].name].asnumpy())\n reshape_shape = [int(i) for i in reshape_shape]\n new_attrs = {'shape': reshape_shape}\n return 'reshape', new_attrs, inputs[:1]\n\ndef cast(attrs, inputs, proto_obj):\n \"\"\" Cast input to a given dtype\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n + \"Instructions to install - https://github.com/onnx/onnx\")\n new_attrs = translation_utils._fix_attribute_names(attrs, {'to' : 'dtype'})\n new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attrs['dtype'])]\n return 'cast', new_attrs, inputs\n\ndef split(attrs, inputs, proto_obj):\n \"\"\"Splits an array along a particular axis into multiple sub-arrays.\"\"\"\n split_list = attrs.get('split') if 'split' in attrs else []\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'split' : 'num_outputs'})\n if 'axis' not in attrs:\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'axis': 0})\n\n if not split_list:\n num_outputs = len(proto_obj.model_metadata.get('output_tensor_data'))\n else:\n if len(set(split_list)) == 1:\n num_outputs = len(split_list)\n else:\n raise NotImplementedError(\"Operator {} in MXNet does not support variable splits.\"\n \"Tracking the issue to support variable split here: \"\n \"https://github.com/apache/incubator-mxnet/issues/11594\"\n .format('split'))\n\n new_attrs['num_outputs'] = num_outputs\n return 'split', new_attrs, inputs\n\ndef _slice(attrs, inputs, proto_obj):\n \"\"\"Returns a slice of the input tensor along multiple axes.\"\"\"\n input_tensor_data = proto_obj.model_metadata.get('input_tensor_data')[0]\n input_shape = input_tensor_data[1]\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'axes' : 'axis',\n 'ends' : 'end',\n 'starts' : 'begin'})\n # onnx slice provides slicing on multiple axis. Adding multiple slice_axis operator\n # for multiple axes from mxnet\n begin = new_attrs.get('begin')\n end = list(new_attrs.get('end'))\n axes = new_attrs.get('axis', tuple(range(len(begin))))\n for i, axis in enumerate(axes):\n end[i] = None if end[i] >= input_shape[axis] else end[i]\n slice_op = symbol.slice_axis(inputs[0], axis=axes[0], begin=begin[0], end=end[0])\n if len(axes) > 1:\n for i, axis in enumerate(axes):\n slice_op = symbol.slice_axis(slice_op, axis=axis, begin=begin[i], end=end[i])\n return slice_op, new_attrs, inputs\n\ndef transpose(attrs, inputs, proto_obj):\n \"\"\"Transpose the input array.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'perm' : 'axes'})\n return 'transpose', new_attrs, inputs\n\ndef squeeze(attrs, inputs, proto_obj):\n \"\"\"Remove single-dimensional entries from the shape of a tensor.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'axes' : 'axis'})\n return 'squeeze', new_attrs, inputs\n\ndef unsqueeze(attrs, inputs, cls):\n \"\"\"Inserts a new axis of size 1 into the array shape\"\"\"\n # MXNet can only add one axis at a time.\n mxnet_op = inputs[0]\n for axis in attrs[\"axes\"]:\n mxnet_op = symbol.expand_dims(mxnet_op, axis=axis)\n\n return mxnet_op, attrs, inputs\n\ndef flatten(attrs, inputs, proto_obj):\n \"\"\"Flattens the input array into a 2-D array by collapsing the higher dimensions.\"\"\"\n #Mxnet does not have axis support. By default uses axis=1\n if 'axis' in attrs and attrs['axis'] != 1:\n raise RuntimeError(\"Flatten operator only supports axis=1\")\n new_attrs = translation_utils._remove_attributes(attrs, ['axis'])\n return 'Flatten', new_attrs, inputs\n\ndef clip(attrs, inputs, proto_obj):\n \"\"\"Clips (limits) the values in an array.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'min' : 'a_min',\n 'max' : 'a_max'})\n if 'a_max' not in new_attrs:\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'a_max' : np.inf})\n if 'a_min' not in new_attrs:\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'a_min' : -np.inf})\n return 'clip', new_attrs, inputs\n\ndef gather(attrs, inputs, proto_obj):\n \"\"\"Gather elements from an input array along the given axis.\"\"\"\n return 'take', attrs, inputs\n\n#Powers\ndef reciprocal(attrs, inputs, proto_obj):\n \"\"\"Returns the reciprocal of the argument, element-wise.\"\"\"\n return 'reciprocal', attrs, inputs\n\ndef squareroot(attrs, inputs, proto_obj):\n \"\"\"Returns element-wise square-root value of the input.\"\"\"\n return 'sqrt', attrs, inputs\n\ndef power(attrs, inputs, proto_obj):\n \"\"\"Returns element-wise result of base element raised to powers from exp element.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'exponent':'exp'})\n if 'broadcast' in attrs:\n new_attrs = translation_utils._remove_attributes(new_attrs, ['broadcast'])\n if attrs['broadcast'] == 1:\n return 'broadcast_power', new_attrs, inputs\n else:\n mxnet_op = symbol.pow(inputs[0], inputs[1])\n return mxnet_op, new_attrs, inputs\n mxnet_op = symbol.broadcast_power(inputs[0], inputs[1])\n return mxnet_op, new_attrs, inputs\n\ndef exponent(attrs, inputs, proto_obj):\n \"\"\"Elementwise exponent of input array.\"\"\"\n return 'exp', attrs, inputs\n\ndef _cos(attrs, inputs, proto_obj):\n \"\"\"Elementwise cosine of input array.\"\"\"\n return 'cos', attrs, inputs\n\ndef _sin(attrs, inputs, proto_obj):\n \"\"\"Elementwise sine of input array.\"\"\"\n return 'sin', attrs, inputs\n\ndef _tan(attrs, inputs, proto_obj):\n \"\"\"Elementwise tan of input array.\"\"\"\n return 'tan', attrs, inputs\n\ndef arccos(attrs, inputs, proto_obj):\n \"\"\"Elementwise inverse cos of input array.\"\"\"\n return 'arccos', attrs, inputs\n\ndef arcsin(attrs, inputs, proto_obj):\n \"\"\"Elementwise inverse sin of input array.\"\"\"\n return 'arcsin', attrs, inputs\n\ndef arctan(attrs, inputs, proto_obj):\n \"\"\"Elementwise inverse tan of input array.\"\"\"\n return 'arctan', attrs, inputs\n\ndef _log(attrs, inputs, proto_obj):\n \"\"\"Elementwise log of input array.\"\"\"\n return 'log', attrs, inputs\n\n# Reduce Functions\ndef reduce_max(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by maximum value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'max', new_attrs, inputs\n\ndef reduce_mean(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by mean value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'mean', new_attrs, inputs\n\ndef reduce_min(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by minimum value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'min', new_attrs, inputs\n\ndef reduce_sum(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by sum value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'sum', new_attrs, inputs\n\ndef reduce_prod(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by product value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'prod', new_attrs, inputs\n\ndef reduce_log_sum(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by log sum value\"\"\"\n keep_dims = True if 'keepdims' not in attrs else attrs.get('keepdims')\n sum_op = symbol.sum(inputs[0], axis=attrs.get('axes'),\n keepdims=keep_dims)\n log_sym = symbol.log(sum_op)\n return log_sym, attrs, inputs\n\ndef reduce_log_sum_exp(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by log sum exp value\"\"\"\n keep_dims = True if 'keepdims' not in attrs else attrs.get('keepdims')\n exp_op = symbol.exp(inputs[0])\n sum_op = symbol.sum(exp_op, axis=attrs.get('axes'),\n keepdims=keep_dims)\n log_sym = symbol.log(sum_op)\n return log_sym, attrs, inputs\n\ndef reduce_sum_square(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by sum square value\"\"\"\n square_op = symbol.square(inputs[0])\n sum_op = symbol.sum(square_op, axis=attrs.get('axes'),\n keepdims=attrs.get('keepdims'))\n return sum_op, attrs, inputs\n\ndef reduce_l1(attrs, inputs, proto_obj):\n \"\"\"Reduce input tensor by l1 normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'ord' : 1})\n return 'norm', new_attrs, inputs\n\ndef shape(attrs, inputs, proto_obj):\n \"\"\"Returns shape of input array.\"\"\"\n return 'shape_array', attrs, inputs\n\ndef size(attrs, inputs, proto_obj):\n \"\"\"Returns array containing size of data.\"\"\"\n return \"size_array\", attrs, inputs\n\ndef reduce_l2(attrs, inputs, proto_obj):\n \"\"\"Reduce input tensor by l2 normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'norm', new_attrs, inputs\n\ndef avg_pooling(attrs, inputs, proto_obj):\n \"\"\" Average pooling\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'kernel_shape': 'kernel',\n 'strides': 'stride',\n 'pads': 'pad',\n })\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'pooling_convention': 'valid'\n })\n new_op = translation_utils._fix_pooling('avg', inputs, new_attrs)\n\n return new_op, new_attrs, inputs\n\ndef lp_pooling(attrs, inputs, proto_obj):\n \"\"\"LP Pooling\"\"\"\n p_value = attrs.get('p', 2)\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'kernel_shape': 'kernel',\n 'strides': 'stride',\n 'pads': 'pad'\n })\n new_attrs = translation_utils._remove_attributes(new_attrs, ['p'])\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'pooling_convention': 'valid',\n 'p_value': p_value\n })\n new_op = translation_utils._fix_pooling('lp', inputs, new_attrs)\n return new_op, new_attrs, inputs\n\ndef max_pooling(attrs, inputs, proto_obj):\n \"\"\" Average pooling\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'kernel_shape': 'kernel',\n 'strides': 'stride',\n 'pads': 'pad',\n })\n\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'pooling_convention': 'valid'\n })\n new_op = translation_utils._fix_pooling('max', inputs, new_attrs)\n\n return new_op, new_attrs, inputs\n\ndef max_roi_pooling(attrs, inputs, proto_obj):\n \"\"\"Max ROI Pooling.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'pooled_shape': 'pooled_size',\n 'spatial_scale': 'spatial_scale'\n })\n return 'ROIPooling', new_attrs, inputs\n\ndef depthtospace(attrs, inputs, proto_obj):\n \"\"\"Rearranges data from depth into blocks of spatial data.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'blocksize':'block_size'})\n\n return \"depth_to_space\", new_attrs, inputs\n\ndef spacetodepth(attrs, inputs, proto_obj):\n \"\"\"Rearranges blocks of spatial data into depth.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'blocksize':'block_size'})\n\n return \"space_to_depth\", new_attrs, inputs\n\ndef hardmax(attrs, inputs, proto_obj):\n \"\"\"Returns batched one-hot vectors.\"\"\"\n input_tensor_data = proto_obj.model_metadata.get('input_tensor_data')[0]\n input_shape = input_tensor_data[1]\n\n axis = int(attrs.get('axis', 1))\n axis = axis if axis >= 0 else len(input_shape) + axis\n\n if axis == len(input_shape) - 1:\n amax = symbol.argmax(inputs[0], axis=-1)\n one_hot = symbol.one_hot(amax, depth=input_shape[-1])\n return one_hot, attrs, inputs\n\n # since reshape doesn't take a tensor for shape,\n # computing with np.prod. This needs to be changed to\n # to use mx.sym.prod() when mx.sym.reshape() is fixed.\n # (https://github.com/apache/incubator-mxnet/issues/10789)\n new_shape = (int(np.prod(input_shape[:axis])),\n int(np.prod(input_shape[axis:])))\n reshape_op = symbol.reshape(inputs[0], new_shape)\n amax = symbol.argmax(reshape_op, axis=-1)\n one_hot = symbol.one_hot(amax, depth=new_shape[-1])\n hardmax_op = symbol.reshape(one_hot, input_shape)\n return hardmax_op, attrs, inputs\n\ndef lpnormalization(attrs, inputs, proto_obj):\n \"\"\"ONNX does not have eps attribute, so cannot map it to L2normalization in MXNet\n without that, it works as norm operator discussion in PR:\n https://github.com/onnx/onnx/pull/1330\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'p': 'ord'})\n axis = int(attrs.get(\"axis\", -1))\n new_attrs.update(axis=axis)\n return 'norm', new_attrs, inputs\n\n\ndef topk(attrs, inputs, proto_obj):\n \"\"\"Returns the top k elements in an input array along the given axis.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs,\n {'ret_typ': 'both',\n 'dtype': 'int64'})\n return 'topk', new_attrs, inputs\n" ]	[ [ "numpy.prod" ] ]
Aadi0902/AirSim	[ "50411c2e7b5ff85916485f8ed08e07dff12153db" ]	[ "PythonClient/multirotor/AK testing/PWM model/PWMtest.py" ]	[ "# -- coding: utf-8 --\n\"\"\"\nCreated on Sun Jul 19 13:02:17 2020\n\n@author: amk170930\nG\"\"\"\n\n\nimport numpy as np\nimport airsim\nfrom airsim import Vector3r\nimport time\nimport xlrd\nimport control\nimport matrixmath\nimport gain_matrix_calculator as calK\nfrom scipy import signal\nfrom squaternion import Quaternion\nimport control.matlab\nfrom scipy.spatial.transform import Rotation as R\n\nclass PWMtest:\n def main(self):\n multirotorClient = airsim.MultirotorClient()\n multirotorClient.confirmConnection()\n multirotorClient.enableApiControl(True)\n \n pwm = 0.6\n state = multirotorClient.getMultirotorState()\n initialTime = state.timestamp/1000000000\n \n for ind in range(5):\n print(\"Iteration: %d\" %(ind)) \n multirotorClient.moveByMotorPWMsAsync(pwm, pwm, pwm, pwm, 2).join()\n \n state = multirotorClient.getMultirotorState()\n FinalTime = state.timestamp/1000000000\n print(\"Time: %f\" %(FinalTime - initialTime))\n \n print(\"Out\")\n time.sleep(20)\n print(\"Hover\")\n multirotorClient.hoverAsync().join()\n time.sleep(10)\n \nclass LQRtestPWM:\n def main(self): \n #Time step\n Ts = 0.1\n \n # Maximum angular velocity\n max_angular_vel = 6393.667 * 2 * np.pi / 60\n \n #Final state\n x_bar = np.array([[10.0],\n [10.0],\n [10.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0]])\n #Gain matrix\n K, u_bar = calK.gainMatrix(Ts,max_angular_vel)\n\n # #Setup airsim multirotor multirotorClient\n multirotorClient = airsim.MultirotorClient()\n multirotorClient.confirmConnection()\n multirotorClient.enableApiControl(True)\n \n vehicleClient = airsim.VehicleClient()\n \n state = multirotorClient.getMultirotorState()\n print(state.kinematics_estimated.position)\n # Arm the drone\n print(\"arming the drone...\")\n multirotorClient.armDisarm(True)\n \n if state.landed_state == airsim.LandedState.Landed:\n print(\"taking off...\")\n multirotorClient.takeoffAsync().join()\n else:\n multirotorClient.hoverAsync().join()\n \n time.sleep(2)\n \n\n \n # Declare u matrix 4 x 1\n # u = [0,\n # 0,\n # 0,\n # 0]\n # pwm = np.array([0,\n # 0,\n # 0,\n # 0])\n \n print(\"Controls start\")\n #time.sleep(2)\n #multirotorClient.moveByMotorPWMsAsync(1, 1, 1, 1,3).join()\n #newX = [[],[],[],[],[],[],[],[],[],[],[],[]]\n # Start step loop\n for index in range(1000):\n # Re initilize u for every iteration\n # u = [0,\n # 0,\n # 0,\n # 0]\n\n # Get state of the multiorotor\n state = multirotorClient.getMultirotorState()\n state = state.kinematics_estimated\n \n initialState = state.position\n \n #Convert from quaternion to euler angle\n #euler = ls.quaternion_to_euler(state.orientation.x_val,state.orientation.y_val, state.orientation.z_val,state.orientation.w_val)\n \n q = R.from_quat([state.orientation.x_val,\n state.orientation.y_val,\n state.orientation.z_val,\n state.orientation.w_val])\n e = q.as_euler('zyx')\n # q = Quaternion(state.orientation.w_val,\n # state.orientation.x_val,\n # state.orientation.y_val,\n # state.orientation.z_val)\n # e = q.to_euler()\n # rotationMatrix = np.linalg.inv([[0, 1, 0],\n # [1, 0, 0],\n # [0, 0, -1]])\n # position = [[state.position.x_val], \n # [state.position.y_val], \n # [state.position.z_val]]\n # linear_velocity = [[state.linear_velocity.x_val], \n # [state.linear_velocity.x_val], \n # [state.linear_velocity.z_val]]\n #Store the current state of multirotor in x\n #e[2] = e[2] + np.pi if e[2]<=np.pi else e[2] - np.pi\n x = np.array([[state.position.x_val],\n [-state.position.y_val],\n [-state.position.z_val],\n [e[0]],\n [-e[1]],\n [-e[2]],\n [state.linear_velocity.x_val],\n [-state.linear_velocity.y_val],\n [-state.linear_velocity.z_val],\n [state.angular_velocity.x_val],\n [-state.angular_velocity.y_val],\n [-state.angular_velocity.z_val]])\n \n # Compute u\n u = np.dot(K, x_bar-x) + u_bar\n #print(np.dot(K, x_bar - x))\n #squared_angular_velocity = u_bar\n # pwmHover = 0.5937\n # # Compute required pwm signal\n # sq_ctrl_hover = (pwmHover * max_angular_vel)*2\n #sq_ctrl_delta = np.dot(K, x_bar - x)\n sq_ctrl = [max(u[0][0], 0.0),\n max(u[1][0], 0.0),\n max(u[2][0], 0.0),\n max(u[3][0], 0.0)] # max is just in case norm of sq_ctrl_delta is too large (can be negative)\n pwm1 = min((np.sqrt(sq_ctrl[0])/max_angular_vel),1.0)\n pwm2 = min((np.sqrt(sq_ctrl[1])/max_angular_vel),1.0)\n pwm3 = min((np.sqrt(sq_ctrl[2])/max_angular_vel),1.0)\n pwm4 = min((np.sqrt(sq_ctrl[3])/max_angular_vel),1.0)\n #pwm = np.sqrt(max(squared_angular_velocity + (pwmHovermax_angular_vel)*2, 0)) / max_angular_vel\n \n multirotorClient.moveByMotorPWMsAsync(pwm4, pwm1, pwm3, pwm2,Ts).join()\n #multirotorClient.moveToPositionAsync(x_bar[0], x_bar[1], x_bar[2], 0, 1200,\n #airsim.DrivetrainType.MaxDegreeOfFreedom, airsim.YawMode(False,0), -1, 1).join()\n\n #multirotorClient.moveByMotorPWMsAsync(pwmHover, pwmHover, pwmHover, pwmHover, Ts).join()\n \n # print(x_bar[0][0])\n # multirotorClient.moveToPositionAsync(x_bar[0][0], x_bar[1][0], -x_bar[2][0], 1.0).join() \n\n state = multirotorClient.getMultirotorState()\n state = state.kinematics_estimated\n\n \n # print(state)\n time.sleep(10)\n print(\"Free fall\")\n multirotorClient.moveByMotorPWMsAsync(0, 0, 0, 0, 10).join\n time.sleep(10)\n \n print(\"disarming...\")\n multirotorClient.armDisarm(False)\n \n multirotorClient.enableApiControl(False)\n print(\"done.\")\n \n def quaternion_to_euler(self,x, y, z, w):\n \n \n r = R.from_quat([x,y,z,w])\n r = r.as_euler('xyz')\n # import math\n # t0 = +2.0 (w * x + y * z)\n # t1 = +1.0 - 2.0 * (x 2 + y y)\n # X = math.atan2(t0, t1)\n \n # t2 = +2.0 * (w * y - z * x)\n # t2 = +1.0 if t2 > +1.0 else t2\n # t2 = -1.0 if t2 < -1.0 else t2\n # Y = math.asin(t2)\n \n # t3 = +2.0 * (w * z + x * y)\n # t4 = +1.0 - 2.0 * (y * y + z * z)\n # Z = math.atan2(t3, t4)\n \n return r[0], r[1], r[2]\n\nls = LQRtestPWM()\nprint(ls.quaternion_to_euler(0.7071068, 0, 0, 0.7071068))\nls.main()\n" ]	[ [ "numpy.dot", "numpy.array", "numpy.sqrt", "scipy.spatial.transform.Rotation.from_quat" ] ]
anhdhbn/face	[ "e29b6396cd9d2bce4bff5889daef9735a8129db0" ]	[ "Learner.py" ]	[ "import bcolz\nimport math\nfrom torchvision import transforms as trans\nfrom torchvision.utils import make_grid\nfrom PIL import Image\nfrom utils import get_time, gen_plot, hflip_batch, separate_bn_paras\nfrom matplotlib import pyplot as plt\nfrom tensorboardX import SummaryWriter\nfrom tqdm import tqdm\nimport numpy as np\nfrom torch import optim\nimport torch\nfrom verifacation import evaluate, evaluate_custom\nfrom model import Backbone, Arcface, MobileFaceNet, Am_softmax, l2_norm\nfrom data.data_pipe import de_preprocess, get_train_loader, get_val_loader, get_val_data\nplt.switch_backend('agg')\n\n\nclass face_learner(object):\n def __init__(self, conf, inference=False):\n print(conf)\n self.conf = conf\n if conf.use_mobilfacenet:\n self.model = MobileFaceNet(conf.embedding_size).to(conf.device)\n print('MobileFaceNet model generated')\n else:\n self.model = Backbone(\n conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device)\n print('{}_{} model generated'.format(\n conf.net_mode, conf.net_depth))\n\n if not inference:\n self.milestones = conf.milestones\n self.train_loader, self.class_num = get_train_loader(conf)\n self.val_loader = get_val_loader(conf)\n\n self.writer = SummaryWriter(conf.log_path)\n self.step = 0\n self.head = Arcface(embedding_size=conf.embedding_size,\n classnum=self.class_num).to(conf.device)\n\n print('two model heads generated')\n\n paras_only_bn, paras_wo_bn = separate_bn_paras(self.model)\n\n if conf.use_mobilfacenet:\n self.optimizer = optim.SGD([\n {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5},\n {'params': [\n paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4},\n {'params': paras_only_bn}\n ], lr=conf.lr, momentum=conf.momentum)\n else:\n self.optimizer = optim.SGD([\n {'params': paras_wo_bn +\n [self.head.kernel], 'weight_decay': 5e-4},\n {'params': paras_only_bn}\n ], lr=conf.lr, momentum=conf.momentum)\n print(self.optimizer)\n# self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True)\n\n print('[INFO] Optimizers generated')\n # self.board_loss_every = len(self.train_loader)//100\n self.board_loss_every = 5\n if (self.board_loss_every < 5):\n self.board_loss_every = 5\n print(f\"[INFO] Board loss every: {self.board_loss_every}\")\n self.evaluate_every = len(self.train_loader)//4\n print(f\"[INFO] Evaluate every: {self.evaluate_every}\")\n self.save_every = len(self.train_loader)//4\n print(f\"[INFO] Save every: {self.save_every}\")\n # self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(self.train_loader.dataset.root.parent)\n else:\n self.threshold = conf.threshold\n\n def save_state(self, accuracy, to_save_folder=False, extra=None, model_only=False):\n if to_save_folder:\n save_path = self.conf.save_path\n else:\n save_path = self.conf.model_path\n torch.save(\n self.model.state_dict(), save_path /\n ('model_{}_accuracy:{}_step:{}_{}.pth'.format(get_time(), accuracy, self.step, extra)))\n if not model_only:\n torch.save(\n self.head.state_dict(), save_path /\n ('head_{}_accuracy:{}_step:{}_{}.pth'.format(get_time(), accuracy, self.step, extra)))\n torch.save(\n self.optimizer.state_dict(), save_path /\n ('optimizer_{}_accuracy:{}_step:{}_{}.pth'.format(get_time(), accuracy, self.step, extra)))\n\n def load_state(self, fixed_str, from_save_folder=True, model_only=False):\n if from_save_folder:\n save_path = self.conf.save_path\n else:\n save_path = self.conf.model_path\n self.model.load_state_dict(torch.load(\n save_path/'model_{}'.format(fixed_str)))\n if not model_only:\n self.head.load_state_dict(torch.load(\n save_path/'head_{}'.format(fixed_str)))\n self.optimizer.load_state_dict(torch.load(\n save_path/'optimizer_{}'.format(fixed_str)))\n\n def board_val(self, db_name, accuracy, best_threshold, roc_curve_tensor):\n self.writer.add_scalar('{}_accuracy'.format(\n db_name), accuracy, self.step)\n self.writer.add_scalar('{}_best_threshold'.format(\n db_name), best_threshold, self.step)\n self.writer.add_image('{}_roc_curve'.format(\n db_name), roc_curve_tensor, self.step)\n# self.writer.add_scalar('{}_val:true accept ratio'.format(db_name), val, self.step)\n# self.writer.add_scalar('{}_val_std'.format(db_name), val_std, self.step)\n# self.writer.add_scalar('{}_far:False Acceptance Ratio'.format(db_name), far, self.step)\n\n\n def evaluate(self, carray, issame, nrof_folds=5, tta=False):\n self.model.eval()\n idx = 0\n embeddings = np.zeros([len(carray), self.conf.embedding_size])\n with torch.no_grad():\n while idx + self.conf.batch_size <= len(carray):\n batch = torch.tensor(carray[idx:idx + self.conf.batch_size])\n if tta:\n fliped = hflip_batch(batch)\n emb_batch = self.model(\n batch.to(self.conf.device)) + self.model(fliped.to(self.conf.device))\n embeddings[idx:idx + self.conf.batch_size] = l2_norm(emb_batch)\n else:\n embeddings[idx:idx +\n self.conf.batch_size] = self.model(batch.to(self.conf.device)).cpu()\n idx += self.conf.batch_size\n if idx < len(carray):\n batch = torch.tensor(carray[idx:])\n if tta:\n fliped = hflip_batch(batch)\n emb_batch = self.model(\n batch.to(self.conf.device)) + self.model(fliped.to(self.conf.device))\n embeddings[idx:] = l2_norm(emb_batch)\n else:\n embeddings[idx:] = self.model(batch.to(self.conf.device)).cpu()\n tpr, fpr, accuracy, best_thresholds = evaluate(\n embeddings, issame, nrof_folds)\n buf = gen_plot(fpr, tpr)\n roc_curve = Image.open(buf)\n roc_curve_tensor = trans.ToTensor()(roc_curve)\n return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor\n\n def find_lr(self,\n init_value=1e-8,\n final_value=10.,\n beta=0.98,\n bloding_scale=3.,\n num=None):\n if not num:\n num = len(self.train_loader)\n mult = (final_value / init_value)*(1 / num)\n lr = init_value\n for params in self.optimizer.param_groups:\n params['lr'] = lr\n self.model.train()\n avg_loss = 0.\n best_loss = 0.\n batch_num = 0\n losses = []\n log_lrs = []\n for i, (imgs, labels) in tqdm(enumerate(self.train_loader), total=num):\n\n imgs = imgs.to(self.conf.device)\n labels = labels.to(self.conf.device)\n batch_num += 1\n\n self.optimizer.zero_grad()\n\n embeddings = self.model(imgs)\n thetas = self.head(embeddings, labels)\n loss = self.conf.ce_loss(thetas, labels)\n\n # Compute the smoothed loss\n avg_loss = beta avg_loss + (1 - beta) * loss.item()\n self.writer.add_scalar('avg_loss', avg_loss, batch_num)\n smoothed_loss = avg_loss / (1 - beta*batch_num)\n self.writer.add_scalar('smoothed_loss', smoothed_loss, batch_num)\n # Stop if the loss is exploding\n if batch_num > 1 and smoothed_loss > bloding_scale best_loss:\n print('exited with best_loss at {}'.format(best_loss))\n plt.plot(log_lrs[10:-5], losses[10:-5])\n return log_lrs, losses\n # Record the best loss\n if smoothed_loss < best_loss or batch_num == 1:\n best_loss = smoothed_loss\n # Store the values\n losses.append(smoothed_loss)\n log_lrs.append(math.log10(lr))\n self.writer.add_scalar('log_lr', math.log10(lr), batch_num)\n # Do the SGD step\n # Update the lr for the next step\n\n loss.backward()\n self.optimizer.step()\n\n lr = mult\n for params in self.optimizer.param_groups:\n params['lr'] = lr\n if batch_num > num:\n plt.plot(log_lrs[10:-5], losses[10:-5])\n return log_lrs, losses\n\n def evaluate_custom(self, nrof_folds=5, tta=False):\n self.model.eval()\n idx = 0\n embeddings1 = np.zeros(\n (len(self.val_loader.dataset), self.conf.embedding_size))\n # print(embeddings1.shape)\n embeddings2 = np.zeros(\n (len(self.val_loader.dataset), self.conf.embedding_size))\n # print(embeddings1.shape)\n actual_issame = np.zeros((len(self.val_loader.dataset)))\n\n with torch.no_grad():\n samples_tqdm = tqdm(iter(self.val_loader))\n for idx, (imgs1, imgs2, issame) in enumerate(samples_tqdm):\n\n embedding1 = self.model(imgs1.to(self.conf.device)).cpu().numpy()\n embedding2 = self.model(imgs2.to(self.conf.device)).cpu().numpy()\n # print(f\"[INFO] shape embedding1: {embedding1.shape[0]}\")\n embeddings1[idx self.conf.batch_size : idx * self.conf.batch_size + embedding1.shape[0], :] = embedding1\n\n embeddings2[idx * self.conf.batch_size:idx * self.conf.batch_size + embedding2.shape[0], :] = embedding2\n actual_issame[idx * self.conf.batch_size : idx * self.conf.batch_size + issame.shape[0]] = issame\n # print(f\"[INFO] actual_issame : {actual_issame.shape}\")\n tpr, fpr, accuracy, best_thresholds = evaluate_custom(\n embeddings1, embeddings2, actual_issame, nrof_folds)\n buf = gen_plot(fpr, tpr)\n roc_curve = Image.open(buf)\n roc_curve_tensor = trans.ToTensor()(roc_curve)\n # print(f\"[INFO] Acc: {accuracy.mean()}\");\n # print(f\"[INFO] TF: {best_thresholds.mean()}\");\n return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor, tpr, fpr\n\n def train(self, epochs):\n self.model.train()\n running_loss = 0.\n accuracy = 0\n loss_board = 0\n for e in range(epochs):\n print('epoch {} started'.format(e))\n if e == self.milestones[0]:\n self.schedule_lr()\n if e == self.milestones[1]:\n self.schedule_lr()\n if e == self.milestones[2]:\n self.schedule_lr()\n\n samples_tqdm = tqdm(iter(self.train_loader), position=0, leave=True)\n for imgs, labels in samples_tqdm:\n imgs = imgs.to(self.conf.device)\n # print(f\"[INFO] Images: {imgs}\")\n labels = labels.to(self.conf.device)\n # print(f\"[INFO] Labels: {labels}\")\n self.optimizer.zero_grad()\n embeddings = self.model(imgs)\n # print(f\"[INFO] Embeddings: {embeddings}\")\n thetas = self.head(embeddings, labels)\n loss = self.conf.ce_loss(thetas, labels)\n # print(\"size of thetas: \", thetas.size())\n # print(f\"[INFO] Loss: {loss}\")\n loss.backward()\n running_loss += loss.item()\n self.optimizer.step()\n\n if self.step % self.board_loss_every == 0 and self.step != 0:\n loss_board = running_loss / self.board_loss_every\n self.writer.add_scalar('train_loss', loss_board, self.step)\n samples_tqdm.set_description('Epoch: {:.0f}, Step: {:.0f}, Loss: {:.4f}'.format(\n e, self.step, loss_board\n ))\n running_loss = 0.\n\n if self.step % self.evaluate_every == 0 and self.step != 0:\n accuracy, best_threshold, roc_curve_tensor, tpr, fpr = self.evaluate_custom()\n print('\\n Loss: {:.4f}, Accuracy: {:.4f}, Best_threshold: {:.4f}'.format(\n loss_board, accuracy, best_threshold\n ))\n self.board_val('cfp_fp', accuracy, best_threshold, roc_curve_tensor)\n\n self.model.train()\n\n if self.step % self.save_every == 0 and self.step != 0:\n self.save_state(accuracy)\n\n self.step += 1\n self.save_state(accuracy, to_save_folder=True, extra='final')\n\n def schedule_lr(self):\n for params in self.optimizer.param_groups:\n params['lr'] /= 10\n print(self.optimizer)\n\n def infer(self, faces, target_embs, tta=False):\n '''\n faces : list of PIL Image\n target_embs : [n, 512] computed embeddings of faces in facebank\n names : recorded names of faces in facebank\n tta : test time augmentation (hfilp, that's all)\n '''\n embs = []\n for img in faces:\n if tta:\n mirror = trans.functional.hflip(img)\n emb = self.model(self.conf.test_transform(\n img).to(self.conf.device).unsqueeze(0))\n emb_mirror = self.model(self.conf.test_transform(\n mirror).to(self.conf.device).unsqueeze(0))\n embs.append(l2_norm(emb + emb_mirror))\n else:\n embs.append(self.model(self.conf.test_transform(\n img).to(self.conf.device).unsqueeze(0)))\n source_embs = torch.cat(embs)\n\n diff = source_embs.unsqueeze(-1) - \\\n target_embs.transpose(1, 0).unsqueeze(0)\n dist = torch.sum(torch.pow(diff, 2), dim=1)\n minimum, min_idx = torch.min(dist, dim=1)\n min_idx[minimum > self.threshold] = -1 # if no match, set idx to -1\n return min_idx, minimum\n" ]	[ [ "torch.cat", "matplotlib.pyplot.switch_backend", "torch.min", "torch.tensor", "matplotlib.pyplot.plot", "torch.no_grad", "torch.optim.SGD", "torch.pow" ] ]
ijnek/ipm	[ "dee4f2ac99f5d24bd0d2a8c9ff7c748b74727a2f" ]	[ "ipm_library/ipm_library/utils.py" ]	[ "# Copyright (c) 2022 Hamburg Bit-Bots\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Optional, Tuple\n\nfrom geometry_msgs.msg import Transform\nimport numpy as np\nfrom rclpy.duration import Duration\nfrom sensor_msgs.msg import CameraInfo\nfrom shape_msgs.msg import Plane\nfrom tf2_geometry_msgs import PointStamped\nimport tf2_ros\n\n\ndef transform_to_normal_plane(plane: Plane) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Convert a plane msg to a normal vector and a base point.\n\n :param plane: The input plane\n :returns: A tuple with the normal vector and the base_point\n \"\"\"\n # ax + by + cz + d = 0 where a, b, c are the normal vector\n a, b, c, d = plane.coef\n normal = np.array([a, b, c])\n normal = normal / np.linalg.norm(normal)\n base_point = normal * d\n return normal, base_point\n\n\ndef transform_plane_to_frame(\n plane: Tuple[np.ndarray, np.ndarray],\n input_frame: str,\n output_frame: str,\n stamp,\n buffer: tf2_ros.Buffer,\n timeout: Optional[Duration] = None) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Transform a plane from one frame to another.\n\n :param plane: The planes normal and base point as numpy arrays\n :param input_frame: Current frame of the plane\n :param output_frame: The desired frame of the plane\n :param stamp: Timestamp which is used to query\n the tf buffer and get the tranform at this moment\n :param buffer: The refrence to the used tf buffer\n :param timeout: An optinal timeout after which an exception is raised\n :returns: A Tuple containing the planes normal and base point in the\n new frame at the provided timestamp\n \"\"\"\n # Set optinal timeout\n if timeout is None:\n timeout = Duration(seconds=0.2)\n\n # Create two points to transform the base point and the normal vector\n # The second point is generated by adding the normal to the base point\n field_normal = PointStamped()\n field_normal.header.frame_id = input_frame\n field_normal.header.stamp = stamp\n field_normal.point.x = plane[0][0] + plane[1][0]\n field_normal.point.y = plane[0][1] + plane[1][1]\n field_normal.point.z = plane[0][2] + plane[1][2]\n field_normal = buffer.transform(\n field_normal, output_frame, timeout=timeout)\n field_point = PointStamped()\n field_point.header.frame_id = input_frame\n field_point.header.stamp = stamp\n field_point.point.x = plane[1][0]\n field_point.point.y = plane[1][1]\n field_point.point.z = plane[1][2]\n field_point = buffer.transform(field_point, output_frame, timeout=timeout)\n\n field_normal = np.array([\n field_normal.point.x,\n field_normal.point.y,\n field_normal.point.z])\n field_point = np.array([\n field_point.point.x,\n field_point.point.y,\n field_point.point.z])\n\n # field normal is a vector! so it stats at field point and goes up in z direction\n field_normal = field_point - field_normal\n return field_normal, field_point\n\n\ndef get_field_intersection_for_pixels(\n camera_info: CameraInfo,\n points: np.ndarray,\n plane_normal: np.ndarray,\n plane_base_point: np.ndarray,\n scale: float = 1.0) -> np.ndarray:\n \"\"\"\n Project an NumPy array of points in image space on the given plane.\n\n :param points: A nx3 array with n being the number of points\n :param plane_normal: The normal vector of the projection plane\n :param plane_base_point: The base point of the projection plane\n :param scale: A scaling factor used if e.g. a mask with a lower resolution is transformed\n :returns: A NumPy array containing the projected points\n in 3d relative to the camera optical frame\n \"\"\"\n camera_projection_matrix = camera_info.k\n\n # Calculate binning and scale\n binning_x = max(camera_info.binning_x, 1) / scale\n binning_y = max(camera_info.binning_y, 1) / scale\n\n # Create rays\n points[:, 0] = (points[:, 0] - (camera_projection_matrix[2] /\n binning_x)) / (camera_projection_matrix[0] / binning_x)\n points[:, 1] = (points[:, 1] - (camera_projection_matrix[5] /\n binning_y)) / (camera_projection_matrix[4] / binning_y)\n points[:, 2] = 1\n\n # Calculate ray -> plane intersections\n intersections = line_plane_intersections(\n plane_normal, plane_base_point, points)\n\n return intersections\n\n\ndef line_plane_intersections(\n plane_normal: np.ndarray,\n plane_base_point: np.ndarray,\n ray_directions: np.ndarray) -> np.ndarray:\n \"\"\"\n Calculate the intersections of rays with a plane described by a normal and a point.\n\n :param plane_normal: The normal vector of the projection plane\n :param plane_base_point: The base point of the projection plane\n :param ray_directions: A nx3 array with n being the number of rays\n :returns: A nx3 array containing the 3d intersection points with n being the number of rays.\n \"\"\"\n n_dot_u = np.tensordot(plane_normal, ray_directions, axes=([0], [1]))\n relative_ray_distance = -plane_normal.dot(-plane_base_point) / n_dot_u\n\n # we are casting a ray, intersections need to be in front of the camera\n relative_ray_distance[relative_ray_distance <= 0] = np.nan\n\n ray_directions[:, 0] = np.multiply(\n relative_ray_distance, ray_directions[:, 0])\n ray_directions[:, 1] = np.multiply(\n relative_ray_distance, ray_directions[:, 1])\n ray_directions[:, 2] = np.multiply(\n relative_ray_distance, ray_directions[:, 2])\n\n return ray_directions\n\n\ndef transform_points(point_cloud: np.ndarray, transform: Transform) -> np.ndarray:\n \"\"\"\n Transform a bulk of points from an numpy array using a provided `Transform`.\n\n :param point_cloud: nx3 Array of points where n is the number of points\n :param transform: TF2 transform used for the transformation\n :returns: Array with the same shape as the input array, but with the transformation applied\n \"\"\"\n # Build affine transformation\n transform_translation = np.array([\n transform.translation.x,\n transform.translation.y,\n transform.translation.z\n ])\n transform_rotation_matrix = _get_mat_from_quat(\n np.array([\n transform.rotation.w,\n transform.rotation.x,\n transform.rotation.y,\n transform.rotation.z\n ]))\n\n # \"Batched\" matmul meaning a matmul for each point\n # First we offset all points by the translation part\n # followed by a rotation using the rotation matrix\n return np.einsum(\n 'ij, pj -> pi',\n transform_rotation_matrix,\n point_cloud) + transform_translation\n\n\ndef _get_mat_from_quat(quaternion: np.ndarray) -> np.ndarray:\n \"\"\"\n Convert a quaternion to a rotation matrix.\n\n This method is currently needed because transforms3d is not released as a `.dep` and\n would require user interaction to set up.\n For reference see: https://github.com/matthew-brett/transforms3d/blob/\n f185e866ecccb66c545559bc9f2e19cb5025e0ab/transforms3d/quaternions.py#L101\n\n :param quaternion: A numpy array containing the w, x, y, and z components of the quaternion\n :returns: The rotation matrix\n \"\"\"\n Nq = np.sum(np.square(quaternion))\n if Nq < np.finfo(np.float64).eps:\n return np.eye(3)\n\n XYZ = quaternion[1:] * 2.0 / Nq\n wXYZ = XYZ * quaternion[0]\n xXYZ = XYZ * quaternion[1]\n yYZ = XYZ[1:] * quaternion[2]\n zZ = XYZ[2] * quaternion[3]\n\n return np.array(\n [[1.0-(yYZ[0]+zZ), xXYZ[1]-wXYZ[2], xXYZ[2]+wXYZ[1]],\n [xXYZ[1]+wXYZ[2], 1.0-(xXYZ[0]+zZ), yYZ[1]-wXYZ[0]],\n [xXYZ[2]-wXYZ[1], yYZ[1]+wXYZ[0], 1.0-(xXYZ[0]+yYZ[0])]])\n" ]	[ [ "numpy.square", "numpy.multiply", "numpy.einsum", "numpy.eye", "numpy.linalg.norm", "numpy.finfo", "numpy.tensordot", "numpy.array" ] ]
akosik-anyvision/incubator-tvm	[ "e1b11712ac09c32614483d24a4c7e0245ee4cb4b" ]	[ "python/tvm/relay/frontend/tflite.py" ]	[ "# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n# pylint: disable=invalid-name, unused-argument, too-many-lines, import-outside-toplevel\n\"\"\"Tensorflow lite frontend.\"\"\"\nimport math\nimport itertools\nimport numpy as np\nimport tvm\nfrom tvm.ir import IRModule\n\nfrom tvm import relay\nfrom .. import analysis\nfrom .. import expr as _expr\nfrom .. import function as _function\nfrom .. import op as _op\nfrom .. import qnn as _qnn\nfrom ... import nd as _nd\nfrom .common import ExprTable\nfrom .common import infer_shape as _infer_shape\nfrom .tflite_flexbuffer import FlexBufferDecoder\n\n\n__all__ = ['from_tflite']\n\nclass TensorWrapper(object):\n \"\"\"Tensor wrapper for TFLite Tensor\"\"\"\n def __init__(self, tensor_idx, tensor, buffer, qnn_params=None):\n self.tensor_idx = tensor_idx\n self.tensor = tensor\n self.buffer = buffer\n self.qnn_params = qnn_params\n\nclass OperatorConverter(object):\n \"\"\"Operator Converted for converting TFLite ops to Relay ops\"\"\"\n def __init__(self, model, subgraph, exp_tab):\n\n try:\n from tflite.BuiltinOperator import BuiltinOperator\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ActivationFunctionType import ActivationFunctionType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n self.model = model\n self.subgraph = subgraph\n self.exp_tab = exp_tab\n self.builtin_op_code = build_str_map(BuiltinOperator())\n self.activation_fn_type = build_str_map(ActivationFunctionType())\n self.builtin_options = build_str_map(BuiltinOptions())\n\n # Add more operators\n self.convert_map = {\n 'ABS': self.convert_abs,\n 'ADD': self.convert_add,\n 'ADD_N': self.convert_add_n,\n 'AVERAGE_POOL_2D': self.convert_average_pool2d,\n 'BATCH_TO_SPACE_ND': self.convert_batch_to_space_nd,\n 'CAST': self.convert_cast,\n 'CEIL': self.convert_ceil,\n 'CONCATENATION': self.convert_concatenation,\n 'CONV_2D': self.convert_conv2d,\n 'COS': self.convert_cos,\n 'DEPTH_TO_SPACE': self.convert_depth_to_space,\n 'DEPTHWISE_CONV_2D': self.convert_depthwise_conv2d,\n 'DEQUANTIZE': self.convert_dequantize,\n 'DETECTION_POSTPROCESS': self.convert_detection_postprocess,\n 'DIV': self.convert_div,\n 'ELU': self.convert_elu,\n 'EQUAL': self.convert_equal,\n 'EXP': self.convert_exp,\n 'FILL': self.convert_fill,\n 'FLOOR_DIV': self.convert_floor_div,\n 'FLOOR_MOD': self.convert_floor_mod,\n 'FLOOR': self.convert_floor,\n 'FULLY_CONNECTED': self.convert_fully_connected,\n 'GATHER': self.convert_gather,\n 'GATHER_ND' : self.convert_gather_nd,\n 'GREATER_EQUAL': self.convert_greater_equal,\n 'GREATER': self.convert_greater,\n 'HARD_SWISH': self.convert_hard_swish,\n 'L2_NORMALIZATION': self.convert_l2_normalization,\n 'L2_POOL_2D': self.convert_l2_pool2d,\n 'LESS_EQUAL': self.convert_less_equal,\n 'LESS': self.convert_less,\n 'LOCAL_RESPONSE_NORMALIZATION': self.convert_lrn,\n 'LOG': self.convert_log,\n 'LOGICAL_AND': self.convert_logical_and,\n 'LOGICAL_NOT': self.convert_logical_not,\n 'LOGICAL_OR': self.convert_logical_or,\n 'LOGISTIC': self.convert_logistic,\n 'MAX_POOL_2D': self.convert_max_pool2d,\n 'MAXIMUM': self.convert_maximum,\n 'MEAN': self.convert_reduce_mean,\n 'MINIMUM': self.convert_minimum,\n 'MIRROR_PAD': self.convert_mirror_pad,\n 'MUL': self.convert_mul,\n 'NEG': self.convert_neg,\n 'NOT_EQUAL': self.convert_not_equal,\n 'PACK': self.convert_pack,\n 'PAD': self.convert_pad,\n 'POW': self.convert_pow,\n 'PRELU': self.convert_prelu,\n 'RANGE': self.convert_range,\n 'QUANTIZE': self.convert_quantize,\n 'REDUCE_ANY': self.convert_reduce_any,\n 'REDUCE_MAX': self.convert_reduce_max,\n 'REDUCE_MIN': self.convert_reduce_min,\n 'REDUCE_PROD': self.convert_reduce_prod,\n 'RELU':self.convert_relu,\n 'RESHAPE': self.convert_reshape,\n 'RESIZE_BILINEAR': self.convert_resize_bilinear,\n 'RESIZE_NEAREST_NEIGHBOR': self.convert_resize_nearest_neighbor,\n 'ROUND': self.convert_round,\n 'RSQRT': self.convert_rsqrt,\n 'SELECT': self.convert_select,\n 'SHAPE': self.convert_shape,\n 'SIN': self.convert_sin,\n 'SLICE': self.convert_slice,\n 'SOFTMAX': self.convert_softmax,\n 'SPACE_TO_BATCH_ND': self.convert_space_to_batch_nd,\n 'SPACE_TO_DEPTH': self.convert_space_to_depth,\n 'SPARSE_TO_DENSE': self.convert_sparse_to_dense,\n 'SPLIT': self.convert_split,\n 'SPLIT_V': self.convert_split_v,\n 'SQRT': self.convert_sqrt,\n 'SQUARE': self.convert_square,\n 'SQUARED_DIFFERENCE': self.convert_squared_difference,\n 'SQUEEZE': self.convert_squeeze,\n 'STRIDED_SLICE': self.convert_strided_slice,\n 'SUB': self.convert_sub,\n 'SUM': self.convert_reduce_sum,\n 'TAN': self.convert_tan,\n 'TANH':self.convert_tanh,\n 'TILE': self.convert_tile,\n 'TOPK_V2': self.convert_topk_v2,\n 'TRANSPOSE_CONV': self.convert_transpose_conv,\n 'TRANSPOSE': self.convert_transpose,\n 'UNPACK': self.convert_unpack,\n 'WHERE': self.convert_select,\n 'ZEROS_LIKE': self.convert_zeros_like,\n }\n\n def check_unsupported_ops(self):\n \"\"\"Check unsupported TFLite ops in our converter.\"\"\"\n unsupported_ops_set = set()\n\n for op_idx in range(self.subgraph.OperatorsLength()):\n op = self.subgraph.Operators(op_idx)\n op_code_str = self.get_op_code_str(op)\n if op_code_str not in self.convert_map:\n unsupported_ops_set.add(op_code_str)\n\n if unsupported_ops_set:\n msg = 'The following operators are not supported in frontend ' \\\n 'TFLite: {}'\n ops = str(list(unsupported_ops_set)).strip('[,]')\n raise tvm.error.OpNotImplemented(msg.format(ops))\n\n def convert_op_to_relay(self):\n \"\"\"Convert TFLite ops to relay ops\"\"\"\n for op_idx in range(self.subgraph.OperatorsLength()):\n op = self.subgraph.Operators(op_idx)\n op_code_str = self.get_op_code_str(op)\n output_tensors = self.get_output_tensors(op)\n try:\n from tflite.Operator import Operator\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n assert isinstance(op, Operator)\n ret = self.convert_map[op_code_str](op)\n\n if len(output_tensors) == 1:\n tensor_idx = output_tensors[0].tensor_idx\n self.exp_tab.set_expr(get_tensor_name(self.subgraph, tensor_idx), ret)\n else:\n for idx, output_tensor in enumerate(output_tensors):\n self.exp_tab.set_expr(get_tensor_name(self.subgraph, output_tensor.tensor_idx),\n ret[idx])\n\n def get_op_code_str(self, op):\n \"\"\"Get TFLite ops string representation\"\"\"\n try:\n from tflite.BuiltinOperator import BuiltinOperator\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n op_code_list_idx = op.OpcodeIndex()\n op_code_id = self.model.OperatorCodes(op_code_list_idx).BuiltinCode()\n try:\n op_code_str = self.builtin_op_code[op_code_id]\n except KeyError:\n raise NotImplementedError('TFLite operator with code ' + str(op_code_id) + \\\n ' is not supported by this version of the fbs schema.')\n if op_code_id == BuiltinOperator.CUSTOM:\n # Custom operator\n custom_op_code_str = self.model.OperatorCodes(op_code_list_idx).CustomCode()\n if custom_op_code_str == b'TFLite_Detection_PostProcess':\n return \"DETECTION_POSTPROCESS\"\n\n raise NotImplementedError(\"Custom operators are currently not supported\")\n return op_code_str\n\n def get_input_tensors(self, op):\n operator_inputs = op.InputsAsNumpy()\n return self.get_tensors(operator_inputs)\n\n def get_output_tensors(self, op):\n operator_outputs = op.OutputsAsNumpy()\n return self.get_tensors(operator_outputs)\n\n def get_tensors(self, tensors_idx_list):\n \"\"\"Get tensor wrapper list from given TFLite tensor index list\"\"\"\n return_list = list()\n for tensor_idx in tensors_idx_list:\n if tensor_idx < 0:\n return_list.append(TensorWrapper(tensor_idx, 0, 0))\n continue\n\n tensor = self.subgraph.Tensors(tensor_idx)\n buffer_idx = tensor.Buffer()\n buffer = self.model.Buffers(buffer_idx)\n\n # Check if the tensors are quantized. Parse if yes.\n qnn_params = None\n tflite_qnn_params = tensor.Quantization()\n if tflite_qnn_params is not None:\n scale = float(tflite_qnn_params.ScaleAsNumpy())\n zero_point = int(tflite_qnn_params.ZeroPointAsNumpy())\n # Check that the scale and zero points are valid.\n if scale != 0 or zero_point != 0:\n qnn_params = dict()\n qnn_params['scale'] = relay.const(scale, 'float32')\n qnn_params['zero_point'] = relay.const(zero_point, 'int32')\n return_list.append(TensorWrapper(tensor_idx, tensor, buffer, qnn_params))\n return return_list\n\n def get_tensor_value(self, tensor_wrapper):\n \"\"\"Get tensor buffer value from given tensor wrapper\"\"\"\n assert isinstance(tensor_wrapper, TensorWrapper)\n\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if tensor_wrapper.tensor.Type() == TensorType.UINT8:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.uint8).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.FLOAT32:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.float32).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.INT32:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.int32).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.INT64:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.int64).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.BOOL:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.bool_).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n raise NotImplementedError(\"Tensor type {} is currently not supported\"\n .format(str(tensor_wrapper.tensor.Type())))\n\n def get_tensor_type_str(self, tensor_type):\n \"\"\"Get tensor type string representation when given TFLite tensor type\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if tensor_type == TensorType.INT8:\n return \"int8\"\n if tensor_type == TensorType.UINT8:\n return \"uint8\"\n if tensor_type == TensorType.FLOAT32:\n return \"float32\"\n if tensor_type == TensorType.INT32:\n return \"int32\"\n if tensor_type == TensorType.INT64:\n return \"int64\"\n if tensor_type == TensorType.BOOL:\n return \"bool\"\n raise NotImplementedError(\"Tensor type {} is currently not supported\"\n .format(str(tensor_type)))\n\n def has_same_qnn_params(self, lhs_tensor, rhs_tensor):\n lhs_scale = lhs_tensor.qnn_params['scale']\n rhs_scale = rhs_tensor.qnn_params['scale']\n lhs_zero_point = lhs_tensor.qnn_params['zero_point']\n rhs_zero_point = rhs_tensor.qnn_params['zero_point']\n lhs_scale_value = get_scalar_from_constant(lhs_scale)\n rhs_scale_value = get_scalar_from_constant(rhs_scale)\n lhs_zero_point_value = get_scalar_from_constant(lhs_zero_point)\n rhs_zero_point_value = get_scalar_from_constant(rhs_zero_point)\n return lhs_scale_value == rhs_scale_value and \\\n lhs_zero_point_value == rhs_zero_point_value\n\n def is_quantized(self, op):\n \"\"\"Check if an input tensor is quantized.\"\"\"\n input_tensors = self.get_input_tensors(op)\n first_tensor = input_tensors[0]\n return first_tensor.qnn_params is not None\n\n def quantize(self, expr, tensor_to_quantize):\n \"\"\" Helper function to quantize a tensor with Relay \"\"\"\n tensor_type = tensor_to_quantize.tensor.Type()\n tensor_type_str = self.get_tensor_type_str(tensor_type)\n quantized = _qnn.op.quantize(data=expr,\n output_scale=tensor_to_quantize.qnn_params['scale'],\n output_zero_point=tensor_to_quantize.qnn_params['zero_point'],\n out_dtype=tensor_type_str)\n return quantized\n\n def dequantize(self, expr, tensor):\n \"\"\" Helper function to dequantize a tensor with Relay \"\"\"\n dequantized = _qnn.op.dequantize(data=expr,\n input_scale=tensor.qnn_params['scale'],\n input_zero_point=tensor.qnn_params['zero_point'])\n return dequantized\n\n\n def convert_qnn_fused_activation_function(self, expr, fused_activation_fn,\n scale, zero_point, dtype):\n \"\"\"Convert TFLite fused activation function. The expr is an input quantized tensor with\n scale and zero point \"\"\"\n try:\n from tflite.ActivationFunctionType import ActivationFunctionType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n # Quantize a float value to an quantized integer value\n quantize = lambda x: float(int(round(x / scale)) + zero_point)\n\n # Get min/max of the output dtype. This will be used to ensure that clip a_min/a_max are not\n # beyond the dtype range.\n qmin = float(tvm.tir.op.min_value(dtype).value)\n qmax = float(tvm.tir.op.max_value(dtype).value)\n\n # The input expr is a quantized tensor with its scale and zero point. We calculate the\n # suitable clip off points based on these scale and zero point.\n if fused_activation_fn == ActivationFunctionType.NONE:\n return expr\n if fused_activation_fn == ActivationFunctionType.RELU6:\n return _op.clip(expr,\n a_min=max(qmin, quantize(0)),\n a_max=min(qmax, quantize(6.0)))\n if fused_activation_fn == ActivationFunctionType.RELU_N1_TO_1:\n return _op.clip(expr,\n a_min=max(qmin, quantize(-1.0)),\n a_max=min(qmax, quantize(1.0)))\n if fused_activation_fn == ActivationFunctionType.RELU:\n return _op.clip(expr,\n a_min=max(qmin, quantize(0.0)),\n a_max=qmax)\n\n fused_activation_fn_str = self.activation_fn_type[fused_activation_fn]\n raise tvm.error.OpNotImplemented(\n 'Quantized activation {} is not supported yet.'.format(fused_activation_fn_str))\n\n def convert_conv2d(self, op):\n \"\"\"Convert TFLite conv2d\"\"\"\n return self.convert_conv(op, \"conv2d\")\n\n def convert_depthwise_conv2d(self, op):\n \"\"\"Convert TFLite depthwise conv2d\"\"\"\n return self.convert_conv(op, \"depthwise\")\n\n def convert_average_pool2d(self, op):\n \"\"\"Convert TFLite average pool2d\"\"\"\n return self.convert_pool2d(op, \"average\")\n\n def convert_max_pool2d(self, op):\n \"\"\"Convert TFLite max pool2d\"\"\"\n return self.convert_pool2d(op, \"max\")\n\n def convert_l2_pool2d(self, op):\n \"\"\"Convert TFLite l2 pool2d\"\"\"\n return self.convert_pool2d(op, \"l2\")\n\n def convert_reshape(self, op):\n \"\"\"Convert TFLite reshape\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ReshapeOptions import ReshapeOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert input_tensors, \"input tensors should not be empty\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n assert op.BuiltinOptionsType() == BuiltinOptions.ReshapeOptions\n op_options = op.BuiltinOptions()\n reshape_options = ReshapeOptions()\n reshape_options.Init(op_options.Bytes, op_options.Pos)\n target_shape = reshape_options.NewShapeAsNumpy()\n\n in_expr = self.get_expr(input_tensor_idx)\n\n # If the tensors are quantized, ensure that input/output qnn params are same.\n if input_tensor.qnn_params:\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"There should be only 1 output tensor\"\n output_tensor = output_tensors[0]\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n \"TFLite reshape requires input and output scale and zero points to be equal\"\n out = _op.reshape(in_expr, newshape=tuple(target_shape))\n return out\n\n def _convert_resize(self, method, op):\n \"\"\"Generic method to Convert TFLite RESIZE operators\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ResizeBilinearOptions import ResizeBilinearOptions\n # ResizeNearestNeighborOptions was added in tflite v1.13\n tflite_ver = 1120\n if 'ResizeNearestNeighborOptions' in dir(BuiltinOptions):\n from tflite.ResizeNearestNeighborOptions import ResizeNearestNeighborOptions\n tflite_ver = 1130\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # images, 4-D Tensor with shape NHWC.\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # size - 1-D int32 Tensor of 2 elements: new_height, new_width\n target_size = tuple(self.get_tensor_value(input_tensors[1]))\n\n # Options - align_corners (bool)\n resize_options = None\n align_corners = False\n if method == \"bilinear\":\n assert op.BuiltinOptionsType() == BuiltinOptions.ResizeBilinearOptions\n resize_options = ResizeBilinearOptions()\n elif tflite_ver >= 1130:\n assert op.BuiltinOptionsType() == BuiltinOptions.ResizeNearestNeighborOptions\n resize_options = ResizeNearestNeighborOptions()\n\n if resize_options is not None:\n op_options = op.BuiltinOptions()\n resize_options.Init(op_options.Bytes, op_options.Pos)\n align_corners = resize_options.AlignCorners()\n\n # Use layout NHWC\n coord_trans = \"align_corners\" if align_corners else \"asymmetric\"\n out = _op.image.resize(in_expr, target_size, \"NHWC\", method,\n coordinate_transformation_mode=coord_trans)\n return out\n\n def convert_resize_bilinear(self, op):\n \"\"\"Convert TFLite RESIZE_BILINEAR\"\"\"\n return self._convert_resize(\"bilinear\", op)\n\n def convert_resize_nearest_neighbor(self, op):\n \"\"\"Convert TFLite RESIZE_NEAREST_NEIGHBOR\"\"\"\n return self._convert_resize(\"nearest_neighbor\", op)\n\n def convert_l2_normalization(self, op):\n \"\"\"Convert TFLite L2_NORMALIZATION \"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.L2NormOptions import L2NormOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n assert op.BuiltinOptionsType() == BuiltinOptions.L2NormOptions\n op_options = op.BuiltinOptions()\n l2_norm_options = L2NormOptions()\n l2_norm_options.Init(op_options.Bytes, op_options.Pos)\n fused_activation_fn = l2_norm_options.FusedActivationFunction()\n\n # TFLite supports normalization only over the last dim\n input_tensor_rank = len(input_tensor.tensor.ShapeAsNumpy())\n\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFLite quantized L2_NORMALIZATION operator is not supported yet.')\n\n # TFL uses only the default epsilon value\n out = _op.nn.l2_normalize(in_expr, eps=1e-12, axis=[input_tensor_rank - 1])\n\n # if we have fused activation fn\n if output_tensor.qnn_params:\n raise tvm.error.OpNotImplemented(\n 'TFLite quantized L2_NORMALIZATION operator is not supported yet.')\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_lrn(self, op):\n \"\"\"Convert TFLite LOCAL_RESPONSE_NORMALIZATION \"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.LocalResponseNormalizationOptions import LocalResponseNormalizationOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LRN operator is not supported yet.')\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n\n assert op.BuiltinOptionsType() == BuiltinOptions.LocalResponseNormalizationOptions\n op_options = op.BuiltinOptions()\n lrn_options = LocalResponseNormalizationOptions()\n lrn_options.Init(op_options.Bytes, op_options.Pos)\n radius = lrn_options.Radius()\n bias = lrn_options.Bias()\n alpha = lrn_options.Alpha()\n beta = lrn_options.Beta()\n size = (radius * 2) + 1\n alpha = alpha * size\n axis = 3 # NHWC format\n out = _op.nn.lrn(in_expr, size=size, axis=axis, bias=bias, alpha=alpha, beta=beta)\n\n return out\n\n def convert_logistic(self, op):\n \"\"\"Convert TFLite LOGISTIC\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n if input_tensor.qnn_params:\n in_expr = self.dequantize(in_expr, input_tensor)\n out = _op.sigmoid(in_expr)\n if output_tensor.qnn_params:\n out = self.quantize(out, output_tensor)\n\n return out\n\n def convert_softmax(self, op):\n \"\"\"Convert TFLite softmax\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n params = {'axis': 1} # 1 is channel\n in_expr = self.get_expr(input_tensor_idx)\n\n # TODO - Naive softmax int8 implementation leads to bad accuracy. Currently, we can\n # dequantize to FP32 and perform softmax on FP32. We can investigate an integer only softmax\n # implementation in future.\n if input_tensor.qnn_params:\n in_expr = self.dequantize(in_expr, input_tensor)\n\n out = _op.nn.softmax(in_expr, *params)\n\n # Go back to integer dataype if the original operator was quantized.\n if output_tensor.qnn_params:\n out = self.quantize(out, output_tensor)\n\n return out\n\n def convert_tanh(self, op):\n \"\"\"Convert TFLite TANH\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.tanh(in_expr)\n\n return out\n\n def convert_range(self, op):\n \"\"\"Convert TFLite Range\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n start, limit, delta = input_tensors[0], input_tensors[1], input_tensors[2]\n\n expressions = [self.get_tensor_expr(t) for t in [start, limit, delta]]\n\n # out type inference\n if delta.tensor.Type() == TensorType.FLOAT32:\n out_type = self.get_tensor_type_str(delta.tensor.Type())\n else:\n out_type = self.get_tensor_type_str(start.tensor.Type())\n\n out = _op.arange(expressions[0], expressions[1], expressions[2], out_type)\n\n return out\n\n def convert_shape(self, op):\n \"\"\"Convert TFLite Shape\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n out = _op.shape_of(self.get_tensor_expr(input_tensors[0]))\n\n return out\n\n def convert_relu(self, op):\n \"\"\"Convert TFLite ReLU\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.nn.relu(in_expr)\n\n return out\n\n def convert_hard_swish(self, op):\n \"\"\"Convert TFLite Hard swish\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n def _relu6(data):\n return _op.tensor.clip(data, 0.0, 6.0)\n\n def _hard_swish(data):\n return data _relu6(data + relay.const(3.0)) / relay.const(6.0)\n\n # Dequantize if the input is quantized.\n if input_tensor.qnn_params:\n in_expr = self.dequantize(in_expr, input_tensor)\n\n # Perform hardswish\n out = _hard_swish(in_expr)\n\n # Go back to integer dataype if the original operator was quantized.\n if output_tensor.qnn_params:\n out = self.quantize(out, output_tensor)\n\n return out\n\n def convert_concatenation(self, op):\n \"\"\"Convert TFLite concatenation\"\"\"\n try:\n from tflite.ConcatenationOptions import ConcatenationOptions\n from tflite.BuiltinOptions import BuiltinOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 1, \"input tensors should greater than 1\"\n in_exprs = [self.get_expr(input_tensor.tensor_idx) for input_tensor in input_tensors]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n assert op.BuiltinOptionsType() == BuiltinOptions.ConcatenationOptions\n op_options = op.BuiltinOptions()\n concatenation_options = ConcatenationOptions()\n concatenation_options.Init(op_options.Bytes, op_options.Pos)\n concatenation_axis = concatenation_options.Axis()\n fused_activation_fn = concatenation_options.FusedActivationFunction()\n\n if not input_tensors[0].qnn_params:\n out = _op.concatenate(in_exprs, axis=concatenation_axis)\n else:\n input_scales = [input_tensor.qnn_params['scale'] for input_tensor in input_tensors]\n input_zero_points = \\\n [input_tensor.qnn_params['zero_point'] for input_tensor in input_tensors]\n out = _qnn.op.concatenate(in_exprs,\n input_scales=input_scales,\n input_zero_points=input_zero_points,\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n axis=concatenation_axis)\n\n # Handle fused activations\n if output_tensor.qnn_params:\n scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n output_tensor_type_str = self.get_tensor_type_str(output_tensor.tensor.Type())\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=scale_val,\n zero_point=zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def _convert_unary_elemwise(self, relay_op, op):\n \"\"\"Generic method to convert TFLite unary elemwise functions\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = relay_op(in_expr)\n\n return out\n\n def convert_abs(self, op):\n \"\"\"Convert TFLite ABS\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized ABS operator is not supported yet.')\n return self._convert_unary_elemwise(_op.abs, op)\n\n def convert_ceil(self, op):\n \"\"\"Convert TFLite CEIL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized CEIL operator is not supported yet.')\n return self._convert_unary_elemwise(_op.ceil, op)\n\n def convert_floor(self, op):\n \"\"\"Convert TFLite FLOOR\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized FLOOR operator is not supported yet.')\n return self._convert_unary_elemwise(_op.floor, op)\n\n def convert_round(self, op):\n \"\"\"Convert TFLite ROUND\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized ROUND operator is not supported yet.')\n return self._convert_unary_elemwise(_op.round, op)\n\n def convert_exp(self, op):\n \"\"\"Convert TFLite EXP\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized EXP operator is not supported yet.')\n return self._convert_unary_elemwise(_op.exp, op)\n\n def convert_log(self, op):\n \"\"\"Convert TFLite LOG\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LOG operator is not supported yet.')\n return self._convert_unary_elemwise(_op.log, op)\n\n def convert_sin(self, op):\n \"\"\"Convert TFLite SIN\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized SIN operator is not supported yet.')\n return self._convert_unary_elemwise(_op.sin, op)\n\n def convert_tan(self, op):\n \"\"\"Convert TFLite TAN\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized TAN operator is not supported yet.')\n return self._convert_unary_elemwise(_op.tan, op)\n\n def convert_cos(self, op):\n \"\"\"Convert TFLite COS\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized COS operator is not supported yet.')\n return self._convert_unary_elemwise(_op.cos, op)\n\n def convert_sqrt(self, op):\n \"\"\"Convert TFLite SQRT\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized SQRT operator is not supported yet.')\n return self._convert_unary_elemwise(_op.sqrt, op)\n\n def convert_rsqrt(self, op):\n \"\"\"Convert TFLite RSQRT\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized RSQRT operator is not supported yet.')\n return self._convert_unary_elemwise(_op.rsqrt, op)\n\n def convert_neg(self, op):\n \"\"\"Convert TFLite NEG\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized NEG operator is not supported yet.')\n return self._convert_unary_elemwise(_op.negative, op)\n\n def convert_elu(self, op):\n \"\"\"Convert TFLite ELU\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized ELU operator is not supported yet.')\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n exp_type = self.get_tensor_type_str(input_tensor.tensor.Type())\n out = relay.const(-1.0, exp_type) * \\\n _op.nn.relu(relay.const(1., exp_type) - _op.exp(in_expr)) + \\\n _op.nn.relu(in_expr)\n\n return out\n\n def convert_square(self, op):\n \"\"\"Convert TFLite SQUARE\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized SQUARE operator is not supported yet.')\n\n exp_type = self.get_tensor_type_str(output_tensor.tensor.Type())\n out = _op.power(in_expr, relay.const(2, exp_type))\n\n return out\n\n def _convert_elemwise(self, relay_op, op):\n \"\"\"Generic method to Convert TFLite elemwise\"\"\"\n try:\n from tflite.AddOptions import AddOptions\n from tflite.SubOptions import SubOptions\n from tflite.MulOptions import MulOptions\n from tflite.DivOptions import DivOptions\n from tflite.BuiltinOptions import BuiltinOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n lhs_tensor = input_tensors[0]\n rhs_tensor = input_tensors[1]\n lhs_expr = self.get_tensor_expr(lhs_tensor)\n rhs_expr = self.get_tensor_expr(rhs_tensor)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n # If quantized, extracts qnn params and call QNN add operator.\n if lhs_tensor.qnn_params:\n assert rhs_tensor.qnn_params, \"Both tensors should be quantized.\"\n assert output_tensor.qnn_params, \"Output tensor should be quantized.\"\n out = relay_op(lhs=lhs_expr,\n rhs=rhs_expr,\n lhs_scale=lhs_tensor.qnn_params['scale'],\n lhs_zero_point=lhs_tensor.qnn_params['zero_point'],\n rhs_scale=rhs_tensor.qnn_params['scale'],\n rhs_zero_point=rhs_tensor.qnn_params['zero_point'],\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'])\n else:\n out = relay_op(lhs_expr, rhs_expr)\n\n # Options (fused_activation_function)\n options = None\n if op.BuiltinOptionsType() == BuiltinOptions.AddOptions:\n options = AddOptions()\n elif op.BuiltinOptionsType() == BuiltinOptions.SubOptions:\n options = SubOptions()\n elif op.BuiltinOptionsType() == BuiltinOptions.MulOptions:\n options = MulOptions()\n elif op.BuiltinOptionsType() == BuiltinOptions.DivOptions:\n options = DivOptions()\n\n if options is not None:\n op_options = op.BuiltinOptions()\n options.Init(op_options.Bytes, op_options.Pos)\n fused_activation_fn = options.FusedActivationFunction()\n\n # Handle fused activations\n if output_tensor.qnn_params:\n scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n output_tensor_type_str = self.get_tensor_type_str(output_tensor.tensor.Type())\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=scale_val,\n zero_point=zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n return out\n\n def convert_add(self, op):\n \"\"\"Convert TFLite ADD\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n return self._convert_elemwise(_qnn.op.add, op)\n return self._convert_elemwise(_op.add, op)\n\n def convert_add_n(self, op):\n \"\"\"Convert TFLite ADD_N\"\"\"\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n\n input_tensors = self.get_input_tensors(op)\n assert not input_tensors[0].qnn_params, \"TFLite does not support quantized ADD_N.\"\n lhs_expr = self.get_tensor_expr(input_tensors[0])\n for rhs_tensor in input_tensors[1:]:\n assert not rhs_tensor.qnn_params, \"TFLite does not support quantized ADD_N\"\n rhs_expr = self.get_tensor_expr(rhs_tensor)\n lhs_expr = _op.add(lhs_expr, rhs_expr)\n return lhs_expr\n\n def convert_sub(self, op):\n \"\"\"Convert TFLite SUB\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n return self._convert_elemwise(_qnn.op.subtract, op)\n return self._convert_elemwise(_op.subtract, op)\n\n def convert_mul(self, op):\n \"\"\"Convert TFLite MUL\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n return self._convert_elemwise(_qnn.op.mul, op)\n return self._convert_elemwise(_op.multiply, op)\n\n def convert_div(self, op):\n \"\"\"Convert TFLite DIV\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized DIV operator is not supported yet.')\n return self._convert_elemwise(_op.divide, op)\n\n def convert_pow(self, op):\n \"\"\"Convert TFLite POW\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized POW operator is not supported yet.')\n return self._convert_elemwise(_op.power, op)\n\n def convert_maximum(self, op):\n \"\"\"Convert TFLite MAXIMUM\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized MAXIMUM operator is not supported yet.')\n return self._convert_elemwise(_op.maximum, op)\n\n def convert_minimum(self, op):\n \"\"\"Convert TFLite MINIMUM\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized MINIMUM operator is not supported yet.')\n return self._convert_elemwise(_op.minimum, op)\n\n def convert_greater(self, op):\n \"\"\"Convert TFLite GREATER\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized GREATER operator is not supported yet.')\n return self._convert_elemwise(_op.greater, op)\n\n def convert_squared_difference(self, op):\n \"\"\"Convert TFLite SQUARED DIFFERENCE\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized squared difference operator is not supported yet.')\n difference = self._convert_elemwise(_op.subtract, op)\n # _convert_elemwise has guaranteed only have one output tensor\n exp_type = self.get_tensor_type_str(self.get_output_tensors(op)[0].tensor.Type())\n out = _op.power(difference, relay.const(2, exp_type))\n return out\n\n def convert_greater_equal(self, op):\n \"\"\"Convert TFLite GREATER_EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized GREATER_EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.greater_equal, op)\n\n def convert_less(self, op):\n \"\"\"Convert TFLite LESS\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LESS operator is not supported yet.')\n return self._convert_elemwise(_op.less, op)\n\n def convert_less_equal(self, op):\n \"\"\"Convert TFLite LESS_EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LESS_EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.less_equal, op)\n\n def convert_equal(self, op):\n \"\"\"Convert TFLite EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.equal, op)\n\n def convert_not_equal(self, op):\n \"\"\"Convert TFLite NOT_EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized NOT_EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.not_equal, op)\n\n def _convert_logical_binary(self, relay_op, op):\n \"\"\"Generic method to convert logical binary ops\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n lhs_tensor = input_tensors[0]\n lhs_expr = self.get_expr(lhs_tensor.tensor_idx)\n rhs_tensor = input_tensors[1]\n rhs_expr = self.get_expr(rhs_tensor.tensor_idx)\n out = relay_op(lhs_expr, rhs_expr)\n\n return out\n\n def convert_logical_and(self, op):\n \"\"\"Convert tflite LOGICAL_AND\"\"\"\n return self._convert_logical_binary(_op.logical_and, op)\n\n def convert_logical_or(self, op):\n \"\"\"Convert tflite LOGICAL_OR\"\"\"\n return self._convert_logical_binary(_op.logical_or, op)\n\n def convert_logical_not(self, op):\n \"\"\"Convert tflite LOGICAL_NOT\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n data = self.get_expr(input_tensors[0].tensor_idx)\n out = _op.logical_not(data)\n\n return out\n\n def convert_gather(self, op):\n \"\"\"Method to Convert TFLite GATHER operator\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.GatherOptions import GatherOptions\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n data = self.get_expr(input_tensors[0].tensor_idx)\n\n indices = input_tensors[1]\n indices_type = indices.tensor.Type()\n assert indices_type in (TensorType.INT32, TensorType.INT64)\n indices_type_str = self.get_tensor_type_str(indices_type)\n indices = self.exp_tab.new_const(self.get_tensor_value(indices),\n dtype=indices_type_str)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.GatherOptions\n op_options = op.BuiltinOptions()\n gather_options = GatherOptions()\n gather_options.Init(op_options.Bytes, op_options.Pos)\n axis = gather_options.Axis()\n\n # Check the indices are with in bounds.\n data_shape = list(input_tensors[0].tensor.ShapeAsNumpy())\n data_dim = len(data_shape)\n\n axis_n = axis\n if axis_n < 0:\n axis_n += axis_n + data_dim\n assert axis_n >= 0, \"Axis out of bounds\"\n assert axis_n < data_dim, \"Axis out of bounds\"\n\n indices_val = self.get_tensor_value(input_tensors[1])\n indices_shape = list(indices_val.shape)\n indices_len = len(indices_shape)\n\n out_shape = []\n for i in range(data_dim):\n if axis_n == i:\n for j in range(indices_len):\n out_shape.append(indices_shape[j])\n else:\n out_shape.append(data_shape[i])\n\n loopover = [range(s) for s in out_shape]\n for idx in list(itertools.product(loopover)):\n indices_position = [idx[j] for j in range(axis_n, axis_n+indices_len)]\n\n real_indices = [idx[j] for j in range(axis_n)]\n real_indices.append(indices_val[tuple(indices_position)])\n real_indices.extend([idx[j] for j in range(axis_n + indices_len, len(idx))])\n for r, d in zip(real_indices, data_shape):\n if r >= d:\n raise ValueError(\"TFLite out of bound indices are not supported.\")\n\n # Use mode 'fast' since indices are already checked within bounds.\n out = _op.take(data, indices, axis=axis, mode=\"fast\")\n return out\n\n def convert_gather_nd(self, op):\n \"\"\"Method to Convert TFLite GATHER_ND operator\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n for t in input_tensors:\n assert not t.qnn_params, \"Quantized input is not expected.\"\n\n data = self.get_tensor_expr(input_tensors[0])\n indices = self.get_tensor_expr(input_tensors[1])\n\n indices_type = input_tensors[1].tensor.Type()\n assert indices_type in (TensorType.INT32, TensorType.INT64)\n\n indices_dims = len(_infer_shape(indices))\n indices_t = _op.transpose(indices, axes=[-1] + list(range(indices_dims-1)))\n\n out = _op.gather_nd(data, indices_t)\n return out\n\n def convert_strided_slice(self, op):\n \"\"\"Method to Convert TFLite STRIDED_SLICE operator.\n NOTE: Eventhough tensorflow supports begin_mask, end_mask, ellipsis_mask, new_axis_mask\n and shrink_axis_mask, tflite doesn't support these and expect these values to be zero.\n But in future, they may open up the mask implementation, so kept the implementation\n same as tensorflow.\n\n This op extracts a slice of size (end - begin) / stride from the given input tensor.\n Starting at the location specified by begin the slice continues by adding stride to the\n index until all dimensions are not less than end. Note that a stride can be negative,\n which causes a reverse slice.\n\n For slice input[val0, val1, ..., valn], begin/end/strides will be vectors of length n.\n\n In each mask field(begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask)\n the ith bit will correspond to the ith val.\n\n If the ith bit of begin_mask is set, begin[i] is ignored and the fullest possible range\n in that dimension is used instead.\n\n If the ith bit of ellipsis_mask is set, as many unspecified dimensions as needed will be\n inserted between other dimensions. Only one non-zero bit is allowed in ellipsis_mask.\n\n If the ith bit of new_axis_mask is set, then begin, end, and stride are ignored and a\n new length 1 dimension is added at this point in the output tensor.\n\n If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks\n the dimensionality by 1, taking on the value at index begin[i]. end[i] and strides[i]\n are ignored in this case.\n begin and end are zero-indexed. strides entries must be non-zero.\n\n TVM Relay implementation of doesn't support mask, so the mask values are processed in\n this function and begin/end/strides are updated accordingly. If any mask is present, and\n since tvm doesn't support mask computation directly, the output need a final reshape.\n \"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.StridedSliceOptions import StridedSliceOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 4, \"input tensors length should be 4\"\n\n data_expr = self.get_expr(input_tensors[0].tensor_idx)\n\n begin = list(self.get_tensor_value(input_tensors[1]))\n end = list(self.get_tensor_value(input_tensors[2]))\n stride = list(self.get_tensor_value(input_tensors[3]))\n\n assert op.BuiltinOptionsType() == BuiltinOptions.StridedSliceOptions\n op_options = op.BuiltinOptions()\n options = StridedSliceOptions()\n options.Init(op_options.Bytes, op_options.Pos)\n begin_mask = options.BeginMask()\n end_mask = options.EndMask()\n ellipsis_mask = options.EllipsisMask()\n new_axis_mask = options.NewAxisMask()\n shrink_axis_mask = options.ShrinkAxisMask()\n\n data_shape = list(input_tensors[0].tensor.ShapeAsNumpy())\n data_dim = len(data_shape)\n stride_dim = len(stride)\n def _transform_mask(stride_dim, ellipsis_mask):\n \"\"\"Handle mask inputs to create new begin, end, stride and output shape\"\"\"\n m_begin = [0] data_dim\n m_end = [0] * data_dim\n m_stride = [0] * data_dim\n fshape_indices = []\n #Count new axis after ellipsis_mask, consider while applying ellipsis_mask.\n ellipsis_seen = False\n new_axes_after_ellipsis = 0\n for i in range(stride_dim):\n mask = 1 << i\n if ellipsis_seen and (mask & new_axis_mask) != 0:\n new_axes_after_ellipsis += 1\n if (mask & ellipsis_mask) != 0:\n ellipsis_seen = True\n if not ellipsis_seen:\n #Used later for extending the stride attributes in the below loop.\n ellipsis_mask \|= (1 << stride_dim)\n stride_dim += 1\n final_index = 0\n for index in range(stride_dim):\n mask = 1 << index\n if mask & ellipsis_mask:\n #Identify the end index for applying ellipsis_mask\n to_index = min(((data_dim - (stride_dim-index)) + 1 \\\n + new_axes_after_ellipsis), data_dim)\n for i in range(final_index, to_index):\n m_begin[final_index] = 0\n m_end[final_index] = data_shape[final_index]\n m_stride[final_index] = 1\n fshape_indices.append(final_index)\n final_index += 1\n elif mask &new_axis_mask:\n fshape_indices.append(-1)\n elif not mask & new_axis_mask:\n if final_index == len(m_begin):\n break\n if mask & begin_mask:\n m_begin[final_index] = data_shape[final_index] \\\n if stride[index] < 0 else 0\n elif begin[index]:\n m_begin[final_index] = begin[index]\n if mask & end_mask:\n m_end[final_index] = 0 if stride[index] < 0 \\\n else data_shape[final_index]\n elif end[index]:\n m_end[final_index] = end[index]\n m_stride[final_index] = stride[index]\n if mask & shrink_axis_mask:\n #Tensorflow make axis with shrink_axis_mask as dimension 1\n m_begin[final_index] = data_shape[final_index] + begin[index] \\\n if begin[index] < 0 else begin[index]\n m_end[final_index] = begin[index] + 1\n m_stride[final_index] = 1\n fshape_indices.append(-2)\n else:\n fshape_indices.append(final_index)\n\n final_index += 1\n return m_begin, m_end, m_stride, fshape_indices\n\n fshape_indices = None\n if begin_mask or end_mask or ellipsis_mask or new_axis_mask or shrink_axis_mask:\n begin, end, stride, fshape_indices = _transform_mask(stride_dim, ellipsis_mask)\n\n out = _op.strided_slice(data_expr, begin=begin, end=end, strides=stride)\n out_shape = _infer_shape(out)\n if not fshape_indices:\n fshape_indices = range(len(out_shape))\n\n #Create final output shape.\n final_output = []\n for gather_index in fshape_indices:\n if gather_index == -1:\n final_output.append(1)\n elif gather_index == -2:\n pass\n else:\n final_output.append(out_shape[gather_index])\n\n if not final_output:\n return out\n return _op.reshape(out, newshape=tuple(final_output))\n\n def convert_zeros_like(self, op):\n \"\"\"Convert TFLite ZEROS LIKE\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.zeros_like(in_expr)\n\n return out\n\n def convert_fill(self, op):\n \"\"\"Convert TFLite FILL\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n if self.has_expr(input_tensors[0].tensor_idx):\n raise tvm.error.OpNotImplemented(\"For dims parameter of Fill operator,\"\n \" only constant values are supported.\")\n\n in_dims = list(self.get_tensor_value(input_tensors[0]))\n in_value_expr = self.get_expr(input_tensors[1].tensor_idx)\n out = _op.full(in_value_expr, in_dims)\n\n return out\n\n def _convert_reduce(self, relay_op, op):\n \"\"\"Generic method to Convert TFLite REDUCE operators\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ReducerOptions import ReducerOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # input_tensor\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # axis\n axis = tuple(self.get_tensor_value(input_tensors[1]))\n\n # Options - keep_dims (bool)\n assert op.BuiltinOptionsType() == BuiltinOptions.ReducerOptions\n reduce_options = ReducerOptions()\n op_options = op.BuiltinOptions()\n reduce_options.Init(op_options.Bytes, op_options.Pos)\n keep_dims = reduce_options.KeepDims()\n\n if input_tensor.qnn_params:\n in_expr = _op.cast(in_expr, \"int32\")\n\n out = relay_op(in_expr, axis, keep_dims)\n\n # Finally if the reduce is quantized. Add a requantize at the end.\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type_str = self.get_tensor_type_str(output_tensor.tensor.Type())\n if output_tensor.qnn_params:\n out = _qnn.op.requantize(out,\n input_scale=input_tensor.qnn_params['scale'],\n input_zero_point=input_tensor.qnn_params['zero_point'],\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n out_dtype=output_tensor_type_str)\n\n return out\n\n def convert_reduce_min(self, op):\n return self._convert_reduce(_op.reduce.min, op)\n\n def convert_reduce_max(self, op):\n return self._convert_reduce(_op.reduce.max, op)\n\n def convert_reduce_mean(self, op):\n return self._convert_reduce(_op.reduce.mean, op)\n\n def convert_reduce_prod(self, op):\n return self._convert_reduce(_op.reduce.prod, op)\n\n def convert_reduce_sum(self, op):\n return self._convert_reduce(_op.reduce.sum, op)\n\n def convert_reduce_any(self, op):\n return self._convert_reduce(_op.reduce.any, op)\n\n def convert_fully_connected(self, op):\n \"\"\"Convert TFLite fully connected\"\"\"\n try:\n from tflite.FullyConnectedOptions import FullyConnectedOptions\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 2, \"input tensors length should be >= 2\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n weight_tensor = input_tensors[1]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n input_tensor_shape = input_tensor.tensor.ShapeAsNumpy()\n weight_tensor_shape = weight_tensor.tensor.ShapeAsNumpy()\n\n # Weight should have only 2 dimensions(TFLite convention)\n assert len(weight_tensor_shape) == 2, \"Weight should be only 2-dim\"\n\n # Input shape: [i_batch_size, ..., n_inputs]\n # Filter shape: [n_inputs, n_units]\n #\n # As we will transform Fully_Connected Input to Dense Op inputs as below\n # Dense expected Input shape: [batch_size, n_units]\n # Dense expected Weight shape: [out_dim, n_units]\n # Dense output shape: [batch_size, out_dim]\n # So it is evident that input shape: [batch_size = input_size / n_units, n_units]\n input_size = 1\n for _, shape in enumerate(input_tensor_shape):\n input_size = shape\n\n # First get the batch size\n batch_size = int(input_size / weight_tensor_shape[1])\n target_shape = tuple((batch_size, weight_tensor_shape[1]))\n in_expr = self.get_expr(input_tensor_idx)\n in_expr = _op.reshape(in_expr, target_shape)\n\n #TODO: Change the output shape calculation based on keep_dim option\n assert op.BuiltinOptionsType() == BuiltinOptions.FullyConnectedOptions\n op_options = op.BuiltinOptions()\n fully_connected_options = FullyConnectedOptions()\n fully_connected_options.Init(op_options.Bytes, op_options.Pos)\n fused_activation_fn = fully_connected_options.FusedActivationFunction()\n\n # weight tensor type should be UINT8 (quantization) or FLOAT32\n weight_tensor_type = weight_tensor.tensor.Type()\n assert weight_tensor_type in (TensorType.UINT8, TensorType.FLOAT32)\n weight_tensor_type_str = self.get_tensor_type_str(weight_tensor_type)\n\n if self.has_expr(weight_tensor.tensor_idx):\n weight_expr = self.get_expr(weight_tensor.tensor_idx)\n else:\n weight_value = self.get_tensor_value(weight_tensor)\n weight_expr = self.exp_tab.new_const(weight_value, dtype=weight_tensor_type_str)\n weight_shape = _infer_shape(weight_expr)\n\n if input_tensor.qnn_params:\n out = _qnn.op.dense(in_expr, weight_expr,\n input_zero_point=input_tensor.qnn_params['zero_point'],\n kernel_zero_point=weight_tensor.qnn_params['zero_point'],\n input_scale=input_tensor.qnn_params['scale'],\n kernel_scale=weight_tensor.qnn_params['scale'],\n units=weight_shape[0],\n out_dtype='int32')\n else:\n out = _op.nn.dense(in_expr, weight_expr)\n\n # if we have bias\n if len(input_tensors) == 3:\n bias_tensor = input_tensors[2]\n bias_tensor_type = bias_tensor.tensor.Type()\n # bias tensor type should be INT32 (quantization) or FLOAT32\n assert bias_tensor_type in (TensorType.INT32, TensorType.FLOAT32)\n bias_tensor_type_str = self.get_tensor_type_str(bias_tensor_type)\n bias_expr = self.exp_tab.new_const(self.get_tensor_value(bias_tensor),\n dtype=bias_tensor_type_str)\n out = _op.nn.bias_add(out, bias_expr)\n\n # Finally if the dense is quantized. Add a requantize at the end.\n if output_tensor.qnn_params:\n data_scale = input_tensor.qnn_params['scale']\n weight_scale = weight_tensor.qnn_params['scale']\n data_scale_val = get_scalar_from_constant(data_scale)\n weight_scale_val = get_scalar_from_constant(weight_scale)\n new_input_scale_val = data_scale_val weight_scale_val\n new_input_scale = relay.const(new_input_scale_val, 'float32')\n new_input_zero_point = relay.const(0, 'int32')\n\n # Requantize\n out = _qnn.op.requantize(out,\n input_scale=new_input_scale,\n input_zero_point=new_input_zero_point,\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n out_dtype=output_tensor_type_str)\n\n # Call activation function\n output_scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n output_zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=output_scale_val,\n zero_point=output_zero_point_val,\n dtype=output_tensor_type_str)\n\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_squeeze(self, op):\n \"\"\"Convert TFLite squeeze\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.SqueezeOptions import SqueezeOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n output_tensors = self.get_output_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n assert op.BuiltinOptionsType() == BuiltinOptions.SqueezeOptions\n op_options = op.BuiltinOptions()\n squeeze_options = SqueezeOptions()\n squeeze_options.Init(op_options.Bytes, op_options.Pos)\n squeeze_axis = squeeze_options.SqueezeDimsAsNumpy()\n\n in_expr = self.get_expr(input_tensor_idx)\n out = _op.squeeze(in_expr, axis=tuple(squeeze_axis))\n\n return out\n\n def convert_fused_activation_function(self, in_expr, fused_activation_fn):\n \"\"\"Convert TFLite fused activation function\"\"\"\n try:\n from tflite.ActivationFunctionType import ActivationFunctionType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if fused_activation_fn == ActivationFunctionType.NONE:\n return in_expr\n if fused_activation_fn == ActivationFunctionType.RELU6:\n return _op.clip(in_expr, a_min=0, a_max=6)\n if fused_activation_fn == ActivationFunctionType.RELU:\n return _op.nn.relu(in_expr)\n if fused_activation_fn == ActivationFunctionType.RELU_N1_TO_1:\n return _op.clip(in_expr, a_min=-1, a_max=1)\n if fused_activation_fn == ActivationFunctionType.TANH:\n return _op.tanh(in_expr)\n fused_activation_fn_str = self.activation_fn_type[fused_activation_fn]\n raise tvm.error.OpNotImplemented(\n 'Fused activation {} is not supported yet.'.format(fused_activation_fn_str))\n\n def convert_conv(self, op, conv_type):\n \"\"\"convolution implementation.\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.TensorType import TensorType\n from tflite.Conv2DOptions import Conv2DOptions\n from tflite.DepthwiseConv2DOptions import DepthwiseConv2DOptions\n from tflite.Padding import Padding\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 2, \"input tensors length should be >= 2\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n weight_tensor = input_tensors[1]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n is_depthwise_conv = False\n if conv_type == 'conv2d':\n assert op.BuiltinOptionsType() == BuiltinOptions.Conv2DOptions\n op_options = op.BuiltinOptions()\n conv_options = Conv2DOptions()\n conv_options.Init(op_options.Bytes, op_options.Pos)\n elif conv_type == 'depthwise':\n is_depthwise_conv = True\n assert op.BuiltinOptionsType() == BuiltinOptions.DepthwiseConv2DOptions\n op_options = op.BuiltinOptions()\n conv_options = DepthwiseConv2DOptions()\n conv_options.Init(op_options.Bytes, op_options.Pos)\n depth_multiplier = conv_options.DepthMultiplier()\n else:\n raise tvm.error.OpNotImplemented(\n 'Operator {} is not supported for frontend TFLite.'.format(conv_type))\n\n stride_h = conv_options.StrideH()\n stride_w = conv_options.StrideW()\n dilation_h = conv_options.DilationHFactor()\n dilation_w = conv_options.DilationWFactor()\n padding = conv_options.Padding()\n fused_activation_fn = conv_options.FusedActivationFunction()\n\n _, input_h, input_w, input_c = input_tensor.tensor.ShapeAsNumpy()\n\n if is_depthwise_conv:\n # TFLite depthwise convolution kernel layout is:\n # 1 KH KW C(input_c * depth_multiplier)\n _, kernel_h, kernel_w, in_channels = weight_tensor.tensor.ShapeAsNumpy()\n assert in_channels == input_c * depth_multiplier\n else:\n output_channels, kernel_h, kernel_w, _ = weight_tensor.tensor.ShapeAsNumpy()\n\n dilated_kernel_h = dilation_h * (kernel_h - 1) + 1\n dilated_kernel_w = dilation_w * (kernel_w - 1) + 1\n\n params = {'kernel_size': [kernel_h, kernel_w],\n 'strides': [stride_h, stride_w],\n 'dilation': [dilation_h, dilation_w],\n 'padding': [0, 0],\n 'data_layout': 'NHWC'}\n\n if is_depthwise_conv:\n params['channels'] = int(in_channels)\n params['groups'] = int(input_c)\n # If number of input channels is 1, treat as normal\n # convolution.\n params['kernel_layout'] = 'HWIO' if input_c == 1 else 'HWOI'\n else:\n params['channels'] = int(output_channels)\n params['kernel_layout'] = 'HWIO'\n\n # weight tensor type should be UINT8 (quantization) or FLOAT32\n weight_tensor_type = weight_tensor.tensor.Type()\n assert weight_tensor_type in (TensorType.UINT8, TensorType.FLOAT32)\n weight_tensor_type_str = self.get_tensor_type_str(weight_tensor_type)\n\n in_expr = self.get_expr(input_tensor_idx)\n weight_value = self.get_tensor_value(weight_tensor)\n\n # TFLite kernel layout:\n # convolution:\n # OC KH KW IC, we require KH KW IC OC (HWIO)\n # depthwise convolution:\n # 1 KH KW C(input_c * depth_multiplier), we require\n # KH KW IC M (depth_multiplier) (HWOI)\n if is_depthwise_conv:\n weight_value = weight_value.reshape(kernel_h, kernel_w, input_c, depth_multiplier)\n else:\n weight_value = weight_value.transpose((1, 2, 3, 0))\n\n weight_expr = self.exp_tab.new_const(weight_value, dtype=weight_tensor_type_str)\n\n if padding == Padding.VALID:\n pass\n elif padding == Padding.SAME:\n pad_top, pad_bottom = get_pad_value(input_h, dilated_kernel_h, stride_h)\n pad_left, pad_right = get_pad_value(input_w, dilated_kernel_w, stride_w)\n do_pad = not (pad_top == 0 and pad_bottom == 0 and pad_left == 0 and pad_right == 0)\n if do_pad:\n params['padding'] = [pad_top, pad_left, pad_bottom, pad_right]\n\n else:\n raise tvm.error.OpAttributeUnImplemented(\n 'Padding format {} is not supported for operator Conv.'.format(padding))\n\n if input_tensor.qnn_params:\n qnn_conv2d_params = dict(params)\n qnn_conv2d_params['input_zero_point'] = input_tensor.qnn_params['zero_point']\n qnn_conv2d_params['kernel_zero_point'] = weight_tensor.qnn_params['zero_point']\n qnn_conv2d_params['out_dtype'] = 'int32'\n qnn_conv2d_params['input_scale'] = input_tensor.qnn_params['scale']\n qnn_conv2d_params['kernel_scale'] = weight_tensor.qnn_params['scale']\n out = _qnn.op.conv2d(in_expr, weight_expr, qnn_conv2d_params)\n else:\n out = _op.nn.conv2d(in_expr, weight_expr, params)\n\n # if we have bias\n if len(input_tensors) == 3:\n bias_tensor = input_tensors[2]\n bias_tensor_type = bias_tensor.tensor.Type()\n # bias tensor type should be INT32 (quantization) or FLOAT32\n assert bias_tensor_type in (TensorType.INT32, TensorType.FLOAT32)\n bias_tensor_type_str = self.get_tensor_type_str(bias_tensor_type)\n bias_expr = self.exp_tab.new_const(self.get_tensor_value(bias_tensor),\n dtype=bias_tensor_type_str)\n channel_axis = 3\n out = _op.nn.bias_add(out, bias_expr, axis=channel_axis)\n\n # Handle fused activation.\n if output_tensor.qnn_params:\n # Calculate the intermediate scale and zero point of the int32 output.\n data_scale = input_tensor.qnn_params['scale']\n weight_scale = weight_tensor.qnn_params['scale']\n data_scale_val = get_scalar_from_constant(data_scale)\n weight_scale_val = get_scalar_from_constant(weight_scale)\n new_input_scale_val = data_scale_val * weight_scale_val\n new_input_scale = relay.const(new_input_scale_val, 'float32')\n new_input_zero_point = relay.const(0, 'int32')\n\n # Finally requantize\n out = _qnn.op.requantize(out,\n input_scale=new_input_scale,\n input_zero_point=new_input_zero_point,\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n out_dtype=output_tensor_type_str)\n\n # Call activation function\n output_scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n output_zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=output_scale_val,\n zero_point=output_zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_split(self, op):\n \"\"\"split implementation.\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.SplitOptions import SplitOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n\n assert len(input_tensors) == 2, \"input tensors length should be == 2\"\n\n axis_tensor = input_tensors[0]\n split_axis = self.get_tensor_value(axis_tensor)\n input_tensor = input_tensors[1]\n input_tensor_idx = input_tensor.tensor_idx\n\n assert op.BuiltinOptionsType() == BuiltinOptions.SplitOptions\n op_options = op.BuiltinOptions()\n split_options = SplitOptions()\n split_options.Init(op_options.Bytes, op_options.Pos)\n num_splits = split_options.NumSplits()\n\n in_expr = self.get_expr(input_tensor_idx)\n out = _op.split(in_expr, num_splits, axis=int(split_axis))\n # Relay does not like a TupleWrapper of 1 element, further this\n # only shows up with tf1.13 if we use a split with num_splits==1.\n # In tf 1.14 this doesn't appear as it is automatically a reshape\n # operation.\n if isinstance(out, _expr.TupleWrapper):\n if out.size == 1:\n out = out[0]\n\n return out\n\n def convert_split_v(self, op):\n \"\"\"SPLIT_V implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n\n if self.has_expr(input_tensors[1].tensor_idx):\n raise tvm.error.OpNotImplemented(\"For size_splits parameter of SPLIT_V operator, \"\n \"only constant values are supported.\")\n size_splits = list(self.get_tensor_value(input_tensors[1]))\n size_splits = tuple(np.cumsum(size_splits)[:-1])\n\n axis_tensor = input_tensors[2]\n split_axis = self.get_tensor_value(axis_tensor)\n\n out = _op.split(in_expr, size_splits, axis=int(split_axis))\n # Relay does not like a TupleWrapper of 1 element, further this\n # only shows up with tf1.13 if we use a split with num_splits==1.\n # In tf 1.14 this doesn't appear as it is automatically a reshape\n # operation.\n if isinstance(out, _expr.TupleWrapper) and out.size == 1:\n out = out[0]\n\n return out\n\n def convert_slice(self, op):\n \"\"\"Convert TFLite SLICE\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be == 3\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n begin = list(self.get_tensor_value(input_tensors[1]))\n size = list(self.get_tensor_value(input_tensors[2]))\n # strided_slice(Relay) needs the slice's end indices, not the size\n end = size\n input_tensor_shape = input_tensor.tensor.ShapeAsNumpy()\n input_tensor_rank = len(input_tensor_shape)\n for i in range(input_tensor_rank):\n if size[i] == -1:\n end[i] = input_tensor_shape[i]\n else:\n end[i] += begin[i]\n\n out = _op.strided_slice(in_expr, begin, end)\n\n return out\n\n def convert_select(self, op):\n \"\"\"Convert TFLite SELECT\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be == 3\"\n cond = self.get_tensor_expr(input_tensors[0])\n x = self.get_tensor_expr(input_tensors[1])\n y = self.get_tensor_expr(input_tensors[2])\n\n out = _op.where(cond, x, y)\n\n return out\n\n def convert_transpose(self, op):\n \"\"\"transpose implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n in_expr = self.get_expr(input_tensor_idx)\n\n # axis\n in_axis = tuple(self.get_tensor_value(input_tensors[1]))\n\n if not in_axis:\n out = _op.transpose(in_expr)\n else:\n out = _op.transpose(in_expr, in_axis)\n\n return out\n\n def convert_cast(self, op):\n \"\"\"Convert TFLite CAST\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.CastOptions import CastOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.CastOptions\n op_options = op.BuiltinOptions()\n cast_options = CastOptions()\n cast_options.Init(op_options.Bytes, op_options.Pos)\n cast_dtype = cast_options.OutDataType()\n\n out = _op.cast(in_expr, self.get_tensor_type_str(cast_dtype))\n\n return out\n\n def convert_tile(self, op):\n \"\"\"tile implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n in_expr = self.get_expr(input_tensor_idx)\n\n # reps (tuple of int) – The number of times repeating the tensor data.\n reps = tuple(self.get_tensor_value(input_tensors[1]))\n\n out = _op.tile(in_expr, reps)\n\n return out\n\n def convert_topk_v2(self, op):\n \"\"\" Convert TFLite TOPK_v2 \"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n k = self.get_tensor_value(input_tensors[1])\n out = _op.topk(in_expr, int(k))\n\n return out\n\n def convert_pool2d(self, op, pool_type):\n \"\"\"pool2d implementation.\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.Pool2DOptions import Pool2DOptions\n from tflite.Padding import Padding\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.Pool2DOptions\n op_options = op.BuiltinOptions()\n pool2d_options = Pool2DOptions()\n pool2d_options.Init(op_options.Bytes, op_options.Pos)\n stride_h = pool2d_options.StrideH()\n stride_w = pool2d_options.StrideW()\n padding = pool2d_options.Padding()\n filter_h = pool2d_options.FilterHeight()\n filter_w = pool2d_options.FilterWidth()\n fused_activation_fn = pool2d_options.FusedActivationFunction()\n\n params = {'pool_size': (filter_h, filter_w),\n 'strides': (stride_h, stride_w),\n 'padding': [0, 0],\n 'layout': 'NHWC'}\n\n in_expr = self.get_expr(input_tensor_idx)\n\n _, input_h, input_w, _ = input_tensor.tensor.ShapeAsNumpy()\n if padding == Padding.VALID:\n pass\n elif padding == Padding.SAME:\n pad_top, pad_bottom = get_pad_value(input_h, filter_h, stride_h)\n pad_left, pad_right = get_pad_value(input_w, filter_w, stride_w)\n params['padding'] = [pad_top, pad_left, pad_bottom, pad_right]\n else:\n raise tvm.error.OpAttributeUnImplemented(\n 'Padding format {} for operator Pool2D is not supported.'.format(padding))\n\n if pool_type == \"average\":\n if input_tensor.qnn_params:\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n 'TFLite avg_pool2dreshape requires input and output scale' \\\n 'and zero points to be equal'\n out = _op.cast(in_expr, dtype=\"int32\")\n out = _op.nn.avg_pool2d(out, params)\n out = _op.cast(out, dtype=output_tensor_type_str)\n else:\n out = _op.nn.avg_pool2d(in_expr, params)\n elif pool_type == \"max\":\n if input_tensor.qnn_params:\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n \"qnn.op.max_pool2d requires input and output qnn params to be same\"\n out = _op.nn.max_pool2d(in_expr, params)\n elif pool_type == \"l2\":\n # L2_POOL_2D is equivalent to square_root(avg_pool(square(in_data)))\n # TFLite does not have support for quantised L2_POOL_2D op.\n assert not input_tensor.qnn_params, \\\n \"As TFLite does not have support for quantized L2_POOL_2D, \\\n Quantized input is not expected.\"\n exp_type = self.get_tensor_type_str(output_tensor.tensor.Type())\n square_exp = _op.power(in_expr, relay.const(2, exp_type))\n avg_pool_exp = _op.nn.avg_pool2d(square_exp, params)\n out = _op.sqrt(avg_pool_exp)\n else:\n raise tvm.error.OpNotImplemented(\n 'Operator {} is not supported for frontend TFLite.'.format(pool_type + ' pool'))\n\n # Handle fused activations\n if output_tensor.qnn_params:\n scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=scale_val,\n zero_point=zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_pad(self, op):\n \"\"\"Convert TFLite PAD\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # TFLite PAD only support CONSTANT mode and does not support constant_values parameter.\n # tensor\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # paddings\n pad_list = self.get_tensor_value(input_tensors[1])\n # convert list of lists to tuple of tuples\n paddings = tuple(tuple(l) for l in pad_list)\n\n # Set the pad value\n pad_value = 0\n if input_tensor.qnn_params:\n # Check that input and output tensor have same qnn params.\n output_tensors = self.get_output_tensors(op)\n output_tensor = output_tensors[0]\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n \"TFLite reshape requires input and output scale and zero points to be equal\"\n\n # The pad value for quantized pad is the input zero point.\n pad_value = float(input_tensor.qnn_params['zero_point'].data.asnumpy())\n\n out = _op.nn.pad(in_expr, pad_width=paddings, pad_value=pad_value)\n return out\n\n def convert_floor_div(self, op):\n \"\"\"Convert TFLite FLOOR_DIV\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized FLOOR DIV operator is not supported yet.')\n return self._convert_elemwise(_op.floor_divide, op)\n\n def convert_floor_mod(self, op):\n \"\"\"Convert TFLite FLOOR_MOD\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized FLOOR MOD operator is not supported yet.')\n return self._convert_elemwise(_op.floor_mod, op)\n\n def convert_mirror_pad(self, op):\n \"\"\"Convert TFLite MIRROR_PAD\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.MirrorPadOptions import MirrorPadOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n # the quantized form MirrorPad is not yet implemented in TFLite.\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized MIRROR_PAD operator is not supported yet.')\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # tensor\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # paddings\n pad_list = self.get_tensor_value(input_tensors[1])\n # convert list of lists to tuple of tuples\n paddings = tuple(tuple(l) for l in pad_list)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.MirrorPadOptions\n op_options = op.BuiltinOptions()\n mirror_pad_options = MirrorPadOptions()\n mirror_pad_options.Init(op_options.Bytes, op_options.Pos)\n mode_byte = mirror_pad_options.Mode()\n\n mode = \"REFLECT\" if mode_byte == 0 else \"SYMMETRIC\"\n out = _op.nn.mirror_pad(in_expr, paddings, mode)\n\n return out\n\n def convert_pack(self, op):\n \"\"\"Convert TFLite pack\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.PackOptions import PackOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 1, \"input tensors should greater than 1\"\n in_exprs = [self.get_expr(input_tensor.tensor_idx) for input_tensor in input_tensors]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n\n assert op.BuiltinOptionsType() == BuiltinOptions.PackOptions\n op_options = op.BuiltinOptions()\n pack_options = PackOptions()\n pack_options.Init(op_options.Bytes, op_options.Pos)\n pack_axis = pack_options.Axis()\n\n in_exprs_reshaped = [_op.expand_dims(i, axis=pack_axis, num_newaxis=1) for i in in_exprs]\n out = _op.concatenate(in_exprs_reshaped, pack_axis)\n return out\n\n def convert_unpack(self, op):\n \"\"\"Convert TFLite unpack\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.UnpackOptions import UnpackOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n assert op.BuiltinOptionsType() == BuiltinOptions.UnpackOptions\n op_options = op.BuiltinOptions()\n unpack_options = UnpackOptions()\n unpack_options.Init(op_options.Bytes, op_options.Pos)\n num_unpacks = unpack_options.Num()\n unpack_axis = unpack_options.Axis()\n\n # Relay doesn't support 'unpack' operator so we use 'split' & 'squeeze' instead.\n # We have to do 'squeeze' along the split axis but Relay expects\n # squeeze_axis to be either None or List.\n squeeze_axis = None if unpack_axis == 0 else [unpack_axis]\n\n # Relay doesn't like TupleWrapper of 1 element so we isolate the case of unpacking\n # a tensor by an axis with len(axis) == 1. For reference see convert_split().\n # Such unpacking will result in the same tensor so we omit 'split' and only squeeze\n # along the axis of dim == 1.\n if num_unpacks == 1:\n squeezed = _op.squeeze(in_expr, axis=squeeze_axis)\n if isinstance(squeezed, _expr.TupleWrapper):\n squeezed = squeezed[0]\n else:\n splitted = _op.split(in_expr,\n indices_or_sections=num_unpacks,\n axis=unpack_axis)\n squeezed = _expr.TupleWrapper(\n _expr.Tuple([_op.squeeze(split_item, axis=squeeze_axis) \\\n for split_item in splitted]), len(splitted))\n\n return squeezed\n\n def convert_batch_to_space_nd(self, op):\n \"\"\"batch_to_space_nd implementation.\"\"\"\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n\n input_shape = list(input_tensor.tensor.ShapeAsNumpy())\n batch = input_shape[0]\n\n block_shape = list(self.get_tensor_value(input_tensors[1]))\n M = len(block_shape)\n\n crops = list(self.get_tensor_value(input_tensors[2]))\n\n # From https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/batch-to-space-n-d:\n # Reshape input to reshaped of shape\n shape1 = block_shape + [batch // np.prod(block_shape)] + input_shape[1:]\n reshaped = _op.reshape(in_expr, newshape=shape1)\n\n # Permute dimensions of reshaped to produce permuted of shape\n axes = [M] + [axis for i in range(M) for axis in [M + i + 1, i]] + \\\n list(range(2 * M + 1, len(shape1)))\n permuted = _op.transpose(reshaped, axes=axes)\n\n # Reshape permuted to produce reshaped_permuted of shape\n shape2 = [0] + [-3] * M + [-2]\n reshaped_permuted = _op.reshape(permuted, newshape=shape2)\n\n # Crop the start and end of dimensions [1, ..., M] of reshaped_permuted according to crops\n # to produce the output of shape:\n reshaped_permuted_shape = _infer_shape(reshaped_permuted)\n cropped = reshaped_permuted\n for axis in range(1, M + 1):\n crop = crops[axis - 1]\n if (crop != [0, 0]).all():\n indices = _op.arange(\n _expr.const(crop[0]),\n _expr.const(reshaped_permuted_shape[axis] - crop[1]),\n dtype='int32'\n )\n cropped = _op.take(cropped, indices=indices, axis=axis)\n\n return cropped\n\n def convert_space_to_batch_nd(self, op):\n \"\"\"space_to_batch_nd implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n\n input_shape = list(input_tensor.tensor.ShapeAsNumpy())\n batch = input_shape[0]\n N = len(input_shape)\n\n block_shape = list(self.get_tensor_value(input_tensors[1]))\n M = len(block_shape)\n\n paddings = list(self.get_tensor_value(input_tensors[2]))\n\n # From https://www.tensorflow.org/api_docs/python/tf/space_to_batch_nd:\n # Zero-pad the start and end of dimensions [1, ..., M] of the input according to paddings\n # to produce padded of shape padded_shape.\n remaining_shape_length = N - M - 1\n padded_list = [(0, 0)] + paddings + [(0, 0)] * remaining_shape_length\n\n padded_shape = []\n for element in padded_list:\n if isinstance(element, np.ndarray):\n element = element.tolist()\n\n padded_shape.append(element)\n\n padded_shape = tuple(padded_shape)\n padded = _op.nn.pad(in_expr, pad_width=tuple(padded_shape))\n\n # Reshape padded to reshaped_padded of shape:\n shape1 = [batch] + [item for i in range(M) for item in [-4, -1, block_shape[i]]] + [-2]\n reshaped_padded = _op.reshape(padded, newshape=shape1)\n\n # Permute dimensions of reshaped_padded to produce permuted_reshaped_padded of shape:\n axes = [2 * i + 2 for i in range(M)] + [0] + [2 * i + 1 for i in range(M)] + \\\n list(range(1 + 2 * M, 1 + 2 * M + remaining_shape_length))\n permuted_reshaped_padded = _op.transpose(reshaped_padded, axes=axes)\n permuted_reshaped_padded_shape = _infer_shape(permuted_reshaped_padded)\n\n # Reshape permuted_reshaped_padded to flatten block_shape into the batch dimension,\n # producing an output tensor of shape:\n shape2 = [batch * np.prod(block_shape)] + list(permuted_reshaped_padded_shape)[M + 1:]\n reshaped_permuted_reshaped_padded = _op.reshape(permuted_reshaped_padded, newshape=shape2)\n\n return reshaped_permuted_reshaped_padded\n\n def convert_depth_to_space(self, op):\n \"\"\"Convert TFLite DEPTH_TO_SPACE\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.DepthToSpaceOptions import DepthToSpaceOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.DepthToSpaceOptions\n op_options = op.BuiltinOptions()\n depth_to_space_options = DepthToSpaceOptions()\n depth_to_space_options.Init(op_options.Bytes, op_options.Pos)\n block_size = depth_to_space_options.BlockSize()\n out = _op.nn.depth_to_space(in_expr, block_size, layout='NHWC')\n\n return out\n\n def convert_space_to_depth(self, op):\n \"\"\"Convert TFLite SPACE_TO_DEPTH\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.SpaceToDepthOptions import SpaceToDepthOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.SpaceToDepthOptions\n op_options = op.BuiltinOptions()\n space_to_depth_options = SpaceToDepthOptions()\n space_to_depth_options.Init(op_options.Bytes, op_options.Pos)\n block_size = space_to_depth_options.BlockSize()\n out = _op.nn.space_to_depth(in_expr, block_size, layout='NHWC')\n\n return out\n\n def convert_sparse_to_dense(self, op):\n \"\"\"Convert TFLite SPARSE_TO_DENSE\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 4, \"input tensors length should be 4\"\n\n indices, values = input_tensors[0], input_tensors[2]\n default_value = input_tensors[3]\n output_shape = input_tensors[1]\n\n for t in input_tensors:\n assert not t.qnn_params, \"Quantized input is not expected.\"\n\n for t in [indices, output_shape]:\n t_type = t.tensor.Type()\n assert t_type in (TensorType.INT32, TensorType.INT64)\n\n out = _op.sparse_to_dense(\n self.get_tensor_expr(indices),\n list(self.get_tensor_value(output_shape)),\n self.get_tensor_expr(values),\n self.get_tensor_expr(default_value)\n )\n\n return out\n\n def convert_prelu(self, op):\n \"\"\"Convert TFLite PReLU\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n input_tensor = input_tensors[0]\n alpha_tensor = input_tensors[1]\n alpha_tensor_type = alpha_tensor.tensor.Type()\n alpha_tensor_type_str = self.get_tensor_type_str(alpha_tensor_type)\n alpha_expr = self.exp_tab.new_const(self.get_tensor_value(alpha_tensor).flatten(),\n dtype=alpha_tensor_type_str)\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.nn.prelu(in_expr, alpha_expr, axis=3)\n\n return out\n\n def convert_transpose_conv(self, op):\n \"\"\"Convert TFLite TRANSPOSE_CONV\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.TensorType import TensorType\n from tflite.TransposeConvOptions import TransposeConvOptions\n from tflite.Padding import Padding\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n # Input (data) Tensor. NHWC layout\n input_tensor = input_tensors[2]\n _, _, _, input_c = input_tensor.tensor.ShapeAsNumpy()\n # Weights tensor. TFLite uses OHWI layout\n weights_tensor = input_tensors[1]\n out_channels, kernel_h, kernel_w, in_channels = weights_tensor.tensor.ShapeAsNumpy()\n assert input_c == in_channels, \\\n \"Input channel in the filter should match to channel in the input\"\n # output_shape Tensor. NHWC layout\n output_shape_tensor = input_tensors[0]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.TransposeConvOptions\n op_options = op.BuiltinOptions()\n deconv_options = TransposeConvOptions()\n deconv_options.Init(op_options.Bytes, op_options.Pos)\n\n padding = deconv_options.Padding()\n stride_h = deconv_options.StrideH()\n stride_w = deconv_options.StrideW()\n assert padding in (Padding.VALID, Padding.SAME), \\\n 'Padding format {} is not supported for operator TRANSPOSE_CONV'.format(padding)\n\n # Data\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # Weights\n weights_tensor_type = weights_tensor.tensor.Type()\n # weights tensor type should be UINT8 (quantization) or FLOAT32\n assert weights_tensor_type in (TensorType.UINT8, TensorType.FLOAT32)\n weight_tensor_type_str = self.get_tensor_type_str(weights_tensor_type)\n weight_value_ohwi = self.get_tensor_value(weights_tensor)\n # Relay kernel_layout should be OIHW\n # Relay weights layout should be different from kernel_layout - it should be IOHW\n weight_value_iohw = np.transpose(weight_value_ohwi, (3, 0, 1, 2))\n weight_expr_iohw = self.exp_tab.new_const(weight_value_iohw, dtype=weight_tensor_type_str)\n\n # Output shape value\n output_shape_value = self.get_tensor_value(output_shape_tensor)\n # Relay expects filter output channel to match to output tensor channel.\n assert out_channels == output_shape_value[3], \\\n \"Output channel in the filter should match to channel in the output_shape\"\n\n # TF frontend supports 'SAME' padding for kernel 1x1 only. Lets do the same here\n if padding == Padding.SAME:\n assert (kernel_h, kernel_w) == (1, 1), \\\n \"SAME padding is supported for kernel (1,1) only\"\n\n out = _op.nn.conv2d_transpose(in_expr, weight_expr_iohw,\n strides=(stride_h, stride_w),\n channels=int(out_channels),\n kernel_size=(int(kernel_h), int(kernel_w)),\n data_layout=\"NHWC\",\n kernel_layout=\"OIHW\",\n out_dtype=output_tensor_type_str)\n\n return out\n\n def convert_quantize(self, op):\n \"\"\"Convert TFLite Quantize\"\"\"\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n # The output must be quantized\n assert output_tensor.qnn_params\n # Quantize the input\n out = self.quantize(in_expr, output_tensor)\n\n return out\n\n def convert_dequantize(self, op):\n \"\"\"Convert TFLite Dequantize\"\"\"\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # The input must be quantized\n assert input_tensor.qnn_params\n # Dequantize the input.\n out = self.dequantize(in_expr, input_tensor)\n\n return out\n\n def convert_detection_postprocess(self, op):\n \"\"\"Convert TFLite_Detection_PostProcess\"\"\"\n flexbuffer = op.CustomOptionsAsNumpy().tobytes()\n custom_options = FlexBufferDecoder(flexbuffer).decode()\n\n if \"use_regular_nms\" in custom_options:\n if custom_options[\"use_regular_nms\"]:\n raise tvm.error.OpAttributeUnImplemented(\n \"use_regular_nms=True is not yet supported for operator {}.\"\n .format(\"TFLite_Detection_PostProcess\")\n )\n\n inputs = self.get_input_tensors(op)\n assert len(inputs) == 3, \"inputs length should be 3\"\n cls_pred = self.get_expr(inputs[1].tensor_idx)\n loc_prob = self.get_expr(inputs[0].tensor_idx)\n batch_size = inputs[1].tensor.Shape(0)\n anchor_values = self.get_tensor_value(inputs[2])\n anchor_boxes = len(anchor_values)\n anchor_type = self.get_tensor_type_str(inputs[2].tensor.Type())\n anchor_expr = self.exp_tab.new_const(anchor_values, dtype=anchor_type)\n\n if inputs[0].qnn_params:\n loc_prob = _qnn.op.dequantize(data=loc_prob,\n input_scale=inputs[0].qnn_params['scale'],\n input_zero_point=inputs[0].qnn_params['zero_point'])\n if inputs[1].qnn_params:\n cls_pred = _qnn.op.dequantize(data=cls_pred,\n input_scale=inputs[1].qnn_params['scale'],\n input_zero_point=inputs[1].qnn_params['zero_point'])\n if inputs[2].qnn_params:\n anchor_expr = _qnn.op.dequantize(data=anchor_expr,\n input_scale=inputs[2].qnn_params['scale'],\n input_zero_point=inputs[2].qnn_params['zero_point'])\n\n # reshape the cls_pred and loc_prob tensors so\n # they can be consumed by multibox_transform_loc\n cls_pred = _op.transpose(cls_pred, [0, 2, 1])\n # loc_prob coords are in yxhw format\n # need to convert to xywh\n loc_coords = _op.split(loc_prob, 4, axis=2)\n loc_prob = _op.concatenate(\n [loc_coords[1], loc_coords[0], loc_coords[3], loc_coords[2]], axis=2\n )\n loc_prob = _op.reshape(loc_prob, [batch_size, anchor_boxes4])\n\n # anchor coords are in yxhw format\n # need to convert to ltrb\n anchor_coords = _op.split(anchor_expr, 4, axis=1)\n anchor_y = anchor_coords[0]\n anchor_x = anchor_coords[1]\n anchor_h = anchor_coords[2]\n anchor_w = anchor_coords[3]\n plus_half = _expr.const(0.5, dtype='float32')\n minus_half = _expr.const(-0.5, dtype='float32')\n anchor_l = _op.add(anchor_x, _op.multiply(anchor_w, minus_half))\n anchor_r = _op.add(anchor_x, _op.multiply(anchor_w, plus_half))\n anchor_t = _op.add(anchor_y, _op.multiply(anchor_h, minus_half))\n anchor_b = _op.add(anchor_y, _op.multiply(anchor_h, plus_half))\n anchor_expr = _op.concatenate([anchor_l, anchor_t, anchor_r, anchor_b], axis=1)\n anchor_expr = _op.expand_dims(anchor_expr, 0)\n\n # attributes for multibox_transform_loc\n multibox_transform_loc_attrs = {}\n multibox_transform_loc_attrs[\"clip\"] = False\n multibox_transform_loc_attrs[\"threshold\"] = custom_options[\"nms_score_threshold\"]\n multibox_transform_loc_attrs[\"variances\"] = (\n 1 / custom_options[\"x_scale\"],\n 1 / custom_options[\"y_scale\"],\n 1 / custom_options[\"w_scale\"],\n 1 / custom_options[\"h_scale\"],\n )\n\n # attributes for non_max_suppression\n non_max_suppression_attrs = {}\n non_max_suppression_attrs[\"return_indices\"] = False\n non_max_suppression_attrs[\"iou_threshold\"] = custom_options[\"nms_iou_threshold\"]\n non_max_suppression_attrs[\"force_suppress\"] = False\n non_max_suppression_attrs[\"top_k\"] = anchor_boxes\n non_max_suppression_attrs[\"max_output_size\"] = custom_options[\"max_detections\"]\n non_max_suppression_attrs[\"invalid_to_bottom\"] = False\n\n ret = _op.vision.multibox_transform_loc(cls_pred, loc_prob,\n anchor_expr, multibox_transform_loc_attrs)\n ret = _op.vision.non_max_suppression(ret[0], ret[1], non_max_suppression_attrs)\n ret = _op.vision.get_valid_counts(ret, 0)\n valid_count = ret[0]\n # keep only the top 'max_detections' rows\n ret = _op.strided_slice(ret[1],\n [0, 0, 0],\n [batch_size, custom_options[\"max_detections\"], anchor_boxes])\n # the output needs some reshaping to match tflite\n ret = _op.split(ret, 6, axis=2)\n cls_ids = _op.reshape(ret[0], [batch_size, -1])\n scores = _op.reshape(ret[1], [batch_size, -1])\n boxes = _op.concatenate([ret[3], ret[2], ret[5], ret[4]], axis=2)\n ret = _expr.TupleWrapper(_expr.Tuple([boxes, cls_ids, scores, valid_count]), size=4)\n return ret\n\n def get_expr(self, input_tensor_idx):\n return self.exp_tab.get_expr(get_tensor_name(self.subgraph, input_tensor_idx))\n\n def has_expr(self, input_tensor_idx):\n return self.exp_tab.has_expr(get_tensor_name(self.subgraph, input_tensor_idx))\n\n def get_tensor_expr(self, tensor):\n \"\"\" Returns constant expr for constant else a tensor expr\"\"\"\n if self.has_expr(tensor.tensor_idx):\n # In most cases, we can assume that TOCO fuses elemwise operators\n # with constants - it means both will be tensors.\n expr = self.get_expr(tensor.tensor_idx)\n else:\n # However, in some corner cases, the elemwise operator is not fused,\n # we can receive as constant.\n type_str = self.get_tensor_type_str(tensor.tensor.Type())\n expr = self.exp_tab.new_const(self.get_tensor_value(tensor), dtype=type_str)\n\n return expr\n\n\ndef get_scalar_from_constant(expr):\n \"\"\" Returns scalar value from Relay constant scalar. \"\"\"\n assert isinstance(expr, _expr.Constant) and not expr.data.shape, \\\n \"Expr is not a constant scalar.\"\n value = expr.data.asnumpy()\n assert value.dtype == np.dtype(np.int32) or value.dtype == np.dtype(np.float32), \\\n \"value must be float32/int32\"\n return np.asscalar(value)\n\n\ndef build_str_map(obj):\n \"\"\"Build string map of TFLite enum int value\n\n Parameters\n ----------\n obj:\n TFLite class which contains enum int value, such as BuiltInOptions\n\n Returns\n -------\n String representation map of TFLite class enum int value\n \"\"\"\n ret = {}\n for field_name in dir(obj):\n if not field_name.startswith('_'):\n field_value = getattr(obj, field_name)\n if isinstance(field_value, int):\n ret[field_value] = field_name\n return ret\n\n# SAME padding: https://www.tensorflow.org/api_guides/python/nn\ndef get_pad_value(data, kernel, stride):\n \"\"\"Get the pad tuple of value for SAME padding\n\n Parameters\n ----------\n data:\n 1D input data\n\n kernel:\n 1D input kernel\n\n stride:\n 1D input stride\n\n Returns\n -------\n pad tuple of value\n \"\"\"\n\n out = int(math.ceil(float(data) / float(stride)))\n pad = max(0, (out - 1) stride + kernel - data)\n pad_before = pad // 2\n pad_after = pad - pad_before\n return pad_before, pad_after\n\n\ndef get_tensor_name(subgraph, tensor_idx):\n \"\"\"Get the tensor name.\n\n Parameters\n ----------\n subgraph:\n tflite.Subgraph.Subgraph\n\n tensor:\n tensor index in subgraph\n\n Returns\n -------\n tensor name in UTF-8 encoding\n \"\"\"\n return subgraph.Tensors(tensor_idx).Name().decode(\"utf-8\")\n\n\ndef from_tflite(model, shape_dict, dtype_dict):\n \"\"\"Convert from tflite model into compatible relay Function.\n\n Parameters\n ----------\n model:\n tflite.Model or tflite.Model.Model (depending on tflite version)\n\n shape_dict : dict of str to int list/tuple\n Input shapes of the model.\n\n dtype_dict : dict of str to str\n Input types of the model.\n\n Returns\n -------\n mod : tvm.IRModule\n The relay module for compilation.\n\n params : dict of str to tvm.nd.NDArray\n The parameter dict to be used by relay\n \"\"\"\n try:\n import tflite.SubGraph\n import tflite.BuiltinOperator\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n # TFLite.Model.Model has changed to TFLite.Model from 1.14 to 2.1\n try:\n import tflite\n assert isinstance(model, tflite.Model)\n except TypeError:\n import tflite.Model\n assert isinstance(model, tflite.Model.Model)\n\n # keep the same as tflite\n assert model.SubgraphsLength() == 1, \"only support one subgraph (main subgraph)\"\n subgraph = model.Subgraphs(0)\n\n # model inputs / outputs\n model_inputs = subgraph.InputsAsNumpy()\n model_outputs = subgraph.OutputsAsNumpy()\n\n exp_tab = ExprTable()\n for model_input in model_inputs:\n model_input_name = get_tensor_name(subgraph, model_input)\n shape = shape_dict[model_input_name] if model_input_name in shape_dict else None\n dtype = dtype_dict[model_input_name] if model_input_name in dtype_dict else \"float32\"\n exp_tab.set_expr(model_input_name, _expr.var(model_input_name, shape=shape, dtype=dtype))\n\n # op code in model\n op_converter = OperatorConverter(model, subgraph, exp_tab)\n op_converter.check_unsupported_ops()\n op_converter.convert_op_to_relay()\n\n # params and outputs\n params = {k:_nd.array(np.array(v)) for k, v in exp_tab.params.items()}\n outputs = [exp_tab.get_expr(get_tensor_name(subgraph, i)) for i in model_outputs]\n outputs = outputs[0] if len(outputs) == 1 else _expr.Tuple(outputs)\n func = _function.Function(analysis.free_vars(outputs), outputs)\n mod = IRModule.from_expr(func)\n return mod, params\n" ]	[ [ "numpy.asscalar", "numpy.cumsum", "numpy.dtype", "numpy.prod", "numpy.transpose", "numpy.array" ] ]
illdopejake/data_driven_pathology	[ "489e2d7dc8b6b7e459a56b70a95317b1619e31b7" ]	[ "CrossDecomp.py" ]	[ "import pandas\nimport numpy as np\nimport scipy.stats as stats\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\n\ndef evaluate_components(clf, x, y, n_iterations=500, check = 100,\n evaluate = True, plot = True, thr = 0.95,\n metric=None, random_state=123):\n \n if type(x) != type(pandas.DataFrame()):\n x = pandas.DataFrame(x)\n \n # fit model\n clf.fit(x,y)\n n_comps = clf.n_components\n \n # prepare output\n results = pandas.DataFrame(index = range(n_comps * (n_iterations+1)),\n columns = ['score', 'component', 'model'])\n results.loc[:,'component'] = list(range(n_comps))(n_iterations+1)\n results.loc[range(n_comps),'model'] = ['True']n_comps\n results.loc[range(n_comps,n_comps(n_iterations+1)), 'model'\n ] = ['Null'](n_compsn_iterations)\n if not metric:\n \ttrue_scores = [stats.pearsonr(clf.x_scores_[:,x], clf.y_scores_[:,x]\n )[0]2 for x in range(n_comps)]\n else:\n true_scores = [metric(clf.x_scores_[:,x], clf.y_scores_[:,x]\n ) for x in range(n_comps)]\n results.loc[results[results.model=='True'].index,'score'] = true_scores\n \n k = clf.n_components\n # permute and refit model\n rs = np.random.RandomState(random_state)\n x.index = range(len(x.index))\n for i in range(n_iterations):\n new_ind = rs.permutation(x.index)\n new_x = x.iloc[new_ind]\n newmod = clf.fit(new_x,y)\n if not metric:\n new_scores = [stats.pearsonr(newmod.x_scores_[:,x], \n newmod.y_scores_[:,x]\n )[0]2 for x in range(n_comps)]\n else:\n new_scores = [metric(newmod.x_scores_[:,x], newmod.y_scores_[:,x]\n ) for x in range(n_comps)]\n results.loc[range(k, k+n_comps), 'score'] = new_scores\n if check:\n if i % check == 0:\n print('finished iteration',i)\n \n k += n_comps\n \n if evaluate:\n if plot:\n cr = display_results(results, thr)\n else:\n cr = display_results(results, thr, False)\n \n return results, cr\n\ndef display_results(results, thr = 0.95, plot=True):\n \n if plot:\n # plot components\n sns.set_context('paper')\n plt.close()\n sns.catplot(x='component', y = 'score', hue='model', data=results,kind='point')\n plt.show()\n \n # get p-values\n comp_results = pandas.DataFrame(index=results.component.unique(),\n columns = ['r','p','sig'])\n for i in results.component.unique():\n nullz = results[(results.component==i) & (results.model=='Null')\n ]['score'].sort_values().values\n real = results[(results.component==i) & (results.model=='True')]['score'].values[0]\n comp_results.loc[i,'r'] = real\n p = (len(nullz[nullz>real])+1) / len(nullz)\n if p < (1 - thr):\n comp_results.loc[i,['p','sig']] = [p, 1]\n print('component %s: p = %s '%(i,p))\n else:\n comp_results.loc[i,['p','sig']] = [p, 0]\n print('component %s: p = %s'%(i,p))\n \n \n return comp_results\n\n\ndef bootstrap_features(clf, fit_model, X, y, n_iterations=500, check = 100, on ='x'):\n \n if type(X) != type(pandas.DataFrame()):\n X = pandas.DataFrame(X)\n if type(y) != type(pandas.DataFrame()):\n y = pandas.DataFrame(y)\n\n # fit model\n orig = fit_model\n\n # prepare output\n n_feats_x = X.shape[-1]\n n_feats_y = y.shape[-1]\n all_results_x = {}\n all_results_y = {}\n\n for i in range(orig.n_components):\n results = pandas.DataFrame(index = range(n_iterations), columns = range(n_feats_x))\n all_results_x.update({i: results})\n results = pandas.DataFrame(index = range(n_iterations), columns = range(n_feats_y))\n all_results_y.update({i: results})\n bs_ratio_x = pandas.DataFrame(index = range(orig.n_components), \n columns = range(n_feats_x))\n bs_ratio_y = pandas.DataFrame(index = range(orig.n_components), \n columns = range(n_feats_y))\n\n # bootstrap\n for i in range(n_iterations):\n n_ind = np.random.choice(X.index, len(X.index))\n n_samp = pandas.DataFrame(X.loc[n_ind],copy=True)\n ny = pandas.DataFrame(y.loc[n_ind],copy=True)\n newmod = clf.fit(n_samp,ny)\n for c in range(orig.n_components):\n xcorrs = [stats.pearsonr(orig.x_loadings_[:,c],\n newmod.x_loadings_[:,x])[0]2 for x in range(orig.n_components)]\n closest = np.argmax(xcorrs)\n # account for possible inversion\n if stats.pearsonr(orig.x_loadings_[:,c],\n newmod.x_loadings_[:,closest])[0] < 0:\n new_loadingsX = newmod.x_loadings_[:,closest] * -1\n new_loadingsy = newmod.y_loadings_[:,closest] * -1\n else:\n new_loadingsX = newmod.x_loadings_[:,closest]\n new_loadingsy = newmod.y_loadings_[:,closest]\n\n all_results_x[c].loc[i] = new_loadingsX\n all_results_y[c].loc[i] = new_loadingsy\n if check:\n if i % check == 0:\n print('finished iteration',i)\n\n # calculate bootstrap ratio\n bs_ratio_x = bootstrap_ratio(all_results_x, bs_ratio_x)\n bs_ratio_y = bootstrap_ratio(all_results_y, bs_ratio_y)\n \n return bs_ratio_x, bs_ratio_y, all_results_x, all_results_y\n\ndef bootstrap_ratio(all_results, bs_ratio):\n\n all_stats = {'mean': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns),\n 'se': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns),\n 'bsr': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns),\n 'p': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns)}\n \n for i,res in all_results.items():\n mn = res.mean()\n sem = res.sem()\n all_stats['bsr'].loc[i] = mn / sem\n all_stats['mean'].loc[i] = mn\n all_stats['se'].loc[i] = sem\n ps = []\n for x in range(res.shape[-1]):\n jnk = res.values[:,x]\n if mn[x] > 0:\n p = (len(jnk[jnk<0])+1) / len(jnk)\n else:\n p = (len(jnk[jnk>0])+1) / len(jnk)\n ps.append(p)\n all_stats['p'].loc[i] = ps\n \n \n return all_stats\n\n \n" ]	[ [ "scipy.stats.pearsonr", "pandas.DataFrame", "numpy.argmax", "matplotlib.pyplot.close", "numpy.random.RandomState", "matplotlib.pyplot.show" ] ]
trumanw/ESP_DNN	[ "26b08787dc2836fac3c50559447ebaa56c2c8277" ]	[ "esp_dnn/graph_conv.py" ]	[ "# Copyright 2019 Astex Therapeutics Ltd.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom __future__ import absolute_import\n\nfrom keras import activations, initializers, regularizers, constraints\nfrom keras import backend as K\nfrom keras.constraints import min_max_norm\nfrom keras.engine.topology import Layer, InputSpec\nimport tensorflow as tf\n\n\nclass PrintLayerInput(Layer):\n def call(self, inputs):\n inputs = tf.Print(inputs, data=[inputs],\n message=\"layer inputs: \", summarize=100)\n return inputs\n\n\nclass GraphConv(Layer):\n\n def __init__(self,\n width,\n activation=None,\n use_bias=True,\n kernel_initializer=\"glorot_uniform\",\n bias_initializer=\"zeros\",\n kernel_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n kernel_constraint=None,\n bias_constraint=None,\n # \"single\": only one weight applied to all neighbor sums\n # \"all\": a different weight for each property\n conv_wts=\"single\",\n kwargs):\n\n if \"input_shape\" not in kwargs and \"input_dim\" in kwargs:\n kwargs[\"input_shape\"] = (kwargs.pop(\"input_dim\"),)\n\n allowed_conv_wts = (\"all\", \"single\")\n if conv_wts not in allowed_conv_wts:\n raise ValueError(\"conv_wt should be one of %r\" % allowed_conv_wts)\n\n super(GraphConv, self).__init__(kwargs)\n\n self.width = width\n self.conv_wts = conv_wts\n\n self.activation = activations.get(activation)\n self.use_bias = use_bias\n self.kernel_initializer = initializers.get(kernel_initializer)\n self.bias_initializer = initializers.get(bias_initializer)\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\n self.bias_regularizer = regularizers.get(bias_regularizer)\n self.activity_regularizer = regularizers.get(activity_regularizer)\n self.kernel_constraint = constraints.get(kernel_constraint)\n self.bias_constraint = constraints.get(bias_constraint)\n self.input_spec = [InputSpec(ndim=3), InputSpec(ndim=3)]\n\n def build(self, input_shapes):\n X_shape = input_shapes[0]\n # number of atom props * output width\n kernel_shape = (X_shape[-1], self.width)\n\n # atom (self) weights\n self.kernel_dense = self.add_weight(shape=kernel_shape,\n initializer=self.kernel_initializer,\n name=\"dense_kernel\",\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint)\n if self.use_bias is not None:\n self.bias = self.add_weight(shape=(self.width,),\n initializer=self.bias_initializer,\n name=\"bias\",\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint)\n else:\n self.bias = None\n\n constraint = min_max_norm(\n min_value=0.0, max_value=1.0, rate=1.0, axis=0)\n if self.conv_wts == \"single\":\n self.kernel_neigh = self.add_weight(shape=[1],\n initializer=self.kernel_initializer,\n name=\"kernel_neigh\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n self.kernel_self = self.add_weight(shape=[1],\n initializer=self.kernel_initializer,\n name=\"kernel_self\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n elif self.conv_wts == \"all\":\n self.kernel_neigh = self.add_weight(shape=(self.width,),\n initializer=self.kernel_initializer,\n name=\"kernel_neigh\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n self.kernel_self = self.add_weight(shape=(self.width,),\n initializer=self.kernel_initializer,\n name=\"kernel_neigh\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n\n self.built = True\n\n def call(self, inputs):\n x = inputs[0] # n_atom * n_props\n d = inputs[1] # [n_atoms, n_atoms]\n\n self_output = K.dot(x, self.kernel_dense)\n # sum values from the neighbors\n neigh_output = K.batch_dot(d, self_output, axes=[2, 1])\n\n if self.conv_wts == \"single\":\n neigh_output = neigh_output * self.kernel_neigh[0]\n self_output = self_output * self.kernel_self[0]\n elif self.conv_wts == \"all\":\n neigh_output = neigh_output * self.kernel_neigh\n self_output = self_output * self.kernel_self\n\n output = self_output + neigh_output\n if self.use_bias is not None:\n output += K.reshape(self.bias, (1, self.width))\n output = self.activation(output)\n return output\n\n def compute_output_shape(self, input_shape):\n return (input_shape[0][0], input_shape[0][1], self.width)\n\n def get_config(self):\n config = {\n \"width\": self.width,\n \"conv_wts\": self.conv_wts,\n \"activation\": activations.serialize(self.activation),\n \"use_bias\": self.use_bias,\n \"kernel_initializer\": initializers.serialize(self.kernel_initializer),\n \"bias_initializer\": initializers.serialize(self.bias_initializer),\n \"kernel_regularizer\": regularizers.serialize(self.kernel_regularizer),\n \"bias_regularizer\": regularizers.serialize(self.bias_regularizer),\n \"activity_regularizer\": regularizers.serialize(self.activity_regularizer),\n \"kernel_constraint\": constraints.serialize(self.kernel_constraint),\n \"bias_constraint\": constraints.serialize(self.bias_constraint)\n }\n base_config = super(GraphConv, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n" ]	[ [ "tensorflow.Print" ] ]
remz1337/DataFrame	[ "e5aa82854a56201d75ed87cdc1f5b4059409ef8d" ]	[ "test/pandas_performance.py" ]	[ "import numpy as np\nimport pandas as pd\n\n# ------------------------------------------------------------------------------\n\ntimestamps = pd.date_range(\"1970-01-01\", \"2019-08-15\", freq='S')\ndf = pd.DataFrame({\"timestamp\": timestamps,\n \"normal\": np.random.normal(size=len(timestamps)),\n \"log_normal\": np.random.lognormal(size=len(timestamps)),\n \"exponential\": np.random.exponential(size=len(timestamps)),\n })\ndf.set_index(\"timestamp\")\n\nprint(\"All memory allocations are done. Calculating means ...\")\n\ndf[\"normal\"].mean()\ndf[\"log_normal\"].mean()\ndf[\"exponential\"].mean()\n\n# ------------------------------------------------------------------------------\n\n# Local Variables:\n# mode:Python\n# tab-width:4\n# c-basic-offset:4\n# End:\n" ]	[ [ "pandas.date_range" ] ]
Shall-Chee/Vision-based-Vehicle-Detection-and-Tracking	[ "dff14e34779f142daa3254934f1e001e0777733f" ]	[ "iou.py" ]	[ "'''\nCombining detector and tracker\ntracker can track multiple object in the video\n'''\nimport numpy as np\nimport json\nfrom utils import \nfrom constant import \n\nfrom constant import t_min\n\nfrom ast import literal_eval\n\ndef overlap(box1, box2):\n '''\n check the overlap of two boxes\n @param\n box: shape(4,) ndarray, [x, y, w, h]\n\n @return\n ratio: intersection / union\n '''\n x1, y1, w1, h1 = box1\n x2, y2, w2, h2 = box2\n\n # compute each box's area\n s1 = w1 * h1\n s2 = w2 * h2\n\n # compute intersection\n left = min(x1, x2)\n right = max(x1 + w1, x2 + w2)\n w = w1 + w2 - (right - left)\n\n up = min(y1, y2)\n down = max(y1 + h1, y2 + h2)\n h = h1 + h2 - (down - up)\n\n if w <= 0 or h <= 0:\n return 0\n else:\n intersect = w * h\n union = s1 + s2 - intersect\n ratio = intersect / union\n return ratio\n\n\ndef update_track_object(detections, iou_ratio):\n '''\n IOU tracker\n https://ieeexplore.ieee.org/document/8078516\n\n @param:\n detections: list of detections per frame\n iou_ratio: iou threshold\n\n @return:\n track_finished: list of track\n '''\n tracks_active = []\n tracks_finished = []\n for frame_idx, dets_per_frame in enumerate(detections, start = 1):\n for trk_a in tracks_active:\n if len(dets_per_frame) > 0:\n iou = [overlap(trk_a['boxes'][-1], det) for det in dets_per_frame]\n iou = np.array(iou)\n det_best_idx = np.argmax(iou)\n det_best = dets_per_frame[det_best_idx]\n if overlap(trk_a['boxes'][-1], det_best) >= iou_ratio:\n # add d_best to t_i\n trk_a['boxes'].append(det_best)\n # remove d_best from dets_per_frame\n dets_per_frame.pop(det_best_idx)\n else:\n # finish track when min # of matches is hit\n if len(trk_a['boxes']) >= t_min:\n tracks_finished.append(trk_a)\n tracks_active.remove(trk_a)\n \n # start new track with new detection and insert into tracks_active\n new_tracks = [{'boxes': [det], 'start frame': frame_idx} for det in dets_per_frame]\n tracks_active += new_tracks\n \n # finish all remaining active tracks\n tracks_finished += [trk_a for trk_a in tracks_active if len(trk_a['boxes']) >= t_min]\n\n return tracks_finished\n\nif __name__ == \"__main__\":\n # read detections\n detections = []\n with open('export/file.txt') as f:\n for line in f:\n line = line.rstrip()\n line = literal_eval(line)\n detections.append(line)\n \n track_object = update_track_object(detections, 0.15)\n\n with open('export/object.txt', 'w') as f:\n for t in track_object:\n json.dump(t, f)\n f.write('\\n')\n \n" ]	[ [ "numpy.array", "numpy.argmax" ] ]
vodev/vocloud-RDF	[ "a98468cfe7e805e12ba14218b2508936143ba6d3" ]	[ "data_set_handler.py" ]	[ "import io\nimport os\n\nimport pandas as pd\nimport pyfits\nfrom astropy.io.votable import parse\nfrom astropy.io.votable.tree import VOTableFile, Resource, Table, Field\nfrom sklearn.cross_validation import StratifiedKFold, KFold\nfrom sklearn.cross_validation import train_test_split\n\n\ndef load_header(uri):\n votable = parse(uri)\n table = votable.get_table_by_index(0)\n values = table.array[0][1].tolist()\n return [str(value) for value in values] + [\"class\"]\n\n\ndef load_set(uri, format='csv', header=None, delimiter=','):\n print(str(header))\n return pd.read_csv(uri, header=None, names=header, sep=None, dtype=None,\n na_values='?', skipinitialspace=True)\n\n\ndef _to_votable(data, file_name):\n votable = VOTableFile()\n resource = Resource()\n votable.resources.append(resource)\n table = Table(votable)\n resource.tables.append(table)\n columns = data.columns\n if data.columns[-1] == 'class':\n columns = columns[:-1]\n fields = [\n Field(votable, name=\"intensities\", datatype=\"double\", arraysize='*')]\n table.fields.extend(fields)\n table.create_arrays(1)\n table.array[0] = columns.tolist()\n votable.to_xml(file_name)\n\n\ndef _write_csv(data, uri, header=None, separator=',', dtypes=None):\n with io.open(uri, 'w', encoding='utf-8') as out:\n if header is not None:\n _to_votable(header,\n \"meta.xml\")\n\n for row in data:\n rec_num = 0\n for record in row:\n val = record\n if (dtypes is not None and 'int' in str(dtypes[rec_num])):\n val = int(val)\n elif (dtypes is not None and 'float' in str(dtypes[rec_num])):\n val = float(val)\n out.write(str(val))\n if (rec_num != len(row) - 1):\n out.write(separator)\n rec_num += 1\n out.write('\\n')\n\n\ndef _parse_fits(uri):\n fits = pyfits.open(uri, memmap=False)\n dat = fits[1].data\n fits.close()\n return dat.tolist()\n\n\ndef split_train_set(uri, label=-1, ratio=0.67, sep=',', header=None):\n header_num = None if not header else 0\n array = pd.read_csv(uri, delimiter=sep, skipinitialspace=True,\n na_values=['?'])\n train, test = train_test_split(array.values, train_size=ratio)\n base_name, ext = os.path.splitext(os.path.basename(uri))\n directory = os.path.dirname(uri)\n train_name = directory + base_name + '_train' + ext\n test_name = directory + base_name + '_score' + ext\n _write_csv(train, train_name, separator=sep, header=None)\n _write_csv(test, test_name, separator=sep, header=None)\n return (train_name, test_name)\n\n\ndef create_xvalidation_files(data_uri, data_conf, header, configuration,\n target=None, base_folder='./result/xvalidation'):\n df = pd.read_csv(data_uri, sep=None, header=None, names=header,\n skipinitialspace=True, na_values=['?'])\n kfold = None\n labels = df[target].values\n folds = configuration['folds']\n if (target is not None):\n kfold = StratifiedKFold(labels, folds)\n else:\n kfold = KFold(n=len(labels), n_folds=folds)\n\n if not os.path.exists(base_folder):\n os.makedirs(os.path.abspath(base_folder))\n i = 1\n uris = []\n for train, test in kfold:\n train_uri = base_folder + '/train_' + str(i)\n test_uri = base_folder + '/test_' + str(i)\n _write_csv(df.values[train], train_uri, header=header, dtypes=df.dtypes)\n _write_csv(df.values[test], test_uri, header=header, dtypes=df.dtypes)\n uris.append((train_uri, test_uri))\n i += 1\n return uris\n" ]	[ [ "sklearn.cross_validation.train_test_split", "pandas.read_csv", "sklearn.cross_validation.StratifiedKFold" ] ]
matthewlchambers/flowsa	[ "97fdab9250d205bfd8d9341e3b62cc464bc854c7" ]	[ "flowsa/data_source_scripts/StatCan_LFS.py" ]	[ "# Stat_Canada.py (flowsa)\n# !/usr/bin/env python3\n# coding=utf-8\n\n\"\"\"\nLabour force characteristics by industry, annual (x 1,000)\nHow to cite: Statistics Canada. Table 14-10-0023-01 Labour\nforce characteristics by industry, annual (x 1,000)\nDOI: https://doi.org/10.25318/1410002301-eng\n\"\"\"\n\nimport io\nimport zipfile\nimport pycountry\nimport pandas as pd\nfrom flowsa.common import WITHDRAWN_KEYWORD\n\n\ndef sc_lfs_call(, resp, _):\n \"\"\"\n Convert response for calling url to pandas dataframe, begin parsing df\n into FBA format\n :param resp: df, response from url call\n :return: pandas dataframe of original source data\n \"\"\"\n # Convert response to dataframe\n # read all files in the stat canada zip\n with zipfile.ZipFile(io.BytesIO(resp.content), \"r\") as f:\n # read in file names\n for name in f.namelist():\n # if filename does not contain \"MetaData\", then create dataframe\n if \"MetaData\" not in name:\n data = f.open(name)\n df = pd.read_csv(data, header=0)\n return df\n\n\ndef sc_lfs_parse(, df_list, *_):\n \"\"\"\n Combine, parse, and format the provided dataframes\n :param df_list: list of dataframes to concat and format\n :return: df, parsed and partially formatted to flowbyactivity\n specifications\n \"\"\"\n # concat dataframes\n df = pd.concat(df_list, sort=False)\n # drop columns\n df = df.drop(columns=['COORDINATE', 'DECIMALS', 'DGUID', 'SYMBOL',\n 'TERMINATED', 'UOM_ID', 'SCALAR_ID', 'VECTOR'])\n # rename columns\n df = df.rename(columns={'GEO': 'Location',\n 'North American Industry Classification System '\n '(NAICS)': 'Description',\n 'REF_DATE': 'Year',\n 'STATUS': 'Spread',\n 'VALUE': \"FlowAmount\",\n 'Labour force characteristics': 'FlowName'})\n # limit data to pull\n df = df[df['Location'] == 'Canada']\n df = df[df['Sex'] == 'Both sexes']\n df = df[df['Age group'] == '15 years and over']\n df = df[df['FlowName'] == 'Employment'].reset_index(drop=True)\n df.loc[:, 'FlowAmount'] = df['FlowAmount'] 10000\n df.loc[:, 'Unit'] = 'p'\n df = df.drop(columns=['Sex', 'Age group', 'UOM', 'SCALAR_FACTOR'])\n # extract NAICS as activity column. rename activity based on flowname\n df['Activity'] = df['Description'].str.extract('.\\[(.)\\].*')\n df.loc[df['Description'] == 'Total, all industries', 'Activity'] = '31-33'\n df.loc[df['Description'] ==\n 'Other manufacturing industries', 'Activity'] = 'Other'\n df['FlowName'] = df['FlowName'].str.strip()\n df.loc[df['FlowName'] == 'Water intake',\n 'ActivityConsumedBy'] = df['Activity']\n df.loc[df['FlowName'].isin(['Water discharge', \"Water recirculation\"]),\n 'ActivityProducedBy'] = df['Activity']\n # drop columns used to create unit and activity columns\n df = df.drop(columns=['Activity'])\n # Modify the assigned RSD letter values to numeric value\n df.loc[df['Spread'] == 'A', 'Spread'] = 2.5 # given range: 0.01 - 4.99%\n df.loc[df['Spread'] == 'B', 'Spread'] = 7.5 # given range: 5 - 9.99%\n df.loc[df['Spread'] == 'C', 'Spread'] = 12.5 # given range: 10 - 14.99%\n df.loc[df['Spread'] == 'D', 'Spread'] = 20 # given range: 15 - 24.99%\n df.loc[df['Spread'] == 'E', 'Spread'] = 37.5 # given range:25 - 49.99%\n df.loc[df['Spread'] == 'F', 'Spread'] = 75 # given range: > 49.99%\n df.loc[df['Spread'] == 'x', 'Spread'] = WITHDRAWN_KEYWORD\n # hard code data\n df['Class'] = 'Employment'\n df['SourceName'] = 'StatCan_LFS'\n # temp hardcode canada iso code\n df['Location'] = call_country_code('Canada')\n df['LocationSystem'] = \"ISO\"\n df[\"MeasureofSpread\"] = 'RSD'\n df[\"DataReliability\"] = 3\n df[\"DataCollection\"] = 4\n return df\n\n\ndef call_country_code(country):\n \"\"\"\n Determine country code, use pycountry to call on 3 digit iso country code\n :param country: str, country name\n :return: str, country code\n \"\"\"\n country_info = pycountry.countries.get(name=country)\n country_numeric_iso = country_info.numeric\n return country_numeric_iso\n" ]	[ [ "pandas.concat", "pandas.read_csv" ] ]
mlindauer/SMAC3	[ "9e871f61d72c789c0c0a25f1ddbcbb39621cfe74" ]	[ "test/test_smbo/test_acquisition.py" ]	[ "import unittest\n\nimport numpy as np\n\nfrom smac.smbo.acquisition import EI\n\n\nclass MockModel(object):\n def __init__(self, num_targets=1):\n self.num_targets = num_targets\n\n def predict_marginalized_over_instances(self, X):\n return np.array([np.mean(X, axis=1).reshape((1, -1))] \n self.num_targets).reshape((-1, 1)), \\\n np.array([np.mean(X, axis=1).reshape((1, -1))] \n self.num_targets).reshape((-1, 1))\n\n\nclass TestEI(unittest.TestCase):\n def setUp(self):\n self.model = MockModel()\n self.ei = EI(self.model)\n\n def test_1xD(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[1.0, 1.0, 1.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (1, 1))\n self.assertAlmostEqual(acq[0][0], 0.3989422804014327)\n\n def test_NxD(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[0.0, 0.0, 0.0],\n [0.1, 0.1, 0.1],\n [1.0, 1.0, 1.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (3, 1))\n self.assertAlmostEqual(acq[0][0], 0.0)\n self.assertAlmostEqual(acq[1][0], 0.90020601136712231)\n self.assertAlmostEqual(acq[2][0], 0.3989422804014327)\n\n def test_1x1(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[1.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (1, 1))\n self.assertAlmostEqual(acq[0][0], 0.3989422804014327)\n\n def test_Nx1(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[0.0001],\n [1.0],\n [2.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (3, 1))\n self.assertAlmostEqual(acq[0][0], 0.9999)\n self.assertAlmostEqual(acq[1][0], 0.3989422804014327)\n self.assertAlmostEqual(acq[2][0], 0.19964122837424575)\n\n def test_zero_variance(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[0.0]])\n acq = np.array(X)\n self.assertAlmostEqual(acq[0][0], 0.0)\n" ]	[ [ "numpy.array", "numpy.mean" ] ]
AdamMiltonBarker/AI-Classification	[ "67a0a9d4ec1636014d51e404b23c5b2ecc8ea149" ]	[ "Projects/2/Classes/Model.py" ]	[ "############################################################################################\n#\n# Project: Peter Moss COVID-19 AI Research Project\n# Repository: AI-Classification\n# Repo Project: COVID-19 Tensorflow DenseNet Classifier\n#\n# Author: Adam Milton-Barker (AdamMiltonBarker.com)\n# Contributors:\n# Title: Model Class\n# Description: Model functions for the COVID-19 Tensorflow DenseNet Classifier.\n# License: MIT License\n# Last Modified: 2020-06-28\n#\n############################################################################################\n\nimport cv2\nimport json\nimport requests\nimport time\n\nimport tensorflow as tf\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom sklearn.metrics import confusion_matrix\n\nfrom Classes.Helpers import Helpers\n\n\nclass Model():\n \"\"\" Model Class\n\n Model functions for the COVID-19 Tensorflow DenseNet Classifier.\n \"\"\"\n\n def __init__(self):\n \"\"\" Initializes the class. \"\"\"\n\n self.Helpers = Helpers(\"Model\", False)\n\n self.Helpers.logger.info(\n \"Model class initialization complete.\")\n\n def do_model(self, data):\n\n self.Data = data\n\n inp = tf.keras.Input(shape=(self.Helpers.confs[\"data\"][\"dim\"], self.Helpers.confs[\"data\"][\"dim\"],\n self.Helpers.confs[\"data\"][\"channels\"]))\n\n net = tf.keras.layers.Conv2D(3, (3, 3), padding='same')(inp)\n\n dnet = tf.keras.applications.DenseNet121(\n weights='imagenet', include_top=False)\n net = dnet(net)\n\n net = tf.keras.layers.GlobalAveragePooling2D()(net)\n net = tf.keras.layers.BatchNormalization()(net)\n net = tf.keras.layers.Dropout(\n self.Helpers.confs[\"model\"][\"dropout\"])(net)\n net = tf.keras.layers.Dense(256, activation='relu')(net)\n net = tf.keras.layers.BatchNormalization()(net)\n net = tf.keras.layers.Dropout(\n self.Helpers.confs[\"model\"][\"dropout\"])(net)\n\n preds = tf.keras.layers.Dense(\n 2, activation='softmax', name='root')(net)\n\n self.tfmodel = tf.keras.Model(inp, preds)\n self.tfmodel.summary()\n\n self.Helpers.logger.info(\"Network initialization complete.\")\n\n def do_train(self):\n \"\"\" Trains the network. \"\"\"\n\n self.Helpers.logger.info(\"Using Adam Optimizer.\")\n\n optimizer = tf.keras.optimizers.Adam(lr=self.Helpers.confs[\"model\"][\"lr\"],\n beta_1=self.Helpers.confs[\"model\"][\"beta_1\"],\n beta_2=self.Helpers.confs[\"model\"][\"beta_2\"],\n epsilon=self.Helpers.confs[\"model\"][\"epsilon\"],\n decay=self.Helpers.confs[\"model\"][\"decay\"])\n\n self.tfmodel.compile(loss='categorical_crossentropy',\n optimizer=optimizer, metrics=[tf.keras.metrics.BinaryAccuracy(name='acc'),\n tf.keras.metrics.Precision(\n name='precision'),\n tf.keras.metrics.Recall(\n name='recall'),\n tf.keras.metrics.AUC(name='auc')])\n\n monitor = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_acc',\n factor=self.Helpers.confs[\"model\"][\"factor\"],\n patience=self.Helpers.confs[\"model\"][\"patience\"],\n verbose=1,\n min_lr=self.Helpers.confs[\"model\"][\"min_lr\"])\n\n checkpoint = tf.keras.callbacks.ModelCheckpoint(\n self.Helpers.confs[\"model\"][\"weights\"], verbose=1, save_best_only=True)\n\n self.history = self.tfmodel.fit(self.Data.X_train, self.Data.y_train,\n batch_size=self.Helpers.confs[\"data\"][\"batch\"],\n epochs=self.Helpers.confs[\"model\"][\"epochs\"],\n callbacks=[monitor, checkpoint],\n validation_data=(self.Data.X_test, self.Data.y_test))\n\n print(self.history)\n print(\"\")\n\n self.save_model_as_json()\n self.export_saved_model()\n\n def save_model_as_json(self):\n \"\"\" Saves the model to JSON. \"\"\"\n\n with open(self.Helpers.confs[\"model\"][\"json\"], \"w\") as file:\n file.write(self.tfmodel.to_json())\n\n self.Helpers.logger.info(\n \"Model JSON saved \" + self.Helpers.confs[\"model\"][\"json\"])\n\n def export_saved_model(self):\n \"\"\" Saves the model as TF SavedModel. \"\"\"\n \n tf.keras.models.save_model(\n self.tfmodel, self.Helpers.confs[\"model\"][\"tf\"], save_format=\"tf\")\n\n self.Helpers.logger.info(\n \"TF Model saved to \" + self.Helpers.confs[\"model\"][\"tf\"])\n\n def do_evaluate(self):\n \"\"\" Evaluates the model \"\"\"\n\n self.do_predictions()\n\n metrics = self.tfmodel.evaluate(\n self.Data.X_test, self.Data.y_test, verbose=0)\n for name, value in zip(self.tfmodel.metrics_names, metrics):\n self.Helpers.logger.info(\"Metrics: \" + name + \" \" + str(value))\n print()\n\n self.visualize_metrics()\n self.confusion_matrix()\n self.figures_of_merit()\n\n def do_predictions(self):\n \"\"\" Makes predictions on the train & test sets. \"\"\"\n\n self.train_preds = self.tfmodel.predict(self.Data.X_train)\n self.test_preds = self.tfmodel.predict(self.Data.X_test)\n\n self.Helpers.logger.info(\n \"Training predictions: \" + str(self.train_preds))\n self.Helpers.logger.info(\n \"Testing predictions: \" + str(self.test_preds))\n print(\"\")\n\n def visualize_metrics(self):\n \"\"\" Visualize the metrics. \"\"\"\n\n plt.plot(self.history.history['acc'])\n plt.plot(self.history.history['val_acc'])\n plt.title('Model Accuracy')\n plt.ylabel('Accuracy')\n plt.xlabel('Epoch')\n plt.ylim((0, 1))\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Accuracy.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['loss'])\n plt.plot(self.history.history['val_loss'])\n plt.title('Model Loss')\n plt.ylabel('loss')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Loss.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['auc'])\n plt.plot(self.history.history['val_auc'])\n plt.title('Model AUC')\n plt.ylabel('AUC')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/AUC.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['precision'])\n plt.plot(self.history.history['val_precision'])\n plt.title('Model Precision')\n plt.ylabel('Precision')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Precision.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['recall'])\n plt.plot(self.history.history['val_recall'])\n plt.title('Model Recall')\n plt.ylabel('Recall')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Recall.png')\n plt.show()\n plt.clf()\n\n def confusion_matrix(self):\n \"\"\" Prints/displays the confusion matrix. \"\"\"\n\n self.matrix = confusion_matrix(self.Data.y_test.argmax(axis=1),\n self.test_preds.argmax(axis=1))\n\n self.Helpers.logger.info(\"Confusion Matrix: \" + str(self.matrix))\n print(\"\")\n\n plt.imshow(self.matrix, cmap=plt.cm.Blues)\n plt.xlabel(\"Predicted labels\")\n plt.ylabel(\"True labels\")\n plt.xticks([], [])\n plt.yticks([], [])\n plt.title('Confusion matrix ')\n plt.colorbar()\n plt.savefig('Model/Plots/Confusion-Matrix.png')\n plt.show()\n plt.clf()\n\n def figures_of_merit(self):\n \"\"\" Calculates/prints the figures of merit. \"\"\"\n\n test_len = len(self.Data.X_test)\n\n TP = self.matrix[1][1]\n TN = self.matrix[0][0]\n FP = self.matrix[0][1]\n FN = self.matrix[1][0]\n\n TPP = (TP * 100)/test_len\n FPP = (FP * 100)/test_len\n FNP = (FN * 100)/test_len\n TNP = (TN * 100)/test_len\n\n specificity = TN/(TN+FP)\n\n misc = FP + FN\n miscp = (misc * 100)/test_len\n\n self.Helpers.logger.info(\n \"True Positives: \" + str(TP) + \"(\" + str(TPP) + \"%)\")\n self.Helpers.logger.info(\n \"False Positives: \" + str(FP) + \"(\" + str(FPP) + \"%)\")\n self.Helpers.logger.info(\n \"True Negatives: \" + str(TN) + \"(\" + str(TNP) + \"%)\")\n self.Helpers.logger.info(\n \"False Negatives: \" + str(FN) + \"(\" + str(FNP) + \"%)\")\n\n self.Helpers.logger.info(\"Specificity: \" + str(specificity))\n self.Helpers.logger.info(\n \"Misclassification: \" + str(misc) + \"(\" + str(miscp) + \"%)\")\n\n def load_model_and_weights(self):\n \"\"\" Loads the model and weights. \"\"\"\n\n with open(self.Helpers.confs[\"model\"][\"json\"]) as file:\n m_json = file.read()\n\n self.tfmodel = tf.keras.models.model_from_json(m_json)\n self.tfmodel.load_weights(self.Helpers.confs[\"model\"][\"weights\"])\n\n self.Helpers.logger.info(\"Model loaded \")\n\n self.tfmodel.summary()\n print(\"\")\n\n def test_classifier(self):\n \"\"\" Tests the trained model. \"\"\"\n\n files = 0\n tp = 0\n fp = 0\n tn = 0\n fn = 0\n\n combined = self.Helpers.confs[\"data\"][\"test_0\"] + \\\n self.Helpers.confs[\"data\"][\"test_1\"]\n\n for testFile in combined:\n\n files += 1\n\n img = tf.keras.preprocessing.image.load_img(testFile, grayscale=False,\n target_size=(self.Helpers.confs[\"data\"][\"dim\"],\n self.Helpers.confs[\"data\"][\"dim\"]))\n self.Helpers.logger.info(\"Loaded test image \" + testFile)\n\n prediction = self.get_prediction(img)\n self.Helpers.logger.info(\"Predicted Label: \" + str(prediction[0]))\n\n msg = \"\"\n if prediction[0] == 1 and testFile.find(\"/1/\") != -1:\n tp += 1\n msg = \"COVID-19 correctly detected (True Positive) with confidence: \" + str(prediction[1])\n elif prediction[0] == 1 and testFile.find(\"/0/\") != -1:\n fp += 1\n msg = \"COVID-19 incorrectly detected (False Positive) with confidence: \" + str(prediction[1])\n elif prediction[0] == 0 and testFile.find(\"/0/\") != -1:\n tn += 1\n msg = \"COVID-19 correctly not detected (True Negative) with confidence: \" + str(prediction[1])\n elif prediction[0] == 0 and testFile.find(\"/1/\") != -1:\n fn += 1\n msg = \"COVID-19 incorrectly not detected (False Negative) with confidence: \" + str(prediction[1])\n\n self.Helpers.logger.info(msg)\n\n self.Helpers.logger.info(\"Images Classified: \" + str(files))\n self.Helpers.logger.info(\"True Positives: \" + str(tp))\n self.Helpers.logger.info(\"False Positives: \" + str(fp))\n self.Helpers.logger.info(\"True Negatives: \" + str(tn))\n self.Helpers.logger.info(\"False Negatives: \" + str(fn))\n\n def test_http_classifier(self):\n \"\"\" Tests the trained model. \"\"\"\n\n files = 0\n tp = 0\n fp = 0\n tn = 0\n fn = 0\n\n combined = self.Helpers.confs[\"data\"][\"test_0\"] + \\\n self.Helpers.confs[\"data\"][\"test_1\"]\n\n for testFile in combined:\n\n files += 1\n\n response = self.send_request(testFile)\n\n msg = \"\"\n if response[\"Diagnosis\"] == \"Positive\" and testFile.find(\"/1/\") != -1:\n tp += 1\n msg = \"COVID-19 correctly detected (True Positive) with confidence: \" + str(response[\"Confidence\"])\n elif response[\"Diagnosis\"] == \"Positive\" and testFile.find(\"/0/\") != -1:\n fp += 1\n msg = \"COVID-19 incorrectly detected (False Positive) with confidence: \" + str(response[\"Confidence\"])\n elif response[\"Diagnosis\"] == \"Negative\" and testFile.find(\"/0/\") != -1:\n tn += 1\n msg = \"COVID-19 correctly not detected (True Negative) with confidence: \" + str(response[\"Confidence\"])\n elif response[\"Diagnosis\"] == \"Negative\" and testFile.find(\"/1/\") != -1:\n fn += 1\n msg = \"COVID-19 incorrectly not detected (False Negative) with confidence: \" + str(response[\"Confidence\"])\n\n self.Helpers.logger.info(msg)\n print()\n time.sleep(7)\n\n self.Helpers.logger.info(\"Images Classifier: \" + str(files))\n self.Helpers.logger.info(\"True Positives: \" + str(tp))\n self.Helpers.logger.info(\"False Positives: \" + str(fp))\n self.Helpers.logger.info(\"True Negatives: \" + str(tn))\n self.Helpers.logger.info(\"False Negatives: \" + str(fn))\n\n def send_request(self, img_path):\n \"\"\" Sends image to the inference API endpoint. \"\"\"\n\n addr = \"http://\" + self.Helpers.confs[\"server\"][\"ip\"] + \\\n ':'+str(self.Helpers.confs[\"server\"][\"port\"]) + '/Inference'\n headers = {'content-type': 'image/jpeg'}\n\n self.Helpers.logger.info(\"Sending request for: \" + img_path)\n\n _, img_encoded = cv2.imencode('.png', cv2.imread(img_path))\n response = requests.post(\n addr, data=img_encoded.tostring(), headers=headers)\n response = json.loads(response.text)\n\n return response\n\n def http_classify(self, req):\n \"\"\" Classifies an image sent via HTTP. \"\"\"\n\n if len(req.files) != 0:\n img = np.fromstring(req.files['file'].read(), np.uint8)\n else:\n img = np.fromstring(req.data, np.uint8)\n\n img = cv2.imdecode(img, cv2.IMREAD_UNCHANGED)\n img = cv2.resize(img, (self.Helpers.confs[\"data\"][\"dim\"],\n self.Helpers.confs[\"data\"][\"dim\"]))\n\n return self.get_prediction(img)\n\n def get_prediction(self, img):\n \"\"\" Gets a prediction for an image. \"\"\"\n\n x = tf.keras.preprocessing.image.img_to_array(img)\n x = cv2.cvtColor(x, cv2.COLOR_BGRA2BGR)\n x = np.expand_dims(x, axis=0)\n x /= 255\n\n predictions = self.tfmodel.predict(x)\n prediction = predictions[0]\n predictioni = np.argmax(prediction)\n prediction = self.Helpers.confs[\"model\"][\"labels\"][predictioni]\n confidence = predictions[0][prediction]\n\n return prediction, confidence\n" ]	[ [ "matplotlib.pyplot.legend", "matplotlib.pyplot.imshow", "numpy.expand_dims", "tensorflow.keras.metrics.BinaryAccuracy", "tensorflow.keras.preprocessing.image.load_img", "tensorflow.keras.models.save_model", "matplotlib.pyplot.plot", "tensorflow.keras.applications.DenseNet121", "tensorflow.keras.layers.Dropout", "tensorflow.keras.Input", "tensorflow.keras.layers.Conv2D", "tensorflow.keras.metrics.AUC", "numpy.argmax", "tensorflow.keras.preprocessing.image.img_to_array", "tensorflow.keras.callbacks.ModelCheckpoint", "matplotlib.pyplot.title", "matplotlib.pyplot.ylim", "tensorflow.keras.layers.Dense", "tensorflow.keras.callbacks.ReduceLROnPlateau", "tensorflow.keras.Model", "matplotlib.pyplot.savefig", "tensorflow.keras.metrics.Precision", "tensorflow.keras.metrics.Recall", "matplotlib.pyplot.show", "matplotlib.pyplot.xticks", "matplotlib.pyplot.ylabel", "tensorflow.keras.layers.GlobalAveragePooling2D", "matplotlib.pyplot.colorbar", "tensorflow.keras.optimizers.Adam", "matplotlib.pyplot.clf", "tensorflow.keras.layers.BatchNormalization", "numpy.fromstring", "tensorflow.keras.models.model_from_json", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.yticks" ] ]
hnmspirit/malaria_centernet	[ "e855e99016e60c6ec7a66f05591ead5993a41a18" ]	[ "lib/models/networks/mobi3.py" ]	[ "from torch.utils import model_zoo\r\nfrom ..backbones import mobilenetv3\r\n\r\n\r\nclass Mobi3Enc(mobilenetv3.MobileNetV3):\r\n def __init__(self, cfgs, mode='large', width_mult=1., outputs=[16], url=None):\r\n self.url = url\r\n super().__init__(cfgs, mode, width_mult=width_mult)\r\n self.outputs = outputs\r\n del self.conv\r\n del self.avgpool\r\n del self.classifier\r\n\r\n def initialize(self):\r\n self.load_state_dict(model_zoo.load_url(self.url), strict=False)\r\n\r\n def forward(self, x):\r\n outputs = []\r\n for idx, feat in enumerate(self.features):\r\n x = feat(x)\r\n if idx in self.outputs:\r\n outputs.append(x)\r\n return outputs\r\n\r\n\r\ndef mobi3_enc():\r\n cfgs = [\r\n # k, t, c, SE, HS, s\r\n [3, 1, 16, 0, 0, 1],\r\n [3, 4, 24, 0, 0, 2],\r\n [3, 3, 24, 0, 0, 1],\r\n [5, 3, 40, 1, 0, 2],\r\n [5, 3, 40, 1, 0, 1],\r\n [5, 3, 40, 1, 0, 1],\r\n [3, 6, 80, 0, 1, 2],\r\n [3, 2.5, 80, 0, 1, 1],\r\n [3, 2.3, 80, 0, 1, 1],\r\n [3, 2.3, 80, 0, 1, 1],\r\n [3, 6, 112, 1, 1, 1],\r\n [3, 6, 112, 1, 1, 1],\r\n [5, 6, 160, 1, 1, 2],\r\n [5, 6, 160, 1, 1, 1],\r\n [5, 6, 160, 1, 1, 1]\r\n ]\r\n mode = 'large'\r\n width_mult = 1.\r\n outputs = [3, 6, 12, 15]\r\n url = 'https://github.com/d-li14/mobilenetv3.pytorch/raw/master/pretrained/mobilenetv3-large-1cd25616.pth'\r\n encoder = Mobi3Enc(cfgs, mode, width_mult, outputs, url)\r\n encoder.initialize()\r\n return encoder\r\n\r\nmobi3_inchannels = [24, 40, 112, 160]" ]	[ [ "torch.utils.model_zoo.load_url" ] ]
kaixindelele/DRL	[ "74bb73caafd30547be0de7cdf0f6b945e51ecf6f", "74bb73caafd30547be0de7cdf0f6b945e51ecf6f", "74bb73caafd30547be0de7cdf0f6b945e51ecf6f" ]	[ "spinup/algos/sac1_rnn/test.py", "spinup/algos/maxsqn/maxsqn_football.py", "spinup/algos/sac1/sac1_BipedalWalkerHardcore-v2_old.py" ]	[ "\nimport tensorflow as tf\nimport gym\nimport joblib\nimport os\nimport os.path as osp\nfrom spinup.utils.logx import restore_tf_graph\n\n\ndef load_policy(fpath, itr='last', deterministic=False):\n\n # handle which epoch to load from\n if itr=='last':\n saves = [int(x[11:]) for x in os.listdir(fpath) if 'simple_save' in x and len(x)>11]\n itr = '%d'%max(saves) if len(saves) > 0 else ''\n else:\n itr = '%d'%itr\n\n # load the things!\n sess = tf.Session()\n model = restore_tf_graph(sess, osp.join(fpath, 'simple_save'+itr))\n\n # get the correct op for executing actions\n if deterministic and 'mu' in model.keys():\n # 'deterministic' is only a valid option for SAC policies\n print('Using deterministic action op.')\n action_op = model['mu']\n else:\n print('Using default action op.')\n action_op = model['pi']\n\n # make function for producing an action given a single state\n get_action = lambda x : sess.run(action_op, feed_dict={model['x']: x[None,:]})[0]\n\n # try to load environment from save\n # (sometimes this will fail because the environment could not be pickled)\n try:\n state = joblib.load(osp.join(fpath, 'vars'+itr+'.pkl'))\n env = state['env']\n except:\n env = None\n\n return env, get_action\n\n\nif __name__ == '__main__':\n\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument('--env', type=str, default='BipedalWalkerHardcore-v2')\n parser.add_argument('--render', type=bool, default=True)\n args = parser.parse_args()\n\n file_model = '/home/liu/project/DRL/data/317biped_sac1_stump6_actnoise0.3_alphaauto_2/biped_sac1_stump6_actnoise0.3_alphaauto_2_s0'\n print(file_model)\n\n _env, get_action = load_policy(file_model, deterministic=True)\n\n test_env = gym.make(args.env)\n ave_ep_ret = 0\n for j in range(10000):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not d: # (d or (ep_len == 2000)):\n o, r, d, _ = test_env.step(get_action(o))\n ep_ret += r\n ep_len += 1\n if args.render:\n test_env.render()\n ave_ep_ret = (jave_ep_ret + ep_ret)/(j+1)\n print('ep_len', ep_len, 'ep_ret:', ep_ret, 'ave_ep_ret:',ave_ep_ret,'({}/10000)'.format(j+1) )\n \n\n\n", "import numpy as np\nimport tensorflow as tf\nfrom numbers import Number\nimport gym\nimport time, os\nfrom spinup.algos.maxsqn import core\nfrom spinup.algos.maxsqn.core import get_vars\nfrom spinup.utils.logx import EpochLogger\nfrom gym.spaces import Box, Discrete\n\nclass ReplayBuffer:\n \"\"\"\n A simple FIFO experience replay buffer for SAC agents.\n \"\"\"\n\n def __init__(self, obs_dim, act_dim, size):\n self.obs1_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.obs2_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.acts_buf = np.zeros([size, act_dim], dtype=np.float32)\n self.rews_buf = np.zeros(size, dtype=np.float32)\n self.done_buf = np.zeros(size, dtype=np.float32)\n self.ptr, self.size, self.max_size = 0, 0, size\n\n def store(self, obs, act, rew, next_obs, done):\n self.obs1_buf[self.ptr] = obs\n self.obs2_buf[self.ptr] = next_obs\n self.acts_buf[self.ptr] = act\n self.rews_buf[self.ptr] = rew\n self.done_buf[self.ptr] = done\n self.ptr = (self.ptr+1) % self.max_size\n self.size = min(self.size+1, self.max_size)\n\n def sample_batch(self, batch_size=32):\n idxs = np.random.randint(0, self.size, size=batch_size)\n return dict(obs1=self.obs1_buf[idxs],\n obs2=self.obs2_buf[idxs],\n acts=self.acts_buf[idxs],\n rews=self.rews_buf[idxs],\n done=self.done_buf[idxs])\n\n\"\"\"\n\nSoft Actor-Critic\n\n(With slight variations that bring it closer to TD3)\n\n\"\"\"\n\n\"\"\" make sure: max_ep_len < steps_per_epoch \"\"\"\n\ndef maxsqn(args, env_fn, actor_critic=core.mlp_actor_critic, ac_kwargs=dict(), seed=0,\n steps_per_epoch=5000, epochs=100, replay_size=int(5e6), gamma=0.99,\n polyak=0.995, lr=1e-3, alpha=0.2, batch_size=256, start_steps=20000,\n max_ep_len=1000, logger_kwargs=dict(), save_freq=1):\n \"\"\"\n\n Args:\n env_fn : A function which creates a copy of the environment.\n The environment must satisfy the OpenAI Gym API.\n\n actor_critic: A function which takes in placeholder symbols\n for state, ``x_ph``, and action, ``a_ph``, and returns the main\n outputs from the agent's Tensorflow computation graph:\n\n =========== ================ ======================================\n Symbol Shape Description\n =========== ================ ======================================\n ``mu`` (batch, act_dim) \| Computes mean actions from policy\n \| given states.\n ``pi`` (batch, act_dim) \| Samples actions from policy given\n \| states.\n ``logp_pi`` (batch,) \| Gives log probability, according to\n \| the policy, of the action sampled by\n \| ``pi``. Critical: must be differentiable\n \| with respect to policy parameters all\n \| the way through action sampling.\n ``q1`` (batch,) \| Gives one estimate of Q for\n \| states in ``x_ph`` and actions in\n \| ``a_ph``.\n ``q2`` (batch,) \| Gives another estimate of Q* for\n \| states in ``x_ph`` and actions in\n \| ``a_ph``.\n ``q1_pi`` (batch,) \| Gives the composition of ``q1`` and\n \| ``pi`` for states in ``x_ph``:\n \| q1(x, pi(x)).\n ``q2_pi`` (batch,) \| Gives the composition of ``q2`` and\n \| ``pi`` for states in ``x_ph``:\n \| q2(x, pi(x)).\n =========== ================ ======================================\n\n ac_kwargs (dict): Any kwargs appropriate for the actor_critic\n function you provided to SAC.\n\n seed (int): Seed for random number generators.\n\n steps_per_epoch (int): Number of steps of interaction (state-action pairs)\n for the agent and the environment in each epoch.\n\n epochs (int): Number of epochs to run and train agent.\n\n replay_size (int): Maximum length of replay buffer.\n\n gamma (float): Discount factor. (Always between 0 and 1.)\n\n polyak (float): Interpolation factor in polyak averaging for target\n networks. Target networks are updated towards main networks\n according to:\n\n .. math:: \\\\theta_{\\\\text{targ}} \\\\leftarrow\n \\\\rho \\\\theta_{\\\\text{targ}} + (1-\\\\rho) \\\\theta\n\n where :math:`\\\\rho` is polyak. (Always between 0 and 1, usually\n close to 1.)\n\n lr (float): Learning rate (used for policy/value/alpha learning).\n\n alpha (float/'auto'): Entropy regularization coefficient. (Equivalent to\n inverse of reward scale in the original SAC paper.) / 'auto': alpha is automated.\n\n batch_size (int): Minibatch size for SGD.\n\n start_steps (int): Number of steps for uniform-random action selection,\n before running real policy. Helps exploration.\n\n max_ep_len (int): Maximum length of trajectory / episode / rollout.\n\n logger_kwargs (dict): Keyword args for EpochLogger.\n\n save_freq (int): How often (in terms of gap between epochs) to save\n the current policy and value function.\n\n \"\"\"\n if not args.is_test:\n logger = EpochLogger(logger_kwargs)\n logger.save_config(locals())\n\n tf.set_random_seed(seed)\n np.random.seed(seed)\n\n\n env, test_env = env_fn(3), env_fn(1)\n # obs_dim = env.observation_space.shape[0]\n # obs_space = env.observation_space\n\n scenario_obsdim = {'academy_empty_goal':32, 'academy_empty_goal_random':32, 'academy_3_vs_1_with_keeper':44, 'academy_3_vs_1_with_keeper_random':44, 'academy_single_goal_versus_lazy':108}\n obs_dim = scenario_obsdim[args.env]\n obs_space = Box(low=-1.0, high=1.0, shape=(obs_dim,), dtype=np.float32)\n\n act_dim = env.action_space.n\n act_space = env.action_space\n\n\n # Share information about action space with policy architecture\n ac_kwargs['action_space'] = env.action_space\n\n # Inputs to computation graph\n x_ph, a_ph, x2_ph, r_ph, d_ph = core.placeholders_from_space(obs_space, act_space, obs_space, None, None)\n\n\n ######\n if alpha == 'auto':\n # target_entropy = (-np.prod(env.action_space.n))\n # target_entropy = (np.prod(env.action_space.n))/4/10\n target_entropy = 0.5\n\n log_alpha = tf.get_variable('log_alpha', dtype=tf.float32, initializer=0.0)\n alpha = tf.exp(log_alpha)\n ######\n\n\n # Main outputs from computation graph\n with tf.variable_scope('main'):\n mu, pi, logp_pi, logp_pi2, q1, q2, q1_pi, q2_pi, q1_mu, q2_mu = actor_critic(x_ph,x2_ph, a_ph, alpha, ac_kwargs)\n\n # Target value network\n with tf.variable_scope('target'):\n _, _, logp_pi_, _, _, _,q1_pi_, q2_pi_,q1_mu_, q2_mu_= actor_critic(x2_ph, x2_ph,a_ph, alpha, *ac_kwargs)\n\n # Experience buffer\n if isinstance(act_space, Box):\n a_dim = act_dim\n elif isinstance(act_space, Discrete):\n a_dim = 1\n replay_buffer = ReplayBuffer(obs_dim=obs_dim, act_dim=a_dim, size=replay_size)\n\n # Count variables\n var_counts = tuple(core.count_vars(scope) for scope in\n ['main/pi', 'main/q1', 'main/q2', 'main'])\n print(('\\nNumber of parameters: \\t pi: %d, \\t' + \\\n 'q1: %d, \\t q2: %d, \\t total: %d\\n')%var_counts)\n\n\n######\n if isinstance(alpha,tf.Tensor):\n alpha_loss = tf.reduce_mean(-log_alpha tf.stop_gradient(logp_pi_ + target_entropy))\n\n alpha_optimizer = tf.train.AdamOptimizer(learning_rate=lr, name='alpha_optimizer')\n train_alpha_op = alpha_optimizer.minimize(loss=alpha_loss, var_list=[log_alpha])\n######\n\n # Min Double-Q:\n min_q_pi = tf.minimum(q1_pi_, q2_pi_)\n # min_q_pi = tf.minimum(q1_mu_, q2_mu_)\n\n # min_q_pi = tf.clip_by_value(min_q_pi, 0.0, 200.0)\n\n\n # Targets for Q and V regression\n v_backup = tf.stop_gradient(min_q_pi - alpha * logp_pi2) ############################## alpha=0\n q_backup = r_ph + gamma(1-d_ph)v_backup\n\n\n # Soft actor-critic losses\n q1_loss = 0.5 * tf.reduce_mean((q_backup - q1)*2)\n q2_loss = 0.5 tf.reduce_mean((q_backup - q2)*2)\n value_loss = q1_loss + q2_loss\n\n # # Policy train op\n # # (has to be separate from value train op, because q1_pi appears in pi_loss)\n # pi_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n # train_pi_op = pi_optimizer.minimize(pi_loss, var_list=get_vars('main/pi'))\n\n # Value train op\n # (control dep of train_pi_op because sess.run otherwise evaluates in nondeterministic order)\n value_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n value_params = get_vars('main/q')\n #with tf.control_dependencies([train_pi_op]):\n train_value_op = value_optimizer.minimize(value_loss, var_list=value_params)\n\n # Polyak averaging for target variables\n # (control flow because sess.run otherwise evaluates in nondeterministic order)\n with tf.control_dependencies([train_value_op]):\n target_update = tf.group([tf.assign(v_targ, polyakv_targ + (1-polyak)v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n # All ops to call during one training step\n if isinstance(alpha, Number):\n step_ops = [q1_loss, q2_loss, q1, q2, logp_pi_, tf.identity(alpha),\n train_value_op, target_update]\n else:\n step_ops = [q1_loss, q2_loss, q1, q2, logp_pi_, alpha,\n train_value_op, target_update, train_alpha_op]\n\n # Initializing targets to match main variables\n target_init = tf.group([tf.assign(v_targ, v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n sess.run(target_init)\n\n\n\n ############################## save and restore ############################\n\n saver = tf.train.Saver()\n\n checkpoint_path = logger_kwargs['output_dir'] + '/checkpoints'\n if not os.path.exists(checkpoint_path):\n os.makedirs(checkpoint_path)\n\n if args.is_test or args.is_restore_train:\n ckpt = tf.train.get_checkpoint_state(checkpoint_path)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(sess, ckpt.model_checkpoint_path)\n print(\"Model restored.\")\n\n\n def get_action(o, deterministic=False):\n act_op = mu if deterministic else pi\n return sess.run(act_op, feed_dict={x_ph: np.expand_dims(o, axis=0)})[0]\n\n\n\n ############################## test ############################\n\n if args.is_test:\n test_env = football_env.create_environment(env_name=args.env, representation='simple115', with_checkpoints=False, render=True)\n ave_ep_ret = 0\n for j in range(10000):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not (d or (ep_len == 500)): # (d or (ep_len == 2000)):\n o, r, d, _ = test_env.step(get_action(o, True))\n # print(r, d)\n time.sleep(0.05)\n ep_ret += r\n ep_len += 1\n if args.test_render:\n test_env.render()\n ave_ep_ret = (jave_ep_ret + ep_ret)/(j+1)\n print('ep_len', ep_len, 'ep_ret:', ep_ret, 'ave_ep_ret:',ave_ep_ret,'({}/10000)'.format(j+1) )\n return\n\n\n ############################## train ############################\n\n def test_agent(n=20): # n: number of tests\n global sess, mu, pi, q1, q2, q1_pi, q2_pi\n for j in range(n):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not(d or (ep_len == max_ep_len)): # max_ep_len\n # Take deterministic actions at test time\n o, r, d, _ = test_env.step(get_action(o, args.test_determin))\n ep_ret += r\n ep_len += 1\n logger.store(TestEpRet=ep_ret, TestEpLen=ep_len)\n\n start_time = time.time()\n\n\n # o = env.reset() #####################\n # o, r, d, ep_ret, ep_len = env.step(1)[0], 0, False, 0, 0 #####################\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n\n\n total_steps = steps_per_epoch * epochs\n\n ep_index = 0\n test_ep_ret_best = test_ep_ret = -10000.0\n is_wrap = False\n # Main loop: collect experience in env and update/log each epoch\n for t in range(total_steps):\n\n \"\"\"\n Until start_steps have elapsed, randomly sample actions\n from a uniform distribution for better exploration. Afterwards, \n use the learned policy. \n \"\"\"\n # if t > start_steps and 100t/total_steps > np.random.random(): # greedy, avoid falling into sub-optimum\n if t > start_steps:\n a = get_action(o)\n else:\n a = env.action_space.sample()\n\n # if np.random.random() > t/(3e6):\n # a = env.action_space.sample()\n # else:\n # a = get_action(o)\n\n\n\n # Step the env\n o2, r, d, _ = env.step(a)\n #print(a,o2)\n # o2, r, _, d = env.step(a) #####################\n # d = d['ale.lives'] < 5 #####################\n\n ep_ret += r\n ep_len += 1\n\n # Ignore the \"done\" signal if it comes from hitting the time\n # horizon (that is, when it's an artificial terminal signal\n # that isn't based on the agent's state)\n d = False if ep_len==max_ep_len else d\n\n # d_store = True if r == 1.0 else False\n\n # Store experience to replay buffer\n replay_buffer.store(o, a, r, o2, d)\n # print(a,r,d)\n\n # Super critical, easy to overlook step: make sure to update\n # most recent observation!\n o = o2\n\n # End of episode. Training (ep_len times).\n if d or (ep_len == max_ep_len): # make sure: max_ep_len < steps_per_epoch\n ep_index += 1\n print('episode: {}, ep_len: {}, reward: {}'.format(ep_index, ep_len, ep_ret))\n \"\"\"\n Perform all SAC updates at the end of the trajectory.\n This is a slight difference from the SAC specified in the\n original paper.\n \"\"\"\n for j in range(ep_len):\n batch = replay_buffer.sample_batch(batch_size)\n feed_dict = {x_ph: batch['obs1'],\n x2_ph: batch['obs2'],\n a_ph: batch['acts'],\n r_ph: batch['rews'],\n d_ph: batch['done'],\n }\n # step_ops = [q1_loss, q2_loss, q1, q2, logp_pi, alpha, train_pi_op, train_value_op, target_update]\n outs = sess.run(step_ops, feed_dict)\n logger.store(LossQ1=outs[0], LossQ2=outs[1],\n Q1Vals=outs[2], Q2Vals=outs[3],\n LogPi=outs[4], Alpha=outs[5])\n logger.store(EpRet=ep_ret, EpLen=ep_len)\n\n\n\n\n # End of epoch wrap-up\n if is_wrap:\n epoch = t // steps_per_epoch\n\n # if epoch < 30:\n # test_agent(1)\n # # test_ep_ret = logger.get_stats('TestEpRet')[0]\n # # print('TestEpRet', test_ep_ret, 'Best:', test_ep_ret_best)\n # else:\n # test_agent(1)\n # test_ep_ret = logger.get_stats('TestEpRet')[0]\n # # if test_ep_ret > test_ep_ret_best:\n # # test_agent(30)\n # # test_ep_ret = logger.get_stats('TestEpRet')[0]\n # print('TestEpRet', test_ep_ret, 'Best:', test_ep_ret_best)\n\n # logger.store(): store the data; logger.log_tabular(): log the data; logger.dump_tabular(): write the data\n # Log info about epoch\n logger.log_tabular('Epoch', epoch)\n logger.log_tabular('EpRet', with_min_and_max=True)\n # logger.log_tabular('TestEpRet', with_min_and_max=True)\n logger.log_tabular('EpLen', average_only=True)\n # logger.log_tabular('TestEpLen', average_only=True)\n logger.log_tabular('TotalEnvInteracts', t)\n logger.log_tabular('Alpha',average_only=True)\n logger.log_tabular('Q1Vals', with_min_and_max=True)\n logger.log_tabular('Q2Vals', with_min_and_max=True)\n # logger.log_tabular('VVals', with_min_and_max=True)\n logger.log_tabular('LogPi', with_min_and_max=True)\n # logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('LossQ1', average_only=True)\n logger.log_tabular('LossQ2', average_only=True)\n # logger.log_tabular('LossV', average_only=True)\n logger.log_tabular('Time', time.time()-start_time)\n logger.dump_tabular()\n\n\n # Save model\n if ((epoch % args.save_freq == 0) or (epoch == epochs - 1)): # or test_ep_ret > test_ep_ret_best:\n save_path = saver.save(sess, checkpoint_path+'/model.ckpt', t)\n print(\"Model saved in path: %s\" % save_path)\n test_ep_ret_best = test_ep_ret\n\n is_wrap = False\n\n\n # o = env.reset() #####################\n # o, r, d, ep_ret, ep_len = env.step(1)[0], 0, False, 0, 0 #####################\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n if t > 0 and t % steps_per_epoch == 0:\n is_wrap = True\n\n\nif __name__ == '__main__':\n import argparse\n parser = argparse.ArgumentParser()\n # {'academy_empty_goal':32, 'academy_3_vs_1_with_keeper':44, 'academy_single_goal_versus_lazy':108}\n parser.add_argument('--env', type=str, default='academy_3_vs_1_with_keeper_random')\n parser.add_argument('--epochs', type=int, default=200000)\n parser.add_argument('--steps_per_epoch', type=int, default=int(5e3))\n parser.add_argument('--save_freq', type=int, default=40)\n parser.add_argument('--is_restore_train', type=bool, default=False)\n\n parser.add_argument('--is_test', type=bool, default=False)\n parser.add_argument('--test_determin', type=bool, default=True)\n parser.add_argument('--test_render', type=bool, default=False)\n\n # replay_size, steps_per_epoch, batch_size, start_steps, save_freq\n\n parser.add_argument('--replay_size', type=int, default=int(5e6))\n parser.add_argument('--net', type=list, default=[600,400,200])\n parser.add_argument('--batch_size', type=int, default=300)\n parser.add_argument('--start_steps', type=int, default=int(3e4))\n\n parser.add_argument('--gamma', type=float, default=0.997)\n parser.add_argument('--seed', '-s', type=int, default=0) # maxsqn_football100_a 790, maxsqn_football100_b 110\n\n parser.add_argument('--max_ep_len', type=int, default=170) # make sure: max_ep_len < steps_per_epoch\n parser.add_argument('--alpha', default='auto', help=\"alpha can be either 'auto' or float(e.g:0.2).\")\n parser.add_argument('--lr', type=float, default=5e-5)\n parser.add_argument('--exp_name', type=str, default='debug')#'3v1_scale200_repeat2_c_True')#'1_academy_empty_goal_random_seed0')#'1_academy_empty_goal_0-0')#'1_{}_seed{}-0-half-random_repeat2'.format(parser.parse_args().env,parser.parse_args().seed))\n args = parser.parse_args()\n\n from spinup.utils.run_utils import setup_logger_kwargs\n logger_kwargs = setup_logger_kwargs(args.exp_name, args.seed)\n\n import gfootball.env as football_env\n\n\n # reward wrapper\n class FootballWrapper(object):\n\n def __init__(self, env):\n self._env = env\n\n def __getattr__(self, name):\n return getattr(self._env, name)\n\n # def reset(self):\n # obs = self._env.reset()\n # if obs[0] > 0.5:\n # obs, _, _, _ = self._env.step(12)\n # return obs\n\n def step(self, action):\n r = 0.0\n for _ in range(2):\n obs, reward, done, info = self._env.step(action)\n # if reward != 0.0:\n # done = True\n # else:\n # done = False\n if reward < 0.0:\n reward = 0.0\n # reward -= 0.00175\n # reward += (0.5obs[0] + (0.5-np.abs(obs[1])))0.001\n if obs[0] < 0.0:\n done = True\n # reward = reward + self.incentive1(obs)\n r += reward\n\n if done:\n return obs, r 200, done, info\n\n return obs, r200, done, info\n\n def incentive1(self, obs):\n who_controls_ball = obs[7:9]\n pos_ball = obs[0:2]\n distance_to_goal =np.array([np.exp(-np.linalg.norm(pos_ball-[1.01,0])), -np.exp(-np.linalg.norm(pos_ball-[-1.01,0]))])\n r = np.dot(who_controls_ball,distance_to_goal)0.003\n return r\n\n def incentive2(self, obs):\n who_controls_ball = obs[7:9]\n pos_ball = obs[0]\n distance_to_goal =np.array([(pos_ball+1)/2.0, (pos_ball-1)/2.0])\n r = np.dot(who_controls_ball,distance_to_goal)0.003\n return r\n\n\n # academy_empty_goal academy_empty_goal_close\n env0 = football_env.create_environment(env_name=args.env, representation='simple115', with_checkpoints=False, render=False)\n env_1 = FootballWrapper(env0)\n env_3 = env_1\n maxsqn(args, lambda n : env_3 if n==3 else env_1, actor_critic=core.mlp_actor_critic,\n ac_kwargs=dict(hidden_sizes=args.net), replay_size=args.replay_size, steps_per_epoch=args.steps_per_epoch,\n batch_size=args.batch_size, start_steps=args.start_steps, save_freq=args.save_freq,\n gamma=args.gamma, seed=args.seed, epochs=args.epochs, alpha=args.alpha, lr=args.lr, max_ep_len = args.max_ep_len,\n logger_kwargs=logger_kwargs)", "import numpy as np\nimport tensorflow as tf\nfrom numbers import Number\nimport gym\nimport time\nfrom spinup.algos.sac1 import core\nfrom spinup.algos.sac1.core import get_vars\nfrom spinup.utils.logx import EpochLogger\nfrom gym.spaces import Box, Discrete\nfrom spinup.utils.frame_stack import FrameStack\n\n\n\nconfig = tf.ConfigProto()\nconfig.gpu_options.allow_growth = True\nsession = tf.Session(config=config)\n\n\nclass ReplayBuffer:\n \"\"\"\n A simple FIFO experience replay buffer for SAC agents.\n \"\"\"\n\n def __init__(self, obs_dim, act_dim, size):\n self.obs1_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.obs2_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.acts_buf = np.zeros([size, act_dim], dtype=np.float32)\n self.rews_buf = np.zeros(size, dtype=np.float32)\n self.done_buf = np.zeros(size, dtype=np.float32)\n self.ptr, self.size, self.max_size = 0, 0, size\n\n def store(self, obs, act, rew, next_obs, done):\n self.obs1_buf[self.ptr] = obs\n self.obs2_buf[self.ptr] = next_obs\n self.acts_buf[self.ptr] = act\n self.rews_buf[self.ptr] = rew\n self.done_buf[self.ptr] = done\n self.ptr = (self.ptr+1) % self.max_size\n self.size = min(self.size+1, self.max_size)\n\n def sample_batch(self, batch_size=32):\n idxs = np.random.randint(0, self.size, size=batch_size)\n return dict(obs1=self.obs1_buf[idxs],\n obs2=self.obs2_buf[idxs],\n acts=self.acts_buf[idxs],\n rews=self.rews_buf[idxs],\n done=self.done_buf[idxs])\n\n\"\"\"\n\nSoft Actor-Critic\n\n(With slight variations that bring it closer to TD3)\n\n\"\"\"\ndef sac1(env_fn, actor_critic=core.mlp_actor_critic, ac_kwargs=dict(), seed=0,\n steps_per_epoch=5000, epochs=100, replay_size=int(1e6), gamma=0.99, reward_scale=1.0,\n polyak=0.995, lr=5e-4, alpha=0.2, batch_size=100, start_steps=10000,\n max_ep_len_train=1000, max_ep_len_test=1000, logger_kwargs=dict(), save_freq=1):\n \"\"\"\n\n Args:\n env_fn : A function which creates a copy of the environment.\n The environment must satisfy the OpenAI Gym API.\n\n actor_critic: A function which takes in placeholder symbols \n for state, ``x_ph``, and action, ``a_ph``, and returns the main \n outputs from the agent's Tensorflow computation graph:\n\n =========== ================ ======================================\n Symbol Shape Description\n =========== ================ ======================================\n ``mu`` (batch, act_dim) \| Computes mean actions from policy\n \| given states.\n ``pi`` (batch, act_dim) \| Samples actions from policy given \n \| states.\n ``logp_pi`` (batch,) \| Gives log probability, according to\n \| the policy, of the action sampled by\n \| ``pi``. Critical: must be differentiable\n \| with respect to policy parameters all\n \| the way through action sampling.\n ``q1`` (batch,) \| Gives one estimate of Q for \n \| states in ``x_ph`` and actions in\n \| ``a_ph``.\n ``q2`` (batch,) \| Gives another estimate of Q* for \n \| states in ``x_ph`` and actions in\n \| ``a_ph``.\n ``q1_pi`` (batch,) \| Gives the composition of ``q1`` and \n \| ``pi`` for states in ``x_ph``: \n \| q1(x, pi(x)).\n ``q2_pi`` (batch,) \| Gives the composition of ``q2`` and \n \| ``pi`` for states in ``x_ph``: \n \| q2(x, pi(x)).\n =========== ================ ======================================\n\n ac_kwargs (dict): Any kwargs appropriate for the actor_critic \n function you provided to SAC.\n\n seed (int): Seed for random number generators.\n\n steps_per_epoch (int): Number of steps of interaction (state-action pairs) \n for the agent and the environment in each epoch.\n\n epochs (int): Number of epochs to run and train agent.\n\n replay_size (int): Maximum length of replay buffer.\n\n gamma (float): Discount factor. (Always between 0 and 1.)\n\n polyak (float): Interpolation factor in polyak averaging for target \n networks. Target networks are updated towards main networks \n according to:\n\n .. math:: \\\\theta_{\\\\text{targ}} \\\\leftarrow \n \\\\rho \\\\theta_{\\\\text{targ}} + (1-\\\\rho) \\\\theta\n\n where :math:`\\\\rho` is polyak. (Always between 0 and 1, usually \n close to 1.)\n\n lr (float): Learning rate (used for policy/value/alpha learning).\n\n alpha (float/'auto'): Entropy regularization coefficient. (Equivalent to\n inverse of reward scale in the original SAC paper.) / 'auto': alpha is automated.\n\n batch_size (int): Minibatch size for SGD.\n\n start_steps (int): Number of steps for uniform-random action selection,\n before running real policy. Helps exploration.\n\n max_ep_len (int): Maximum length of trajectory / episode / rollout.\n\n logger_kwargs (dict): Keyword args for EpochLogger.\n\n save_freq (int): How often (in terms of gap between epochs) to save\n the current policy and value function.\n\n \"\"\"\n\n logger = EpochLogger(logger_kwargs)\n logger.save_config(locals())\n\n tf.set_random_seed(seed)\n np.random.seed(seed)\n\n env, test_env = env_fn(3), env_fn(1)\n obs_dim = env.observation_space.shape[0]\n act_dim = env.action_space.shape[0]\n\n # Action limit for clamping: critically, assumes all dimensions share the same bound!\n act_limit = env.action_space.high[0]\n\n # Share information about action space with policy architecture\n ac_kwargs['action_space'] = env.action_space\n\n # Inputs to computation graph\n x_ph, a_ph, x2_ph, r_ph, d_ph = core.placeholders(obs_dim, act_dim, obs_dim, None, None)\n\n # Main outputs from computation graph\n with tf.variable_scope('main'):\n mu, pi, logp_pi, logp_pi2, q1, q2, q1_pi, q2_pi = actor_critic(x_ph, x2_ph, a_ph, ac_kwargs)\n\n # Target value network\n with tf.variable_scope('target'):\n _, _, logp_pi_, _, _, _, q1_pi_, q2_pi_ = actor_critic(x2_ph, x2_ph, a_ph, *ac_kwargs)\n\n # Experience buffer\n replay_buffer = ReplayBuffer(obs_dim=obs_dim, act_dim=act_dim, size=replay_size)\n\n # Count variables\n var_counts = tuple(core.count_vars(scope) for scope in \n ['main/pi', 'main/q1', 'main/q2', 'main'])\n print(('\\nNumber of parameters: \\t pi: %d, \\t' + \\\n 'q1: %d, \\t q2: %d, \\t total: %d\\n')%var_counts)\n\n######\n if alpha == 'auto':\n target_entropy = (-np.prod(env.action_space.shape))\n\n log_alpha = tf.get_variable( 'log_alpha', dtype=tf.float32, initializer=0.0)\n alpha = tf.exp(log_alpha)\n\n alpha_loss = tf.reduce_mean(-log_alpha tf.stop_gradient(logp_pi + target_entropy))\n\n alpha_optimizer = tf.train.AdamOptimizer(learning_rate=lr0.1, name='alpha_optimizer')\n train_alpha_op = alpha_optimizer.minimize(loss=alpha_loss, var_list=[log_alpha])\n######\n\n # Min Double-Q:\n min_q_pi = tf.minimum(q1_pi_, q2_pi_)\n\n # Targets for Q and V regression\n v_backup = tf.stop_gradient(min_q_pi - alpha logp_pi2)\n q_backup = r_ph + gamma(1-d_ph)v_backup\n\n\n # Soft actor-critic losses\n pi_loss = tf.reduce_mean(alpha * logp_pi - q1_pi)\n q1_loss = 0.5 * tf.reduce_mean((q_backup - q1)*2)\n q2_loss = 0.5 tf.reduce_mean((q_backup - q2)*2)\n value_loss = q1_loss + q2_loss\n\n # Policy train op \n # (has to be separate from value train op, because q1_pi appears in pi_loss)\n pi_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n train_pi_op = pi_optimizer.minimize(pi_loss, var_list=get_vars('main/pi'))\n\n # Value train op\n # (control dep of train_pi_op because sess.run otherwise evaluates in nondeterministic order)\n value_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n value_params = get_vars('main/q')\n with tf.control_dependencies([train_pi_op]):\n train_value_op = value_optimizer.minimize(value_loss, var_list=value_params)\n\n # Polyak averaging for target variables\n # (control flow because sess.run otherwise evaluates in nondeterministic order)\n with tf.control_dependencies([train_value_op]):\n target_update = tf.group([tf.assign(v_targ, polyakv_targ + (1-polyak)v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n # All ops to call during one training step\n if isinstance(alpha, Number):\n step_ops = [pi_loss, q1_loss, q2_loss, q1, q2, logp_pi, tf.identity(alpha),\n train_pi_op, train_value_op, target_update]\n else:\n step_ops = [pi_loss, q1_loss, q2_loss, q1, q2, logp_pi, alpha,\n train_pi_op, train_value_op, target_update, train_alpha_op]\n\n\n # Initializing targets to match main variables\n target_init = tf.group([tf.assign(v_targ, v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n sess.run(target_init)\n\n # Setup model saving\n logger.setup_tf_saver(sess, inputs={'x': x_ph, 'a': a_ph}, \n outputs={'mu': mu, 'pi': pi, 'q1': q1, 'q2': q2})\n\n def get_action(o, deterministic=False):\n act_op = mu if deterministic else pi\n return sess.run(act_op, feed_dict={x_ph: o.reshape(1,-1)})[0]\n\n def test_agent(n=25):\n global sess, mu, pi, q1, q2, q1_pi, q2_pi\n for j in range(n):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not(d or (ep_len == max_ep_len_test)):\n # Take deterministic actions at test time \n o, r, d, _ = test_env.step(get_action(o, True))\n ep_ret += r\n ep_len += 1\n # test_env.render()\n logger.store(TestEpRet=ep_ret, TestEpLen=ep_len)\n\n start_time = time.time()\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n total_steps = steps_per_epoch epochs\n\n # Main loop: collect experience in env and update/log each epoch\n for t in range(total_steps):\n\n \"\"\"\n Until start_steps have elapsed, randomly sample actions\n from a uniform distribution for better exploration. Afterwards, \n use the learned policy. \n \"\"\"\n if t > start_steps:\n a = get_action(o)\n else:\n a = env.action_space.sample()\n\n # Step the env\n o2, r, d, _ = env.step(a)\n ep_ret += r\n ep_len += 1\n\n # Ignore the \"done\" signal if it comes from hitting the time\n # horizon (that is, when it's an artificial terminal signal\n # that isn't based on the agent's state)\n # d = False if ep_len==max_ep_len_train else d\n\n # Store experience to replay buffer\n replay_buffer.store(o, a, r, o2, d)\n\n # Super critical, easy to overlook step: make sure to update \n # most recent observation!\n o = o2\n\n # End of episode. Training (ep_len times).\n if d or (ep_len == max_ep_len_train):\n \"\"\"\n Perform all SAC updates at the end of the trajectory.\n This is a slight difference from the SAC specified in the\n original paper.\n \"\"\"\n for j in range(ep_len):\n batch = replay_buffer.sample_batch(batch_size)\n feed_dict = {x_ph: batch['obs1'],\n x2_ph: batch['obs2'],\n a_ph: batch['acts'],\n r_ph: batch['rews'],\n d_ph: batch['done'],\n }\n # step_ops = [pi_loss, q1_loss, q2_loss, q1, q2, logp_pi, alpha, train_pi_op, train_value_op, target_update]\n outs = sess.run(step_ops, feed_dict)\n logger.store(LossPi=outs[0], LossQ1=outs[1], LossQ2=outs[2],\n Q1Vals=outs[3], Q2Vals=outs[4],\n LogPi=outs[5], Alpha=outs[6])\n\n logger.store(EpRet=ep_ret/reward_scale, EpLen=ep_len)\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n\n # End of epoch wrap-up\n if t > 0 and t % steps_per_epoch == 0:\n epoch = t // steps_per_epoch\n\n # Save model\n if (epoch % save_freq == 0) or (epoch == epochs-1):\n logger.save_state({'env': env}, None)\n\n # Test the performance of the deterministic version of the agent.\n test_agent()\n\n # logger.store(): store the data; logger.log_tabular(): log the data; logger.dump_tabular(): write the data\n # Log info about epoch\n logger.log_tabular('Epoch', epoch)\n logger.log_tabular('EpRet', with_min_and_max=True)\n logger.log_tabular('TestEpRet', with_min_and_max=False)\n logger.log_tabular('EpLen', average_only=True)\n logger.log_tabular('TestEpLen', average_only=True)\n logger.log_tabular('TotalEnvInteracts', t)\n logger.log_tabular('Alpha',average_only=True)\n logger.log_tabular('Q1Vals', with_min_and_max=False)\n ### logger.log_tabular('Q2Vals', with_min_and_max=True)\n # logger.log_tabular('VVals', with_min_and_max=True)\n ### logger.log_tabular('LogPi', with_min_and_max=True)\n logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('LossQ1', average_only=True)\n logger.log_tabular('LossQ2', average_only=True)\n # logger.log_tabular('LossV', average_only=True)\n logger.log_tabular('Time', time.time()-start_time)\n logger.dump_tabular()\n\nif __name__ == '__main__':\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument('--env', type=str, default='BipedalWalkerHardcore-v2') # 'Pendulum-v0'\n parser.add_argument('--max_ep_len_test', type=int, default=2000) # 'BipedalWalkerHardcore-v2' max_ep_len is 2000\n parser.add_argument('--max_ep_len_train', type=int, default=400) # max_ep_len_train < 2000//3 # 'BipedalWalkerHardcore-v2' max_ep_len is 2000\n parser.add_argument('--hid', type=int, default=300)\n parser.add_argument('--l', type=int, default=1)\n parser.add_argument('--gamma', type=float, default=0.99)\n parser.add_argument('--lr', type=float, default=1e-4)\n parser.add_argument('--seed', '-s', type=int, default=0)\n parser.add_argument('--epochs', type=int, default=10000)\n parser.add_argument('--alpha', default=0.1, help=\"alpha can be either 'auto' or float(e.g:0.2).\")\n parser.add_argument('--reward_scale', type=float, default=5.0)\n parser.add_argument('--act_noise', type=float, default=0.3)\n parser.add_argument('--obs_noise', type=float, default=0.0)\n parser.add_argument('--exp_name', type=str, default='sac1_BipedalWalkerHardcore-v2')\n parser.add_argument('--stack_frames', type=int, default=4)\n args = parser.parse_args()\n\n from spinup.utils.run_utils import setup_logger_kwargs\n logger_kwargs = setup_logger_kwargs(args.exp_name, args.seed)\n\n\n\n class Wrapper(object):\n\n def __init__(self, env, action_repeat=3):\n self._env = env\n self.action_repeat = action_repeat\n\n def __getattr__(self, name):\n return getattr(self._env, name)\n\n def reset(self):\n obs = self._env.reset() + args.obs_noise * (-2 * np.random.random(24) + 1)\n return obs\n\n def step(self, action):\n action += args.act_noise * (-2 * np.random.random(4) + 1)\n r = 0.0\n for _ in range(self.action_repeat):\n obs_, reward_, done_, info_ = self._env.step(action)\n r = r + reward_\n # r -= 0.001\n if done_ and self.action_repeat!=1:\n return obs_+ args.obs_noise * (-2 * np.random.random(24) + 1), 0.0, done_, info_\n if self.action_repeat==1:\n return obs_, r, done_, info_\n return obs_+ args.obs_noise * (-2 * np.random.random(24) + 1), args.reward_scale*r, done_, info_\n\n\n # env = FrameStack(env, args.stack_frames)\n\n env3 = Wrapper(gym.make(args.env), 3)\n env1 = Wrapper(gym.make(args.env), 1)\n\n sac1(lambda n : env3 if n==3 else env1, actor_critic=core.mlp_actor_critic,\n ac_kwargs=dict(hidden_sizes=[400,300]),\n gamma=args.gamma, seed=args.seed, epochs=args.epochs, alpha=args.alpha,\n logger_kwargs=logger_kwargs, lr = args.lr, reward_scale=args.reward_scale,\n max_ep_len_train = args.max_ep_len_train, max_ep_len_test=args.max_ep_len_test)\n\n" ]	[ [ "tensorflow.Session" ], [ "numpy.dot", "tensorflow.get_variable", "numpy.expand_dims", "tensorflow.control_dependencies", "tensorflow.minimum", "tensorflow.train.AdamOptimizer", "numpy.random.randint", "tensorflow.stop_gradient", "tensorflow.Session", "tensorflow.train.Saver", "numpy.zeros", "tensorflow.identity", "tensorflow.exp", "tensorflow.global_variables_initializer", "tensorflow.set_random_seed", "numpy.array", "tensorflow.train.get_checkpoint_state", "numpy.random.seed", "tensorflow.reduce_mean", "tensorflow.assign", "numpy.linalg.norm", "tensorflow.variable_scope" ], [ "tensorflow.get_variable", "tensorflow.control_dependencies", "tensorflow.minimum", "tensorflow.train.AdamOptimizer", "numpy.random.randint", "tensorflow.stop_gradient", "tensorflow.ConfigProto", "tensorflow.Session", "numpy.zeros", "tensorflow.identity", "tensorflow.exp", "tensorflow.global_variables_initializer", "tensorflow.set_random_seed", "numpy.random.random", "numpy.random.seed", "tensorflow.reduce_mean", "tensorflow.assign", "numpy.prod", "tensorflow.variable_scope" ] ]
TuomasJalonen/visual-product-tracking-system	[ "bc6c5499c4f146d4e2f77c79394018328615c19b" ]	[ "Preprocess_data.py" ]	[ "#!/usr/bin/env python3\n# -- coding: utf-8 --\n\"\"\"\nCreated on Wed Aug 12 22:02:20 2020\n\n@author: Tuomas Jalonen\n\nThis file is used for preprocessing the data.\n\n\"\"\"\nimport os\nimport pandas as pd\nimport cv2\nimport numpy as np\n\ndef process_img(path, size):\n \"\"\"\n\n Parameters\n ----------\n path : Complete path to the image\n size : target image size, e.g. (224, 224)\n\n Returns\n -------\n img : Preprocessed image\n\n \"\"\"\n\n img = cv2.imread(path, 1)\n img = cv2.normalize(img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX,\n dtype=cv2.CV_32F)\n img = cv2.resize(img, size)\n\n return img\n\n# Define targeted image size\nIMG_SIZE = (224, 224)\n\n# Define how many image pairs are saved for validation and testing. Rest is\n# used for training.\nTEST_SIZE = 500\nVAL_SIZE = 200\n\n# Define path to CSV-file containing which images are pairs\nPATH_TO_CSV = '/path/'\n\n# Define path to folder containing wet images\nPATH_TO_WET = '/path/'\n\n# Define path to folder containing dry images\nPATH_TO_DRY = '/path/'\n\n# Read csv-file to pandas dataframe\ndf = pd.read_csv(PATH_TO_CSV, sep=';')\n\n# Print some info\nprint(df.head())\nprint(df.info())\n\n# Split the dataframe into test, validation and train data\ntest = df.sample(n=TEST_SIZE, random_state=42)\ndata_without_test = df.drop(test.index)\nval = data_without_test.sample(n=VAL_SIZE, random_state=42)\ntrain = data_without_test.drop(val.index)\n\n# Create empty lists for images and labels\ntrain_wet_imgs = []\ntrain_dry_imgs = []\n\ntest_wet_imgs = []\ntest_dry_imgs = []\n\nval_wet_imgs = []\nval_dry_imgs = []\n\ntrain_labels = []\ntest_labels = []\nval_labels = []\n\n# Loop dataframe rows\nfor index, row in df.iterrows():\n\n # Print progress\n if index % 10 == 0:\n print(index, '/', len(df))\n\n # Create correct path for the wet image, corresponding dry image\n wet_path = os.path.join(PATH_TO_WET, row['Filename_wet'])\n dry_path_pair = os.path.join(PATH_TO_DRY, row['Filename_dry'])\n\n # Read and process images\n wet_img = process_img(wet_path, IMG_SIZE)\n dry_img_pair = process_img(dry_path_pair, IMG_SIZE)\n\n # Next there are three if statements determining whether the image\n # belongs to train, validation or test set\n if row['Filename_wet'] in train['Filename_wet'].values:\n # Append four wet images to the list (one for pair and three for\n # not-pair images)\n train_wet_imgs.append(wet_img)\n train_wet_imgs.append(wet_img)\n train_wet_imgs.append(wet_img)\n train_wet_imgs.append(wet_img)\n\n # Append the pair dry image to list\n train_dry_imgs.append(dry_img_pair)\n\n # Get three random image paths from the correct dataset\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n dry_path_random2 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n\n # Make sure it's not pair\n while dry_path_pair == dry_path_random1:\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random2:\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random3:\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n\n # Process the image and append to list\n dry_img_random1 = process_img(dry_path_random1, IMG_SIZE)\n dry_img_random2 = process_img(dry_path_random2, IMG_SIZE)\n dry_img_random3 = process_img(dry_path_random3, IMG_SIZE)\n train_dry_imgs.append(dry_img_random1)\n train_dry_imgs.append(dry_img_random2)\n train_dry_imgs.append(dry_img_random3)\n\n # Append correct labels to lists\n train_labels.append([0, 1])\n train_labels.append([1, 0])\n train_labels.append([1, 0])\n train_labels.append([1, 0])\n\n continue\n\n if row['Filename_wet'] in val['Filename_wet'].values:\n # Append four wet images to the list (one for pair and three for\n # not-pair images)\n val_wet_imgs.append(wet_img)\n val_wet_imgs.append(wet_img)\n val_wet_imgs.append(wet_img)\n val_wet_imgs.append(wet_img)\n\n # Append the pair dry image to list\n val_dry_imgs.append(dry_img_pair)\n\n # Get random image path from the correct dataset\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n dry_path_random2 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n\n # Make sure it's not pair\n while dry_path_pair == dry_path_random1:\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random2:\n dry_path_random2 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random3:\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n\n # Process the image and append to list\n dry_img_random1 = process_img(dry_path_random1, IMG_SIZE)\n dry_img_random2 = process_img(dry_path_random2, IMG_SIZE)\n dry_img_random3 = process_img(dry_path_random3, IMG_SIZE)\n val_dry_imgs.append(dry_img_random1)\n val_dry_imgs.append(dry_img_random2)\n val_dry_imgs.append(dry_img_random3)\n\n # Append correct labels to lists\n val_labels.append([0, 1])\n val_labels.append([1, 0])\n val_labels.append([1, 0])\n val_labels.append([1, 0])\n\n continue\n\n if row['Filename_wet'] in test['Filename_wet'].values:\n # Append wet image to the list\n test_wet_imgs.append(wet_img)\n\n # Append the pair dry image to list\n test_dry_imgs.append(dry_img_pair)\n\n # Append correct labels to lists\n test_labels.append([0, 1])\n\n continue\n\n# let's double the sample size by cross-sampling:\ntrain_input_A = train_wet_imgs + train_dry_imgs\ntrain_input_B = train_dry_imgs + train_wet_imgs\nval_input_A = val_wet_imgs + val_dry_imgs\nval_input_B = val_dry_imgs + val_wet_imgs\ntest_input_A = test_wet_imgs\ntest_input_B = test_dry_imgs\n\ntrain_labels += train_labels\n# test_labels stay the same\nval_labels += val_labels\n\n# Save the inputs to Numpy arrays\nnp.save('train_input_A.npy',\n np.array(train_input_A))\nnp.save('train_input_B.npy',\n np.array(train_input_B))\nnp.save('test_input_A.npy',\n np.array(test_input_A))\nnp.save('test_input_B.npy',\n np.array(test_input_B))\nnp.save('val_input_A.npy',\n np.array(val_input_A))\nnp.save('val_input_B.npy',\n np.array(val_input_B))\nnp.save('train_labels.npy',\n np.array(train_labels))\nnp.save('test_labels.npy',\n np.array(test_labels))\nnp.save('val_labels.npy',\n np.array(val_labels))\n" ]	[ [ "numpy.array", "pandas.read_csv" ] ]
rob-luke/mnelab	[ "4f2aa82fbc7d95ead253c463a7f8afee35e94163" ]	[ "mnelab/viz.py" ]	[ "# Authors: Clemens Brunner <[email protected]>\n#\n# License: BSD (3-clause)\n\nimport math\nimport matplotlib.pyplot as plt\nfrom mne.time_frequency import tfr_multitaper\nfrom mne.viz.utils import center_cmap\n\n\ndef _get_rows_cols(n):\n if n <= 3:\n rows, cols = 1, n\n else:\n rows = round(math.sqrt(n))\n cols = math.ceil(math.sqrt(n))\n return rows, cols\n\n\ndef plot_erds(data, freqs, n_cycles, baseline, times=(None, None)):\n tfr = tfr_multitaper(data, freqs, n_cycles, average=False, return_itc=False)\n tfr.apply_baseline(baseline, mode=\"percent\")\n tfr.crop(times)\n\n figs = []\n n_rows, n_cols = _get_rows_cols(data.info[\"nchan\"])\n widths = n_cols [10] + [1] # each map has width 10, each colorbar width 1\n\n for event in data.event_id: # separate figures for each event ID\n fig, axes = plt.subplots(n_rows, n_cols + 1, gridspec_kw={\"width_ratios\": widths})\n tfr_avg = tfr[event].average()\n vmin, vmax = -1, 2 # default for ERDS maps\n cmap = center_cmap(plt.cm.RdBu, vmin, vmax)\n for ch, ax in enumerate(axes[..., :-1].flat): # skip last column\n tfr_avg.plot([ch], vmin=vmin, vmax=vmax, cmap=(cmap, False), axes=ax,\n colorbar=False, show=False)\n ax.set_title(data.ch_names[ch], fontsize=10)\n ax.axvline(0, linewidth=1, color=\"black\", linestyle=\":\")\n ax.set(xlabel=\"t (s)\", ylabel=\"f (Hz)\")\n ax.label_outer()\n for ax in axes[..., -1].flat: # colorbars in last column\n fig.colorbar(axes.flat[0].images[-1], cax=ax)\n\n fig.suptitle(f\"ERDS ({event})\")\n figs.append(fig)\n return figs\n" ]	[ [ "matplotlib.pyplot.subplots" ] ]
richardwu/holoclean	[ "90668091f1c3baa5a8d19a5874194e8fcec13f6d" ]	[ "detect/detect.py" ]	[ "import pandas as pd\nimport time\nfrom dataset import AuxTables\n\n\nclass DetectEngine:\n def __init__(self, env, dataset):\n self.env = env\n self.ds = dataset\n\n def detect_errors(self, detectors):\n errors = []\n tic_total = time.clock()\n for detector in detectors:\n detector.setup(self.ds, self.env)\n for detector in detectors:\n tic = time.clock()\n error_df = detector.detect_noisy_cells()\n toc = time.clock()\n if self.env['verbose']:\n print(\"DONE with Error Detector: %s in %.2f secs\"%(detector.name, toc-tic))\n errors.append(error_df)\n errors_df = pd.concat(errors, ignore_index=True).drop_duplicates().reset_index(drop=True)\n errors_df['_cid_'] = errors_df.apply(lambda x: self.ds.get_cell_id(x['_tid_'], x['attribute']), axis=1)\n try:\n self.store_detected_errors(errors_df)\n status = \"DONE with error detection.\"\n except Exception as e:\n status = \"ERROR in detection: \"+str(e)\n toc_total = time.clock()\n detect_time = toc_total - tic_total\n return status, detect_time\n\n def store_detected_errors(self, errors_df):\n if errors_df.empty:\n raise Exception(\"ERROR: Detected errors dataframe is empty.\")\n else:\n self.ds.generate_aux_table(AuxTables.dk_cells, errors_df, store=True)\n self.ds.aux_table[AuxTables.dk_cells].create_db_index(self.ds.engine, ['_cid_'])\n\n" ]	[ [ "pandas.concat" ] ]
stevennic/pandas	[ "27aae225e82d602e1092a10adf018a3e05682bc5" ]	[ "pandas/tests/io/parser/test_common.py" ]	[ "\"\"\"\nTests that work on both the Python and C engines but do not have a\nspecific classification into the other test modules.\n\"\"\"\nimport codecs\nimport csv\nfrom datetime import datetime\nfrom inspect import signature\nfrom io import StringIO\nimport os\nimport platform\nfrom urllib.error import URLError\n\nimport numpy as np\nimport pytest\n\nfrom pandas._libs.tslib import Timestamp\nfrom pandas.errors import DtypeWarning, EmptyDataError, ParserError\nimport pandas.util._test_decorators as td\n\nfrom pandas import DataFrame, Index, MultiIndex, Series, compat, concat, option_context\nimport pandas._testing as tm\n\nfrom pandas.io.parsers import CParserWrapper, TextFileReader, TextParser\n\n\ndef test_override_set_noconvert_columns():\n # see gh-17351\n #\n # Usecols needs to be sorted in _set_noconvert_columns based\n # on the test_usecols_with_parse_dates test from test_usecols.py\n class MyTextFileReader(TextFileReader):\n def __init__(self):\n self._currow = 0\n self.squeeze = False\n\n class MyCParserWrapper(CParserWrapper):\n def _set_noconvert_columns(self):\n if self.usecols_dtype == \"integer\":\n # self.usecols is a set, which is documented as unordered\n # but in practice, a CPython set of integers is sorted.\n # In other implementations this assumption does not hold.\n # The following code simulates a different order, which\n # before GH 17351 would cause the wrong columns to be\n # converted via the parse_dates parameter\n self.usecols = list(self.usecols)\n self.usecols.reverse()\n return CParserWrapper._set_noconvert_columns(self)\n\n data = \"\"\"a,b,c,d,e\n0,1,20140101,0900,4\n0,1,20140102,1000,4\"\"\"\n\n parse_dates = [[1, 2]]\n cols = {\n \"a\": [0, 0],\n \"c_d\": [Timestamp(\"2014-01-01 09:00:00\"), Timestamp(\"2014-01-02 10:00:00\")],\n }\n expected = DataFrame(cols, columns=[\"c_d\", \"a\"])\n\n parser = MyTextFileReader()\n parser.options = {\n \"usecols\": [0, 2, 3],\n \"parse_dates\": parse_dates,\n \"delimiter\": \",\",\n }\n parser._engine = MyCParserWrapper(StringIO(data), parser.options)\n\n result = parser.read()\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_decimal_marker(all_parsers):\n data = \"\"\"A\|B\|C\n1\|2,334\|5\n10\|13\|10.\n\"\"\"\n # Parsers support only length-1 decimals\n msg = \"Only length-1 decimal markers supported\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), decimal=\"\")\n\n\ndef test_bad_stream_exception(all_parsers, csv_dir_path):\n # see gh-13652\n #\n # This test validates that both the Python engine and C engine will\n # raise UnicodeDecodeError instead of C engine raising ParserError\n # and swallowing the exception that caused read to fail.\n path = os.path.join(csv_dir_path, \"sauron.SHIFT_JIS.csv\")\n codec = codecs.lookup(\"utf-8\")\n utf8 = codecs.lookup(\"utf-8\")\n parser = all_parsers\n msg = \"'utf-8' codec can't decode byte\"\n\n # Stream must be binary UTF8.\n with open(path, \"rb\") as handle, codecs.StreamRecoder(\n handle, utf8.encode, utf8.decode, codec.streamreader, codec.streamwriter\n ) as stream:\n\n with pytest.raises(UnicodeDecodeError, match=msg):\n parser.read_csv(stream)\n\n\ndef test_read_csv_local(all_parsers, csv1):\n prefix = \"file:///\" if compat.is_platform_windows() else \"file://\"\n parser = all_parsers\n\n fname = prefix + str(os.path.abspath(csv1))\n result = parser.read_csv(fname, index_col=0, parse_dates=True)\n\n expected = DataFrame(\n [\n [0.980269, 3.685731, -0.364216805298, -1.159738],\n [1.047916, -0.041232, -0.16181208307, 0.212549],\n [0.498581, 0.731168, -0.537677223318, 1.346270],\n [1.120202, 1.567621, 0.00364077397681, 0.675253],\n [-0.487094, 0.571455, -1.6116394093, 0.103469],\n [0.836649, 0.246462, 0.588542635376, 1.062782],\n [-0.157161, 1.340307, 1.1957779562, -1.097007],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index(\n [\n datetime(2000, 1, 3),\n datetime(2000, 1, 4),\n datetime(2000, 1, 5),\n datetime(2000, 1, 6),\n datetime(2000, 1, 7),\n datetime(2000, 1, 10),\n datetime(2000, 1, 11),\n ],\n name=\"index\",\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_1000_sep(all_parsers):\n parser = all_parsers\n data = \"\"\"A\|B\|C\n1\|2,334\|5\n10\|13\|10.\n\"\"\"\n expected = DataFrame({\"A\": [1, 10], \"B\": [2334, 13], \"C\": [5, 10.0]})\n\n result = parser.read_csv(StringIO(data), sep=\"\|\", thousands=\",\")\n tm.assert_frame_equal(result, expected)\n\n\ndef test_squeeze(all_parsers):\n data = \"\"\"\\\na,1\nb,2\nc,3\n\"\"\"\n parser = all_parsers\n index = Index([\"a\", \"b\", \"c\"], name=0)\n expected = Series([1, 2, 3], name=1, index=index)\n\n result = parser.read_csv(StringIO(data), index_col=0, header=None, squeeze=True)\n tm.assert_series_equal(result, expected)\n\n # see gh-8217\n #\n # Series should not be a view.\n assert not result._is_view\n\n\ndef test_malformed(all_parsers):\n # see gh-6607\n parser = all_parsers\n data = \"\"\"ignore\nA,B,C\n1,2,3 # comment\n1,2,3,4,5\n2,3,4\n\"\"\"\n msg = \"Expected 3 fields in line 4, saw 5\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), header=1, comment=\"#\")\n\n\[email protected](\"nrows\", [5, 3, None])\ndef test_malformed_chunks(all_parsers, nrows):\n data = \"\"\"ignore\nA,B,C\nskip\n1,2,3\n3,5,10 # comment\n1,2,3,4,5\n2,3,4\n\"\"\"\n parser = all_parsers\n msg = \"Expected 3 fields in line 6, saw 5\"\n reader = parser.read_csv(\n StringIO(data), header=1, comment=\"#\", iterator=True, chunksize=1, skiprows=[2]\n )\n\n with pytest.raises(ParserError, match=msg):\n reader.read(nrows)\n\n\ndef test_unnamed_columns(all_parsers):\n data = \"\"\"A,B,C,,\n1,2,3,4,5\n6,7,8,9,10\n11,12,13,14,15\n\"\"\"\n parser = all_parsers\n expected = DataFrame(\n [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]],\n dtype=np.int64,\n columns=[\"A\", \"B\", \"C\", \"Unnamed: 3\", \"Unnamed: 4\"],\n )\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_csv_mixed_type(all_parsers):\n data = \"\"\"A,B,C\na,1,2\nb,3,4\nc,4,5\n\"\"\"\n parser = all_parsers\n expected = DataFrame({\"A\": [\"a\", \"b\", \"c\"], \"B\": [1, 3, 4], \"C\": [2, 4, 5]})\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_low_memory_no_rows_with_index(all_parsers):\n # see gh-21141\n parser = all_parsers\n\n if not parser.low_memory:\n pytest.skip(\"This is a low-memory specific test\")\n\n data = \"\"\"A,B,C\n1,1,1,2\n2,2,3,4\n3,3,4,5\n\"\"\"\n result = parser.read_csv(StringIO(data), low_memory=True, index_col=0, nrows=0)\n expected = DataFrame(columns=[\"A\", \"B\", \"C\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_dataframe(all_parsers, csv1):\n parser = all_parsers\n result = parser.read_csv(csv1, index_col=0, parse_dates=True)\n\n expected = DataFrame(\n [\n [0.980269, 3.685731, -0.364216805298, -1.159738],\n [1.047916, -0.041232, -0.16181208307, 0.212549],\n [0.498581, 0.731168, -0.537677223318, 1.346270],\n [1.120202, 1.567621, 0.00364077397681, 0.675253],\n [-0.487094, 0.571455, -1.6116394093, 0.103469],\n [0.836649, 0.246462, 0.588542635376, 1.062782],\n [-0.157161, 1.340307, 1.1957779562, -1.097007],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index(\n [\n datetime(2000, 1, 3),\n datetime(2000, 1, 4),\n datetime(2000, 1, 5),\n datetime(2000, 1, 6),\n datetime(2000, 1, 7),\n datetime(2000, 1, 10),\n datetime(2000, 1, 11),\n ],\n name=\"index\",\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_no_index_name(all_parsers, csv_dir_path):\n parser = all_parsers\n csv2 = os.path.join(csv_dir_path, \"test2.csv\")\n result = parser.read_csv(csv2, index_col=0, parse_dates=True)\n\n expected = DataFrame(\n [\n [0.980269, 3.685731, -0.364216805298, -1.159738, \"foo\"],\n [1.047916, -0.041232, -0.16181208307, 0.212549, \"bar\"],\n [0.498581, 0.731168, -0.537677223318, 1.346270, \"baz\"],\n [1.120202, 1.567621, 0.00364077397681, 0.675253, \"qux\"],\n [-0.487094, 0.571455, -1.6116394093, 0.103469, \"foo2\"],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\", \"E\"],\n index=Index(\n [\n datetime(2000, 1, 3),\n datetime(2000, 1, 4),\n datetime(2000, 1, 5),\n datetime(2000, 1, 6),\n datetime(2000, 1, 7),\n ]\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_wrong_num_columns(all_parsers):\n # Too few columns.\n data = \"\"\"A,B,C,D,E,F\n1,2,3,4,5,6\n6,7,8,9,10,11,12\n11,12,13,14,15,16\n\"\"\"\n parser = all_parsers\n msg = \"Expected 6 fields in line 3, saw 7\"\n\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data))\n\n\ndef test_read_duplicate_index_explicit(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo,12,13,14,15\nbar,12,13,14,15\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=0)\n\n expected = DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index([\"foo\", \"bar\", \"baz\", \"qux\", \"foo\", \"bar\"], name=\"index\"),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_duplicate_index_implicit(all_parsers):\n data = \"\"\"A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo,12,13,14,15\nbar,12,13,14,15\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data))\n\n expected = DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index([\"foo\", \"bar\", \"baz\", \"qux\", \"foo\", \"bar\"]),\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,kwargs,expected\",\n [\n (\n \"A,B\\nTrue,1\\nFalse,2\\nTrue,3\",\n dict(),\n DataFrame([[True, 1], [False, 2], [True, 3]], columns=[\"A\", \"B\"]),\n ),\n (\n \"A,B\\nYES,1\\nno,2\\nyes,3\\nNo,3\\nYes,3\",\n dict(true_values=[\"yes\", \"Yes\", \"YES\"], false_values=[\"no\", \"NO\", \"No\"]),\n DataFrame(\n [[True, 1], [False, 2], [True, 3], [False, 3], [True, 3]],\n columns=[\"A\", \"B\"],\n ),\n ),\n (\n \"A,B\\nTRUE,1\\nFALSE,2\\nTRUE,3\",\n dict(),\n DataFrame([[True, 1], [False, 2], [True, 3]], columns=[\"A\", \"B\"]),\n ),\n (\n \"A,B\\nfoo,bar\\nbar,foo\",\n dict(true_values=[\"foo\"], false_values=[\"bar\"]),\n DataFrame([[True, False], [False, True]], columns=[\"A\", \"B\"]),\n ),\n ],\n)\ndef test_parse_bool(all_parsers, data, kwargs, expected):\n parser = all_parsers\n result = parser.read_csv(StringIO(data), kwargs)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_int_conversion(all_parsers):\n data = \"\"\"A,B\n1.0,1\n2.0,2\n3.0,3\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data))\n\n expected = DataFrame([[1.0, 1], [2.0, 2], [3.0, 3]], columns=[\"A\", \"B\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"nrows\", [3, 3.0])\ndef test_read_nrows(all_parsers, nrows):\n # see gh-10476\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n expected = DataFrame(\n [[\"foo\", 2, 3, 4, 5], [\"bar\", 7, 8, 9, 10], [\"baz\", 12, 13, 14, 15]],\n columns=[\"index\", \"A\", \"B\", \"C\", \"D\"],\n )\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data), nrows=nrows)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"nrows\", [1.2, \"foo\", -1])\ndef test_read_nrows_bad(all_parsers, nrows):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n msg = r\"'nrows' must be an integer >=0\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), nrows=nrows)\n\n\[email protected](\"index_col\", [0, \"index\"])\ndef test_read_chunksize_with_index(all_parsers, index_col):\n parser = all_parsers\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n\n reader = parser.read_csv(StringIO(data), index_col=0, chunksize=2)\n expected = DataFrame(\n [\n [\"foo\", 2, 3, 4, 5],\n [\"bar\", 7, 8, 9, 10],\n [\"baz\", 12, 13, 14, 15],\n [\"qux\", 12, 13, 14, 15],\n [\"foo2\", 12, 13, 14, 15],\n [\"bar2\", 12, 13, 14, 15],\n ],\n columns=[\"index\", \"A\", \"B\", \"C\", \"D\"],\n )\n expected = expected.set_index(\"index\")\n\n chunks = list(reader)\n tm.assert_frame_equal(chunks[0], expected[:2])\n tm.assert_frame_equal(chunks[1], expected[2:4])\n tm.assert_frame_equal(chunks[2], expected[4:])\n\n\[email protected](\"chunksize\", [1.3, \"foo\", 0])\ndef test_read_chunksize_bad(all_parsers, chunksize):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n msg = r\"'chunksize' must be an integer >=1\"\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), chunksize=chunksize)\n\n\[email protected](\"chunksize\", [2, 8])\ndef test_read_chunksize_and_nrows(all_parsers, chunksize):\n # see gh-15755\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0, nrows=5)\n\n reader = parser.read_csv(StringIO(data), chunksize=chunksize, kwargs)\n expected = parser.read_csv(StringIO(data), kwargs)\n tm.assert_frame_equal(concat(reader), expected)\n\n\ndef test_read_chunksize_and_nrows_changing_size(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0, nrows=5)\n\n reader = parser.read_csv(StringIO(data), chunksize=8, kwargs)\n expected = parser.read_csv(StringIO(data), kwargs)\n\n tm.assert_frame_equal(reader.get_chunk(size=2), expected.iloc[:2])\n tm.assert_frame_equal(reader.get_chunk(size=4), expected.iloc[2:5])\n\n with pytest.raises(StopIteration, match=\"\"):\n reader.get_chunk(size=3)\n\n\ndef test_get_chunk_passed_chunksize(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C\n1,2,3\n4,5,6\n7,8,9\n1,2,3\"\"\"\n\n reader = parser.read_csv(StringIO(data), chunksize=2)\n result = reader.get_chunk()\n\n expected = DataFrame([[1, 2, 3], [4, 5, 6]], columns=[\"A\", \"B\", \"C\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"kwargs\", [dict(), dict(index_col=0)])\ndef test_read_chunksize_compat(all_parsers, kwargs):\n # see gh-12185\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n reader = parser.read_csv(StringIO(data), chunksize=2, kwargs)\n\n result = parser.read_csv(StringIO(data), kwargs)\n tm.assert_frame_equal(concat(reader), result)\n\n\ndef test_read_chunksize_jagged_names(all_parsers):\n # see gh-23509\n parser = all_parsers\n data = \"\\n\".join([\"0\"] * 7 + [\",\".join([\"0\"] * 10)])\n\n expected = DataFrame([[0] + [np.nan] * 9] * 7 + [[0] * 10])\n reader = parser.read_csv(StringIO(data), names=range(10), chunksize=4)\n\n result = concat(reader)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_data_list(all_parsers):\n parser = all_parsers\n kwargs = dict(index_col=0)\n data = \"A,B,C\\nfoo,1,2,3\\nbar,4,5,6\"\n\n data_list = [[\"A\", \"B\", \"C\"], [\"foo\", \"1\", \"2\", \"3\"], [\"bar\", \"4\", \"5\", \"6\"]]\n expected = parser.read_csv(StringIO(data), kwargs)\n\n parser = TextParser(data_list, chunksize=2, kwargs)\n result = parser.read()\n\n tm.assert_frame_equal(result, expected)\n\n\ndef test_iterator(all_parsers):\n # see gh-6607\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0)\n\n expected = parser.read_csv(StringIO(data), kwargs)\n reader = parser.read_csv(StringIO(data), iterator=True, kwargs)\n\n first_chunk = reader.read(3)\n tm.assert_frame_equal(first_chunk, expected[:3])\n\n last_chunk = reader.read(5)\n tm.assert_frame_equal(last_chunk, expected[3:])\n\n\ndef test_iterator2(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C\nfoo,1,2,3\nbar,4,5,6\nbaz,7,8,9\n\"\"\"\n\n reader = parser.read_csv(StringIO(data), iterator=True)\n result = list(reader)\n\n expected = DataFrame(\n [[1, 2, 3], [4, 5, 6], [7, 8, 9]],\n index=[\"foo\", \"bar\", \"baz\"],\n columns=[\"A\", \"B\", \"C\"],\n )\n tm.assert_frame_equal(result[0], expected)\n\n\ndef test_reader_list(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0)\n\n lines = list(csv.reader(StringIO(data)))\n reader = TextParser(lines, chunksize=2, kwargs)\n\n expected = parser.read_csv(StringIO(data), kwargs)\n chunks = list(reader)\n\n tm.assert_frame_equal(chunks[0], expected[:2])\n tm.assert_frame_equal(chunks[1], expected[2:4])\n tm.assert_frame_equal(chunks[2], expected[4:])\n\n\ndef test_reader_list_skiprows(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0)\n\n lines = list(csv.reader(StringIO(data)))\n reader = TextParser(lines, chunksize=2, skiprows=[1], kwargs)\n\n expected = parser.read_csv(StringIO(data), kwargs)\n chunks = list(reader)\n\n tm.assert_frame_equal(chunks[0], expected[1:3])\n\n\ndef test_iterator_stop_on_chunksize(all_parsers):\n # gh-3967: stopping iteration when chunksize is specified\n parser = all_parsers\n data = \"\"\"A,B,C\nfoo,1,2,3\nbar,4,5,6\nbaz,7,8,9\n\"\"\"\n\n reader = parser.read_csv(StringIO(data), chunksize=1)\n result = list(reader)\n\n assert len(result) == 3\n expected = DataFrame(\n [[1, 2, 3], [4, 5, 6], [7, 8, 9]],\n index=[\"foo\", \"bar\", \"baz\"],\n columns=[\"A\", \"B\", \"C\"],\n )\n tm.assert_frame_equal(concat(result), expected)\n\n\[email protected](\n \"kwargs\", [dict(iterator=True, chunksize=1), dict(iterator=True), dict(chunksize=1)]\n)\ndef test_iterator_skipfooter_errors(all_parsers, kwargs):\n msg = \"'skipfooter' not supported for 'iteration'\"\n parser = all_parsers\n data = \"a\\n1\\n2\"\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), skipfooter=1, kwargs)\n\n\ndef test_nrows_skipfooter_errors(all_parsers):\n msg = \"'skipfooter' not supported with 'nrows'\"\n data = \"a\\n1\\n2\\n3\\n4\\n5\\n6\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), skipfooter=1, nrows=5)\n\n\[email protected](\n \"data,kwargs,expected\",\n [\n (\n \"\"\"foo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\",\n dict(index_col=0, names=[\"index\", \"A\", \"B\", \"C\", \"D\"]),\n DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n index=Index([\"foo\", \"bar\", \"baz\", \"qux\", \"foo2\", \"bar2\"], name=\"index\"),\n columns=[\"A\", \"B\", \"C\", \"D\"],\n ),\n ),\n (\n \"\"\"foo,one,2,3,4,5\nfoo,two,7,8,9,10\nfoo,three,12,13,14,15\nbar,one,12,13,14,15\nbar,two,12,13,14,15\n\"\"\",\n dict(index_col=[0, 1], names=[\"index1\", \"index2\", \"A\", \"B\", \"C\", \"D\"]),\n DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n index=MultiIndex.from_tuples(\n [\n (\"foo\", \"one\"),\n (\"foo\", \"two\"),\n (\"foo\", \"three\"),\n (\"bar\", \"one\"),\n (\"bar\", \"two\"),\n ],\n names=[\"index1\", \"index2\"],\n ),\n columns=[\"A\", \"B\", \"C\", \"D\"],\n ),\n ),\n ],\n)\ndef test_pass_names_with_index(all_parsers, data, kwargs, expected):\n parser = all_parsers\n result = parser.read_csv(StringIO(data), kwargs)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"index_col\", [[0, 1], [1, 0]])\ndef test_multi_index_no_level_names(all_parsers, index_col):\n data = \"\"\"index1,index2,A,B,C,D\nfoo,one,2,3,4,5\nfoo,two,7,8,9,10\nfoo,three,12,13,14,15\nbar,one,12,13,14,15\nbar,two,12,13,14,15\n\"\"\"\n headless_data = \"\\n\".join(data.split(\"\\n\")[1:])\n\n names = [\"A\", \"B\", \"C\", \"D\"]\n parser = all_parsers\n\n result = parser.read_csv(\n StringIO(headless_data), index_col=index_col, header=None, names=names\n )\n expected = parser.read_csv(StringIO(data), index_col=index_col)\n\n # No index names in headless data.\n expected.index.names = [None] * 2\n tm.assert_frame_equal(result, expected)\n\n\ndef test_multi_index_no_level_names_implicit(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C,D\nfoo,one,2,3,4,5\nfoo,two,7,8,9,10\nfoo,three,12,13,14,15\nbar,one,12,13,14,15\nbar,two,12,13,14,15\n\"\"\"\n\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=MultiIndex.from_tuples(\n [\n (\"foo\", \"one\"),\n (\"foo\", \"two\"),\n (\"foo\", \"three\"),\n (\"bar\", \"one\"),\n (\"bar\", \"two\"),\n ]\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,expected,header\",\n [\n (\"a,b\", DataFrame(columns=[\"a\", \"b\"]), [0]),\n (\n \"a,b\\nc,d\",\n DataFrame(columns=MultiIndex.from_tuples([(\"a\", \"c\"), (\"b\", \"d\")])),\n [0, 1],\n ),\n ],\n)\[email protected](\"round_trip\", [True, False])\ndef test_multi_index_blank_df(all_parsers, data, expected, header, round_trip):\n # see gh-14545\n parser = all_parsers\n data = expected.to_csv(index=False) if round_trip else data\n\n result = parser.read_csv(StringIO(data), header=header)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_no_unnamed_index(all_parsers):\n parser = all_parsers\n data = \"\"\" id c0 c1 c2\n0 1 0 a b\n1 2 0 c d\n2 2 2 e f\n\"\"\"\n result = parser.read_csv(StringIO(data), sep=\" \")\n expected = DataFrame(\n [[0, 1, 0, \"a\", \"b\"], [1, 2, 0, \"c\", \"d\"], [2, 2, 2, \"e\", \"f\"]],\n columns=[\"Unnamed: 0\", \"id\", \"c0\", \"c1\", \"c2\"],\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_parse_simple_list(all_parsers):\n parser = all_parsers\n data = \"\"\"foo\nbar baz\nqux foo\nfoo\nbar\"\"\"\n\n result = parser.read_csv(StringIO(data), header=None)\n expected = DataFrame([\"foo\", \"bar baz\", \"qux foo\", \"foo\", \"bar\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected]\ndef test_url(all_parsers, csv_dir_path):\n # TODO: FTP testing\n parser = all_parsers\n kwargs = dict(sep=\"\\t\")\n\n url = (\n \"https://raw.github.com/pandas-dev/pandas/master/\"\n \"pandas/tests/io/parser/data/salaries.csv\"\n )\n url_result = parser.read_csv(url, kwargs)\n\n local_path = os.path.join(csv_dir_path, \"salaries.csv\")\n local_result = parser.read_csv(local_path, kwargs)\n tm.assert_frame_equal(url_result, local_result)\n\n\[email protected]\ndef test_local_file(all_parsers, csv_dir_path):\n parser = all_parsers\n kwargs = dict(sep=\"\\t\")\n\n local_path = os.path.join(csv_dir_path, \"salaries.csv\")\n local_result = parser.read_csv(local_path, kwargs)\n url = \"file://localhost/\" + local_path\n\n try:\n url_result = parser.read_csv(url, kwargs)\n tm.assert_frame_equal(url_result, local_result)\n except URLError:\n # Fails on some systems.\n pytest.skip(\"Failing on: \" + \" \".join(platform.uname()))\n\n\ndef test_path_path_lib(all_parsers):\n parser = all_parsers\n df = tm.makeDataFrame()\n result = tm.round_trip_pathlib(df.to_csv, lambda p: parser.read_csv(p, index_col=0))\n tm.assert_frame_equal(df, result)\n\n\ndef test_path_local_path(all_parsers):\n parser = all_parsers\n df = tm.makeDataFrame()\n result = tm.round_trip_localpath(\n df.to_csv, lambda p: parser.read_csv(p, index_col=0)\n )\n tm.assert_frame_equal(df, result)\n\n\ndef test_nonexistent_path(all_parsers):\n # gh-2428: pls no segfault\n # gh-14086: raise more helpful FileNotFoundError\n # GH#29233 \"File foo\" instead of \"File b'foo'\"\n parser = all_parsers\n path = f\"{tm.rands(10)}.csv\"\n\n msg = r\"\\[Errno 2\\]\"\n with pytest.raises(FileNotFoundError, match=msg) as e:\n parser.read_csv(path)\n assert path == e.value.filename\n\n\[email protected]_if_windows # os.chmod does not work in windows\ndef test_no_permission(all_parsers):\n # GH 23784\n parser = all_parsers\n\n msg = r\"\\[Errno 13\\]\"\n with tm.ensure_clean() as path:\n os.chmod(path, 0) # make file unreadable\n\n # verify that this process cannot open the file (not running as sudo)\n try:\n with open(path):\n pass\n pytest.skip(\"Running as sudo.\")\n except PermissionError:\n pass\n\n with pytest.raises(PermissionError, match=msg) as e:\n parser.read_csv(path)\n assert path == e.value.filename\n\n\ndef test_missing_trailing_delimiters(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C,D\n1,2,3,4\n1,3,3,\n1,4,5\"\"\"\n\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n [[1, 2, 3, 4], [1, 3, 3, np.nan], [1, 4, 5, np.nan]],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_skip_initial_space(all_parsers):\n data = (\n '\"09-Apr-2012\", \"01:10:18.300\", 2456026.548822908, 12849, '\n \"1.00361, 1.12551, 330.65659, 0355626618.16711, 73.48821, \"\n \"314.11625, 1917.09447, 179.71425, 80.000, 240.000, -350, \"\n \"70.06056, 344.98370, 1, 1, -0.689265, -0.692787, \"\n \"0.212036, 14.7674, 41.605, -9999.0, -9999.0, \"\n \"-9999.0, -9999.0, -9999.0, -9999.0, 000, 012, 128\"\n )\n parser = all_parsers\n\n result = parser.read_csv(\n StringIO(data),\n names=list(range(33)),\n header=None,\n na_values=[\"-9999.0\"],\n skipinitialspace=True,\n )\n expected = DataFrame(\n [\n [\n \"09-Apr-2012\",\n \"01:10:18.300\",\n 2456026.548822908,\n 12849,\n 1.00361,\n 1.12551,\n 330.65659,\n 355626618.16711,\n 73.48821,\n 314.11625,\n 1917.09447,\n 179.71425,\n 80.0,\n 240.0,\n -350,\n 70.06056,\n 344.9837,\n 1,\n 1,\n -0.689265,\n -0.692787,\n 0.212036,\n 14.7674,\n 41.605,\n np.nan,\n np.nan,\n np.nan,\n np.nan,\n np.nan,\n np.nan,\n 0,\n 12,\n 128,\n ]\n ]\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_trailing_delimiters(all_parsers):\n # see gh-2442\n data = \"\"\"A,B,C\n1,2,3,\n4,5,6,\n7,8,9,\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=False)\n\n expected = DataFrame({\"A\": [1, 4, 7], \"B\": [2, 5, 8], \"C\": [3, 6, 9]})\n tm.assert_frame_equal(result, expected)\n\n\ndef test_escapechar(all_parsers):\n # https://stackoverflow.com/questions/13824840/feature-request-for-\n # pandas-read-csv\n data = '''SEARCH_TERM,ACTUAL_URL\n\"bra tv bord\",\"http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord\"\n\"tv p\\xc3\\xa5 hjul\",\"http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord\"\n\"SLAGBORD, \\\\\"Bergslagen\\\\\", IKEA:s 1700-tals series\",\"http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord\"''' # noqa\n\n parser = all_parsers\n result = parser.read_csv(\n StringIO(data), escapechar=\"\\\\\", quotechar='\"', encoding=\"utf-8\"\n )\n\n assert result[\"SEARCH_TERM\"][2] == 'SLAGBORD, \"Bergslagen\", IKEA:s 1700-tals series'\n\n tm.assert_index_equal(result.columns, Index([\"SEARCH_TERM\", \"ACTUAL_URL\"]))\n\n\ndef test_int64_min_issues(all_parsers):\n # see gh-2599\n parser = all_parsers\n data = \"A,B\\n0,0\\n0,\"\n result = parser.read_csv(StringIO(data))\n\n expected = DataFrame({\"A\": [0, 0], \"B\": [0, np.nan]})\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_integers_above_fp_precision(all_parsers):\n data = \"\"\"Numbers\n17007000002000191\n17007000002000191\n17007000002000191\n17007000002000191\n17007000002000192\n17007000002000192\n17007000002000192\n17007000002000192\n17007000002000192\n17007000002000194\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n {\n \"Numbers\": [\n 17007000002000191,\n 17007000002000191,\n 17007000002000191,\n 17007000002000191,\n 17007000002000192,\n 17007000002000192,\n 17007000002000192,\n 17007000002000192,\n 17007000002000192,\n 17007000002000194,\n ]\n }\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_chunks_have_consistent_numerical_type(all_parsers):\n parser = all_parsers\n integers = [str(i) for i in range(499999)]\n data = \"a\\n\" + \"\\n\".join(integers + [\"1.0\", \"2.0\"] + integers)\n\n # Coercions should work without warnings.\n with tm.assert_produces_warning(None):\n result = parser.read_csv(StringIO(data))\n\n assert type(result.a[0]) is np.float64\n assert result.a.dtype == float\n\n\ndef test_warn_if_chunks_have_mismatched_type(all_parsers):\n warning_type = None\n parser = all_parsers\n integers = [str(i) for i in range(499999)]\n data = \"a\\n\" + \"\\n\".join(integers + [\"a\", \"b\"] + integers)\n\n # see gh-3866: if chunks are different types and can't\n # be coerced using numerical types, then issue warning.\n if parser.engine == \"c\" and parser.low_memory:\n warning_type = DtypeWarning\n\n with tm.assert_produces_warning(warning_type):\n df = parser.read_csv(StringIO(data))\n assert df.a.dtype == object\n\n\[email protected](\"sep\", [\" \", r\"\\s+\"])\ndef test_integer_overflow_bug(all_parsers, sep):\n # see gh-2601\n data = \"65248E10 11\\n55555E55 22\\n\"\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data), header=None, sep=sep)\n expected = DataFrame([[6.5248e14, 11], [5.5555e59, 22]])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_catch_too_many_names(all_parsers):\n # see gh-5156\n data = \"\"\"\\\n1,2,3\n4,,6\n7,8,9\n10,11,12\\n\"\"\"\n parser = all_parsers\n msg = (\n \"Too many columns specified: expected 4 and found 3\"\n if parser.engine == \"c\"\n else \"Number of passed names did not match \"\n \"number of header fields in the file\"\n )\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), header=0, names=[\"a\", \"b\", \"c\", \"d\"])\n\n\ndef test_ignore_leading_whitespace(all_parsers):\n # see gh-3374, gh-6607\n parser = all_parsers\n data = \" a b c\\n 1 2 3\\n 4 5 6\\n 7 8 9\"\n result = parser.read_csv(StringIO(data), sep=r\"\\s+\")\n\n expected = DataFrame({\"a\": [1, 4, 7], \"b\": [2, 5, 8], \"c\": [3, 6, 9]})\n tm.assert_frame_equal(result, expected)\n\n\ndef test_chunk_begins_with_newline_whitespace(all_parsers):\n # see gh-10022\n parser = all_parsers\n data = \"\\n hello\\nworld\\n\"\n\n result = parser.read_csv(StringIO(data), header=None)\n expected = DataFrame([\" hello\", \"world\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_with_index(all_parsers):\n # see gh-10184\n data = \"x,y\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=0)\n\n expected = DataFrame(columns=[\"y\"], index=Index([], name=\"x\"))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_with_multi_index(all_parsers):\n # see gh-10467\n data = \"x,y,z\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=[\"x\", \"y\"])\n\n expected = DataFrame(\n columns=[\"z\"], index=MultiIndex.from_arrays([[]] * 2, names=[\"x\", \"y\"])\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_with_reversed_multi_index(all_parsers):\n data = \"x,y,z\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=[1, 0])\n\n expected = DataFrame(\n columns=[\"z\"], index=MultiIndex.from_arrays([[]] * 2, names=[\"y\", \"x\"])\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_float_parser(all_parsers):\n # see gh-9565\n parser = all_parsers\n data = \"45e-1,4.5,45.,inf,-inf\"\n result = parser.read_csv(StringIO(data), header=None)\n\n expected = DataFrame([[float(s) for s in data.split(\",\")]])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_scientific_no_exponent(all_parsers):\n # see gh-12215\n df = DataFrame.from_dict({\"w\": [\"2e\"], \"x\": [\"3E\"], \"y\": [\"42e\"], \"z\": [\"632E\"]})\n data = df.to_csv(index=False)\n parser = all_parsers\n\n for precision in parser.float_precision_choices:\n df_roundtrip = parser.read_csv(StringIO(data), float_precision=precision)\n tm.assert_frame_equal(df_roundtrip, df)\n\n\[email protected](\"conv\", [None, np.int64, np.uint64])\ndef test_int64_overflow(all_parsers, conv):\n data = \"\"\"ID\n00013007854817840016671868\n00013007854817840016749251\n00013007854817840016754630\n00013007854817840016781876\n00013007854817840017028824\n00013007854817840017963235\n00013007854817840018860166\"\"\"\n parser = all_parsers\n\n if conv is None:\n # 13007854817840016671868 > UINT64_MAX, so this\n # will overflow and return object as the dtype.\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n [\n \"00013007854817840016671868\",\n \"00013007854817840016749251\",\n \"00013007854817840016754630\",\n \"00013007854817840016781876\",\n \"00013007854817840017028824\",\n \"00013007854817840017963235\",\n \"00013007854817840018860166\",\n ],\n columns=[\"ID\"],\n )\n tm.assert_frame_equal(result, expected)\n else:\n # 13007854817840016671868 > UINT64_MAX, so attempts\n # to cast to either int64 or uint64 will result in\n # an OverflowError being raised.\n msg = (\n \"(Python int too large to convert to C long)\|\"\n \"(long too big to convert)\|\"\n \"(int too big to convert)\"\n )\n\n with pytest.raises(OverflowError, match=msg):\n parser.read_csv(StringIO(data), converters={\"ID\": conv})\n\n\[email protected](\n \"val\", [np.iinfo(np.uint64).max, np.iinfo(np.int64).max, np.iinfo(np.int64).min]\n)\ndef test_int64_uint64_range(all_parsers, val):\n # These numbers fall right inside the int64-uint64\n # range, so they should be parsed as string.\n parser = all_parsers\n result = parser.read_csv(StringIO(str(val)), header=None)\n\n expected = DataFrame([val])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"val\", [np.iinfo(np.uint64).max + 1, np.iinfo(np.int64).min - 1]\n)\ndef test_outside_int64_uint64_range(all_parsers, val):\n # These numbers fall just outside the int64-uint64\n # range, so they should be parsed as string.\n parser = all_parsers\n result = parser.read_csv(StringIO(str(val)), header=None)\n\n expected = DataFrame([str(val)])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"exp_data\", [[str(-1), str(2 63)], [str(2 63), str(-1)]])\ndef test_numeric_range_too_wide(all_parsers, exp_data):\n # No numerical dtype can hold both negative and uint64\n # values, so they should be cast as string.\n parser = all_parsers\n data = \"\\n\".join(exp_data)\n expected = DataFrame(exp_data)\n\n result = parser.read_csv(StringIO(data), header=None)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"iterator\", [True, False])\ndef test_empty_with_nrows_chunksize(all_parsers, iterator):\n # see gh-9535\n parser = all_parsers\n expected = DataFrame(columns=[\"foo\", \"bar\"])\n\n nrows = 10\n data = StringIO(\"foo,bar\\n\")\n\n if iterator:\n result = next(iter(parser.read_csv(data, chunksize=nrows)))\n else:\n result = parser.read_csv(data, nrows=nrows)\n\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,kwargs,expected,msg\",\n [\n # gh-10728: WHITESPACE_LINE\n (\n \"a,b,c\\n4,5,6\\n \",\n dict(),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # gh-10548: EAT_LINE_COMMENT\n (\n \"a,b,c\\n4,5,6\\n#comment\",\n dict(comment=\"#\"),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_CRNL_NOP\n (\n \"a,b,c\\n4,5,6\\n\\r\",\n dict(),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_COMMENT\n (\n \"a,b,c\\n4,5,6#comment\",\n dict(comment=\"#\"),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # SKIP_LINE\n (\n \"a,b,c\\n4,5,6\\nskipme\",\n dict(skiprows=[2]),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_LINE_COMMENT\n (\n \"a,b,c\\n4,5,6\\n#comment\",\n dict(comment=\"#\", skip_blank_lines=False),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # IN_FIELD\n (\n \"a,b,c\\n4,5,6\\n \",\n dict(skip_blank_lines=False),\n DataFrame([[\"4\", 5, 6], [\" \", None, None]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_CRNL\n (\n \"a,b,c\\n4,5,6\\n\\r\",\n dict(skip_blank_lines=False),\n DataFrame([[4, 5, 6], [None, None, None]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # ESCAPED_CHAR\n (\n \"a,b,c\\n4,5,6\\n\\\\\",\n dict(escapechar=\"\\\\\"),\n None,\n \"(EOF following escape character)\|(unexpected end of data)\",\n ),\n # ESCAPE_IN_QUOTED_FIELD\n (\n 'a,b,c\\n4,5,6\\n\"\\\\',\n dict(escapechar=\"\\\\\"),\n None,\n \"(EOF inside string starting at row 2)\|(unexpected end of data)\",\n ),\n # IN_QUOTED_FIELD\n (\n 'a,b,c\\n4,5,6\\n\"',\n dict(escapechar=\"\\\\\"),\n None,\n \"(EOF inside string starting at row 2)\|(unexpected end of data)\",\n ),\n ],\n ids=[\n \"whitespace-line\",\n \"eat-line-comment\",\n \"eat-crnl-nop\",\n \"eat-comment\",\n \"skip-line\",\n \"eat-line-comment\",\n \"in-field\",\n \"eat-crnl\",\n \"escaped-char\",\n \"escape-in-quoted-field\",\n \"in-quoted-field\",\n ],\n)\ndef test_eof_states(all_parsers, data, kwargs, expected, msg):\n # see gh-10728, gh-10548\n parser = all_parsers\n\n if expected is None:\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), kwargs)\n else:\n result = parser.read_csv(StringIO(data), kwargs)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"usecols\", [None, [0, 1], [\"a\", \"b\"]])\ndef test_uneven_lines_with_usecols(all_parsers, usecols):\n # see gh-12203\n parser = all_parsers\n data = r\"\"\"a,b,c\n0,1,2\n3,4,5,6,7\n8,9,10\"\"\"\n\n if usecols is None:\n # Make sure that an error is still raised\n # when the \"usecols\" parameter is not provided.\n msg = r\"Expected \\d+ fields in line \\d+, saw \\d+\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data))\n else:\n expected = DataFrame({\"a\": [0, 3, 8], \"b\": [1, 4, 9]})\n\n result = parser.read_csv(StringIO(data), usecols=usecols)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,kwargs,expected\",\n [\n # First, check to see that the response of parser when faced with no\n # provided columns raises the correct error, with or without usecols.\n (\"\", dict(), None),\n (\"\", dict(usecols=[\"X\"]), None),\n (\n \",,\",\n dict(names=[\"Dummy\", \"X\", \"Dummy_2\"], usecols=[\"X\"]),\n DataFrame(columns=[\"X\"], index=[0], dtype=np.float64),\n ),\n (\n \"\",\n dict(names=[\"Dummy\", \"X\", \"Dummy_2\"], usecols=[\"X\"]),\n DataFrame(columns=[\"X\"]),\n ),\n ],\n)\ndef test_read_empty_with_usecols(all_parsers, data, kwargs, expected):\n # see gh-12493\n parser = all_parsers\n\n if expected is None:\n msg = \"No columns to parse from file\"\n with pytest.raises(EmptyDataError, match=msg):\n parser.read_csv(StringIO(data), kwargs)\n else:\n result = parser.read_csv(StringIO(data), kwargs)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"kwargs,expected\",\n [\n # gh-8661, gh-8679: this should ignore six lines, including\n # lines with trailing whitespace and blank lines.\n (\n dict(\n header=None,\n delim_whitespace=True,\n skiprows=[0, 1, 2, 3, 5, 6],\n skip_blank_lines=True,\n ),\n DataFrame([[1.0, 2.0, 4.0], [5.1, np.nan, 10.0]]),\n ),\n # gh-8983: test skipping set of rows after a row with trailing spaces.\n (\n dict(\n delim_whitespace=True, skiprows=[1, 2, 3, 5, 6], skip_blank_lines=True\n ),\n DataFrame({\"A\": [1.0, 5.1], \"B\": [2.0, np.nan], \"C\": [4.0, 10]}),\n ),\n ],\n)\ndef test_trailing_spaces(all_parsers, kwargs, expected):\n data = \"A B C \\nrandom line with trailing spaces \\nskip\\n1,2,3\\n1,2.,4.\\nrandom line with trailing tabs\\t\\t\\t\\n \\n5.1,NaN,10.0\\n\" # noqa\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data.replace(\",\", \" \")), kwargs)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_raise_on_sep_with_delim_whitespace(all_parsers):\n # see gh-6607\n data = \"a b c\\n1 2 3\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=\"you can only specify one\"):\n parser.read_csv(StringIO(data), sep=r\"\\s\", delim_whitespace=True)\n\n\[email protected](\"delim_whitespace\", [True, False])\ndef test_single_char_leading_whitespace(all_parsers, delim_whitespace):\n # see gh-9710\n parser = all_parsers\n data = \"\"\"\\\nMyColumn\na\nb\na\nb\\n\"\"\"\n\n expected = DataFrame({\"MyColumn\": list(\"abab\")})\n result = parser.read_csv(\n StringIO(data), skipinitialspace=True, delim_whitespace=delim_whitespace\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"sep,skip_blank_lines,exp_data\",\n [\n (\",\", True, [[1.0, 2.0, 4.0], [5.0, np.nan, 10.0], [-70.0, 0.4, 1.0]]),\n (r\"\\s+\", True, [[1.0, 2.0, 4.0], [5.0, np.nan, 10.0], [-70.0, 0.4, 1.0]]),\n (\n \",\",\n False,\n [\n [1.0, 2.0, 4.0],\n [np.nan, np.nan, np.nan],\n [np.nan, np.nan, np.nan],\n [5.0, np.nan, 10.0],\n [np.nan, np.nan, np.nan],\n [-70.0, 0.4, 1.0],\n ],\n ),\n ],\n)\ndef test_empty_lines(all_parsers, sep, skip_blank_lines, exp_data):\n parser = all_parsers\n data = \"\"\"\\\nA,B,C\n1,2.,4.\n\n\n5.,NaN,10.0\n\n-70,.4,1\n\"\"\"\n\n if sep == r\"\\s+\":\n data = data.replace(\",\", \" \")\n\n result = parser.read_csv(StringIO(data), sep=sep, skip_blank_lines=skip_blank_lines)\n expected = DataFrame(exp_data, columns=[\"A\", \"B\", \"C\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_whitespace_lines(all_parsers):\n parser = all_parsers\n data = \"\"\"\n\n\\t \\t\\t\n\\t\nA,B,C\n\\t 1,2.,4.\n5.,NaN,10.0\n\"\"\"\n expected = DataFrame([[1, 2.0, 4.0], [5.0, np.nan, 10.0]], columns=[\"A\", \"B\", \"C\"])\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,expected\",\n [\n (\n \"\"\" A B C D\na 1 2 3 4\nb 1 2 3 4\nc 1 2 3 4\n\"\"\",\n DataFrame(\n [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=[\"a\", \"b\", \"c\"],\n ),\n ),\n (\n \" a b c\\n1 2 3 \\n4 5 6\\n 7 8 9\",\n DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=[\"a\", \"b\", \"c\"]),\n ),\n ],\n)\ndef test_whitespace_regex_separator(all_parsers, data, expected):\n # see gh-6607\n parser = all_parsers\n result = parser.read_csv(StringIO(data), sep=r\"\\s+\")\n tm.assert_frame_equal(result, expected)\n\n\ndef test_verbose_read(all_parsers, capsys):\n parser = all_parsers\n data = \"\"\"a,b,c,d\none,1,2,3\none,1,2,3\n,1,2,3\none,1,2,3\n,1,2,3\n,1,2,3\none,1,2,3\ntwo,1,2,3\"\"\"\n\n # Engines are verbose in different ways.\n parser.read_csv(StringIO(data), verbose=True)\n captured = capsys.readouterr()\n\n if parser.engine == \"c\":\n assert \"Tokenization took:\" in captured.out\n assert \"Parser memory cleanup took:\" in captured.out\n else: # Python engine\n assert captured.out == \"Filled 3 NA values in column a\\n\"\n\n\ndef test_verbose_read2(all_parsers, capsys):\n parser = all_parsers\n data = \"\"\"a,b,c,d\none,1,2,3\ntwo,1,2,3\nthree,1,2,3\nfour,1,2,3\nfive,1,2,3\n,1,2,3\nseven,1,2,3\neight,1,2,3\"\"\"\n\n parser.read_csv(StringIO(data), verbose=True, index_col=0)\n captured = capsys.readouterr()\n\n # Engines are verbose in different ways.\n if parser.engine == \"c\":\n assert \"Tokenization took:\" in captured.out\n assert \"Parser memory cleanup took:\" in captured.out\n else: # Python engine\n assert captured.out == \"Filled 1 NA values in column a\\n\"\n\n\ndef test_iteration_open_handle(all_parsers):\n parser = all_parsers\n kwargs = dict(squeeze=True, header=None)\n\n with tm.ensure_clean() as path:\n with open(path, \"w\") as f:\n f.write(\"AAA\\nBBB\\nCCC\\nDDD\\nEEE\\nFFF\\nGGG\")\n\n with open(path) as f:\n for line in f:\n if \"CCC\" in line:\n break\n\n result = parser.read_csv(f, kwargs)\n expected = Series([\"DDD\", \"EEE\", \"FFF\", \"GGG\"], name=0)\n tm.assert_series_equal(result, expected)\n\n\[email protected](\n \"data,thousands,decimal\",\n [\n (\n \"\"\"A\|B\|C\n1\|2,334.01\|5\n10\|13\|10.\n\"\"\",\n \",\",\n \".\",\n ),\n (\n \"\"\"A\|B\|C\n1\|2.334,01\|5\n10\|13\|10,\n\"\"\",\n \".\",\n \",\",\n ),\n ],\n)\ndef test_1000_sep_with_decimal(all_parsers, data, thousands, decimal):\n parser = all_parsers\n expected = DataFrame({\"A\": [1, 10], \"B\": [2334.01, 13], \"C\": [5, 10.0]})\n\n result = parser.read_csv(\n StringIO(data), sep=\"\|\", thousands=thousands, decimal=decimal\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_euro_decimal_format(all_parsers):\n parser = all_parsers\n data = \"\"\"Id;Number1;Number2;Text1;Text2;Number3\n1;1521,1541;187101,9543;ABC;poi;4,738797819\n2;121,12;14897,76;DEF;uyt;0,377320872\n3;878,158;108013,434;GHI;rez;2,735694704\"\"\"\n\n result = parser.read_csv(StringIO(data), sep=\";\", decimal=\",\")\n expected = DataFrame(\n [\n [1, 1521.1541, 187101.9543, \"ABC\", \"poi\", 4.738797819],\n [2, 121.12, 14897.76, \"DEF\", \"uyt\", 0.377320872],\n [3, 878.158, 108013.434, \"GHI\", \"rez\", 2.735694704],\n ],\n columns=[\"Id\", \"Number1\", \"Number2\", \"Text1\", \"Text2\", \"Number3\"],\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"na_filter\", [True, False])\ndef test_inf_parsing(all_parsers, na_filter):\n parser = all_parsers\n data = \"\"\"\\\n,A\na,inf\nb,-inf\nc,+Inf\nd,-Inf\ne,INF\nf,-INF\ng,+INf\nh,-INf\ni,inF\nj,-inF\"\"\"\n expected = DataFrame(\n {\"A\": [float(\"inf\"), float(\"-inf\")] * 5},\n index=[\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\"],\n )\n result = parser.read_csv(StringIO(data), index_col=0, na_filter=na_filter)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"na_filter\", [True, False])\ndef test_infinity_parsing(all_parsers, na_filter):\n parser = all_parsers\n data = \"\"\"\\\n,A\na,Infinity\nb,-Infinity\nc,+Infinity\n\"\"\"\n expected = DataFrame(\n {\"A\": [float(\"infinity\"), float(\"-infinity\"), float(\"+infinity\")]},\n index=[\"a\", \"b\", \"c\"],\n )\n result = parser.read_csv(StringIO(data), index_col=0, na_filter=na_filter)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"nrows\", [0, 1, 2, 3, 4, 5])\ndef test_raise_on_no_columns(all_parsers, nrows):\n parser = all_parsers\n data = \"\\n\" * nrows\n\n msg = \"No columns to parse from file\"\n with pytest.raises(EmptyDataError, match=msg):\n parser.read_csv(StringIO(data))\n\n\[email protected]_file_leaks\ndef test_memory_map(all_parsers, csv_dir_path):\n mmap_file = os.path.join(csv_dir_path, \"test_mmap.csv\")\n parser = all_parsers\n\n expected = DataFrame(\n {\"a\": [1, 2, 3], \"b\": [\"one\", \"two\", \"three\"], \"c\": [\"I\", \"II\", \"III\"]}\n )\n\n result = parser.read_csv(mmap_file, memory_map=True)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_null_byte_char(all_parsers):\n # see gh-2741\n data = \"\\x00,foo\"\n names = [\"a\", \"b\"]\n parser = all_parsers\n\n if parser.engine == \"c\":\n expected = DataFrame([[np.nan, \"foo\"]], columns=names)\n out = parser.read_csv(StringIO(data), names=names)\n tm.assert_frame_equal(out, expected)\n else:\n msg = \"NULL byte detected\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), names=names)\n\n\ndef test_temporary_file(all_parsers):\n # see gh-13398\n parser = all_parsers\n data = \"0 0\"\n\n with tm.ensure_clean(mode=\"w+\", return_filelike=True) as new_file:\n new_file.write(data)\n new_file.flush()\n new_file.seek(0)\n\n result = parser.read_csv(new_file, sep=r\"\\s+\", header=None)\n\n expected = DataFrame([[0, 0]])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_internal_eof_byte(all_parsers):\n # see gh-5500\n parser = all_parsers\n data = \"a,b\\n1\\x1a,2\"\n\n expected = DataFrame([[\"1\\x1a\", 2]], columns=[\"a\", \"b\"])\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_internal_eof_byte_to_file(all_parsers):\n # see gh-16559\n parser = all_parsers\n data = b'c1,c2\\r\\n\"test \\x1a test\", test\\r\\n'\n expected = DataFrame([[\"test \\x1a test\", \" test\"]], columns=[\"c1\", \"c2\"])\n path = f\"__{tm.rands(10)}__.csv\"\n\n with tm.ensure_clean(path) as path:\n with open(path, \"wb\") as f:\n f.write(data)\n\n result = parser.read_csv(path)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_sub_character(all_parsers, csv_dir_path):\n # see gh-16893\n filename = os.path.join(csv_dir_path, \"sub_char.csv\")\n expected = DataFrame([[1, 2, 3]], columns=[\"a\", \"\\x1ab\", \"c\"])\n\n parser = all_parsers\n result = parser.read_csv(filename)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_file_handle_string_io(all_parsers):\n # gh-14418\n #\n # Don't close user provided file handles.\n parser = all_parsers\n data = \"a,b\\n1,2\"\n\n fh = StringIO(data)\n parser.read_csv(fh)\n assert not fh.closed\n\n\ndef test_file_handles_with_open(all_parsers, csv1):\n # gh-14418\n #\n # Don't close user provided file handles.\n parser = all_parsers\n\n for mode in [\"r\", \"rb\"]:\n with open(csv1, mode) as f:\n parser.read_csv(f)\n assert not f.closed\n\n\ndef test_invalid_file_buffer_class(all_parsers):\n # see gh-15337\n class InvalidBuffer:\n pass\n\n parser = all_parsers\n msg = \"Invalid file path or buffer object type\"\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(InvalidBuffer())\n\n\ndef test_invalid_file_buffer_mock(all_parsers):\n # see gh-15337\n parser = all_parsers\n msg = \"Invalid file path or buffer object type\"\n\n class Foo:\n pass\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(Foo())\n\n\ndef test_valid_file_buffer_seems_invalid(all_parsers):\n # gh-16135: we want to ensure that \"tell\" and \"seek\"\n # aren't actually being used when we call `read_csv`\n #\n # Thus, while the object may look \"invalid\" (these\n # methods are attributes of the `StringIO` class),\n # it is still a valid file-object for our purposes.\n class NoSeekTellBuffer(StringIO):\n def tell(self):\n raise AttributeError(\"No tell method\")\n\n def seek(self, pos, whence=0):\n raise AttributeError(\"No seek method\")\n\n data = \"a\\n1\"\n parser = all_parsers\n expected = DataFrame({\"a\": [1]})\n\n result = parser.read_csv(NoSeekTellBuffer(data))\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"kwargs\",\n [dict(), dict(error_bad_lines=True)], # Default is True. # Explicitly pass in.\n)\[email protected](\n \"warn_kwargs\", [dict(), dict(warn_bad_lines=True), dict(warn_bad_lines=False)]\n)\ndef test_error_bad_lines(all_parsers, kwargs, warn_kwargs):\n # see gh-15925\n parser = all_parsers\n kwargs.update(warn_kwargs)\n data = \"a\\n1\\n1,2,3\\n4\\n5,6,7\"\n\n msg = \"Expected 1 fields in line 3, saw 3\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), kwargs)\n\n\ndef test_warn_bad_lines(all_parsers, capsys):\n # see gh-15925\n parser = all_parsers\n data = \"a\\n1\\n1,2,3\\n4\\n5,6,7\"\n expected = DataFrame({\"a\": [1, 4]})\n\n result = parser.read_csv(StringIO(data), error_bad_lines=False, warn_bad_lines=True)\n tm.assert_frame_equal(result, expected)\n\n captured = capsys.readouterr()\n assert \"Skipping line 3\" in captured.err\n assert \"Skipping line 5\" in captured.err\n\n\ndef test_suppress_error_output(all_parsers, capsys):\n # see gh-15925\n parser = all_parsers\n data = \"a\\n1\\n1,2,3\\n4\\n5,6,7\"\n expected = DataFrame({\"a\": [1, 4]})\n\n result = parser.read_csv(\n StringIO(data), error_bad_lines=False, warn_bad_lines=False\n )\n tm.assert_frame_equal(result, expected)\n\n captured = capsys.readouterr()\n assert captured.err == \"\"\n\n\[email protected](\"filename\", [\"sé-es-vé.csv\", \"ru-sй.csv\", \"中文文件名.csv\"])\ndef test_filename_with_special_chars(all_parsers, filename):\n # see gh-15086.\n parser = all_parsers\n df = DataFrame({\"a\": [1, 2, 3]})\n\n with tm.ensure_clean(filename) as path:\n df.to_csv(path, index=False)\n\n result = parser.read_csv(path)\n tm.assert_frame_equal(result, df)\n\n\ndef test_read_csv_memory_growth_chunksize(all_parsers):\n # see gh-24805\n #\n # Let's just make sure that we don't crash\n # as we iteratively process all chunks.\n parser = all_parsers\n\n with tm.ensure_clean() as path:\n with open(path, \"w\") as f:\n for i in range(1000):\n f.write(str(i) + \"\\n\")\n\n result = parser.read_csv(path, chunksize=20)\n\n for _ in result:\n pass\n\n\ndef test_read_csv_raises_on_header_prefix(all_parsers):\n # gh-27394\n parser = all_parsers\n msg = \"Argument prefix must be None if argument header is not None\"\n\n s = StringIO(\"0,1\\n2,3\")\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(s, header=0, prefix=\"_X\")\n\n\ndef test_unexpected_keyword_parameter_exception(all_parsers):\n # GH-34976\n parser = all_parsers\n\n msg = \"{}\\\\(\\\\) got an unexpected keyword argument 'foo'\"\n with pytest.raises(TypeError, match=msg.format(\"read_csv\")):\n parser.read_csv(\"foo.csv\", foo=1)\n with pytest.raises(TypeError, match=msg.format(\"read_table\")):\n parser.read_table(\"foo.tsv\", foo=1)\n\n\ndef test_read_table_same_signature_as_read_csv(all_parsers):\n # GH-34976\n parser = all_parsers\n\n table_sign = signature(parser.read_table)\n csv_sign = signature(parser.read_csv)\n\n assert table_sign.parameters.keys() == csv_sign.parameters.keys()\n assert table_sign.return_annotation == csv_sign.return_annotation\n\n for key, csv_param in csv_sign.parameters.items():\n table_param = table_sign.parameters[key]\n if key == \"sep\":\n assert csv_param.default == \",\"\n assert table_param.default == \"\\t\"\n assert table_param.annotation == csv_param.annotation\n assert table_param.kind == csv_param.kind\n continue\n else:\n assert table_param == csv_param\n\n\ndef test_read_table_equivalency_to_read_csv(all_parsers):\n # see gh-21948\n # As of 0.25.0, read_table is undeprecated\n parser = all_parsers\n data = \"a\\tb\\n1\\t2\\n3\\t4\"\n expected = parser.read_csv(StringIO(data), sep=\"\\t\")\n result = parser.read_table(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_first_row_bom(all_parsers):\n # see gh-26545\n parser = all_parsers\n data = '''\\ufeff\"Head1\"\t\"Head2\"\t\"Head3\"'''\n\n result = parser.read_csv(StringIO(data), delimiter=\"\\t\")\n expected = DataFrame(columns=[\"Head1\", \"Head2\", \"Head3\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_first_row_bom_unquoted(all_parsers):\n # see gh-36343\n parser = all_parsers\n data = \"\"\"\\ufeffHead1\tHead2\tHead3\"\"\"\n\n result = parser.read_csv(StringIO(data), delimiter=\"\\t\")\n expected = DataFrame(columns=[\"Head1\", \"Head2\", \"Head3\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_integer_precision(all_parsers):\n # Gh 7072\n s = \"\"\"1,1;0;0;0;1;1;3844;3844;3844;1;1;1;1;1;1;0;0;1;1;0;0,,,4321583677327450765\n5,1;0;0;0;1;1;843;843;843;1;1;1;1;1;1;0;0;1;1;0;0,64.0,;,4321113141090630389\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(s), header=None)[4]\n expected = Series([4321583677327450765, 4321113141090630389], name=4)\n tm.assert_series_equal(result, expected)\n\n\ndef test_file_descriptor_leak(all_parsers):\n # GH 31488\n\n parser = all_parsers\n with tm.ensure_clean() as path:\n\n def test():\n with pytest.raises(EmptyDataError, match=\"No columns to parse from file\"):\n parser.read_csv(path)\n\n td.check_file_leaks(test)()\n\n\[email protected](\"nrows\", range(1, 6))\ndef test_blank_lines_between_header_and_data_rows(all_parsers, nrows):\n # GH 28071\n ref = DataFrame(\n [[np.nan, np.nan], [np.nan, np.nan], [1, 2], [np.nan, np.nan], [3, 4]],\n columns=list(\"ab\"),\n )\n csv = \"\\nheader\\n\\na,b\\n\\n\\n1,2\\n\\n3,4\"\n parser = all_parsers\n df = parser.read_csv(StringIO(csv), header=3, nrows=nrows, skip_blank_lines=False)\n tm.assert_frame_equal(df, ref[:nrows])\n\n\ndef test_no_header_two_extra_columns(all_parsers):\n # GH 26218\n column_names = [\"one\", \"two\", \"three\"]\n ref = DataFrame([[\"foo\", \"bar\", \"baz\"]], columns=column_names)\n stream = StringIO(\"foo,bar,baz,bam,blah\")\n parser = all_parsers\n df = parser.read_csv(stream, header=None, names=column_names, index_col=False)\n tm.assert_frame_equal(df, ref)\n\n\ndef test_read_csv_names_not_accepting_sets(all_parsers):\n # GH 34946\n data = \"\"\"\\\n 1,2,3\n 4,5,6\\n\"\"\"\n parser = all_parsers\n with pytest.raises(ValueError, match=\"Names should be an ordered collection.\"):\n parser.read_csv(StringIO(data), names=set(\"QAZ\"))\n\n\ndef test_read_csv_with_use_inf_as_na(all_parsers):\n # https://github.com/pandas-dev/pandas/issues/35493\n parser = all_parsers\n data = \"1.0\\nNaN\\n3.0\"\n with option_context(\"use_inf_as_na\", True):\n result = parser.read_csv(StringIO(data), header=None)\n expected = DataFrame([1.0, np.nan, 3.0])\n tm.assert_frame_equal(result, expected)\n" ]	[ [ "pandas.Series", "pandas.MultiIndex.from_tuples", "pandas.DataFrame", "pandas.io.parsers.TextParser", "numpy.iinfo", "pandas._testing.assert_frame_equal", "pandas.util._test_decorators.check_file_leaks", "pandas.Index", "pandas._libs.tslib.Timestamp", "pandas._testing.makeDataFrame", "pandas._testing.assert_series_equal", "pandas.concat", "pandas._testing.assert_produces_warning", "pandas.compat.is_platform_windows", "pandas.option_context", "pandas.DataFrame.from_dict", "pandas.MultiIndex.from_arrays", "pandas._testing.ensure_clean", "pandas.io.parsers.CParserWrapper._set_noconvert_columns", "pandas._testing.rands" ] ]
ThomasFavrel/Simple_Deep_NN_Numpy	[ "fe2080bfb5fec6e986294939cf253e6864abdd56" ]	[ "utils.py" ]	[ "import numpy as np\nimport matplotlib.pyplot as plt\nimport h5py\n\n\ndef sigmoid(Z):\n \"\"\"\n Implements the sigmoid activation in numpy\n \n Arguments:\n Z -- numpy array of any shape\n \n Returns:\n A -- output of sigmoid(z), same shape as Z\n cache -- returns Z as well, useful during backpropagation\n \"\"\"\n \n A = 1/(1+np.exp(-Z))\n cache = Z\n \n return A, cache\n\ndef relu(Z):\n \"\"\"\n Implement the RELU function.\n\n Arguments:\n Z -- Output of the linear layer, of any shape\n\n Returns:\n A -- Post-activation parameter, of the same shape as Z\n cache -- a python dictionary containing \"A\" ; stored for computing the backward pass efficiently\n \"\"\"\n \n A = np.maximum(0,Z)\n \n assert(A.shape == Z.shape)\n \n cache = Z \n return A, cache\n\n\ndef relu_backward(dA, cache):\n \"\"\"\n Implement the backward propagation for a single RELU unit.\n\n Arguments:\n dA -- post-activation gradient, of any shape\n cache -- 'Z' where we store for computing backward propagation efficiently\n\n Returns:\n dZ -- Gradient of the cost with respect to Z\n \"\"\"\n \n Z = cache\n dZ = np.array(dA, copy=True) # just converting dz to a correct object.\n \n # When z <= 0, you should set dz to 0 as well. \n dZ[Z <= 0] = 0\n \n assert (dZ.shape == Z.shape)\n \n return dZ\n\ndef sigmoid_backward(dA, cache):\n \"\"\"\n Implement the backward propagation for a single SIGMOID unit.\n\n Arguments:\n dA -- post-activation gradient, of any shape\n cache -- 'Z' where we store for computing backward propagation efficiently\n\n Returns:\n dZ -- Gradient of the cost with respect to Z\n \"\"\"\n \n Z = cache\n \n s = 1/(1+np.exp(-Z))\n dZ = dA * s * (1-s)\n \n assert (dZ.shape == Z.shape)\n \n return dZ\n\n\ndef load_data():\n train_dataset = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n\n test_dataset = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n\n classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n \n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n \n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n\n\ndef initialize_parameters(n_x, n_h, n_y):\n \"\"\"\n Argument:\n n_x -- size of the input layer\n n_h -- size of the hidden layer\n n_y -- size of the output layer\n \n Returns:\n parameters -- python dictionary containing your parameters:\n W1 -- weight matrix of shape (n_h, n_x)\n b1 -- bias vector of shape (n_h, 1)\n W2 -- weight matrix of shape (n_y, n_h)\n b2 -- bias vector of shape (n_y, 1)\n \"\"\"\n \n np.random.seed(1)\n \n W1 = np.random.randn(n_h, n_x)0.01\n b1 = np.zeros((n_h, 1))\n W2 = np.random.randn(n_y, n_h)0.01\n b2 = np.zeros((n_y, 1))\n \n assert(W1.shape == (n_h, n_x))\n assert(b1.shape == (n_h, 1))\n assert(W2.shape == (n_y, n_h))\n assert(b2.shape == (n_y, 1))\n \n parameters = {\"W1\": W1,\n \"b1\": b1,\n \"W2\": W2,\n \"b2\": b2}\n \n return parameters \n\n\n" ]	[ [ "numpy.maximum", "numpy.random.seed", "numpy.random.randn", "numpy.exp", "numpy.array", "numpy.zeros" ] ]
kake777/python_sample	[ "3e69c0e89a67f81ced56193524c2f69913262dda" ]	[ "algorithm/deep_learning/gradient3.py" ]	[ "#勾配のグラフ\nimport numpy as np\nimport matplotlib.pylab as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom common_function import numerical_gradient, function_2\n\ndef tangent_line(f, x):\n d = numerical_gradient(f, x)\n print(d)\n y = f(x) - dx\n return lambda t: dt + y\n\nif __name__ == '__main__':\n x0 = np.arange(-2, 2.5, 0.25)\n x1 = np.arange(-2, 2.5, 0.25)\n X, Y = np.meshgrid(x0, x1)\n \n X = X.flatten()\n Y = Y.flatten()\n\n grad = numerical_gradient(function_2, np.array([X, Y]).T).T\n\n plt.figure()\n plt.quiver(X, Y, -grad[0], -grad[1], angles=\"xy\",color=\"#666666\")\n plt.xlim([-2, 2])\n plt.ylim([-2, 2])\n plt.xlabel('x0')\n plt.ylabel('x1')\n plt.grid()\n plt.draw()\n plt.show()\n" ]	[ [ "matplotlib.pylab.show", "matplotlib.pylab.grid", "matplotlib.pylab.xlim", "numpy.arange", "matplotlib.pylab.draw", "matplotlib.pylab.xlabel", "matplotlib.pylab.figure", "matplotlib.pylab.ylabel", "matplotlib.pylab.ylim", "matplotlib.pylab.quiver", "numpy.array", "numpy.meshgrid" ] ]
craigbig/allennlp	[ "3f15a8bdcae366f3ef732eec1e9df26d91521582" ]	[ "allennlp/modules/token_embedders/pretrained_transformer_embedder.py" ]	[ "import math\nfrom typing import Optional, Tuple\n\nfrom overrides import overrides\n\nimport torch\nimport torch.nn.functional as F\nfrom transformers.modeling_auto import AutoModel\n\nfrom allennlp.data.tokenizers import PretrainedTransformerTokenizer\nfrom allennlp.modules.token_embedders.token_embedder import TokenEmbedder\nfrom allennlp.nn.util import batched_index_select\n\n\[email protected](\"pretrained_transformer\")\nclass PretrainedTransformerEmbedder(TokenEmbedder):\n \"\"\"\n Uses a pretrained model from `transformers` as a `TokenEmbedder`.\n\n # Parameters\n\n model_name : `str`\n The name of the `transformers` model to use. Should be the same as the corresponding\n `PretrainedTransformerIndexer`.\n max_length : `int`, optional (default = None)\n If positive, folds input token IDs into multiple segments of this length, pass them\n through the transformer model independently, and concatenate the final representations.\n Should be set to the same value as the `max_length` option on the\n `PretrainedTransformerIndexer`.\n \"\"\"\n\n def __init__(self, model_name: str, max_length: int = None) -> None:\n super().__init__()\n self.transformer_model = AutoModel.from_pretrained(model_name)\n self._max_length = max_length\n # I'm not sure if this works for all models; open an issue on github if you find a case\n # where it doesn't work.\n self.output_dim = self.transformer_model.config.hidden_size\n\n tokenizer = PretrainedTransformerTokenizer(model_name)\n self._num_added_start_tokens = tokenizer.num_added_start_tokens\n self._num_added_end_tokens = tokenizer.num_added_end_tokens\n self._num_added_tokens = self._num_added_start_tokens + self._num_added_end_tokens\n\n @overrides\n def get_output_dim(self):\n return self.output_dim\n\n def _number_of_token_type_embeddings(self):\n config = self.transformer_model.config\n if hasattr(config, \"type_vocab_size\"):\n return config.type_vocab_size\n else:\n return 0\n\n @overrides\n def forward(\n self,\n token_ids: torch.LongTensor,\n mask: torch.LongTensor,\n type_ids: Optional[torch.LongTensor] = None,\n segment_concat_mask: Optional[torch.LongTensor] = None,\n ) -> torch.Tensor: # type: ignore\n \"\"\"\n # Parameters\n\n token_ids: torch.LongTensor\n Shape: [\n batch_size, num_wordpieces if max_length is None else num_segment_concat_wordpieces\n ].\n num_segment_concat_wordpieces is num_wordpieces plus special tokens inserted in the\n middle, e.g. the length of: \"[CLS] A B C [SEP] [CLS] D E F [SEP]\" (see indexer logic).\n mask: torch.LongTensor\n Shape: [batch_size, num_wordpieces].\n type_ids: Optional[torch.LongTensor]\n Shape: [\n batch_size, num_wordpieces if max_length is None else num_segment_concat_wordpieces\n ].\n segment_concat_mask: Optional[torch.LongTensor]\n Shape: [batch_size, num_segment_concat_wordpieces].\n\n # Returns:\n\n Shape: [batch_size, num_wordpieces, embedding_size].\n \"\"\"\n\n # Some of the huggingface transformers don't support type ids at all and crash when you supply them. For\n # others, you can supply a tensor of zeros, and if you don't, they act as if you did. There is no practical\n # difference to the caller, so here we pretend that one case is the same as another case.\n if type_ids is not None:\n max_type_id = type_ids.max()\n if max_type_id == 0:\n type_ids = None\n else:\n if max_type_id >= self._number_of_token_type_embeddings():\n raise ValueError(\"Found type ids too large for the chosen transformer model.\")\n assert token_ids.shape == type_ids.shape\n\n if self._max_length is not None:\n batch_size, num_segment_concat_wordpieces = token_ids.size()\n token_ids, segment_concat_mask, type_ids = self._fold_long_sequences(\n token_ids, segment_concat_mask, type_ids\n )\n\n transformer_mask = segment_concat_mask if self._max_length is not None else mask\n # Shape: [batch_size, num_wordpieces, embedding_size],\n # or if self._max_length is not None:\n # [batch_size * num_segments, self._max_length, embedding_size]\n\n # We call this with kwargs because some of the huggingface models don't have the token_type_ids parameter\n # and fail even when it's given as None.\n parameters = {\"input_ids\": token_ids, \"attention_mask\": transformer_mask}\n if type_ids is not None:\n parameters[\"token_type_ids\"] = type_ids\n embeddings = self.transformer_model(*parameters)[0]\n\n if self._max_length is not None:\n embeddings = self._unfold_long_sequences(\n embeddings, segment_concat_mask, batch_size, num_segment_concat_wordpieces\n )\n\n return embeddings\n\n def _fold_long_sequences(\n self,\n token_ids: torch.LongTensor,\n mask: torch.LongTensor,\n type_ids: Optional[torch.LongTensor] = None,\n ) -> Tuple[torch.LongTensor, torch.LongTensor, Optional[torch.LongTensor]]:\n \"\"\"\n We fold 1D sequences (for each element in batch), returned by `PretrainedTransformerIndexer`\n that are in reality multiple segments concatenated together, to 2D tensors, e.g.\n\n [ [CLS] A B C [SEP] [CLS] D E [SEP] ]\n -> [ [ [CLS] A B C [SEP] ], [ [CLS] D E [SEP] [PAD] ] ]\n The [PAD] positions can be found in the returned `mask`.\n\n # Parameters\n\n token_ids: `torch.LongTensor`\n Shape: [batch_size, num_segment_concat_wordpieces].\n num_segment_concat_wordpieces is num_wordpieces plus special tokens inserted in the\n middle, i.e. the length of: \"[CLS] A B C [SEP] [CLS] D E F [SEP]\" (see indexer logic).\n mask: `torch.LongTensor`\n Shape: [batch_size, num_segment_concat_wordpieces].\n The mask for the concatenated segments of wordpieces. The same as `segment_concat_mask`\n in `forward()`.\n type_ids: Optional[torch.LongTensor]\n Shape: [batch_size, num_segment_concat_wordpieces].\n\n # Returns:\n\n token_ids: `torch.LongTensor`\n Shape: [batch_size num_segments, self._max_length].\n mask: `torch.LongTensor`\n Shape: [batch_size * num_segments, self._max_length].\n \"\"\"\n num_segment_concat_wordpieces = token_ids.size(1)\n num_segments = math.ceil(num_segment_concat_wordpieces / self._max_length)\n padded_length = num_segments * self._max_length\n length_to_pad = padded_length - num_segment_concat_wordpieces\n\n def fold(tensor): # Shape: [batch_size, num_segment_concat_wordpieces]\n # Shape: [batch_size, num_segments * self._max_length]\n tensor = F.pad(tensor, [0, length_to_pad], value=0)\n # Shape: [batch_size * num_segments, self._max_length]\n return tensor.reshape(-1, self._max_length)\n\n return fold(token_ids), fold(mask), fold(type_ids) if type_ids is not None else None\n\n def _unfold_long_sequences(\n self,\n embeddings: torch.FloatTensor,\n mask: torch.LongTensor,\n batch_size: int,\n num_segment_concat_wordpieces: int,\n ) -> torch.FloatTensor:\n \"\"\"\n We take 2D segments of a long sequence and flatten them out to get the whole sequence\n representation while remove unnecessary special tokens.\n\n [ [ [CLS]_emb A_emb B_emb C_emb [SEP]_emb ], [ [CLS]_emb D_emb E_emb [SEP]_emb [PAD]_emb ] ]\n -> [ [CLS]_emb A_emb B_emb C_emb D_emb E_emb [SEP]_emb ]\n\n We truncate the start and end tokens for all segments, recombine the segments,\n and manually add back the start and end tokens.\n\n # Parameters\n\n embeddings: `torch.FloatTensor`\n Shape: [batch_size * num_segments, self._max_length, embedding_size].\n mask: `torch.LongTensor`\n Shape: [batch_size * num_segments, self._max_length].\n The mask for the concatenated segments of wordpieces. The same as `segment_concat_mask`\n in `forward()`.\n batch_size: `int`\n num_segment_concat_wordpieces: `int`\n The length of the original \"[ [CLS] A B C [SEP] [CLS] D E F [SEP] ]\", i.e.\n the original `token_ids.size(1)`.\n\n # Returns:\n\n embeddings: `torch.FloatTensor`\n Shape: [batch_size, self._num_wordpieces, embedding_size].\n \"\"\"\n\n def lengths_to_mask(lengths, max_len, device):\n return torch.arange(max_len, device=device).expand(\n lengths.size(0), max_len\n ) < lengths.unsqueeze(1)\n\n device = embeddings.device\n num_segments = int(embeddings.size(0) / batch_size)\n embedding_size = embeddings.size(2)\n\n # We want to remove all segment-level special tokens but maintain sequence-level ones\n num_wordpieces = num_segment_concat_wordpieces - (num_segments - 1) * self._num_added_tokens\n\n embeddings = embeddings.reshape(batch_size, num_segments * self._max_length, embedding_size)\n mask = mask.reshape(batch_size, num_segments * self._max_length)\n # We assume that all 1s in the mask preceed all 0s, and add an assert for that.\n # Open an issue on GitHub if this breaks for you.\n # Shape: (batch_size,)\n seq_lengths = mask.sum(-1)\n if not (lengths_to_mask(seq_lengths, mask.size(1), device) == mask).all():\n raise ValueError(\n \"Long sequence splitting only supports masks with all 1s preceding all 0s.\"\n )\n # Shape: (batch_size, self._num_added_end_tokens); this is a broadcast op\n end_token_indices = (\n seq_lengths.unsqueeze(-1) - torch.arange(self._num_added_end_tokens, device=device) - 1\n )\n\n # Shape: (batch_size, self._num_added_start_tokens, embedding_size)\n start_token_embeddings = embeddings[:, : self._num_added_start_tokens, :]\n # Shape: (batch_size, self._num_added_end_tokens, embedding_size)\n end_token_embeddings = batched_index_select(embeddings, end_token_indices)\n\n embeddings = embeddings.reshape(batch_size, num_segments, self._max_length, embedding_size)\n embeddings = embeddings[\n :, :, self._num_added_start_tokens : -self._num_added_end_tokens, :\n ] # truncate segment-level start/end tokens\n embeddings = embeddings.reshape(batch_size, -1, embedding_size) # flatten\n\n # Now try to put end token embeddings back which is a little tricky.\n\n # The number of segment each sequence spans, excluding padding. Mimicking ceiling operation.\n # Shape: (batch_size,)\n num_effective_segments = (seq_lengths + self._max_length - 1) / self._max_length\n # The number of indices that end tokens should shift back.\n num_removed_non_end_tokens = (\n num_effective_segments * self._num_added_tokens - self._num_added_end_tokens\n )\n # Shape: (batch_size, self._num_added_end_tokens)\n end_token_indices -= num_removed_non_end_tokens.unsqueeze(-1)\n assert (end_token_indices >= self._num_added_start_tokens).all()\n # Add space for end embeddings\n embeddings = torch.cat([embeddings, torch.zeros_like(end_token_embeddings)], 1)\n # Add end token embeddings back\n embeddings.scatter_(\n 1, end_token_indices.unsqueeze(-1).expand_as(end_token_embeddings), end_token_embeddings\n )\n\n # Now put back start tokens. We can do this before putting back end tokens, but then\n # we need to change `num_removed_non_end_tokens` a little.\n embeddings = torch.cat([start_token_embeddings, embeddings], 1)\n\n # Truncate to original length\n embeddings = embeddings[:, :num_wordpieces, :]\n return embeddings\n" ]	[ [ "torch.zeros_like", "torch.arange", "torch.nn.functional.pad", "torch.cat" ] ]
Maarten7/neural-network-arca	[ "1ed80519bcfbfa871c30d28f7bc2cc3f35dfbd17" ]	[ "models/toy_model.py" ]	[ "import numpy as np\n\ndef get_random_xyz():\n x = np.random.randint(13)\n y = np.random.randint(13)\n z = np.random.randint(18)\n return x, y, z\n\n\ndef get_event_klass_label(num_mini_timeslices):\n event = np.zeros((num_mini_timeslices, 13, 13, 18, 3))\n klass = np.random.randint(3) \n label = np.zeros(3)\n label[klass] = 1\n return event, klass, label\n \n\ndef get_start(klass, num_mini_timeslices):\n x, y, z = get_random_xyz()\n j = np.random.randint(num_mini_timeslices-18)\n \n if klass == 0:\n z = 0\n elif klass == 1:\n z = 17\n else:\n z = 10\n\n return j, x, y, z \n\n\ndef fill_noise(event, num_mini_timeslices):\n for i in range(num_mini_timeslices):\n x, y, z = get_random_xyz()\n event[i, x, y, z, :] += .30\n return event\n\n\ndef get_next_weird_xyz(x, y, z, klass):\n if klass == 0:\n z = z + 1\n elif klass == 1:\n z = z - 1\n\n if np.random.randint(3) == 0:\n x = x + 1\n elif np.random.randint(3) == 2:\n x = x - 1\n\n if np.random.randint(3) == 0:\n y = y + 1\n elif np.random.randint(3) == 2:\n y = y - 1\n \n x = 0 if x < 0 else x\n y = 0 if y < 0 else y\n x = 12 if 12 < x else x\n y = 12 if 12 < y else y\n return x, y, z\n\ndef get_line_start(klass, num_mini_timeslices):\n j = np.random.randint(num_mini_timeslices-18)\n x, y, z = get_random_xyz()\n if klass == 0:\n x = 0\n elif klass == 1:\n y = 0\n elif klass == 2:\n z = 0\n return j, x, y, z\n \n\ndef fill_noise(event, num_mini_timeslices):\n for i in range(num_mini_timeslices):\n x, y, z = get_random_xyz()\n event[i, x, y, z, :] += .30\n return event\n\n\ndef fill_event(event, label, num_mini_timeslices):\n j, x, y, z = get_start(label, num_mini_timeslices)\n for i in range(18):\n event[j + i, x, y, z, :] += .30\n x, y, z = get_next_xyz(x, y, z, label)\n return event\n\n\ndef random_line(num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n for _ in range(10):\n event = fill_event(event, label)\n event = fill_noise(event, num_mini_timeslices)\n \n\ndef get_next_line_xyz(x, y, z, klass):\n if klass == 0:\n x += 1\n elif klass == 1:\n y += 1\n else:\n z += 1 \n if x == 13: x = 0\n if y == 13: y = 0\n return x, y, z\n\n\ndef random_movement(n_lines, n_noise, num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n for _ in range(n_lines):\n j, x, y, z = get_start(klass, num_mini_timeslices)\n for i in range(18):\n event[j + i, x, y, z, :] += .30\n x, y, z = get_next_weird_xyz(x, y, z, klass)\n for _ in range(n_noise):\n event = fill_noise(event, num_mini_timeslices)\n\n return event, label\n\ndef fill_matrix(num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n if klass == 0:\n event[:, :, :, :, :] = 1.\n if klass == 1:\n event[:, :, :, :, :] = 0.5\n if klass == 2:\n event[:, :, :, :, :] = 0.\n\n return event, label\n\n\ndef add_line(num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n x, y, z = get_random_xyz()\n if klass == 0:\n event[:, x, y, :, :] = 1.\n elif klass == 1:\n event[:, x, :, z, :] = 1.\n elif klass == 2:\n event[:, :, y, z, :] = 1.\n\n return event, label\n\n\ndef add_line_in_steps(n_lines, num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n for _ in range(n_lines):\n j, x, y, z = get_line_start(klass, num_mini_timeslices)\n for i in range(18):\n event[j + i, x, y, z, :] = 1.\n x, y, z = get_next_line_xyz(x, y, z, klass)\n return event, label\n\n\ndef make_toy(num_mini_timeslices):\n# return add_line_in_steps(10, num_mini_timeslices)\n# return fill_matrix() \n# return all_line_in_steps()\n return random_movement(25, 5, num_mini_timeslices)\n" ]	[ [ "numpy.zeros", "numpy.random.randint" ] ]
startnew/auto_work_tools	[ "169832fd9fa2f2f397f1605be4823eeee2e4a83a" ]	[ "auto_test/gen_data_csv.py" ]	[ "#!/usr/bin/env python\n# -- coding: utf-8 --\n# @Time : 2020/11/9 14:19\n# @Author : zhuzhaowen\n# @email : [email protected]\n# @File : gen_data_csv.py\n# @Software: PyCharm\n# @desc : \"获取导入的信息并筛选\"\n\nimport pandas as pd\nimport urllib\nimport pypinyin\nimport time\nfrom util.util import base64_to_image, image_to_base64, exc_time\nimport numpy as np\nimport cv2\nfrom auto_search_address import get_key_words_adname\n\n\nclass dataProcess():\n def __init__(self):\n\n self.ad_name_map_dict = {}\n\n def processOriData(self, data_path, save_data=\"./data/test\"):\n data = pd.read_excel(data_path)\n self.data = data\n print(self.data.shape)\n self.clean_data()\n self.data = self.data[:]\n\n print(self.data.shape)\n if self.data.shape[0] > 0:\n self.add_adname()\n self.add_img_info()\n self.save_data(save_data)\n\n def processOriDatas(self, data_paths, save_data=\"./data/test_union\", has_cache=False):\n datas = []\n for data_path in data_paths:\n try:\n print(data_path)\n data = pd.read_excel(data_path)\n print(data.columns[0], data.shape[1])\n if int(data.shape[1]) == 14 and data.columns[0] != \"城市\":\n data = pd.read_excel(data_path, header=None, names= \\\n [\"城市\", \"楼盘\", \"类型\", \"单价\", \"总价\", \"项目地址\", \"最新开盘\", \"全部图片url\", \"户型\",\n \"户型图\", \"居室\", \"建面\", \"均价\",\n \"状态\"])\n print(data.head())\n elif int(data.shape[1]) == 5 and data.columns[0] == \"house_id\":\n data = pd.read_excel(data_path)\n data[\"楼盘\"] = \"威尼斯水城\"\n data[\"name\"] = data[\"house_id\"].map(lambda x: \"house_id_{}\".format(x))\n data[\"城市\"] = \"南京市\"\n data[\"类型\"] = \"住宅\"\n data[\"项目地址\"] = \"威尼斯水城\"\n data[\"居室\"] = data[\"structure_name\"]\n data[\"建面\"] = data[\"area\"]\n data[\"户型\"] =data[\"house_id\"].map(lambda x: \"house_id_{}\".format(x))\n\n\n\n\n\n self.data = data\n print(self.data.shape)\n self.clean_data()\n if self.data.shape[0]<1:\n continue\n # self.data = self.data[:]\n\n print(self.data.shape)\n self.add_adname()\n self.add_img_info()\n datas.append(self.data)\n except Exception as e:\n print(\"ERROR {}\".format(e))\n continue\n union_pd = pd.concat(datas)\n self.data = union_pd\n self.clean_data()\n print(\"合并后的尺寸大小\", union_pd.shape)\n # 去重后的尺寸大小\n print(len(union_pd.户型图.unique()))\n union_pd.drop_duplicates(\"户型图\", \"first\", inplace=True)\n self.data = union_pd\n print(\"去重后尺寸大小\", union_pd.shape)\n limit = False\n downImg = False\n if limit:\n name = \"建业\"\n data_junfa = self.data[self.data.楼盘.str.contains(name)]\n\n print(\"junfa的户型数据\", )\n # print(data_建业.head())\n self.data[\"junfa与否\"] = self.data.楼盘.str.contains(name)\n\n\n self.data = data_junfa\n\n if has_cache and os.path.exists(save_data+\".pkl\"):\n print(\"使用cache\")\n\n cache_data = pd.read_pickle(save_data + \".pkl\")\n\n self.add_adname(cache=cache_data)\n if downImg:self.add_img_info(cache=cache_data)\n else:\n self.add_adname()\n if downImg:self.add_img_info()\n # self.data = self.data[self.data.cityname.str.contains(\"成都\")]\n #print(\"{}的个数:{}\".format(name, self.data.shape))\n print(self.data.shape)\n\n self.save_data(save_data)\n\n def save_data(self, path):\n self.data.to_excel(path + \".xlsx\")\n self.data.to_csv(path + \".csv\")\n self.data.to_pickle(path + \".pkl\")\n\n @exc_time\n def clean_data(self):\n self.data = self.data[self.data[\"户型图\"].notna()]\n self.data = self.data[self.data[\"楼盘\"].notna()]\n self.data = self.data[self.data[\"项目地址\"].notna()]\n self.data = self.data[self.data[\"户型\"].notna()]\n\n @exc_time\n def add_adname(self,cache=None):\n self.data[\"区\"] = self.data.apply(lambda x: self.map_adname(x[\"楼盘\"], x[\"城市\"],cache), axis=1)\n self.data[\"cityname\"] = self.data.apply(lambda x: self.map_cityname(x[\"楼盘\"], x[\"城市\"],cache), axis=1)\n self.data[\"pname\"] = self.data.apply(lambda x: self.map_pname(x[\"楼盘\"], x[\"城市\"],cache), axis=1)\n self.data[\"location\"] = self.data.apply(lambda x: self.map_location(x[\"楼盘\"], x[\"城市\"], cache), axis=1)\n\n\n def map_adname(self, x, city,cache=None):\n k = str(x) + str(city)\n\n if cache is not None:\n try:\n select_df = cache[(cache.楼盘.str.contains(x)) & (cache.城市.str.contains(city))]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"区\" in select_df.columns:\n if len(select_df[\"区\"].values[0]) != 0:\n # print(select_df[\"图片编码\"].values[0])\n print(\"SUCCESS from cache file LOCPOS{}\".format(type(select_df[\"区\"].values[0])))\n\n return select_df[\"区\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n\n print(\"Error {}:x{} city:{} \".format(e, x, city))\n #raise e\n\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"adname\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"adname\")\n\n def map_pname(self, x, city,cache=None):\n k = str(x) + str(city)\n if cache is not None:\n try:\n select_df = cache[(cache.楼盘.str.contains(x)) & (cache.城市.str.contains(city))]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"pname\" in select_df.columns:\n if len(select_df[\"pname\"].values[0]) != 0:\n\n print(\"SUCCESS from cache file LOCPOS {}\".format(type(select_df[\"pname\"].values[0])))\n\n return select_df[\"pname\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n print(\"Error {}:x{} city:{} \".format(e,x,city))\n\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"pname\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"pname\")\n\n def map_location(self, x, city, cache):\n k = str(x) + str(city)\n if cache is not None:\n try:\n select_df = cache[(cache.楼盘.str.contains(x)) & (cache.城市.str.contains(city))]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"location\" in select_df.columns:\n if len(select_df[\"location\"].values[0]) != 0:\n\n print(\"SUCCESS from cache file LOCPOS {}\".format(type(select_df[\"pname\"].values[0])))\n\n return select_df[\"location\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n print(\"Error {}:x{} city:{} \".format(e, x, city))\n\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"location\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"location\")\n\n def map_cityname(self, x, city,cache):\n k = str(x) + str(city)\n if cache is not None:\n try:\n select_df = cache[cache.楼盘.str.contains(x) & cache.城市.str.contains(city)]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"cityname\" in select_df.columns:\n if len(select_df[\"cityname\"].values[0]) != 0:\n\n print(\"SUCCESS from cache file {} LOCPOS\".format(type(select_df[\"cityname\"].values[0])))\n\n return select_df[\"cityname\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n print(\"ERROR {}\".format(e))\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"cityname\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"cityname\")\n @exc_time\n def add_img_info(self, cache=None):\n self.data[\"图片编码\"] = self.data.户型图.map(lambda x: self.down_and_encode(x,cache))\n\n def gen_name(x, y, z):\n try:\n return str(x) + str(y) + str(z)\n except:\n return str(x)\n\n self.data[\"house_name\"] = self.data.apply(lambda x: gen_name(x[\"户型\"], x[\"类型\"], x[\"居室\"]), axis=1)\n self.data[\"county_name\"] = self.data[\"区\"]\n self.data[\"community_name\"] = self.data[\"楼盘\"]\n if \"全部图片url\" in self.data.columns:\n self.data = self.data.drop([\"全部图片url\"], axis=1)\n\n def down_and_encode(self, imgurl,cache_data):\n #print(imgurl)\n\n num = 0\n try:\n if cache_data is not None:\n select_df = cache_data[cache_data.户型图.str.contains(imgurl)]\n #print(select_df.shape)\n if select_df.shape[0]>0:\n if \"图片编码\" in select_df.columns:\n if len(select_df[\"图片编码\"].values[0]) != 0:\n #print(select_df[\"图片编码\"].values[0])\n print(\"SUCCESS from cache file {}\".format(type(select_df[\"图片编码\"].values[0])))\n\n return select_df[\"图片编码\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url下载并编码\")\n else:\n print(\"cache中没有指定字段使用下载数据\")\n else:\n print(\"没有找到url符合的使用下载数据\")\n print(imgurl)\n r = self.down_load_url(imgurl)\n r = self.encodeImg(r)\n print(\"SUCCESS\")\n except Exception as e:\n # raise e\n print(\"ERROR {}\".format(e))\n r = ''\n if r == '' and \"original\" not in imgurl:\n return self.down_and_encode(imgurl+\"!original\",cache_data)\n return r\n\n def down_load_url(self, imageUrl):\n resp = urllib.request.urlopen(imageUrl)\n image = np.asarray(bytearray(resp.read()), dtype=\"uint8\")\n\n image = cv2.imdecode(image, cv2.IMREAD_COLOR)\n return image\n\n def encodeImg(self, image):\n return image_to_base64(image)\n\n def decodeImg(self, str64):\n return base64_to_image(str64)\n\n\nif __name__ == \"__main__\":\n dp = dataProcess()\n import os\n\n dir_name = r\"D:\\workspace\\2020\\标准户型库\"\n paths = []\n for root, dirs, files in os.walk(dir_name):\n for name in files:\n if name.endswith(\".xlsx\") or name.endswith(\".xls\"):\n k = os.path.join(root, name)\n # if \"河南\" in k:\n paths.append(k)\n\n print(paths)\n # dp.processOriData(r\"D:\\workspace\\2020\\标准户型库\\南京\\贝壳找房-南京-2020-11-06-house.xlsx.xlsx\")\n dp.processOriDatas(paths,save_data=\"./data/test_union\",has_cache=True)\n #dp.processOriDatas(paths, save_data=\"./data/test_jianye\", has_cache=False)\n print(dp.data.head())\n print(dp.data.columns)\n" ]	[ [ "pandas.concat", "pandas.read_excel", "pandas.read_pickle" ] ]
s-gupta/fast-rcnn	[ "da935a12be8078c4d8684100016f82b5a4b02afc" ]	[ "lib/fast_rcnn/config.py" ]	[ "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Fast R-CNN config system.\n\nThis file specifies default config options for Fast R-CNN. You should not\nchange values in this file. Instead, you should write a config file (in yaml)\nand use cfg_from_file(yaml_file) to load it and override the default options.\n\nMost tools in $ROOT/tools take a --cfg option to specify an override file.\n - See tools/{train,test}_net.py for example code that uses cfg_from_file()\n - See experiments/cfgs/*.yml for example YAML config override files\n\"\"\"\n\nimport os\nimport os.path as osp\nimport numpy as np\n# `pip install easydict` if you don't have it\nfrom easydict import EasyDict as edict\n\n__C = edict()\n# Consumers can get config by:\n# from fast_rcnn_config import cfg\ncfg = __C\n\n#\n# Training options\n#\n\n__C.TRAIN = edict()\n\n# Scales to use during training (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TRAIN.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TRAIN.MAX_SIZE = 1000\n\n# Images to use per minibatch\n__C.TRAIN.IMS_PER_BATCH = 2\n\n# Minibatch size (number of regions of interest [ROIs])\n__C.TRAIN.BATCH_SIZE = 128\n\n# Fraction of minibatch that is labeled foreground (i.e. class > 0)\n__C.TRAIN.FG_FRACTION = 0.25\n\n# Overlap threshold for a ROI to be considered foreground (if >= FG_THRESH)\n__C.TRAIN.FG_THRESH = 0.5\n\n# Overlap threshold for a ROI to be considered background (class = 0 if\n# overlap in [LO, HI))\n__C.TRAIN.BG_THRESH_HI = 0.5\n__C.TRAIN.BG_THRESH_LO = 0.1\n\n# Use horizontally-flipped images during training?\n__C.TRAIN.USE_FLIPPED = True\n\n# Train bounding-box regressors\n__C.TRAIN.BBOX_REG = True\n\n# Overlap required between a ROI and ground-truth box in order for that ROI to\n# be used as a bounding-box regression training example\n__C.TRAIN.BBOX_THRESH = 0.5\n\n# Iterations between snapshots\n__C.TRAIN.SNAPSHOT_ITERS = 10000\n\n# solver.prototxt specifies the snapshot path prefix, this adds an optional\n# infix to yield the path: <prefix>[_<infix>]_iters_XYZ.caffemodel\n__C.TRAIN.SNAPSHOT_INFIX = ''\n\n# Use a prefetch thread in roi_data_layer.layer\n# So far I haven't found this useful; likely more engineering work is required\n__C.TRAIN.USE_PREFETCH = False\n\n# What fields are storing bounding box regression parameters\n__C.TRAIN.BBOX_PRED_PARAM_NAMES = ['bbox_pred']\n\n#\n# Testing options\n#\n\n__C.TEST = edict()\n\n# Scales to use during testing (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TEST.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TEST.MAX_SIZE = 1000\n\n# Overlap threshold used for non-maximum suppression (suppress boxes with\n# IoU >= this threshold)\n__C.TEST.NMS = 0.3\n\n# Experimental: treat the (K+1) units in the cls_score layer as linear\n# predictors (trained, eg, with one-vs-rest SVMs).\n__C.TEST.SVM = False\n\n# Test using bounding-box regressors\n__C.TEST.BBOX_REG = True\n\n__C.TEST.MAX_PER_IMAGE = 100\n__C.TEST.MAX_PER_SET_F = 40\n__C.TEST.DET_SALT = ''\n__C.TEST.EVAL_SALT = ''\n\n#\n# MISC\n#\n\n# The mapping from image coordinates to feature map coordinates might cause\n# some boxes that are distinct in image space to become identical in feature\n# coordinates. If DEDUP_BOXES > 0, then DEDUP_BOXES is used as the scale factor\n# for identifying duplicate boxes.\n# 1/16 is correct for {Alex,Caffe}Net, VGG_CNN_M_1024, and VGG16\n__C.DEDUP_BOXES = 1./16.\n\n# Pixel mean values (BGR order) as a (1, 1, 3) array\n# These are the values originally used for training VGG16\n__C.PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]])\n\n# For reproducibility\n__C.RNG_SEED = 3\n\n# A small number that's used many times\n__C.EPS = 1e-14\n\n# Root directory of project\n__C.ROOT_DIR = osp.abspath(osp.join(osp.dirname(__file__), '..', '..'))\n\n# Place outputs under an experiments directory\n__C.EXP_DIR = 'default'\n\ndef get_output_dir(imdb, net):\n \"\"\"Return the directory where experimental artifacts are placed.\n\n A canonical path is built using the name from an imdb and a network\n (if not None).\n \"\"\"\n path = osp.abspath(osp.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name))\n if net is None:\n return path\n else:\n return osp.join(path, net.name)\n\ndef _merge_a_into_b(a, b):\n \"\"\"Merge config dictionary a into config dictionary b, clobbering the\n options in b whenever they are also specified in a.\n \"\"\"\n if type(a) is not edict:\n return\n\n for k, v in a.iteritems():\n # a must specify keys that are in b\n if not b.has_key(k):\n raise KeyError('{} is not a valid config key'.format(k))\n\n # the types must match, too\n if type(b[k]) is not type(v):\n raise ValueError(('Type mismatch ({} vs. {}) '\n 'for config key: {}').format(type(b[k]),\n type(v), k))\n\n # recursively merge dicts\n if type(v) is edict:\n try:\n _merge_a_into_b(a[k], b[k])\n except:\n print('Error under config key: {}'.format(k))\n raise\n else:\n b[k] = v\n\ndef cfg_from_file(filename):\n \"\"\"Load a config file and merge it into the default options.\"\"\"\n import yaml\n with open(filename, 'r') as f:\n yaml_cfg = edict(yaml.load(f))\n\n _merge_a_into_b(yaml_cfg, __C)\n" ]	[ [ "numpy.array" ] ]
Griffin98/fsgan	[ "c4e54cf0579ef95b3ef14174441d66f7b119e06f" ]	[ "preprocess/preprocess_video.py" ]	[ "\"\"\" Video preprocessing.\n\nThis script implements all preprocessing required for both training and inference.\nThe preprocessing information will be cached in a directory by the file's name without the extension,\nresiding in the same directory as the file. The information contains: face detections, face sequences,\nand cropped videos per sequence. In addition for each cropped video, the corresponding pose, landmarks, and\nsegmentation masks will be computed and cached.\n\"\"\"\n\nimport os\nimport argparse\nimport sys\nimport pickle\nfrom tqdm import tqdm\nimport numpy as np\nimport cv2\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nimport torchvision.transforms as transforms\nfrom face_detection_dsfd.face_detector import FaceDetector\nfrom fsgan.utils.utils import set_device, load_model\nfrom fsgan.preprocess.detections2sequences_center import main as detections2sequences_main\nfrom fsgan.preprocess.crop_video_sequences import main as crop_video_sequences_main\nfrom fsgan.preprocess.crop_image_sequences import main as crop_image_sequences_main\nfrom fsgan.datasets.video_inference_dataset import VideoInferenceDataset\nimport fsgan.datasets.img_landmarks_transforms as img_landmarks_transforms\nfrom fsgan.datasets.img_landmarks_transforms import Resize, ToTensor\nfrom fsgan.utils.temporal_smoothing import TemporalSmoothing\nfrom fsgan.utils.landmarks_utils import LandmarksHeatMapEncoder, smooth_landmarks_98pts\nfrom fsgan.utils.seg_utils import encode_binary_mask, remove_inner_mouth\nfrom fsgan.utils.batch import main as batch\n\n\nbase_parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)\n\ngeneral = base_parser.add_argument_group('general')\ngeneral.add_argument('-r', '--resolution', default=256, type=int, metavar='N',\n help='finest processing resolution')\ngeneral.add_argument('-cs', '--crop_scale', default=1.2, type=float, metavar='F',\n help='crop scale relative to bounding box')\ngeneral.add_argument('--gpus', default=None, nargs='+', type=int, metavar='N',\n help='list of gpu ids to use')\ngeneral.add_argument('--cpu_only', action='store_true',\n help='force cpu only')\ngeneral.add_argument('-d', '--display', action='store_true',\n help='display the rendering')\ngeneral.add_argument('-v', '--verbose', default=0, type=int, metavar='N',\n help='verbose level')\ngeneral.add_argument('-ec', '--encoder_codec', default='avc1', metavar='STR',\n help='encoder codec code')\n\ndetection = base_parser.add_argument_group('detection')\ndetection.add_argument('-dm', '--detection_model', metavar='PATH', default='../weights/WIDERFace_DSFD_RES152.pth',\n help='path to face detection model')\ndetection.add_argument('-db', '--det_batch_size', default=8, type=int, metavar='N',\n help='detection batch size')\ndetection.add_argument('-dp', '--det_postfix', default='_dsfd.pkl', metavar='POSTFIX',\n help='detection file postfix')\n\nsequences = base_parser.add_argument_group('sequences')\nsequences.add_argument('-it', '--iou_thresh', default=0.75, type=float,\n metavar='F', help='IOU threshold')\nsequences.add_argument('-ml', '--min_length', default=10, type=int,\n metavar='N', help='minimum sequence length')\nsequences.add_argument('-ms', '--min_size', default=64, type=int,\n metavar='N', help='minimum sequence average bounding box size')\nsequences.add_argument('-ck', '--center_kernel', default=25, type=int,\n metavar='N', help='center average kernel size')\nsequences.add_argument('-sk', '--size_kernel', default=51, type=int,\n metavar='N', help='size average kernel size')\nsequences.add_argument('-dsd', '--disable_smooth_det', dest='smooth_det', action='store_false',\n help='disable smoothing the detection bounding boxes')\nsequences.add_argument('-sp', '--seq_postfix', default='_dsfd_seq.pkl', metavar='POSTFIX',\n help='sequence file postfix')\nsequences.add_argument('-we', '--write_empty', action='store_true',\n help='write empty sequence lists to file')\n\npose = base_parser.add_argument_group('pose')\npose.add_argument('-pm', '--pose_model', default='../weights/hopenet_robust_alpha1.pth', metavar='PATH',\n help='path to face pose model file')\npose.add_argument('-pb', '--pose_batch_size', default=128, type=int, metavar='N',\n help='pose batch size')\npose.add_argument('-pp', '--pose_postfix', default='_pose.npz', metavar='POSTFIX',\n help='pose file postfix')\npose.add_argument('-cp', '--cache_pose', action='store_true',\n help='Toggle whether to cache pose')\npose.add_argument('-cf', '--cache_frontal', action='store_true',\n help='Toggle whether to cache frontal images for each sequence')\npose.add_argument('-spo', '--smooth_poses', default=5, type=int, metavar='N',\n help='poses temporal smoothing kernel size')\n\nlandmarks = base_parser.add_argument_group('landmarks')\nlandmarks.add_argument('-lm', '--lms_model', default='../weights/hr18_wflw_landmarks.pth', metavar='PATH',\n help='landmarks model')\nlandmarks.add_argument('-lb', '--lms_batch_size', default=64, type=int, metavar='N',\n help='landmarks batch size')\nlandmarks.add_argument('-lp', '--landmarks_postfix', default='_lms.npz', metavar='POSTFIX',\n help='landmarks file postfix')\nlandmarks.add_argument('-cl', '--cache_landmarks', action='store_true',\n help='Toggle whether to cache landmarks')\nlandmarks.add_argument('-sl', '--smooth_landmarks', default=7, type=int, metavar='N',\n help='landmarks temporal smoothing kernel size')\n\nsegmentation = base_parser.add_argument_group('segmentation')\nsegmentation.add_argument('-sm', '--seg_model', default='../weights/celeba_unet_256_1_2_segmentation_v2.pth',\n metavar='PATH', help='segmentation model')\nsegmentation.add_argument('-sb', '--seg_batch_size', default=32, type=int, metavar='N',\n help='segmentation batch size')\nsegmentation.add_argument('-sep', '--segmentation_postfix', default='_seg.pkl', metavar='POSTFIX',\n help='segmentation file postfix')\nsegmentation.add_argument('-cse', '--cache_segmentation', action='store_true',\n help='Toggle whether to cache segmentation')\nsegmentation.add_argument('-sse', '--smooth_segmentation', default=5, type=int, metavar='N',\n help='segmentation temporal smoothing kernel size')\nsegmentation.add_argument('-srm', '--seg_remove_mouth', action='store_true',\n help='if true, the inner part of the mouth will be removed from the segmentation')\n\nparser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n parents=[base_parser])\nparser.add_argument('input', metavar='VIDEO', nargs='+',\n help='path to input video')\nparser.add_argument('-o', '--output', metavar='DIR',\n help='output directory')\nd = parser.get_default\n\n\nclass VideoProcessBase(object):\n def __init__(self, resolution=d('resolution'), crop_scale=d('crop_scale'), gpus=d('gpus'),\n cpu_only=d('cpu_only'), display=d('display'), verbose=d('verbose'), encoder_codec=d('encoder_codec'),\n # Detection arguments:\n detection_model=d('detection_model'), det_batch_size=d('det_batch_size'), det_postfix=d('det_postfix'),\n # Sequence arguments:\n iou_thresh=d('iou_thresh'), min_length=d('min_length'), min_size=d('min_size'),\n center_kernel=d('center_kernel'), size_kernel=d('size_kernel'), smooth_det=d('smooth_det'),\n seq_postfix=d('seq_postfix'), write_empty=d('write_empty'),\n # Pose arguments:\n pose_model=d('pose_model'), pose_batch_size=d('pose_batch_size'), pose_postfix=d('pose_postfix'),\n cache_pose=d('cache_pose'), cache_frontal=d('cache_frontal'), smooth_poses=d('smooth_poses'),\n # Landmarks arguments:\n lms_model=d('lms_model'), lms_batch_size=d('lms_batch_size'), landmarks_postfix=d('landmarks_postfix'),\n cache_landmarks=d('cache_landmarks'), smooth_landmarks=d('smooth_landmarks'),\n # Segmentation arguments:\n seg_model=d('seg_model'), seg_batch_size=d('seg_batch_size'), segmentation_postfix=d('segmentation_postfix'),\n cache_segmentation=d('cache_segmentation'), smooth_segmentation=d('smooth_segmentation'),\n seg_remove_mouth=d('seg_remove_mouth')):\n # General\n self.resolution = resolution\n self.crop_scale = crop_scale\n self.display = display\n self.verbose = verbose\n\n # Detection\n self.face_detector = FaceDetector(det_postfix, detection_model, gpus, det_batch_size, display)\n self.det_postfix = det_postfix\n\n # Sequences\n self.iou_thresh = iou_thresh\n self.min_length = min_length\n self.min_size = min_size\n self.center_kernel = center_kernel\n self.size_kernel = size_kernel\n self.smooth_det = smooth_det\n self.seq_postfix = seq_postfix\n self.write_empty = write_empty\n\n # Pose\n self.pose_batch_size = pose_batch_size\n self.pose_postfix = pose_postfix\n self.cache_pose = cache_pose\n self.cache_frontal = cache_frontal\n self.smooth_poses = smooth_poses\n\n # Landmarks\n self.smooth_landmarks = smooth_landmarks\n self.landmarks_postfix = landmarks_postfix\n self.cache_landmarks = cache_landmarks\n self.lms_batch_size = lms_batch_size\n\n # Segmentation\n self.smooth_segmentation = smooth_segmentation\n self.segmentation_postfix = segmentation_postfix\n self.cache_segmentation = cache_segmentation\n self.seg_batch_size = seg_batch_size\n self.seg_remove_mouth = seg_remove_mouth and cache_landmarks\n\n # Initialize device\n torch.set_grad_enabled(False)\n self.device, self.gpus = set_device(gpus, not cpu_only)\n\n # Load models\n self.face_pose = load_model(pose_model, 'face pose', self.device) if cache_pose else None\n self.L = load_model(lms_model, 'face landmarks', self.device) if cache_landmarks else None\n self.S = load_model(seg_model, 'face segmentation', self.device) if cache_segmentation else None\n\n # Initialize heatmap encoder\n self.heatmap_encoder = LandmarksHeatMapEncoder().to(self.device)\n\n # Initialize normalization tensors\n # Note: this is necessary because of the landmarks model\n self.img_mean = torch.as_tensor([0.5, 0.5, 0.5], device=self.device).view(1, 3, 1, 1)\n self.img_std = torch.as_tensor([0.5, 0.5, 0.5], device=self.device).view(1, 3, 1, 1)\n self.context_mean = torch.as_tensor([0.485, 0.456, 0.406], device=self.device).view(1, 3, 1, 1)\n self.context_std = torch.as_tensor([0.229, 0.224, 0.225], device=self.device).view(1, 3, 1, 1)\n\n # Support multiple GPUs\n if self.gpus and len(self.gpus) > 1:\n self.face_pose = nn.DataParallel(self.face_pose, self.gpus) if self.face_pose is not None else None\n self.L = nn.DataParallel(self.L, self.gpus) if self.L is not None else None\n self.S = nn.DataParallel(self.S, self.gpus) if self.S is not None else None\n\n # Initialize temportal smoothing\n if smooth_segmentation > 0:\n self.smooth_seg = TemporalSmoothing(3, smooth_segmentation).to(self.device)\n else:\n self.smooth_seg = None\n\n # Initialize output videos format\n self.encoder_codec = encoder_codec\n self.fourcc = cv2.VideoWriter_fourcc(encoder_codec)\n\n def process_pose(self, input_path, output_dir, seq_file_path):\n if not self.cache_pose:\n return\n input_path_no_ext, input_ext = os.path.splitext(input_path)\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # Initialize transforms\n img_transforms = img_landmarks_transforms.Compose([\n Resize(224), ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.basename(input_path_no_ext) + '_seq%02d%s' % (seq.id, input_ext)\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_pose_path = os.path.splitext(curr_vid_path)[0] + self.pose_postfix\n\n if os.path.isfile(curr_pose_path):\n continue\n print('=> Computing face poses for video: \"%s\"...' % curr_vid_name)\n\n # Initialize input video\n in_vid = VideoInferenceDataset(curr_vid_path, transform=img_transforms)\n in_vid_loader = DataLoader(in_vid, batch_size=self.pose_batch_size, num_workers=1, pin_memory=True,\n drop_last=False, shuffle=False)\n\n # For each batch of frames in the input video\n seq_poses = []\n for i, frame in enumerate(tqdm(in_vid_loader, unit='batches', file=sys.stdout)):\n frame = frame.to(self.device)\n poses = self.face_pose(frame).div_(99.) # Yaw, Pitch, Roll\n seq_poses.append(poses.cpu().numpy())\n seq_poses = np.concatenate(seq_poses)\n\n # Save poses to file\n seq_poses_smoothed = smooth_poses(seq_poses, self.smooth_poses)\n np.savez_compressed(curr_pose_path, poses=seq_poses, poses_smoothed=seq_poses_smoothed)\n\n def extract_frontal_images(self, input_path, output_dir, seq_file_path, out_postfix='.jpg', resolution=None):\n if not self.cache_frontal:\n return\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.splitext(os.path.basename(input_path))[0] + '_seq%02d.mp4' % seq.id\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_pose_path = os.path.splitext(curr_vid_path)[0] + self.pose_postfix\n curr_frontal_path = os.path.splitext(curr_vid_path)[0] + out_postfix\n\n if os.path.isfile(curr_frontal_path):\n continue\n\n # Open current video file\n vid = cv2.VideoCapture(curr_vid_path)\n if not vid.isOpened():\n raise RuntimeError('Failed to read video: ' + curr_vid_path)\n\n # Load current sequence poses\n curr_poses = np.load(curr_pose_path)['poses_smoothed']\n\n # Read frontal image from video\n frontal_index = np.argmin(np.linalg.norm(curr_poses, axis=1))\n vid.set(cv2.CAP_PROP_POS_FRAMES, frontal_index)\n ret, frontal_bgr = vid.read()\n\n # Resize image\n if resolution is not None:\n frontal_bgr = cv2.resize(frontal_bgr, (resolution, resolution), interpolation=cv2.INTER_CUBIC)\n\n # Write frontal image to file\n cv2.imwrite(curr_frontal_path, frontal_bgr)\n\n def process_landmarks(self, input_path, output_dir, seq_file_path):\n if not self.cache_landmarks:\n return\n input_path_no_ext, input_ext = os.path.splitext(input_path)\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # Initialize transforms\n img_transforms = img_landmarks_transforms.Compose([\n ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.basename(input_path_no_ext) + '_seq%02d%s' % (seq.id, input_ext)\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_lms_path = os.path.splitext(curr_vid_path)[0] + self.landmarks_postfix\n\n if os.path.isfile(curr_lms_path):\n continue\n print('=> Computing face landmarks for video: \"%s\"...' % curr_vid_name)\n\n # Initialize input video\n in_vid = VideoInferenceDataset(curr_vid_path, transform=img_transforms)\n in_vid_loader = DataLoader(in_vid, batch_size=self.lms_batch_size, num_workers=1, pin_memory=True,\n drop_last=False, shuffle=False)\n\n # For each batch of frames in the input video\n seq_landmarks = []\n for i, frame in enumerate(tqdm(in_vid_loader, unit='batches', file=sys.stdout)):\n frame = frame.to(self.device)\n H = self.L(frame)\n landmarks = self.heatmap_encoder(H)\n seq_landmarks.append(landmarks.cpu().numpy())\n seq_landmarks = np.concatenate(seq_landmarks)\n\n # Save landmarks to file\n seq_landmarks_smoothed = smooth_landmarks_98pts(seq_landmarks, self.smooth_landmarks)\n np.savez_compressed(curr_lms_path, landmarks=seq_landmarks, landmarks_smoothed=seq_landmarks_smoothed)\n\n def process_segmentation(self, input_path, output_dir, seq_file_path):\n if not self.cache_segmentation:\n return\n input_path_no_ext, input_ext = os.path.splitext(input_path)\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # Initialize transforms\n img_transforms = img_landmarks_transforms.Compose([\n ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.basename(input_path_no_ext) + '_seq%02d%s' % (seq.id, input_ext)\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_seg_path = os.path.splitext(curr_vid_path)[0] + self.segmentation_postfix\n\n if self.seg_remove_mouth:\n curr_lms_path = os.path.splitext(curr_vid_path)[0] + self.landmarks_postfix\n landmarks = np.load(curr_lms_path)['landmarks_smoothed']\n frame_count = 0\n\n if os.path.isfile(curr_seg_path):\n continue\n print('=> Computing face segmentation for video: \"%s\"...' % curr_vid_name)\n\n # Initialize input video\n in_vid = VideoInferenceDataset(curr_vid_path, transform=img_transforms)\n in_vid_loader = DataLoader(in_vid, batch_size=self.seg_batch_size, num_workers=1, pin_memory=True,\n drop_last=False, shuffle=False)\n\n # For each batch of frames in the input video\n pbar = tqdm(in_vid_loader, unit='batches', file=sys.stdout)\n prev_segmentation = None\n r = self.smooth_seg.kernel_radius\n encoded_segmentations = []\n pad_prev, pad_next = r, r # This initialization is only relevant if there is a leftover from last batch\n for i, frame in enumerate(pbar):\n print(frame.shape)\n frame = frame.to(self.device)\n\n # Compute segmentation\n raw_segmentation = self.S(frame)\n segmentation = torch.cat((prev_segmentation, raw_segmentation), dim=0) \\\n if prev_segmentation is not None else raw_segmentation\n if segmentation.shape[0] > r:\n pad_prev, pad_next = r if prev_segmentation is None else 0, min(r, self.seg_batch_size - frame.shape[0])\n segmentation = self.smooth_seg(segmentation, pad_prev=pad_prev, pad_next=pad_next)\n\n # Note: the pad_next value here is only relevant if there is a leftover from last batch\n prev_segmentation = raw_segmentation[-(r 2 - pad_next):]\n\n mask = segmentation.argmax(1) == 1\n\n # Encode segmentation\n for b in range(mask.shape[0]):\n curr_mask = mask[b].cpu().numpy()\n if self.seg_remove_mouth:\n curr_mask = remove_inner_mouth(curr_mask, landmarks[frame_count])\n frame_count += 1\n encoded_segmentations.append(encode_binary_mask(curr_mask))\n\n # Final iteration if we have leftover unsmoothed segmentations from the last batch\n if pad_next < r:\n # Compute segmentation\n segmentation = self.smooth_seg(prev_segmentation, pad_prev=pad_prev, pad_next=r)\n mask = segmentation.argmax(1) == 1\n\n # Encode segmentation\n for b in range(mask.shape[0]):\n curr_mask = mask[b].cpu().numpy()\n if self.seg_remove_mouth:\n curr_mask = remove_inner_mouth(curr_mask, landmarks[frame_count])\n frame_count += 1\n encoded_segmentations.append(encode_binary_mask(curr_mask))\n\n # Write to file\n with open(curr_seg_path, \"wb\") as fp: # Pickling\n pickle.dump(encoded_segmentations, fp)\n\n\n def cache(self, input_path, output_dir=None):\n # Validation\n assert os.path.isfile(input_path), 'Input path \"%s\" does not exist' % input_path\n assert output_dir is None or os.path.isdir(output_dir), 'Output path \"%s\" must be a directory' % output_dir\n is_vid = os.path.splitext(input_path)[1] == '.mp4'\n\n # Set paths\n output_dir = os.path.splitext(input_path)[0] if output_dir is None else output_dir\n det_file_path = os.path.splitext(input_path)[0] + self.det_postfix\n if not os.path.isfile(det_file_path): # Check if there is a detection file in the same directory as the video\n det_file_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] +\n self.det_postfix)\n seq_file_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] + self.seq_postfix)\n first_cropped_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] +\n '_seq00' + os.path.splitext(input_path)[1])\n pose_file_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] + self.pose_postfix)\n\n # Create directory\n if not os.path.isdir(output_dir):\n os.mkdir(output_dir)\n\n # Face detection\n if not os.path.isfile(det_file_path):\n self.face_detector(input_path, det_file_path)\n\n # Detections to sequences\n if not os.path.isfile(seq_file_path):\n detections2sequences_main(input_path, seq_file_path, det_file_path, self.iou_thresh, self.min_length,\n self.min_size, self.crop_scale, self.center_kernel, self.size_kernel,\n self.smooth_det, self.display, self.write_empty)\n\n # Crop video sequences\n if not os.path.isfile(first_cropped_path):\n if is_vid:\n crop_video_sequences_main(input_path, output_dir, seq_file_path, self.seq_postfix, self.resolution,\n self.crop_scale, select='all', disable_tqdm=False,\n encoder_codec=self.encoder_codec)\n else:\n crop_image_sequences_main(input_path, output_dir, seq_file_path, self.seq_postfix, '.jpg',\n self.resolution, self.crop_scale)\n\n # Face poses\n # if not os.path.isfile(pose_file_path) and is_vid:\n # self.process_pose(input_path, output_dir, seq_file_path, pose_file_path)\n # if is_vid:\n self.process_pose(input_path, output_dir, seq_file_path)\n\n # Extract frontal images\n # if self.cache_pose and self.cache_frontal and is_vid:\n # self.extract_frontal_images(input_path, output_dir, pose_file_path)\n if self.cache_pose and self.cache_frontal and is_vid:\n self.extract_frontal_images(input_path, output_dir, seq_file_path)\n\n # Cache landmarks\n self.process_landmarks(input_path, output_dir, seq_file_path)\n\n # Cache segmentation\n self.process_segmentation(input_path, output_dir, seq_file_path)\n\n return output_dir, seq_file_path, pose_file_path if self.cache_pose and is_vid else None\n\n\nclass VideoProcessCallable(VideoProcessBase):\n def __init__(self, args, kwargs):\n super(VideoProcessCallable, self).__init__(args, kwargs)\n\n def __call__(self, input_path, output_dir=None):\n return self.cache(input_path, output_dir)\n\n\ndef smooth_poses(poses, kernel_size=5):\n out_poses = poses.copy() if isinstance(poses, np.ndarray) else np.array(poses)\n\n # Prepare smoothing kernel\n # w = np.hamming(kernel_size)\n w = np.ones(kernel_size)\n w /= w.sum()\n\n # Smooth poses\n poses_padded = np.pad(out_poses, ((kernel_size // 2, kernel_size // 2), (0, 0)), 'reflect')\n for i in range(out_poses.shape[1]):\n out_poses[:, i] = np.convolve(w, poses_padded[:, i], mode='valid')\n\n return out_poses\n\n\ndef main(input, output=d('output'), resolution=d('resolution'), crop_scale=d('crop_scale'), gpus=d('gpus'),\n cpu_only=d('cpu_only'), display=d('display'), verbose=d('verbose'), encoder_codec=d('encoder_codec'),\n # Detection arguments:\n detection_model=d('detection_model'), det_batch_size=d('det_batch_size'), det_postfix=d('det_postfix'),\n # Sequence arguments:\n iou_thresh=d('iou_thresh'), min_length=d('min_length'), min_size=d('min_size'),\n center_kernel=d('center_kernel'), size_kernel=d('size_kernel'), smooth_det=d('smooth_det'),\n seq_postfix=d('seq_postfix'), write_empty=d('write_empty'),\n # Pose arguments:\n pose_model=d('pose_model'), pose_batch_size=d('pose_batch_size'), pose_postfix=d('pose_postfix'),\n cache_pose=d('cache_pose'), cache_frontal=d('cache_frontal'), smooth_poses=d('smooth_poses'),\n # Landmarks arguments:\n lms_model=d('lms_model'), lms_batch_size=d('lms_batch_size'), landmarks_postfix=d('landmarks_postfix'),\n cache_landmarks=d('cache_landmarks'), smooth_landmarks=d('smooth_landmarks'),\n # Segmentation arguments:\n seg_model=d('seg_model'), seg_batch_size=d('seg_batch_size'), segmentation_postfix=d('segmentation_postfix'),\n cache_segmentation=d('cache_segmentation'), smooth_segmentation=d('smooth_segmentation'),\n seg_remove_mouth=d('seg_remove_mouth')):\n video_process = VideoProcessCallable(\n resolution, crop_scale, gpus, cpu_only, display, verbose, encoder_codec,\n detection_model=detection_model, det_batch_size=det_batch_size, det_postfix=det_postfix,\n iou_thresh=iou_thresh, min_length=min_length, min_size=min_size, center_kernel=center_kernel,\n size_kernel=size_kernel, smooth_det=smooth_det, seq_postfix=seq_postfix, write_empty=write_empty,\n pose_model=pose_model, pose_batch_size=pose_batch_size, pose_postfix=pose_postfix, cache_pose=cache_pose,\n cache_frontal=cache_frontal, smooth_poses=smooth_poses, lms_model=lms_model, lms_batch_size=lms_batch_size,\n landmarks_postfix=landmarks_postfix, cache_landmarks=cache_landmarks, smooth_landmarks=smooth_landmarks,\n seg_model=seg_model, seg_batch_size=seg_batch_size, segmentation_postfix=segmentation_postfix,\n cache_segmentation=cache_segmentation, smooth_segmentation=smooth_segmentation,\n seg_remove_mouth=seg_remove_mouth)\n if len(input) == 1 and os.path.isfile(input[0]):\n video_process.cache(input, output)\n else:\n batch(input, None, output, video_process, postfix='.mp4')\n\n\nif __name__ == \"__main__\":\n main(vars(parser.parse_args()))\n" ]	[ [ "numpy.convolve", "numpy.pad", "torch.cat", "torch.utils.data.DataLoader", "numpy.linalg.norm", "numpy.ones", "numpy.concatenate", "numpy.savez_compressed", "torch.set_grad_enabled", "numpy.load", "torch.nn.DataParallel", "numpy.array", "torch.as_tensor" ] ]
RobbeElsermans/GestureControl	[ "c66f4d19fbf9ad785f4a8c721e7c6f8ba8425f4f" ]	[ "Code PlatformIO/Gesture Control PCBV0.3_F302RET6/python/showDataCSV.py" ]	[ "#!/usr/bin/python\nfrom csv import reader\nimport matplotlib.pyplot as plt\n\nfileName = \"links_zonder_duim\"\n\nfile = open(\"Software_Opstelling/\" + fileName + \".csv\", 'r', newline='')\n\ndata = reader(file, delimiter=',')\n\nleft=[]\ncenter=[]\nright=[]\n\nfor items in data:\n if not(\"LEFT\" in items[0]):\n left.append(int(items[0]))\n center.append(int(items[1]))\n right.append(int(items[2]))\n\n#aanmaken x as\nx = range(len(left))\n\nplt.plot(x,left,label=\"left\")\nplt.plot(x,center,label=\"center\")\nplt.plot(x,right,label=\"right\")\nplt.legend()\nplt.show()" ]	[ [ "matplotlib.pyplot.plot", "matplotlib.pyplot.legend", "matplotlib.pyplot.show" ] ]
Yard1/pycaret	[ "b6a0168d9479c7778aea8f07cf1e14b3da169045" ]	[ "pycaret/arules.py" ]	[ "# Module: Association Rules Mining\n# Author: Moez Ali <[email protected]>\n# License: MIT\n# Release: PyCaret 2.0x\n# Last modified : 30/07/2020\n\ndef setup(data, \n transaction_id, \n item_id,\n ignore_items = None,\n session_id = None):\n \n \"\"\"\n \n Description:\n ------------\n This function initializes the environment in pycaret. setup() must called before\n executing any other function in pycaret. It takes three mandatory parameters:\n (i) dataframe {array-like, sparse matrix}, (ii) transaction_id param identifying \n basket and (iii) item_id param used to create rules. These three params are \n normally found in any transactional dataset. pycaret will internally convert the\n dataframe into a sparse matrix which is required for association rules mining.\n \n Example\n -------\n from pycaret.datasets import get_data\n france get_data('france')\n \n experiment_name = setup(data = data, transaction_id = 'InvoiceNo', \n item_id = 'ProductName')\n \n Parameters\n ----------\n data : {array-like, sparse matrix}, shape (n_samples, n_features) where n_samples \n is the number of samples and n_features is the number of features.\n\n transaction_id: string\n Name of column representing transaction id. This will be used to pivot the matrix.\n\n item_id: string\n Name of column used for creation of rules. Normally, this will be the variable of\n interest.\n \n ignore_items: list, default = None\n list of strings to be ignored when considering rule mining.\n\n session_id: int, default = None\n If None, a random seed is generated and returned in the Information grid. The \n unique number is then distributed as a seed in all functions used during the \n experiment. This can be used for later reproducibility of the entire experiment.\n\n Returns:\n --------\n\n info grid: Information grid is printed.\n ----------- \n\n environment: This function returns various outputs that are stored in variable\n ----------- as tuple. They are used by other functions in pycaret.\n \n \n \"\"\"\n \n #exception checking \n import sys\n \n #ignore warnings\n import warnings\n warnings.filterwarnings('ignore') \n \n #load dependencies\n import random\n import pandas as pd\n import numpy as np\n from IPython.display import display, HTML, clear_output, update_display\n \n global X, txid, iid, ignore_list, seed, experiment__\n \n #create an empty list for pickling later.\n experiment__ = []\n \n #storing items in variable\n X = data\n txid = transaction_id\n iid = item_id\n ignore_list = ignore_items\n \n #generate seed to be used globally\n if session_id is None:\n seed = random.randint(150,9000)\n else:\n seed = session_id\n \n #display info grid\n \n #transactions\n \n tx_unique = len(data[transaction_id].unique()) \n item_unique = len(data[item_id].unique()) \n if ignore_items is None:\n ignore_flag = 'None'\n else:\n ignore_flag = ignore_items \n \n functions = pd.DataFrame ( [ ['session_id', seed ],\n ['# Transactions', tx_unique ], \n ['# Items', item_unique ],\n ['Ignore Items', ignore_flag ],\n ], columns = ['Description', 'Value'] )\n\n functions_ = functions.style.hide_index()\n display(functions_)\n \n return X, txid, iid, ignore_list, seed, experiment__\n\ndef create_model(metric='confidence',\n threshold = 0.5,\n min_support = 0.05,\n round = 4):\n \n \"\"\" \n \n Description:\n ------------\n This function creates an association rules model using data and identifiers \n passed at setup stage. This function internally transforms the data for \n association rule mining.\n\n setup() function must be called before using create_model()\n\n Example\n -------\n from pycaret.datasets import get_data\n france get_data('france') \n experiment_name = setup(data = data, transaction_id = 'InvoiceNo', \n item_id = 'ProductName')\n\n This will return dataframe containing rules sorted by metric param. \n\n Parameters\n ----------\n metric : string, default = 'confidence'\n Metric to evaluate if a rule is of interest. Default is set to confidence. \n Other available metrics include 'support', 'lift', 'leverage', 'conviction'. \n These metrics are computed as follows:\n\n - support(A->C) = support(A+C) [aka 'support'], range: [0, 1]\n\n - confidence(A->C) = support(A+C) / support(A), range: [0, 1]\n\n - lift(A->C) = confidence(A->C) / support(C), range: [0, inf]\n\n - leverage(A->C) = support(A->C) - support(A)*support(C),\n range: [-1, 1]\n\n - conviction = [1 - support(C)] / [1 - confidence(A->C)],\n range: [0, inf]\n \n threshold : float, default = 0.5\n Minimal threshold for the evaluation metric, via the `metric` parameter,\n to decide whether a candidate rule is of interest.\n \n min_support : float, default = 0.05\n A float between 0 and 1 for minumum support of the itemsets returned.\n The support is computed as the fraction `transactions_where_item(s)_occur /\n total_transactions`.\n \n round: integer, default = 4\n Number of decimal places metrics in score grid will be rounded to. \n\n\n Returns:\n --------\n\n DataFrame: Dataframe containing rules of interest with all metrics\n --------- including antecedents, consequents, antecedent support,\n consequent support, support, confidence, lift, leverage,\n conviction.\n\n Warnings:\n ---------\n\n - Setting low values for min_support may increase training time.\n \n \n \"\"\"\n \n \n #loading dependencies\n import pandas as pd\n from IPython.display import display, HTML, clear_output, update_display\n from mlxtend.frequent_patterns import apriori\n from mlxtend.frequent_patterns import association_rules\n \n #reshaping the dataframe\n basket = X.groupby([txid, iid])[iid].count().unstack().reset_index().fillna(0).set_index(txid)\n if ignore_list is not None:\n basket = basket.drop(ignore_list, axis=1) \n \n def encode_units(x):\n \n if x <= 0:\n return 0\n if x >= 1:\n return 1\n\n basket = basket.applymap(encode_units)\n \n frequent_itemsets = apriori(basket, min_support=min_support, use_colnames=True)\n rules = association_rules(frequent_itemsets, metric=metric, min_threshold=threshold)\n rules = rules.sort_values(by=[metric],ascending=False).reset_index(drop=True)\n rules = rules.round(round)\n \n #storing into experiment\n tup = ('Basket',basket)\n experiment__.append(tup)\n \n tup = ('Frequent Itemsets',frequent_itemsets)\n experiment__.append(tup)\n\n tup = ('Rules',rules)\n experiment__.append(tup)\n \n \n return(rules)\n\ndef plot_model(model,\n plot = '2d'):\n \n \"\"\"\n \n Description:\n ------------\n This function takes a model dataframe returned by create_model() function. \n '2d' and '3d' plots are available.\n\n Example:\n --------\n \n rule1 = create_model(metric='confidence', threshold=0.7, min_support=0.05)\n plot_model(rule1, plot='2d')\n plot_model(rule1, plot='3d')\n\n Parameters\n ----------\n\n model : DataFrame, default = none\n DataFrame returned by trained model using create_model(). \n\n plot : string, default = '2d'\n Enter abbreviation of type of plot. The current list of plots supported are:\n\n Name Abbreviated String \n --------- ------------------ \n Support, Confidence and Lift (2d) '2d'\n Support, Confidence and Lift (3d) '3d'\n \n \n Returns:\n --------\n\n Visual Plot: Prints the visual plot. \n ------------\n \n \"\"\"\n \n #loading libraries\n import numpy as np\n import pandas as pd\n import plotly.express as px\n from IPython.display import display, HTML, clear_output, update_display\n \n #import cufflinks\n import cufflinks as cf\n cf.go_offline()\n cf.set_config_file(offline=False, world_readable=True)\n \n #copy dataframe\n data_ = model.copy()\n \n antecedents = []\n for i in data_['antecedents']:\n i = str(i)\n a = i.split(sep=\"'\")\n a = a[1]\n antecedents.append(a)\n\n data_['antecedents'] = antecedents\n\n antecedents_short = []\n\n for i in antecedents:\n a = i[:10]\n antecedents_short.append(a)\n\n data_['antecedents_short'] = antecedents_short\n\n consequents = []\n for i in data_['consequents']:\n i = str(i)\n a = i.split(sep=\"'\")\n a = a[1]\n consequents.append(a)\n\n data_['consequents'] = consequents\n \n if plot == '2d':\n\n fig = px.scatter(data_, x=\"support\", y=\"confidence\", text=\"antecedents_short\", log_x=True, size_max=600, color='lift', \n hover_data = ['antecedents', 'consequents'], opacity=0.5, )\n\n fig.update_traces(textposition='top center')\n fig.update_layout(plot_bgcolor='rgb(240,240,240)')\n\n fig.update_layout(\n height=800,\n title_text='2D Plot of Support, Confidence and Lift'\n )\n\n fig.show()\n \n \n if plot == '3d':\n \n fig = px.scatter_3d(data_, x='support', y='confidence', z='lift',\n color='antecedent support', title='3d Plot for Rule Mining', opacity=0.7, width=900, height=800,\n hover_data = ['antecedents', 'consequents' ])\n fig.show() \n\ndef get_rules(data, \n transaction_id, \n item_id,\n ignore_items = None,\n metric='confidence',\n threshold = 0.5,\n min_support = 0.05):\n \n \"\"\"\n Magic function to get Association Rules in Power Query / Power BI. \n \n \"\"\"\n \n s = setup(data=data, transaction_id=transaction_id, item_id=item_id, ignore_items = ignore_items)\n dataset = create_model(metric=metric, threshold=threshold, min_support=min_support, round=4)\n \n return dataset" ]	[ [ "pandas.DataFrame" ] ]
ruarai/epifx.covid	[ "be7aecbf9e86c3402f6851ea65f6705cdb59f3cf" ]	[ "local_epifx/tests/test_select.py" ]	[ "import logging\nimport os\nimport warnings\nimport numpy as np\nimport pypfilt\nimport pypfilt.sweep\nimport epifx\nimport epifx.select\n\n\ndef test_select():\n logging.basicConfig(level=logging.INFO)\n logger = logging.getLogger(\"epifx.select\")\n logger.setLevel(logging.DEBUG)\n out_file = 'test_select_samples.ssv'\n\n # Define the PRNG seed for the selection process.\n seed = 2020\n\n # Draw proposals from the prior distributions defined in the simulation\n # parameters.\n proposal = epifx.select.DefaultProposal()\n\n # Peak times and sizes based on weekly numbers of seasonal influenza case\n # notifications for metropolitan Melbourne over 2012-2017.\n peak_times = np.array([[136, 177, 176, 182, 187, 193]])\n peak_sizes = np.array([360, 417, 691, 1329, 975, 2036])\n target = epifx.select.TargetPeakMVN(peak_sizes, peak_times)\n\n # Write an empty observations file, otherwise an exception will be raised\n # when attempting to load the observations.\n obs_file = 'no-observations.ssv'\n with open(obs_file, 'w') as f:\n f.write('date count\\n')\n\n config = pypfilt.config.from_string(config_str())\n with warnings.catch_warnings():\n # NOTE: pypfilt.sweep() will read the observations date file, which\n # makes numpy.loadtxt() produce a warning about an empty data file.\n # We can suppress this with warnings.filterwarnings().\n warnings.filterwarnings('ignore',\n message='loadtxt: Empty input file:',\n category=UserWarning)\n forecasts = list(pypfilt.sweep.forecasts(config))\n params = forecasts[0].params\n\n # Select particles according to the peak size and time target.\n vec = epifx.select.select(params, proposal, target, seed)\n\n # Retrieve the parameter columns from these particles.\n sample_cols = params['component']['model'].sample_columns()\n column_names = list(sample_cols.keys())\n column_ixs = np.array([sample_cols[n] for n in column_names])\n tbl = vec[:, column_ixs]\n\n # Save the sampled parameter values.\n logger.debug(\"Saving samples to {}\".format(out_file))\n np.savetxt(out_file, tbl, header=' '.join(column_names), comments='')\n\n # Remove the empty observations file.\n os.remove(obs_file)\n # Leave the sampled parameter file for now.\n # os.remove(out_file)\n\n\ndef config_str():\n \"\"\"Define forecast scenarios for these test cases.\"\"\"\n return \"\"\"\n [components]\n model = \"epifx.det.SEIR\"\n time = \"pypfilt.Datetime\"\n summary = \"epifx.summary.make\"\n\n [parameters]\n particles = 2000\n prng_seed = 3001\n steps_per_unit = 1\n last_n_periods = 1\n data_dir = \".\"\n tmp_dir = \".\"\n out_dir = \".\"\n json_dir = \".\"\n max_days = 7\n resample.threshold = 0.25\n resample.regularisation = true\n time.start = \"2020-03-01\"\n time.until = \"2020-12-31\"\n summary.from_first_day = true\n summary.only_forecasts = true\n summary.metadata.packages = [ \"epifx\" ]\n fresh_cache = true\n remove_cache = true\n\n [model.bounds]\n R0 = { min = 1.2, max = 1.6 }\n sigma = { min = 0.1, max = 10.0 }\n gamma = { min = 0.1, max = 10.0 }\n eta = { min = 1.0, max = 1.0 }\n alpha = { min = -0.2, max = 0.0 }\n t0 = { min = 0, max = 60 }\n\n [model.priors]\n R0 = { function = \"uniform\", args.low = 1.2, args.high = 1.6 }\n sigma = { function = \"inverse_uniform\", args.low = 0.5, args.high = 4.0 }\n gamma = { function = \"inverse_uniform\", args.low = 0.5, args.high = 4.0 }\n eta = { function = \"uniform\", args.low = 1.0, args.high = 1.0 }\n alpha = { function = \"uniform\", args.low = 0.0, args.high = 0.0 }\n t0 = { function = \"uniform\", args.low = 0, args.high = 60 }\n\n [summary.init]\n default = true\n\n [scenario.Melbourne]\n name = \"Melbourne\"\n parameters.model.population_size = 5_191_000\n\n [observations.Notifications]\n model = \"epifx.obs.PopnCounts\"\n file = \"no-observations.ssv\"\n init.obs_period = 7\n file_args.time_col = \"date\"\n file_args.value_col = \"count\"\n parameters.bg_obs = 70\n parameters.bg_var = 80\n parameters.pr_obs = 0.00275\n parameters.disp = 100\n format = { bg_obs = \"3.0f\", bg_var = \"03.0f\", pr_obs = \"0.5f\", disp = \"03.0f\" }\n name = { bg_obs = \"bg\", bg_var = \"bgvar\", pr_obs = \"pr\", disp = \"disp\" }\n \"\"\"\n" ]	[ [ "numpy.array" ] ]
huillll/deepface	[ "f17e63b8c8edc989d2d5d0d0861fe976c359d922" ]	[ "deepface/basemodels/OpenFace.py" ]	[ "import os\nfrom pathlib import Path\nimport gdown\n\nimport tensorflow as tf\nimport keras\nfrom keras.models import Model, Sequential\nfrom keras.layers import Conv2D, ZeroPadding2D, Activation, Input, concatenate\nfrom keras.layers.core import Dense, Activation, Lambda, Flatten\nfrom keras.layers.pooling import MaxPooling2D, AveragePooling2D\nfrom keras.layers.merge import Concatenate\nfrom keras.layers.normalization import BatchNormalization\nfrom keras.models import load_model\nfrom keras import backend as K\n\n#---------------------------------------\n\ndef loadModel():\n\tmyInput = Input(shape=(96, 96, 3))\n\n\tx = ZeroPadding2D(padding=(3, 3), input_shape=(96, 96, 3))(myInput)\n\tx = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x)\n\tx = BatchNormalization(axis=3, epsilon=0.00001, name='bn1')(x)\n\tx = Activation('relu')(x)\n\tx = ZeroPadding2D(padding=(1, 1))(x)\n\tx = MaxPooling2D(pool_size=3, strides=2)(x)\n\tx = Lambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name='lrn_1')(x)\n\tx = Conv2D(64, (1, 1), name='conv2')(x)\n\tx = BatchNormalization(axis=3, epsilon=0.00001, name='bn2')(x)\n\tx = Activation('relu')(x)\n\tx = ZeroPadding2D(padding=(1, 1))(x)\n\tx = Conv2D(192, (3, 3), name='conv3')(x)\n\tx = BatchNormalization(axis=3, epsilon=0.00001, name='bn3')(x)\n\tx = Activation('relu')(x)\n\tLambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name='lrn_2')(x)\n\tx = ZeroPadding2D(padding=(1, 1))(x)\n\tx = MaxPooling2D(pool_size=3, strides=2)(x)\n\n\t# Inception3a\n\tinception_3a_3x3 = Conv2D(96, (1, 1), name='inception_3a_3x3_conv1')(x)\n\tinception_3a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_3x3_bn1')(inception_3a_3x3)\n\tinception_3a_3x3 = Activation('relu')(inception_3a_3x3)\n\tinception_3a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3a_3x3)\n\tinception_3a_3x3 = Conv2D(128, (3, 3), name='inception_3a_3x3_conv2')(inception_3a_3x3)\n\tinception_3a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_3x3_bn2')(inception_3a_3x3)\n\tinception_3a_3x3 = Activation('relu')(inception_3a_3x3)\n\n\tinception_3a_5x5 = Conv2D(16, (1, 1), name='inception_3a_5x5_conv1')(x)\n\tinception_3a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_5x5_bn1')(inception_3a_5x5)\n\tinception_3a_5x5 = Activation('relu')(inception_3a_5x5)\n\tinception_3a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3a_5x5)\n\tinception_3a_5x5 = Conv2D(32, (5, 5), name='inception_3a_5x5_conv2')(inception_3a_5x5)\n\tinception_3a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_5x5_bn2')(inception_3a_5x5)\n\tinception_3a_5x5 = Activation('relu')(inception_3a_5x5)\n\n\tinception_3a_pool = MaxPooling2D(pool_size=3, strides=2)(x)\n\tinception_3a_pool = Conv2D(32, (1, 1), name='inception_3a_pool_conv')(inception_3a_pool)\n\tinception_3a_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_pool_bn')(inception_3a_pool)\n\tinception_3a_pool = Activation('relu')(inception_3a_pool)\n\tinception_3a_pool = ZeroPadding2D(padding=((3, 4), (3, 4)))(inception_3a_pool)\n\n\tinception_3a_1x1 = Conv2D(64, (1, 1), name='inception_3a_1x1_conv')(x)\n\tinception_3a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_1x1_bn')(inception_3a_1x1)\n\tinception_3a_1x1 = Activation('relu')(inception_3a_1x1)\n\n\tinception_3a = concatenate([inception_3a_3x3, inception_3a_5x5, inception_3a_pool, inception_3a_1x1], axis=3)\n\n\t# Inception3b\n\tinception_3b_3x3 = Conv2D(96, (1, 1), name='inception_3b_3x3_conv1')(inception_3a)\n\tinception_3b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_3x3_bn1')(inception_3b_3x3)\n\tinception_3b_3x3 = Activation('relu')(inception_3b_3x3)\n\tinception_3b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3b_3x3)\n\tinception_3b_3x3 = Conv2D(128, (3, 3), name='inception_3b_3x3_conv2')(inception_3b_3x3)\n\tinception_3b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_3x3_bn2')(inception_3b_3x3)\n\tinception_3b_3x3 = Activation('relu')(inception_3b_3x3)\n\n\tinception_3b_5x5 = Conv2D(32, (1, 1), name='inception_3b_5x5_conv1')(inception_3a)\n\tinception_3b_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_5x5_bn1')(inception_3b_5x5)\n\tinception_3b_5x5 = Activation('relu')(inception_3b_5x5)\n\tinception_3b_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3b_5x5)\n\tinception_3b_5x5 = Conv2D(64, (5, 5), name='inception_3b_5x5_conv2')(inception_3b_5x5)\n\tinception_3b_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_5x5_bn2')(inception_3b_5x5)\n\tinception_3b_5x5 = Activation('relu')(inception_3b_5x5)\n\n\tinception_3b_pool = Lambda(lambda x: x*2, name='power2_3b')(inception_3a)\n\tinception_3b_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_3b_pool)\n\tinception_3b_pool = Lambda(lambda x: x9, name='mult9_3b')(inception_3b_pool)\n\tinception_3b_pool = Lambda(lambda x: K.sqrt(x), name='sqrt_3b')(inception_3b_pool)\n\tinception_3b_pool = Conv2D(64, (1, 1), name='inception_3b_pool_conv')(inception_3b_pool)\n\tinception_3b_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_pool_bn')(inception_3b_pool)\n\tinception_3b_pool = Activation('relu')(inception_3b_pool)\n\tinception_3b_pool = ZeroPadding2D(padding=(4, 4))(inception_3b_pool)\n\n\tinception_3b_1x1 = Conv2D(64, (1, 1), name='inception_3b_1x1_conv')(inception_3a)\n\tinception_3b_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_1x1_bn')(inception_3b_1x1)\n\tinception_3b_1x1 = Activation('relu')(inception_3b_1x1)\n\n\tinception_3b = concatenate([inception_3b_3x3, inception_3b_5x5, inception_3b_pool, inception_3b_1x1], axis=3)\n\n\t# Inception3c\n\tinception_3c_3x3 = Conv2D(128, (1, 1), strides=(1, 1), name='inception_3c_3x3_conv1')(inception_3b)\n\tinception_3c_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_3x3_bn1')(inception_3c_3x3)\n\tinception_3c_3x3 = Activation('relu')(inception_3c_3x3)\n\tinception_3c_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3c_3x3)\n\tinception_3c_3x3 = Conv2D(256, (3, 3), strides=(2, 2), name='inception_3c_3x3_conv'+'2')(inception_3c_3x3)\n\tinception_3c_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_3x3_bn'+'2')(inception_3c_3x3)\n\tinception_3c_3x3 = Activation('relu')(inception_3c_3x3)\n\n\tinception_3c_5x5 = Conv2D(32, (1, 1), strides=(1, 1), name='inception_3c_5x5_conv1')(inception_3b)\n\tinception_3c_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_5x5_bn1')(inception_3c_5x5)\n\tinception_3c_5x5 = Activation('relu')(inception_3c_5x5)\n\tinception_3c_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3c_5x5)\n\tinception_3c_5x5 = Conv2D(64, (5, 5), strides=(2, 2), name='inception_3c_5x5_conv'+'2')(inception_3c_5x5)\n\tinception_3c_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_5x5_bn'+'2')(inception_3c_5x5)\n\tinception_3c_5x5 = Activation('relu')(inception_3c_5x5)\n\n\tinception_3c_pool = MaxPooling2D(pool_size=3, strides=2)(inception_3b)\n\tinception_3c_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_3c_pool)\n\n\tinception_3c = concatenate([inception_3c_3x3, inception_3c_5x5, inception_3c_pool], axis=3)\n\n\t#inception 4a\n\tinception_4a_3x3 = Conv2D(96, (1, 1), strides=(1, 1), name='inception_4a_3x3_conv'+'1')(inception_3c)\n\tinception_4a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_3x3_bn'+'1')(inception_4a_3x3)\n\tinception_4a_3x3 = Activation('relu')(inception_4a_3x3)\n\tinception_4a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4a_3x3)\n\tinception_4a_3x3 = Conv2D(192, (3, 3), strides=(1, 1), name='inception_4a_3x3_conv'+'2')(inception_4a_3x3)\n\tinception_4a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_3x3_bn'+'2')(inception_4a_3x3)\n\tinception_4a_3x3 = Activation('relu')(inception_4a_3x3)\n\n\tinception_4a_5x5 = Conv2D(32, (1,1), strides=(1,1), name='inception_4a_5x5_conv1')(inception_3c)\n\tinception_4a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_5x5_bn1')(inception_4a_5x5)\n\tinception_4a_5x5 = Activation('relu')(inception_4a_5x5)\n\tinception_4a_5x5 = ZeroPadding2D(padding=(2,2))(inception_4a_5x5)\n\tinception_4a_5x5 = Conv2D(64, (5,5), strides=(1,1), name='inception_4a_5x5_conv'+'2')(inception_4a_5x5)\n\tinception_4a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_5x5_bn'+'2')(inception_4a_5x5)\n\tinception_4a_5x5 = Activation('relu')(inception_4a_5x5)\n\n\tinception_4a_pool = Lambda(lambda x: x*2, name='power2_4a')(inception_3c)\n\tinception_4a_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_4a_pool)\n\tinception_4a_pool = Lambda(lambda x: x9, name='mult9_4a')(inception_4a_pool)\n\tinception_4a_pool = Lambda(lambda x: K.sqrt(x), name='sqrt_4a')(inception_4a_pool)\n\n\tinception_4a_pool = Conv2D(128, (1,1), strides=(1,1), name='inception_4a_pool_conv'+'')(inception_4a_pool)\n\tinception_4a_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_pool_bn'+'')(inception_4a_pool)\n\tinception_4a_pool = Activation('relu')(inception_4a_pool)\n\tinception_4a_pool = ZeroPadding2D(padding=(2, 2))(inception_4a_pool)\n\n\tinception_4a_1x1 = Conv2D(256, (1, 1), strides=(1, 1), name='inception_4a_1x1_conv'+'')(inception_3c)\n\tinception_4a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_1x1_bn'+'')(inception_4a_1x1)\n\tinception_4a_1x1 = Activation('relu')(inception_4a_1x1)\n\n\tinception_4a = concatenate([inception_4a_3x3, inception_4a_5x5, inception_4a_pool, inception_4a_1x1], axis=3)\n\n\t#inception4e\n\tinception_4e_3x3 = Conv2D(160, (1,1), strides=(1,1), name='inception_4e_3x3_conv'+'1')(inception_4a)\n\tinception_4e_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_3x3_bn'+'1')(inception_4e_3x3)\n\tinception_4e_3x3 = Activation('relu')(inception_4e_3x3)\n\tinception_4e_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4e_3x3)\n\tinception_4e_3x3 = Conv2D(256, (3,3), strides=(2,2), name='inception_4e_3x3_conv'+'2')(inception_4e_3x3)\n\tinception_4e_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_3x3_bn'+'2')(inception_4e_3x3)\n\tinception_4e_3x3 = Activation('relu')(inception_4e_3x3)\n\n\tinception_4e_5x5 = Conv2D(64, (1,1), strides=(1,1), name='inception_4e_5x5_conv'+'1')(inception_4a)\n\tinception_4e_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_5x5_bn'+'1')(inception_4e_5x5)\n\tinception_4e_5x5 = Activation('relu')(inception_4e_5x5)\n\tinception_4e_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4e_5x5)\n\tinception_4e_5x5 = Conv2D(128, (5,5), strides=(2,2), name='inception_4e_5x5_conv'+'2')(inception_4e_5x5)\n\tinception_4e_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_5x5_bn'+'2')(inception_4e_5x5)\n\tinception_4e_5x5 = Activation('relu')(inception_4e_5x5)\n\n\tinception_4e_pool = MaxPooling2D(pool_size=3, strides=2)(inception_4a)\n\tinception_4e_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_4e_pool)\n\n\tinception_4e = concatenate([inception_4e_3x3, inception_4e_5x5, inception_4e_pool], axis=3)\n\n\t#inception5a\n\tinception_5a_3x3 = Conv2D(96, (1,1), strides=(1,1), name='inception_5a_3x3_conv'+'1')(inception_4e)\n\tinception_5a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_3x3_bn'+'1')(inception_5a_3x3)\n\tinception_5a_3x3 = Activation('relu')(inception_5a_3x3)\n\tinception_5a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5a_3x3)\n\tinception_5a_3x3 = Conv2D(384, (3,3), strides=(1,1), name='inception_5a_3x3_conv'+'2')(inception_5a_3x3)\n\tinception_5a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_3x3_bn'+'2')(inception_5a_3x3)\n\tinception_5a_3x3 = Activation('relu')(inception_5a_3x3)\n\n\tinception_5a_pool = Lambda(lambda x: x*2, name='power2_5a')(inception_4e)\n\tinception_5a_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_5a_pool)\n\tinception_5a_pool = Lambda(lambda x: x9, name='mult9_5a')(inception_5a_pool)\n\tinception_5a_pool = Lambda(lambda x: K.sqrt(x), name='sqrt_5a')(inception_5a_pool)\n\n\tinception_5a_pool = Conv2D(96, (1,1), strides=(1,1), name='inception_5a_pool_conv'+'')(inception_5a_pool)\n\tinception_5a_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_pool_bn'+'')(inception_5a_pool)\n\tinception_5a_pool = Activation('relu')(inception_5a_pool)\n\tinception_5a_pool = ZeroPadding2D(padding=(1,1))(inception_5a_pool)\n\n\tinception_5a_1x1 = Conv2D(256, (1,1), strides=(1,1), name='inception_5a_1x1_conv'+'')(inception_4e)\n\tinception_5a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_1x1_bn'+'')(inception_5a_1x1)\n\tinception_5a_1x1 = Activation('relu')(inception_5a_1x1)\n\n\tinception_5a = concatenate([inception_5a_3x3, inception_5a_pool, inception_5a_1x1], axis=3)\n\n\t#inception_5b\n\tinception_5b_3x3 = Conv2D(96, (1,1), strides=(1,1), name='inception_5b_3x3_conv'+'1')(inception_5a)\n\tinception_5b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_3x3_bn'+'1')(inception_5b_3x3)\n\tinception_5b_3x3 = Activation('relu')(inception_5b_3x3)\n\tinception_5b_3x3 = ZeroPadding2D(padding=(1,1))(inception_5b_3x3)\n\tinception_5b_3x3 = Conv2D(384, (3,3), strides=(1,1), name='inception_5b_3x3_conv'+'2')(inception_5b_3x3)\n\tinception_5b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_3x3_bn'+'2')(inception_5b_3x3)\n\tinception_5b_3x3 = Activation('relu')(inception_5b_3x3)\n\n\tinception_5b_pool = MaxPooling2D(pool_size=3, strides=2)(inception_5a)\n\n\tinception_5b_pool = Conv2D(96, (1,1), strides=(1,1), name='inception_5b_pool_conv'+'')(inception_5b_pool)\n\tinception_5b_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_pool_bn'+'')(inception_5b_pool)\n\tinception_5b_pool = Activation('relu')(inception_5b_pool)\n\n\tinception_5b_pool = ZeroPadding2D(padding=(1, 1))(inception_5b_pool)\n\n\tinception_5b_1x1 = Conv2D(256, (1,1), strides=(1,1), name='inception_5b_1x1_conv'+'')(inception_5a)\n\tinception_5b_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_1x1_bn'+'')(inception_5b_1x1)\n\tinception_5b_1x1 = Activation('relu')(inception_5b_1x1)\n\n\tinception_5b = concatenate([inception_5b_3x3, inception_5b_pool, inception_5b_1x1], axis=3)\n\n\tav_pool = AveragePooling2D(pool_size=(3, 3), strides=(1, 1))(inception_5b)\n\treshape_layer = Flatten()(av_pool)\n\tdense_layer = Dense(128, name='dense_layer')(reshape_layer)\n\tnorm_layer = Lambda(lambda x: K.l2_normalize(x, axis=1), name='norm_layer')(dense_layer)\n\n\t# Final Model\n\tmodel = Model(inputs=[myInput], outputs=norm_layer)\n\t\n\t#-----------------------------------\n\t\n\thome = str(Path.home())\n\t\n\tif os.path.isfile(home+'/.deepface/weights/openface_weights.h5') != True:\n\t\tprint(\"openface_weights.h5 will be downloaded...\")\n\t\t\n\t\turl = 'https://drive.google.com/uc?id=1LSe1YCV1x-BfNnfb7DFZTNpv_Q9jITxn'\n\t\toutput = home+'/.deepface/weights/openface_weights.h5'\n\t\tgdown.download(url, output, quiet=False)\n\t\n\t#-----------------------------------\n\t\n\tmodel.load_weights(home+'/.deepface/weights/openface_weights.h5')\n\t\n\t#-----------------------------------\n\t\n\treturn model" ]	[ [ "tensorflow.nn.lrn" ] ]
gvisco/ossom	[ "77a455f467eb21e9a0cefdc5447d05f86cd090ec" ]	[ "ossom/som.py" ]	[ "import math\n\nimport scipy\nfrom scipy.spatial.distance import euclidean\n\n\ndef similarity(x, y):\n return euclidean(x, y)\n\n\ndef neighborhood_kernel(radius, i, j, ii, jj):\n \"\"\"Grid distance explained:\n http://keekerdc.com/2011/03/hexagon-grids-coordinate-systems-and-distance-calculations/\n\n \"\"\"\n x1, y1, z1 = hex_3d_coordinates(i, j)\n x2, y2, z2 = hex_3d_coordinates(ii, jj)\n grid_distance = max(abs(x1 - x2), abs(y1 - y2), abs(z1 - z2))\n return math.exp(- grid_distance ** 2 / (2 * radius ** 2))\n\n\ndef hex_3d_coordinates(i, j):\n hex_i = - i / 2\n hex_j = j\n return hex_i, hex_j, -(hex_i + hex_j)\n\n\ndef exponential_decay(initial_value, decay, time):\n return initial_value * math.exp(- float(time) / decay)\n\n\nclass Som(object):\n def __init__(self, width, height, input_size, learning_rate=1.0, radius=2.0, learning_rate_decay=1.0,\n radius_decay=1.0):\n self.lattice = [[scipy.random.uniform(-1.0, 1.0, input_size) for _ in range(width)] for _ in range(height)]\n self.lattice_width = width\n self.lattice_height = height\n self.learning_rate = learning_rate\n self.update_radius = radius\n self.learning_rate_decay = learning_rate_decay\n self.radius_decay = radius_decay\n\n def train(self, x, epoch):\n winner_row, winner_column, winner_weight, winner_distance = self.__compete(x)\n self.__cooperate(epoch, winner_row, winner_column, x)\n return winner_row, winner_column, winner_weight, winner_distance\n\n def classify(self, x):\n return self.__compete(x)\n\n def __compete(self, x):\n winner_row, winner_column, winner_distance = (-1, -1, float('inf'))\n for row in range(self.lattice_height):\n for column in range(self.lattice_width):\n candidate = self.lattice[row][column]\n distance = similarity(candidate, x)\n if distance < winner_distance:\n winner_row, winner_column, winner_distance = (row, column, distance)\n return winner_row, winner_column, self.lattice[winner_row][winner_column], winner_distance\n\n def __cooperate(self, epoch, winner_row, winner_column, x):\n for row in range(self.lattice_height):\n for column in range(self.lattice_width):\n learning = exponential_decay(self.learning_rate, self.learning_rate_decay, epoch)\n radius = exponential_decay(self.update_radius, self.radius_decay, epoch)\n neighborhood = neighborhood_kernel(radius, row, column, winner_row, winner_column)\n\n neuron = self.lattice[row][column]\n weight_increment = learning * neighborhood * (x - neuron)\n neuron += weight_increment\n\n def __str__(self):\n return '\\n'.join([''.join([str(neuron).ljust(10) for neuron in row]) for row in self.lattice])\n" ]	[ [ "scipy.random.uniform", "scipy.spatial.distance.euclidean" ] ]
leroidauphin/agents	[ "858ee36aaaea6fbcf0e5ab1c12929c77bd17abae" ]	[ "tf_agents/environments/parallel_py_environment.py" ]	[ "# coding=utf-8\n# Copyright 2018 The TF-Agents Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Runs multiple environments in parallel processes and steps them in batch.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\n# Using Type Annotations.\nfrom __future__ import print_function\n\nimport atexit\nimport sys\nimport traceback\nfrom typing import Any, Callable, Sequence, Text, Union\n\nfrom absl import logging\n\nimport cloudpickle\nimport gin\nimport numpy as np\nimport tensorflow as tf # pylint: disable=g-explicit-tensorflow-version-import\n\nfrom tf_agents.environments import py_environment\nfrom tf_agents.system import system_multiprocessing as multiprocessing\nfrom tf_agents.trajectories import time_step as ts\nfrom tf_agents.typing import types\nfrom tf_agents.utils import nest_utils\n\n\n# Worker polling period in seconds.\n_POLLING_PERIOD = 0.1\n\nEnvConstructor = Callable[[], py_environment.PyEnvironment]\nPromise = Callable[[], Any]\n\n\[email protected]\nclass ParallelPyEnvironment(py_environment.PyEnvironment):\n \"\"\"Batch together environments and simulate them in external processes.\n\n The environments are created in external processes by calling the provided\n callables. This can be an environment class, or a function creating the\n environment and potentially wrapping it. The returned environment should not\n access global variables.\n \"\"\"\n\n def __init__(self,\n env_constructors: Sequence[EnvConstructor],\n start_serially: bool = True,\n blocking: bool = False,\n flatten: bool = False):\n \"\"\"Batch together environments and simulate them in external processes.\n\n The environments can be different but must use the same action and\n observation specs.\n\n Args:\n env_constructors: List of callables that create environments.\n start_serially: Whether to start environments serially or in parallel.\n blocking: Whether to step environments one after another.\n flatten: Boolean, whether to use flatten action and time_steps during\n communication to reduce overhead.\n\n Raises:\n ValueError: If the action or observation specs don't match.\n \"\"\"\n super(ParallelPyEnvironment, self).__init__()\n self._envs = [ProcessPyEnvironment(ctor, flatten=flatten)\n for ctor in env_constructors]\n self._num_envs = len(env_constructors)\n self._blocking = blocking\n self._start_serially = start_serially\n self.start()\n self._action_spec = self._envs[0].action_spec()\n self._observation_spec = self._envs[0].observation_spec()\n self._time_step_spec = self._envs[0].time_step_spec()\n self._parallel_execution = True\n if any(env.action_spec() != self._action_spec for env in self._envs):\n raise ValueError('All environments must have the same action spec.')\n if any(env.time_step_spec() != self._time_step_spec for env in self._envs):\n raise ValueError('All environments must have the same time_step_spec.')\n self._flatten = flatten\n\n def start(self) -> None:\n logging.info('Spawning all processes.')\n for env in self._envs:\n env.start(wait_to_start=self._start_serially)\n if not self._start_serially:\n logging.info('Waiting for all processes to start.')\n for env in self._envs:\n env.wait_start()\n logging.info('All processes started.')\n\n @property\n def batched(self) -> bool:\n return True\n\n @property\n def batch_size(self) -> int:\n return self._num_envs\n\n @property\n def envs(self):\n return self._envs\n\n def observation_spec(self) -> types.NestedArraySpec:\n return self._observation_spec\n\n def action_spec(self) -> types.NestedArraySpec:\n return self._action_spec\n\n def time_step_spec(self) -> ts.TimeStep:\n return self._time_step_spec\n\n def _reset(self):\n \"\"\"Reset all environments and combine the resulting observation.\n\n Returns:\n Time step with batch dimension.\n \"\"\"\n time_steps = [env.reset(self._blocking) for env in self._envs]\n if not self._blocking:\n time_steps = [promise() for promise in time_steps]\n return self._stack_time_steps(time_steps)\n\n def _step(self, actions):\n \"\"\"Forward a batch of actions to the wrapped environments.\n\n Args:\n actions: Batched action, possibly nested, to apply to the environment.\n\n Raises:\n ValueError: Invalid actions.\n\n Returns:\n Batch of observations, rewards, and done flags.\n \"\"\"\n time_steps = [\n env.step(action, self._blocking)\n for env, action in zip(self._envs, self._unstack_actions(actions))]\n # When blocking is False we get promises that need to be called.\n if not self._blocking:\n time_steps = [promise() for promise in time_steps]\n return self._stack_time_steps(time_steps)\n\n def close(self) -> None:\n \"\"\"Close all external process.\"\"\"\n logging.info('Closing all processes.')\n for env in self._envs:\n env.close()\n logging.info('All processes closed.')\n\n def _stack_time_steps(self, time_steps):\n \"\"\"Given a list of TimeStep, combine to one with a batch dimension.\"\"\"\n if self._flatten:\n return nest_utils.fast_map_structure_flatten(\n lambda arrays: np.stack(arrays), self._time_step_spec, time_steps)\n else:\n return nest_utils.fast_map_structure(\n lambda arrays: np.stack(arrays), time_steps)\n\n def _unstack_actions(self, batched_actions):\n \"\"\"Returns a list of actions from potentially nested batch of actions.\"\"\"\n flattened_actions = tf.nest.flatten(batched_actions)\n if self._flatten:\n unstacked_actions = zip(flattened_actions)\n else:\n unstacked_actions = [\n tf.nest.pack_sequence_as(batched_actions, actions)\n for actions in zip(flattened_actions)\n ]\n return unstacked_actions\n\n def seed(self, seeds: Sequence[types.Seed]) -> Sequence[Any]:\n \"\"\"Seeds the parallel environments.\"\"\"\n if len(seeds) != len(self._envs):\n raise ValueError(\n 'Number of seeds should match the number of parallel_envs.')\n\n promises = [env.call('seed', seed) for seed, env in zip(seeds, self._envs)]\n # Block until all envs are seeded.\n return [promise() for promise in promises]\n\n\nclass ProcessPyEnvironment(object):\n \"\"\"Step a single env in a separate process for lock free paralellism.\"\"\"\n\n # Message types for communication via the pipe.\n _READY = 1\n _ACCESS = 2\n _CALL = 3\n _RESULT = 4\n _EXCEPTION = 5\n _CLOSE = 6\n\n def __init__(self, env_constructor: EnvConstructor, flatten: bool = False):\n \"\"\"Step environment in a separate process for lock free paralellism.\n\n The environment is created in an external process by calling the provided\n callable. This can be an environment class, or a function creating the\n environment and potentially wrapping it. The returned environment should\n not access global variables.\n\n Args:\n env_constructor: Callable that creates and returns a Python environment.\n flatten: Boolean, whether to assume flattened actions and time_steps\n during communication to avoid overhead.\n\n Attributes:\n observation_spec: The cached observation spec of the environment.\n action_spec: The cached action spec of the environment.\n time_step_spec: The cached time step spec of the environment.\n \"\"\"\n # NOTE(ebrevdo): multiprocessing uses the standard py3 pickler which does\n # not support anonymous lambdas. Folks usually pass anonymous lambdas as\n # env constructors. Here we work around this by manually pickling\n # the constructor using cloudpickle; which supports these. In the\n # new process, we'll unpickle this constructor and run it.\n self._pickled_env_constructor = cloudpickle.dumps(env_constructor)\n self._flatten = flatten\n self._observation_spec = None\n self._action_spec = None\n self._time_step_spec = None\n\n def start(self, wait_to_start: bool = True) -> None:\n \"\"\"Start the process.\n\n Args:\n wait_to_start: Whether the call should wait for an env initialization.\n \"\"\"\n mp_context = multiprocessing.get_context()\n self._conn, conn = mp_context.Pipe()\n self._process = mp_context.Process(target=self._worker, args=(conn,))\n atexit.register(self.close)\n self._process.start()\n if wait_to_start:\n self.wait_start()\n\n def wait_start(self) -> None:\n \"\"\"Wait for the started process to finish initialization.\"\"\"\n result = self._conn.recv()\n if isinstance(result, Exception):\n self._conn.close()\n self._process.join(5)\n raise result\n assert result == self._READY, result\n\n def observation_spec(self) -> types.NestedArraySpec:\n if not self._observation_spec:\n self._observation_spec = self.call('observation_spec')()\n return self._observation_spec\n\n def action_spec(self) -> types.NestedArraySpec:\n if not self._action_spec:\n self._action_spec = self.call('action_spec')()\n return self._action_spec\n\n def time_step_spec(self) -> ts.TimeStep:\n if not self._time_step_spec:\n self._time_step_spec = self.call('time_step_spec')()\n return self._time_step_spec\n\n def __getattr__(self, name: Text) -> Any:\n \"\"\"Request an attribute from the environment.\n\n Note that this involves communication with the external process, so it can\n be slow.\n\n This method is only called if the attribute is not found in the dictionary\n of `ParallelPyEnvironment`'s definition.\n\n Args:\n name: Attribute to access.\n\n Returns:\n Value of the attribute.\n \"\"\"\n # Private properties are always accessed on this object, not in the\n # wrapped object in another process. This includes properties used\n # for pickling (incl. __getstate__, __setstate__, _conn, _ACCESS, _receive),\n # as well as private properties and methods created and used by subclasses\n # of this class. Allowing arbitrary private attributes to be requested\n # from the other process can lead to deadlocks.\n if name.startswith('_'):\n return super(ProcessPyEnvironment, self).__getattribute__(name)\n\n # All other requests get sent to the worker.\n self._conn.send((self._ACCESS, name))\n return self._receive()\n\n def call(self, name: Text, args, kwargs) -> Promise:\n \"\"\"Asynchronously call a method of the external environment.\n\n Args:\n name: Name of the method to call.\n args: Positional arguments to forward to the method.\n *kwargs: Keyword arguments to forward to the method.\n\n Returns:\n The attribute.\n \"\"\"\n payload = name, args, kwargs\n self._conn.send((self._CALL, payload))\n return self._receive\n\n def access(self, name: Text) -> Any:\n \"\"\"Access an attribute of the external environment.\n\n This method blocks.\n\n Args:\n name: Name of the attribute to access.\n\n Returns:\n The attribute value.\n \"\"\"\n self._conn.send((self._ACCESS, name))\n return self._receive()\n\n def close(self) -> None:\n \"\"\"Send a close message to the external process and join it.\"\"\"\n try:\n self._conn.send((self._CLOSE, None))\n self._conn.close()\n except IOError:\n # The connection was already closed.\n pass\n if self._process.is_alive():\n self._process.join(5)\n\n def step(self,\n action: types.NestedArray,\n blocking: bool = True) -> Union[ts.TimeStep, Promise]:\n \"\"\"Step the environment.\n\n Args:\n action: The action to apply to the environment.\n blocking: Whether to wait for the result.\n\n Returns:\n time step when blocking, otherwise callable that returns the time step.\n \"\"\"\n promise = self.call('step', action)\n if blocking:\n return promise()\n else:\n return promise\n\n def reset(self, blocking: bool = True) -> Union[ts.TimeStep, Promise]:\n \"\"\"Reset the environment.\n\n Args:\n blocking: Whether to wait for the result.\n\n Returns:\n New observation when blocking, otherwise callable that returns the new\n observation.\n \"\"\"\n promise = self.call('reset')\n if blocking:\n return promise()\n else:\n return promise\n\n def _receive(self):\n \"\"\"Wait for a message from the worker process and return its payload.\n\n Raises:\n Exception: An exception was raised inside the worker process.\n KeyError: The reveived message is of an unknown type.\n\n Returns:\n Payload object of the message.\n \"\"\"\n message, payload = self._conn.recv()\n # Re-raise exceptions in the main process.\n if message == self._EXCEPTION:\n stacktrace = payload\n raise Exception(stacktrace)\n if message == self._RESULT:\n return payload\n self.close()\n raise KeyError('Received message of unexpected type {}'.format(message))\n\n def _worker(self, conn):\n \"\"\"The process waits for actions and sends back environment results.\n\n Args:\n conn: Connection for communication to the main process.\n\n Raises:\n KeyError: When receiving a message of unknown type.\n \"\"\"\n try:\n env = cloudpickle.loads(self._pickled_env_constructor)()\n action_spec = env.action_spec()\n conn.send(self._READY) # Ready.\n while True:\n try:\n # Only block for short times to have keyboard exceptions be raised.\n if not conn.poll(_POLLING_PERIOD):\n continue\n message, payload = conn.recv()\n except (EOFError, KeyboardInterrupt):\n break\n if message == self._ACCESS:\n name = payload\n result = getattr(env, name)\n conn.send((self._RESULT, result))\n continue\n if message == self._CALL:\n name, args, kwargs = payload\n if self._flatten and name == 'step':\n args = [tf.nest.pack_sequence_as(action_spec, args[0])]\n result = getattr(env, name)(args, **kwargs)\n if self._flatten and name in ['step', 'reset']:\n result = tf.nest.flatten(result)\n conn.send((self._RESULT, result))\n continue\n if message == self._CLOSE:\n assert payload is None\n env.close()\n break\n raise KeyError('Received message of unknown type {}'.format(message))\n except Exception: # pylint: disable=broad-except\n etype, evalue, tb = sys.exc_info()\n stacktrace = ''.join(traceback.format_exception(etype, evalue, tb))\n message = 'Error in environment process: {}'.format(stacktrace)\n logging.error(message)\n conn.send((self._EXCEPTION, stacktrace))\n finally:\n conn.close()\n" ]	[ [ "tensorflow.nest.flatten", "tensorflow.nest.pack_sequence_as", "numpy.stack" ] ]
rainzhop/ConvNetQuake	[ "a3e6de3f7992eac72f1b9883fec36b8c7fdefd48" ]	[ "openquake.hazardlib/openquake/hazardlib/gsim/fukushima_tanaka_1990.py" ]	[ "# -- coding: utf-8 --\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2014-2016 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.\n\n\"\"\"\nModule exports :class:'FukushimaTanaka1990' and :class:\n'FukushimaTanakaSite1990'\n\"\"\"\nfrom __future__ import division\nimport numpy as np\n# standard acceleration of gravity in m/s2\nfrom scipy.constants import g\n\n\nfrom openquake.hazardlib.gsim.base import GMPE, CoeffsTable\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA\n\n\nclass FukushimaTanaka1990(GMPE):\n \"\"\"\n Implements the PGA GMPE of Fukushima and Tanaka (1990)\n Fukushima, Y. and Tanaka, T. (1990) A New Attenuation Relation for Peak\n Horizontal Acceleration of Strong Earthquake Ground Motion in Japan.\n Bulletin of the Seismological Society of America, 80(4), 757 - 783\n \"\"\"\n #: The GMPE is derived from shallow earthquakes in California and Japan\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n\n #: Supported intensity measure types are peak ground acceleration\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n ])\n\n #: Supported intensity measure component is the average horizontal\n #: component\n #: :attr:`openquake.hazardlib.const.IMC.AVERAGE_HORIZONTAL`,\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.AVERAGE_HORIZONTAL\n\n #: Supported standard deviation types is total.\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL\n ])\n\n #: Required site parameters. The GMPE was developed for an ''average''\n #: site conditions. The authors specify that for rock sites the\n #: values should be lowered by 40 % and for soil site they should be\n #: raised by 40 %. For greatest consistencty the site condition is\n #: neglected currently but a site-dependent GMPE may be implemented\n #: inside a subclass.\n REQUIRES_SITES_PARAMETERS = set(())\n\n #: Required rupture parameters are magnitude\n REQUIRES_RUPTURE_PARAMETERS = set(('mag', ))\n\n #: Required distance measure is rupture distance\n REQUIRES_DISTANCES = set(('rrup',))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n\n C = self.COEFFS[imt]\n\n imean = (self._compute_magnitude_scaling(C, rup.mag) +\n self._compute_distance_scaling(C, dists.rrup, rup.mag))\n # Original GMPE returns log10 acceleration in cm/s/s\n # Converts to natural logarithm of g\n mean = np.log((10.0 (imean - 2.0)) / g)\n istddevs = self._compute_stddevs(\n C, dists.rrup.shape, stddev_types\n )\n # Convert from common logarithm to natural logarithm\n stddevs = np.log(10 ** np.array(istddevs))\n return mean, stddevs\n\n def _compute_magnitude_scaling(self, C, mag):\n \"\"\"\n Returns the magnitude scaling term\n \"\"\"\n return C[\"c1\"] * mag + C[\"c5\"]\n\n def _compute_distance_scaling(self, C, rrup, mag):\n \"\"\"\n Returns the distance scaling term\n \"\"\"\n rscale1 = rrup + C[\"c2\"] * (10.0 ** (C[\"c3\"] * mag))\n return -np.log10(rscale1) - (C[\"c4\"] * rrup)\n\n def _compute_stddevs(self, C, num_sites, stddev_types):\n \"\"\"\n Return total standard deviation.\n \"\"\"\n std_total = C['sigma']\n\n stddevs = []\n for _ in stddev_types:\n stddevs.append(np.zeros(num_sites) + std_total)\n return stddevs\n\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\n IMT c1 c2 c3 c4 c5 sigma\n pga 0.41 0.032 0.41 0.0034 1.30 0.21\n \"\"\")\n\n\nclass FukushimaTanakaSite1990(FukushimaTanaka1990):\n \"\"\"\n Implements the Fukushima and Tanaka (1990) model correcting for\n site class. The authors specify that the ground motions should\n be raised by 40 % on soft soil sites and reduced by 40 % on rock sites.\n The specific site classification is not known, so it is assumed that\n in this context \"average\" site conditions refer to NEHRP C, rock conditions\n to NEHRP A and B, and soft soil conditions to NEHRP D and E\n\n \"\"\"\n #: Input sites as vs30 although only three classes considered\n REQUIRES_SITES_PARAMETERS = set((\"vs30\",))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n\n C = self.COEFFS[imt]\n\n imean = (self._compute_magnitude_scaling(C, rup.mag) +\n self._compute_distance_scaling(C, dists.rrup, rup.mag))\n # Original GMPE returns log10 acceleration in cm/s/s\n # Converts to natural logarithm of g\n mean = np.log((10.0 (imean - 2.0)) / g)\n mean = self._compute_site_scaling(sites.vs30, mean)\n istddevs = self._compute_stddevs(\n C, dists.rrup.shape, stddev_types\n )\n # Convert from common logarithm to natural logarithm\n stddevs = np.log(10 np.array(istddevs))\n return mean, stddevs\n\n def _compute_site_scaling(self, vs30, mean):\n \"\"\"\n Scales the ground motions by increasing 40 % on NEHRP class D/E sites,\n and decreasing by 40 % on NEHRP class A/B sites\n \"\"\"\n site_factor = np.ones(len(vs30), dtype=float)\n idx = vs30 <= 360.\n site_factor[idx] = 1.4\n idx = vs30 > 760.0\n site_factor[idx] = 0.6\n return np.log(np.exp(mean) * site_factor)\n" ]	[ [ "numpy.log", "numpy.log10", "numpy.array", "numpy.exp", "numpy.zeros" ] ]
kirkjens/sarpy_apps	[ "e38402b1591512081a83d0f31e6ded325ae196e8" ]	[ "sarpy_apps/supporting_classes/image_reader.py" ]	[ "\"\"\"\nHelper classes mapping the sarpy readers into the CanvasImageReader pattern.\n\"\"\"\n\n__classification__ = \"UNCLASSIFIED\"\n__author__ = \"Thomas McCullough\"\n\n\nimport logging\nimport numpy\nfrom typing import List, Tuple\nimport gc\n\nfrom tk_builder.image_reader import CanvasImageReader\n\nfrom sarpy.io.general.base import AbstractReader, SarpyIOError\nfrom sarpy.visualization.remap import get_remap_list, get_registered_remap, RemapFunction\n\nfrom sarpy.io.complex.converter import open_complex\nfrom sarpy.io.complex.base import SICDTypeReader\nfrom sarpy.io.complex.aggregate import AggregateComplexReader\nfrom sarpy.io.complex.sicd_elements.SICD import SICDType\n\nfrom sarpy.io.product.converter import open_product\nfrom sarpy.io.product.base import SIDDTypeReader\nfrom sarpy.io.product.sidd1_elements.SIDD import SIDDType as SIDDType1\nfrom sarpy.io.product.sidd2_elements.SIDD import SIDDType as SIDDType2\n\n\nfrom sarpy.io.phase_history.converter import open_phase_history\nfrom sarpy.io.phase_history.base import CPHDTypeReader\nfrom sarpy.io.phase_history.cphd1_elements.CPHD import CPHDType as CPHDType1\nfrom sarpy.io.phase_history.cphd0_3_elements.CPHD import CPHDType as CPHDType0_3\n\nfrom sarpy.io.received.converter import open_received\nfrom sarpy.io.received.base import CRSDTypeReader\nfrom sarpy.io.received.crsd1_elements.CRSD import CRSDType\n\nfrom sarpy.io.general.converter import open_general\n\n\ndef _get_default_remap():\n \"\"\"\n Gets the default remap function.\n\n Returns\n -------\n RemapFunction\n \"\"\"\n\n return get_remap_list()[0][1]\n\n\n#######\n# general reader\n\nclass GeneralCanvasImageReader(CanvasImageReader):\n \"\"\"\n This is a general image reader of unknown type. There may be trouble\n with the image segments of unexpected type.\n \"\"\"\n\n __slots__ = ('_base_reader', '_chippers', '_index', '_data_size', '_remap_function')\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str\|AbstractReader\n The reader, or path to appropriate data file.\n \"\"\"\n\n # initialize\n self._base_reader = None\n self._chippers = None\n self._data_size = None\n self._index = None\n self._remap_function = _get_default_remap()\n # set the reader\n self.base_reader = reader\n\n @property\n def base_reader(self):\n # type: () -> AbstractReader\n \"\"\"\n AbstractReader: The reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n value = open_general(value)\n if not isinstance(value, AbstractReader):\n raise TypeError('base_reader must be of type AbstractReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self.index = 0\n\n @property\n def reader_type(self):\n \"\"\"\n str: The reader type.\n \"\"\"\n\n return self.base_reader.reader_type\n\n @property\n def index(self):\n \"\"\"\n int: The reader index.\n \"\"\"\n\n return self._index\n\n @index.setter\n def index(self, value):\n value = int(value)\n data_sizes = self.base_reader.get_data_size_as_tuple()\n if not (0 <= value < len(data_sizes)):\n logging.error(\n 'The index property must be 0 <= index < {}, '\n 'and got argument {}. Setting to 0.'.format(len(data_sizes), value))\n value = 0\n self._index = value\n self._data_size = data_sizes[value]\n\n @property\n def file_name(self):\n return None if self.base_reader is None else self.base_reader.file_name\n\n @property\n def remapable(self):\n return True\n\n @property\n def remap_function(self):\n return self._remap_function\n\n @property\n def image_count(self):\n return 0 if self._chippers is None else len(self._chippers)\n\n def get_meta_data(self):\n \"\"\"\n Gets one of a varieties of metadata structure.\n\n Returns\n -------\n Any\n \"\"\"\n\n if isinstance(self.base_reader, SICDTypeReader):\n if self._index is None:\n return None\n # noinspection PyUnresolvedReferences\n return self.base_reader.get_sicds_as_tuple()[self._index]\n elif isinstance(self.base_reader, SIDDTypeReader):\n if self._index is None:\n return None\n # noinspection PyUnresolvedReferences\n return self.base_reader.get_sidds_as_tuple()[self._index]\n elif isinstance(self.base_reader, CPHDTypeReader):\n # noinspection PyUnresolvedReferences\n return self.base_reader.cphd_meta\n elif isinstance(self.base_reader, CRSDTypeReader):\n # noinspection PyUnresolvedReferences\n return self.base_reader.crsd_meta\n return None\n\n def __getitem__(self, item):\n data = self._chippers[self.index].__getitem__(item)\n return self.remap_data(data)\n\n def __del__(self):\n # noinspection PyBroadException\n try:\n del self._chippers\n gc.collect()\n except Exception:\n pass\n\n def remap_data(self, data):\n \"\"\"\n Remap the given data according to the current remap function, unless it has\n dtype uint8.\n\n Parameters\n ----------\n data : numpy.ndarray\n\n Returns\n -------\n numpy.ndarray\n \"\"\"\n\n if self._remap_function is None or data.dtype.name == 'uint8':\n return data\n return self._remap_function(data)\n\n def set_remap_type(self, remap_type):\n if callable(remap_type):\n self._remap_function = remap_type\n elif isinstance(remap_type, str):\n self._remap_function = get_registered_remap(remap_type, _get_default_remap())\n else:\n default_remap = _get_default_remap()\n logging.error(\n 'Got unexpected value for remap `{}`, using `{}`'.format(remap_type, default_remap.name))\n self._remap_function = default_remap\n\n\n########\n# general complex type reader structure - really just sets the remap\n\nclass ComplexCanvasImageReader(GeneralCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str\|AbstractReader\n The complex valued reader, or path to appropriate data file.\n \"\"\"\n\n self._remap_function = _get_default_remap()\n GeneralCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> AbstractReader\n \"\"\"\n AbstractReader: The complex-valued reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n\n # try to open as sicd type\n try:\n reader = open_complex(value)\n except SarpyIOError:\n pass\n\n # try to open as phase_history\n if reader is None:\n try:\n reader = open_phase_history(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n try:\n reader = open_received(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a one of the complex type readers'.format(value))\n value = reader\n elif isinstance(value, (tuple, list)):\n value = AggregateComplexReader(value)\n\n if not isinstance(value, AbstractReader):\n raise TypeError('base_reader must be of type AbstractReader, got type {}'.format(type(value)))\n if value.reader_type not in [\"SICD\", \"CPHD\", \"CRSD\"]:\n raise SarpyIOError(\n 'base_reader.reader_type must be \"SICD\", \"CPHD\", or \"CRSD\", got {}'.format(value.reader_type))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n\n########\n# SICD specific type readers\n\nclass SICDTypeCanvasImageReader(ComplexCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str\|SICDTypeReader\n The sicd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> SICDTypeReader\n \"\"\"\n SICDTypeReader: The complex-valued reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n try:\n reader = open_complex(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a SICD type reader'.format(value))\n value = reader\n elif isinstance(value, (tuple, list)):\n value = AggregateComplexReader(value)\n\n if not isinstance(value, SICDTypeReader):\n raise TypeError('base_reader must be a SICDTypeReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_sicd(self):\n \"\"\"\n Gets the relevant SICD structure.\n\n Returns\n -------\n None\|SICDType\n \"\"\"\n\n if self._index is None:\n return None\n return self.base_reader.get_sicds_as_tuple()[self._index]\n\n def transform_coordinates(self, image_coordinates):\n sicd = self.get_sicd()\n if sicd is None:\n return None, 'NONE'\n\n return sicd.project_image_to_ground_geo(image_coordinates, projection_type='HAE'), 'LLH_HAE'\n\n\nclass QuadPolCanvasImageReader(ComplexCanvasImageReader):\n __slots__ = (\n '_base_reader', '_chippers', '_sicd_partitions', '_index', '_index_ordering',\n '_data_size', '_remap_function')\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str\|SICDTypeReader\n The sicd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> SICDTypeReader\n \"\"\"\n SICDTypeReader: The complex-valued reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n value = open_complex(value)\n elif isinstance(value, (list, tuple)):\n value = AggregateComplexReader(value)\n if not isinstance(value, SICDTypeReader):\n raise TypeError('Requires that the input is a sicd type reader object. Got type {}'.format(type(value)))\n\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._sicd_partitions = value.get_sicd_partitions()\n try:\n self.index = 0\n except ValueError:\n # the index will be uninitialized\n pass\n\n @property\n def sicd_partition(self):\n \"\"\"\n Tuple[Tuple[int]]: The partitioning of the reader indices into matching components.\n \"\"\"\n\n return self._sicd_partitions\n\n @property\n def index(self):\n \"\"\"\n int: the SICD partition index.\n \"\"\"\n\n return self._index\n\n @index.setter\n def index(self, value):\n if self._sicd_partitions is None:\n return\n\n value = int(value)\n if not (0 <= value < len(self.sicd_partition)):\n raise ValueError('index must be on the range 0 <= index < {}'.format(len(self.sicd_partition)))\n indices = self.sicd_partition[value]\n # determine appropriate ordering for index collection\n data_sizes = self.base_reader.get_data_size_as_tuple()\n data_size = data_sizes[indices[0]]\n for entry in indices:\n if data_sizes[entry] != data_size:\n raise ValueError(\n 'All entries of sicd partition {} do not yield sicd elements of '\n 'the same row/column size.'.format(value))\n self._index = value\n self._data_size = data_size\n self._order_indices(value, indices)\n\n def _order_indices(self, index, indices):\n \"\"\"\n Determine the appropriate ordering for indices.\n\n Parameters\n ----------\n index : int\n indices : Tuple[int]\n\n Returns\n -------\n None\n \"\"\"\n\n def revert():\n self._index = None\n self._index_ordering = None\n self._data_size = None\n\n if len(indices) == 1:\n self._index_ordering = indices\n return\n\n sicds = self.base_reader.get_sicds_as_tuple()\n our_sicds = [sicds[entry] for entry in indices] # type: List[SICDType]\n pols = [entry.ImageFormation.TxRcvPolarizationProc for entry in our_sicds]\n if len(indices) == 2:\n pols_set = set(pols)\n if len(pols_set) != 2:\n ordered_indices = None\n else:\n ordered_indices = None\n for desired_order in [['CV', 'CH'], ['VV', 'HH']]:\n if pols_set == set(desired_order):\n ordered_indices = [pols.index(entry) for entry in desired_order]\n break\n elif len(indices) == 4:\n pols_set = set(pols)\n if len(pols_set) != 4:\n ordered_indices = None\n else:\n ordered_indices = None\n for desired_order in [['VV', 'VH', 'HV', 'HH'], ]:\n if pols_set == set(desired_order):\n ordered_indices = [pols.index(entry) for entry in desired_order]\n break\n else:\n ordered_indices = None\n\n if ordered_indices is None:\n revert()\n raise ValueError(\n 'Got unhandled polarization states for partition {}'.format(pols, index))\n self._index_ordering = ordered_indices\n\n def __getitem__(self, item):\n def get_cdata(the_index):\n return self._chippers[the_index].__getitem__(item)\n\n if self._index_ordering is None:\n return None\n if len(self._index_ordering) == 1:\n complex_data = get_cdata(self._index_ordering[0])\n return self._remap_function(complex_data)\n\n complex_data = [get_cdata(entry) for entry in self._index_ordering]\n out_size = complex_data[0].shape\n for entry in complex_data:\n if entry.shape != out_size:\n raise ValueError('Got unexpected mismatch in sizes {} and {}'.format(entry.shape, out_size))\n data_mean = float(max(numpy.mean(numpy.abs(entry)) for entry in complex_data))\n rgb_image = numpy.zeros(out_size + (3, ), dtype='uint8')\n if len(self._index_ordering) == 2:\n try:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0], data_mean=data_mean)\n rgb_image[:, :, 2] = self._remap_function(complex_data[1], data_mean=data_mean)\n except Exception:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0])\n rgb_image[:, :, 2] = self._remap_function(complex_data[1])\n elif len(self._index_ordering) == 4:\n try:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0], data_mean=data_mean)\n rgb_image[:, :, 1] = self._remap_function(complex_data[1], data_mean=data_mean)/2 + \\\n self._remap_function(complex_data[2], data_mean=data_mean)/2\n rgb_image[:, :, 2] = self._remap_function(complex_data[3], data_mean=data_mean)\n except Exception:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0])\n rgb_image[:, :, 1] = self._remap_function(complex_data[1])/2 + \\\n self._remap_function(complex_data[2])/2\n rgb_image[:, :, 2] = self._remap_function(complex_data[3])\n else:\n raise ValueError('Got unhandled case for collection {}'.format(self._index_ordering))\n return rgb_image\n\n def get_sicd(self):\n \"\"\"\n Gets the relevant SICD structure.\n\n Returns\n -------\n None\|SICDType\n \"\"\"\n\n if self._index is None:\n return None\n return self.base_reader.get_sicds_as_tuple()[self._index]\n\n def transform_coordinates(self, image_coordinates):\n sicd = self.get_sicd()\n if sicd is None:\n return None, 'NONE'\n\n return sicd.project_image_to_ground_geo(image_coordinates, projection_type='HAE'), 'LLH_HAE'\n\n\n#######\n# Phase history specific type reader\n\nclass CPHDTypeCanvasImageReader(ComplexCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str\|CPHDTypeReader\n The cphd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> CPHDTypeReader\n \"\"\"\n CPHDTypeReader: The cphd reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n try:\n reader = open_phase_history(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a CPHD reader'.format(value))\n value = reader\n\n if not isinstance(value, CPHDTypeReader):\n raise TypeError('base_reader must be a CPHDReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_cphd(self):\n \"\"\"\n Gets the relevant CPHD structure.\n\n Returns\n -------\n None\|CPHDType1\|CPHDType0_3\n \"\"\"\n\n return self.base_reader.cphd_meta\n\n\n#######\n# Received data specific type reader\n\nclass CRSDTypeCanvasImageReader(ComplexCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str\|CRSDTypeReader\n The crsd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> CRSDTypeReader\n \"\"\"\n CRSDTypeReader: The crsd reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n try:\n reader = open_received(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a CRSD reader'.format(value))\n value = reader\n\n if not isinstance(value, CRSDTypeReader):\n raise TypeError('base_reader must be a CRSDReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_crsd(self):\n \"\"\"\n Gets the relevant CRSD structure.\n\n Returns\n -------\n None\|CRSDType\n \"\"\"\n\n return self.base_reader.crsd_meta\n\n\n######\n# SIDD specific type reader\n\nclass DerivedCanvasImageReader(GeneralCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str\|SIDDTypeReader\n The sidd type reader, or path to appropriate data file.\n \"\"\"\n\n GeneralCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> SIDDTypeReader\n \"\"\"\n SIDDTypeReader: The SIDD based reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n value = open_product(value)\n if not isinstance(value, SIDDTypeReader):\n raise TypeError('base_reader must be a SIDDTypeReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_sidd(self):\n \"\"\"\n Gets the relevant SIDD structure.\n\n Returns\n -------\n None\|SIDDType1\|SIDDType2\n \"\"\"\n\n if self._index is None:\n return None\n return self.base_reader.get_sidds_as_tuple()[self._index]\n\n def transform_coordinates(self, image_coordinates):\n sidd = self.get_sidd()\n if sidd is None:\n return None, 'NONE'\n\n return sidd.project_image_to_ground_geo(image_coordinates, projection_type='HAE'), 'LLH_HAE'\n" ]	[ [ "numpy.zeros", "numpy.abs" ] ]
al093/pytorch_connectomics	[ "52821951233b061102380fc0d2521843652c580a" ]	[ "torch_connectomics/utils/net/serialSampler.py" ]	[ "from collections import deque\nimport numpy as np\n\nimport torch\n\nfrom torch_connectomics.data.dataset.misc import crop_volume\nfrom torch_connectomics.data.utils.functional_collate import collate_fn_test_2, collate_fn_test\n\nclass SerialSampler():\n\n def __init__(self, dataset, batch_size, pad_size, init_seed_points, in_channel):\n self.dataset = dataset\n self.pos_queue = deque()\n self.pos_processed = deque()\n self.batch_size = batch_size\n self.pad_size = pad_size\n self.sel = np.ones((3, 3, 3), dtype=bool)\n for sp_idx in range(init_seed_points.shape[0]):\n self.pos_queue.append(init_seed_points[sp_idx])\n if in_channel == 1:\n self.need_past_pred = False\n else:\n self.need_past_pred = True\n\n def set_out_array(self, segmentation):\n self.seg = segmentation\n self.seg_shape = segmentation.shape\n\n def compute_new_pos(self, mask, edge_pos, pos):\n # mask_eroded = binary_erosion(mask, structure=self.sel).astype(bool)\n # mask[mask_eroded] = 0\n\n print(\"Num Prospective Positions: \", edge_pos.shape[0])\n for new_pos_id in range(edge_pos.shape[0]):\n new_pos = edge_pos[new_pos_id]\n\n is_edge = False\n if np.all(new_pos == self.dataset.sample_input_size - 1):\n is_edge = True\n\n new_pos += pos # now point is wrt to the origin of the entire padded input vol\n\n # print('----------------For position: ', new_pos)\n # check if the new_pos is already inside the fov of some pos in the queue\n already_covered = False\n for old_pos in reversed(self.pos_queue):\n if np.all(np.abs(new_pos - old_pos, dtype=np.int32) < (self.dataset.half_input_sz // 6)):\n already_covered = True\n # print('A point exists in the NON Processed Queue')\n break\n if not already_covered: # check in the processed queue\n for old_pos in reversed(self.pos_processed):\n if np.all(np.abs(new_pos - old_pos, dtype=np.int32) < (self.dataset.half_input_sz // 6)):\n already_covered = True\n # print('A point exists in the Processed Queue')\n break\n\n if not already_covered:\n # check if the new pos is inside the unpadded region\n if np.all(new_pos >= self.pad_size) and np.all(new_pos < (self.seg_shape - self.pad_size)):\n # print('Is outside padded region.')\n\n # check if the new pos has some neighbouring pixels which are not marked as object?\n # if not then it may be a voxel inside the segmentation\n if (not np.all(self.seg[new_pos[0]-7:new_pos[0]+8,\n new_pos[1]-7:new_pos[1]+8,\n new_pos[2]-7:new_pos[2]+8])) \\\n or is_edge:\n\n # Pos is the center around which the input should be sampled\n self.pos_queue.append(new_pos)\n # print('Position Added')\n # else:\n # print('All points in the surrounding are 1')\n # else:\n # print('Pos inside the padded region')\n print('..Done')\n def get_input_data(self):\n input_batch = []\n pos_batch = []\n past_pred_batch = []\n\n if len(self.pos_queue) > self.batch_size:\n num_data_points = self.batch_size\n else:\n num_data_points = len(self.pos_queue)\n\n for _ in range(num_data_points):\n pos = np.array([0, 0, 0, 0], dtype=np.uint32)\n pos[1:] = self.pos_queue.pop()\n self.pos_processed.append(pos[1:].copy()) # add pos into the processed queue\n pos[1:] = pos[1:] - self.dataset.half_input_sz # since pos was the center shifting it to origin of sampling volume\n # print('Position: ', pos)\n input_batch.append(self.dataset.get_vol(pos))\n pos_batch.append(pos)\n if self.need_past_pred:\n past_pred_cpu = crop_volume(self.seg, self.dataset.sample_input_size, pos[1:])\n past_pred_batch.append((torch.from_numpy(past_pred_cpu.copy().astype(np.float32))).unsqueeze(0))\n return collate_fn_test_2(zip(pos_batch, input_batch, past_pred_batch))\n else:\n return collate_fn_test(zip(pos_batch, input_batch))\n\n def remaining_pos(self):\n return len(self.pos_queue)" ]	[ [ "numpy.all", "numpy.array", "numpy.abs", "numpy.ones" ] ]
democheng/PythonRobotics	[ "0734c14ab7cd6daf9be307693b674e20a676bebb", "0734c14ab7cd6daf9be307693b674e20a676bebb" ]	[ "Localization/legacy/KalmanFilterAnimation.py", "Localization/histogramfilter_robot.py" ]	[ "import sys\nimport math\nimport numpy as np\nfrom scipy.stats import norm\nimport matplotlib.pyplot as plt\nimport mpl_toolkits.mplot3d.axes3d as p3\nfrom matplotlib.animation import FuncAnimation\n\ndef gaussian(x, mu, sig):\n return norm.pdf(x, mu, sig)\n\ndef gaussian_histogram(bin_num, mu, sig):\n sig3 = 3.0 * sig\n step = 2.0 * sig3 / bin_num\n x = np.arange(mu - sig3, mu + sig3 + step, step)\n y = gaussian(x, mu, sig)\n data = np.zeros((2, len(x)))\n data[0, :] = x\n data[1, :] = y\n return data\n\ndef gaussian_entropy(mu, var):\n sig = np.sqrt(var)\n entropy = np.log(sig * np.sqrt(2 * np.pi * np.e))\n return np.array([[mu],[entropy]])\n\ndef gaussian_update(mu0, var0, mu1, var1):\n mu = (mu0 * var1 + mu1 * var0) / (var0 + var1)\n std = 1.0 / (1.0 / var0 + 1.0 / var1)\n return mu, std\n\ndef gaussin_predict(mu0, var0, mu1, var1):\n mu = mu0 + mu1\n var = var0 + var1\n return mu, var\n\ndef draw_one_door(cur_pos):\n w = 1.0\n left_down_x = cur_pos - w\n left_down_y = 1.5\n left_up_x = left_down_x\n left_up_y = 1.5 + 0.3\n right_up_x = cur_pos + w\n right_up_y = left_up_y\n right_down_x = right_up_x\n right_down_y = left_down_y\n return np.array([[left_down_x, left_up_x, right_up_x, right_down_x], \n [left_down_y, left_up_y, right_up_y, right_down_y]])\n\ndef draw_robot(cur_pos):\n p0_x = cur_pos\n p0_y = 1.5\n p1_x = cur_pos\n p1_y = 1.5 + 0.15\n p2_x = cur_pos - 0.1\n p2_y = 1.5 + 0.15\n p3_x = cur_pos\n p3_y = 1.5 + 0.25\n p4_x = cur_pos + 0.1\n p4_y = 1.5 + 0.15\n p5_x = p1_x\n p5_y = p1_y\n return np.array([[p0_x, p1_x, p2_x, p3_x, p4_x, p5_x], \n [p0_y, p1_y, p2_y, p3_y, p4_y, p5_y]])\n\n\nclass update_prob(object):\n def __init__(self, ax, trajectory, doors, total_length, doors_geometry, robot_geometry, robot_pos_entropy):\n # The first is for robot, the second is for the doors\n self.lines = [ax.plot([], [], color='b')[0], # robot_pos_prob\n ax.plot([], [], color='g')[0], # door_pos_prob\n ax.plot([], [], color='black')[0], # road\n ax.plot([], [], color='black')[0], # doors\n ax.plot([], [], color='r')[0], \n ax.plot([], [], color='gray')[0]] # robot entropy\n self.ax = ax\n self.ax.grid(True)\n self.trajectory = trajectory\n self.total_length = total_length\n self.doors = doors[0]\n for door in doors[1:]:\n self.doors = np.concatenate((self.doors, door), axis=1)\n self.doors_geometry = doors_geometry[0]\n for door in doors_geometry[1:]:\n self.doors_geometry = np.concatenate((self.doors_geometry, door), axis=1)\n self.robot_geometry = robot_geometry\n \n self.robot_pos_entropy = robot_pos_entropy[0]\n for entropy in robot_pos_entropy[1:]:\n self.robot_pos_entropy = np.concatenate((self.robot_pos_entropy, entropy), axis=1)\n self.robot_pos_entropy[1,:] -= self.robot_pos_entropy[1,np.argmax(self.robot_pos_entropy[1,:])]\n ## Setting the axes properties\n ax.set_xlim([-0, 50])\n ax.set_xlabel('X')\n ax.set_ylim([-1.5, 3.5])\n ax.set_ylabel('Y')\n ax.set_title('kalman filter')\n\n def init(self):\n for line in self.lines:\n line.set_data([], [])\n return self.lines\n\n def __call__(self, i):\n # This way the plot can continuously run and we just keep\n # watching new realizations of the process\n self.lines[0].set_data(self.trajectory[i])\n self.lines[1].set_data(self.doors)\n self.lines[2].set_data([0, self.total_length], [1.5, 1.5])\n self.lines[3].set_data(self.doors_geometry)\n self.lines[4].set_data(self.robot_geometry[i])\n self.lines[5].set_data(self.robot_pos_entropy[0, 0:i], self.robot_pos_entropy[1, 0:i])\n return self.lines\n\ndef main():\n smp_num = 100\n door_positions = np.array([5.0, 10.0, 15.0, 25.0, 40.0])\n door_stds = np.array([0.5, 0.5, 0.5, 0.5, 0.5])\n door_vars = door_stds ** 2\n doors = []\n doors_geometry = []\n for mu, std in zip(door_positions, door_stds):\n doors.append(gaussian_histogram(smp_num, mu, std))\n doors_geometry.append(draw_one_door(mu))\n step_num = 100\n step_length = 0.5\n step_var = 0.04\n\n total_length = step_num * step_length\n\n cur_pos = 0.0\n cur_var = 0.09\n\n robot_trajectory = []\n robot_geometry = []\n robot_pos_entropy = []\n for step in range(step_num):\n # do measure, update\n for door_pos, door_var in zip(door_positions, door_vars):\n if np.abs(cur_pos - door_pos) < 0.01:\n cur_pos, cur_var = gaussian_update(cur_pos, cur_var, door_pos, door_var)\n robot_pos_entropy.append(gaussian_entropy(cur_pos, cur_var))\n robot_trajectory.append(gaussian_histogram(smp_num, cur_pos, cur_var))\n robot_geometry.append(draw_robot(cur_pos))\n # do move, predict\n cur_pos, cur_var = gaussin_predict(cur_pos, cur_var, step_length, step_var)\n robot_pos_entropy.append(gaussian_entropy(cur_pos, cur_var))\n robot_trajectory.append(gaussian_histogram(smp_num, cur_pos, cur_var))\n robot_geometry.append(draw_robot(cur_pos))\n # more specifical geometry\n # print(robot_trajectory)\n # First set up the figure, the axis, and the plot element we want to animate\n fig = plt.figure()\n ax = plt.axes(xlim=(0, 2), ylim=(0, 20))\n\n up = update_prob(ax, robot_trajectory, doors, total_length, doors_geometry, robot_geometry, robot_pos_entropy)\n # call the animator. blit=True means only re-draw the parts that have changed.\n anim = FuncAnimation(fig, up, frames=len(robot_trajectory), interval=200, blit=True)\n # anim.save('kalmanfilter.gif', dpi=80, writer='imagemagick')\n plt.show()\n\nif __name__ == '__main__':\n main()", "import sys\nimport math\nimport copy\nimport numpy as np\nfrom scipy.stats import norm\nfrom scipy.ndimage import gaussian_filter1d\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.animation import FuncAnimation\n\nclass grid_map():\n def __init__(self, minx, maxx, resolution):\n self.minx = minx\n self.maxx = maxx\n self.resolution = resolution\n self.widthx = int(round((self.maxx - self.minx) / self.resolution))\n self.probability = np.ones(self.widthx) * (1.0 / self.widthx)\n \n def init(self):\n self.minx = 0.0\n self.maxx = 2.5\n self.resolution = 0.5\n self.widthx = int(round((self.maxx - self.minx) / self.resolution))\n self.probability = np.ones(self.widthx) * (1.0 / self.widthx)\n \n def print(self):\n print('[minx, max] = [', self.minx, ',', self.maxx, ']')\n print('resolution = ', self.resolution)\n print('widthx = ', self.widthx)\n print('probability = ', self.probability)\n\n def normalize_probability(self):\n self.probability /= np.sum(self.probability)\n \n def current_position(self):\n position = 0.0\n for i in range(self.widthx):\n cur_pos = self.minx + i * self.resolution\n position += cur_pos * self.probability[i]\n return position\n \n def motion_predict(self, move_length, motion_noise):\n step = round(move_length / self.resolution) * self.resolution\n self.minx += step\n self.maxx += step\n print('before:', self.probability)\n self.probability = gaussian_filter1d(self.probability, motion_noise)\n print('after:', self.probability)\n # there is no need for total probability, I do this just for security\n self.normalize_probability()\n return self.current_position()\n \n def measurement_update(self, min_distance, map_data, measurement_noise):\n # min_distance has been added some noise\n for i in range(self.widthx): # loop all the estimated positions\n cur_pos = self.minx + i * self.resolution\n min_dis = 1e3\n for j in range(len(map_data)):\n delta = np.abs(cur_pos - map_data[j])\n if delta < min_dis:\n min_dis = delta\n # likelihood\n pdf = 1.0 - norm.cdf(np.abs(min_dis - min_distance), 0.0, measurement_noise)\n self.probability[i] = pdf\n self.normalize_probability()\n return self.current_position()\n\nclass hfrobot(object):\n def __init__(self, \n start_position, \n end_position, \n velocity, \n motion_noise, \n measurement_noise, \n sensor_range,\n map_data, \n grid_map):\n self.start_position = start_position # m\n self.end_position = end_position # m\n self.velocity = velocity # m/s\n\n self.groundtruth = start_position\n\n self.motion_noise = motion_noise\n self.measurement_noise = measurement_noise\n\n self.sensor_range = sensor_range\n self.map = map_data\n\n self.grid_map = copy.deepcopy(grid_map)\n self.position = self.grid_map.current_position()\n \n def init(self):\n self.position = 0.0\n self.start_position = 0.0\n self.end_position = 0.0\n self.groundtruth = 0.0\n\n self.velocity = 0.0\n\n self.motion_noise = 0.0\n self.measurement_noise = 0.0\n \n self.sensor_range = 0.0\n self.map = np.array([0.0])\n\n self.grid_map = copy.deepcopy(grid_map(0.0, 10.0, 1.0))\n \n def motion(self):\n self.groundtruth += self.velocity 1.0\n \n def motion_predict(self):\n self.motion()\n # print('motion_predict:current position', self.position)\n # print('motion_predict:groundtruth', self.groundtruth)\n move_length = self.velocity * 1.0 + np.random.randn() * self.motion_noise\n self.position = self.grid_map.motion_predict(move_length, self.motion_noise)\n \n def measurement(self):\n # find what the robot senses\n min_distance = 1e3\n min_door = 1e3\n ret = False\n for item in self.map:\n delta = np.abs(item - self.groundtruth)\n if delta <= self.sensor_range and delta < min_distance:\n ret = True\n min_distance = delta\n min_door = item\n return ret, min_distance, min_door\n \n def measurement_update(self):\n ret, min_distance, _ = self.measurement()\n if ret:\n print('measurement success')\n min_distance += np.random.randn() * self.measurement_noise\n self.position = self.grid_map.measurement_update(min_distance, self.map, self.measurement_noise)\n return ret\n\ndef draw_robot(cur_pos, road_line):\n p0_x = cur_pos\n p0_y = road_line\n p1_x = cur_pos\n p1_y = road_line + 0.15\n p2_x = cur_pos - 0.1\n p2_y = road_line + 0.15\n p3_x = cur_pos\n p3_y = road_line + 0.25\n p4_x = cur_pos + 0.1\n p4_y = road_line + 0.15\n p5_x = p1_x\n p5_y = p1_y\n return np.array([[p0_x, p1_x, p2_x, p3_x, p4_x, p5_x], \n [p0_y, p1_y, p2_y, p3_y, p4_y, p5_y]])\n\ndef draw_gaussian(bin_num, mu, sig):\n sig3 = 3.0 * sig\n step = 2.0 * sig3 / bin_num\n x = np.arange(mu - sig3, mu + sig3 + step, step)\n y = norm.pdf(x, mu, sig)\n data = np.zeros((2, len(x)))\n data[0, :] = x\n data[1, :] = y\n return data\n\ndef draw_robot_groundtruths(robot_groundtruths, road_line):\n res = []\n for item in robot_groundtruths:\n res.append(draw_robot(item, road_line))\n return res\n\ndef draw_robot_groundtruths_with(robot_groundtruths):\n res = []\n for item in robot_groundtruths:\n res.append(np.array([[item, item], [0.0, 1.0]]))\n return res\n\ndef draw_robot_positions(robot_positions_with_noise, road_line):\n res = []\n for item in robot_positions_with_noise:\n res.append(draw_robot(item[0], road_line))\n return res\n\ndef histogram_entropy(grid_map):\n min_prob = 1e-9\n res = 0.0\n for item in grid_map.probability:\n if item > min_prob:\n res += item * np.log(item)\n return -res\n\ndef draw_robot_entropy(robot_groundtruths, robot_positions_with_noise):\n res = np.zeros((2, len(robot_groundtruths)))\n for idx in range(res.shape[1]):\n res[0, idx] = robot_groundtruths[idx]\n item = copy.deepcopy(robot_positions_with_noise[idx])\n res[1, idx] = histogram_entropy(item[1])\n return res\n\ndef draw_robot_grid_map(grid_map):\n res = np.zeros((2, 4 * grid_map.widthx))\n index = 0\n for i in range(grid_map.widthx):\n x = grid_map.minx + i * grid_map.resolution\n y = 0\n res[0, index] = x\n res[1, index] = y\n index += 1\n\n res[0, index] = x\n res[1, index] = y + grid_map.probability[i]\n index += 1\n\n res[0, index] = x + grid_map.resolution\n res[1, index] = y + grid_map.probability[i]\n index += 1\n\n res[0, index] = x + grid_map.resolution\n res[1, index] = y\n index += 1\n return res\n\ndef draw_robot_positions_with_noise(robot_positions_with_noise):\n res = []\n for item in robot_positions_with_noise:\n res.append(draw_robot_grid_map(item[1]))\n return res\n\ndef draw_door(cur_pos, road_line):\n w = 1.0\n h = 0.3\n left_down_x = cur_pos - w\n left_down_y = road_line\n left_up_x = left_down_x\n left_up_y = road_line + h\n right_up_x = cur_pos + w\n right_up_y = left_up_y\n right_down_x = right_up_x\n right_down_y = left_down_y\n return np.array([[left_down_x, left_up_x, right_up_x, right_down_x], \n [left_down_y, left_up_y, right_up_y, right_down_y]])\n\ndef draw_doors(doors, road_line):\n res = draw_door(doors[0], road_line)\n for item in doors[1:]:\n res = np.concatenate((res, draw_door(item, road_line)), axis=1)\n return res\n\ndef draw_doors_with_noise(doors, measurement_noise):\n bin_num = 50\n res = draw_gaussian(bin_num, doors[0], measurement_noise)\n for item in doors[1:]:\n res = np.concatenate((res, draw_gaussian(bin_num, item, measurement_noise)), axis=1)\n return res\n\ndef draw_road_line(start_position, end_position, road_line):\n return np.array([[start_position, end_position], \n [road_line, road_line]])\n\nclass update_draw(object):\n def __init__(self, ax, \n start_position, end_position,\n groundtruth, groundtruth_with, positions, doors, road_line,\n positions_with_noise, doors_with_noise, entropy):\n self.groundtruth = groundtruth\n self.groundtruth_with = groundtruth_with\n self.positions = positions\n self.doors = doors\n self.road_line = road_line\n self.positions_with_noise = positions_with_noise\n self.doors_with_noise = doors_with_noise\n self.entropy = entropy\n\n ## Setting the axes properties\n ax.set_xlim([start_position, end_position])\n ax.set_xlabel('X')\n ax.set_ylim([0, self.road_line[1, 0] * 2])\n ax.set_ylabel('Y')\n ax.set_title('kalman filter')\n\n self.lines = [ax.plot([], [], color='b')[0], # groundtruth\n ax.plot([], [], color='b')[0], # groundtruth_with\n ax.plot([], [], color='g')[0], # positions\n ax.plot([], [], color='black')[0], # doors\n ax.plot([], [], color='black')[0], # road_line\n ax.plot([], [], color='g')[0], # positions_with_noise\n ax.plot([], [], color='black')[0], # doors_with_noise\n ax.plot([], [], color='gray')[0]] # entropy\n ax.legend((self.lines[0], self.lines[2], self.lines[3], self.lines[7]), \n ('groundtruth', 'positions with uncertainty', 'doors', 'entropy'))\n \n def init(self):\n for line in self.lines:\n line.set_data([], [])\n return self.lines\n \n def __call__(self, i):\n # This way the plot can continuously run and we just keep\n # watching new realizations of the process\n self.lines[0].set_data(self.groundtruth[i])\n self.lines[1].set_data(self.groundtruth_with[i])\n self.lines[2].set_data(self.positions[i])\n self.lines[3].set_data(self.doors)\n self.lines[4].set_data(self.road_line)\n self.lines[5].set_data(self.positions_with_noise[i])\n self.lines[6].set_data(self.doors_with_noise)\n self.lines[7].set_data(self.entropy[:, :i + 1])\n return self.lines\n\ndef main():\n start_position = 0.0\n end_position = 50.0\n velocity = 0.5\n motion_noise = np.sqrt(0.1)\n measurement_noise = np.sqrt(0.5)\n sensor_range = 0.1\n doors = np.array([5.0, 10.0, 15.0, 25.0, 40.0])\n\n road_line = 1.5\n\n hf_grid_map = copy.deepcopy(grid_map(0.0, 9.5, 0.5))\n\n hf_robot = hfrobot(start_position, \n end_position, \n velocity, \n motion_noise, \n measurement_noise, \n sensor_range,\n doors,\n hf_grid_map)\n\n loop_num = int((end_position - start_position) / velocity)\n\n # dynamic\n robot_positions_with_noise = []\n robot_groundtruths = []\n # hf_robot.grid_map.print()\n robot_positions_with_noise.append(np.array([hf_robot.position, copy.deepcopy(hf_robot.grid_map) ]))\n robot_groundtruths.append(hf_robot.groundtruth)\n\n for loop in range(loop_num):\n # print(hf_robot.position)\n ret = hf_robot.measurement_update()\n if ret:\n # hf_robot.grid_map.print()\n robot_positions_with_noise.append(np.array([hf_robot.position, copy.deepcopy(hf_robot.grid_map) ]))\n robot_groundtruths.append(hf_robot.groundtruth)\n \n hf_robot.motion_predict()\n # hf_robot.grid_map.print()\n robot_positions_with_noise.append(np.array([hf_robot.position, copy.deepcopy(hf_robot.grid_map) ]))\n robot_groundtruths.append(hf_robot.groundtruth)\n \n # convert data for drawing\n d_groundtruths = draw_robot_groundtruths(robot_groundtruths, road_line)\n d_groundtruths_with = draw_robot_groundtruths_with(robot_groundtruths)\n d_robot_positions = draw_robot_positions(robot_positions_with_noise, road_line)\n d_road_line = draw_road_line(start_position, end_position, road_line)\n d_doors = draw_doors(doors, road_line)\n d_positions_with_noise = draw_robot_positions_with_noise(robot_positions_with_noise)\n d_doors_with_noise = draw_doors_with_noise(doors, measurement_noise)\n d_entropy = draw_robot_entropy(robot_groundtruths, robot_positions_with_noise)\n # draw\n fig = plt.figure()\n ax = plt.axes()\n\n ud = update_draw(ax, start_position, end_position,\n d_groundtruths, d_groundtruths_with, d_robot_positions, d_doors, d_road_line,\n d_positions_with_noise, d_doors_with_noise, d_entropy)\n # call the animator. blit=True means only re-draw the parts that have changed.\n anim = FuncAnimation(fig, ud, frames=loop_num, interval=200, blit=True)\n # anim.save('histogramfilter.gif', dpi=80, writer='imagemagick')\n plt.show()\n\nif __name__ == '__main__':\n main()" ]	[ [ "numpy.sqrt", "scipy.stats.norm.pdf", "numpy.abs", "numpy.arange", "matplotlib.pyplot.axes", "numpy.concatenate", "numpy.argmax", "numpy.array", "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ], [ "numpy.log", "numpy.sqrt", "scipy.stats.norm.pdf", "numpy.abs", "numpy.arange", "scipy.ndimage.gaussian_filter1d", "numpy.ones", "matplotlib.pyplot.axes", "numpy.random.randn", "matplotlib.animation.FuncAnimation", "numpy.array", "numpy.zeros", "numpy.sum", "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ] ]
JDE65/StockAnalysis	[ "6423e05f46fa4630d1c8a03e1630ea6e630b5a8f" ]	[ "util_model.py" ]	[ "# -- coding: utf-8 --\r\n\"\"\"\r\nCreated on Sun Aug 2 23:16:50 2020\r\n\r\nUtility functions for financial analysis to prepare X and Y matrices\r\n 1. LSTM_cleanXset(X_raw, trigger) => return X_clean\r\n 2. create_dataset(dataX, dataY, seq_length, step) => return Xs, ys as np.array\r\n 3. LSTM_train_test_size(dataX, dataY, lstmStart, lstmSize, proportionTrain, classRegr) => return (X_train, y_train), (X_test, y_test), (res_train, res_test)\r\n 4. LSTM_clean_traintest(X_train, X_test, trigger) => return X_train, X_test\r\n 5. LSTM_scaleX(X_train, X_test) => return Xs_train, Xs_test\r\n 6. => return \r\n \r\n@author: JDE65\r\n\"\"\"\r\n# ==== PART 0. Installing libraries ============\r\n\r\nimport pandas as pd\r\nimport numpy as np\r\nfrom sklearn import preprocessing\r\nfrom sklearn.preprocessing import StandardScaler\r\nfrom sklearn.metrics import confusion_matrix\r\nimport seaborn as sns\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib import rc\r\nimport tensorflow as tf\r\n\r\nimport tensorflow.keras\r\nfrom tensorflow.keras import backend as K\r\n\r\n###--- 2. Custom loss functions for training ---###\r\ndef custom_return_loss_function(y_actual, y_predicted):\r\n diff_y = K.square(y_actual- np.squeeze(y_predicted))\r\n bool_idx = K.greater(diff_y, K.square(y_actual))\r\n loss1 = tf.math.scalar_mul(2, diff_y)\r\n y_diff = K.switch(bool_idx, loss1, diff_y)\r\n #diff_y[(y_actual > 0) & (np.squeeze(y_predicted) < 0)] = 2\r\n #diff_y[(y_actual < 0) & (np.squeeze(y_predicted) > 0)] = 3\r\n #diff_y = K.constant(diff_y)\r\n custom_return_loss_value = K.mean(y_diff)\r\n return custom_return_loss_value\r\n\r\n\r\ndef custom_price_loss_function(y_actual, y_predicted): ### To be IMPROVED\r\n diff_y = np.abs(y_actual- np.squeeze(y_predicted))\r\n diff_y[(y_actual > 0) & (np.squeeze(y_predicted) < 0)] = 2\r\n diff_y[(y_actual < 0) & (np.squeeze(y_predicted) > 0)] = 3\r\n custom_price_loss_value = K.mean(diff_y)\r\n return custom_price_loss_value\r\n\r\n###--- 3. Compile model for training ---###\r\ndef model_compile_train(model, loss, optimizer, X_train, y_train, epochs, batch_size, validation_split, verbose = 0):\r\n model.compile(loss = loss, optimizer = optimizer, metrics=['accuracy'])\r\n history = model.fit(X_train, y_train, epochs = epochs, batch_size = batch_size, validation_split = validation_split, verbose = verbose)\r\n return model, history\r\n\r\n\r\n###--- 4. evaluate, predict and assess \r\ndef model_predict(model, history, X_train, y_train, X_test, y_test):\r\n eval_train = model.evaluate(X_train, y_train)\r\n eval_test = model.evaluate(X_test, y_test)\r\n y_pred = model.predict(X_test)\r\n return eval_train, eval_test, y_pred\r\n\r\n\r\n###--- 4. evaluate, predict and assess \r\n## Analysis for regression on price value\r\ndef model_eval_price(X_ref, y_test, y_pred, eval_trigger):\r\n y_testdec = (y_test - X_ref) / X_ref\r\n y_predict = (y_pred[:,0] - X_ref) / X_ref\r\n y_predict[y_predict[:,] > eval_trigger] = 1 # predicted price > close_price by expected trigger => buy\r\n y_predict[y_predict[:,] <= eval_trigger] = 0 # predicted price < close_price by expected trigger => NO buy\r\n y_testdec[y_testdec[:,] > eval_trigger] = 1 # future price > close_price by expected trigger => buy\r\n y_testdec[y_testdec[:,] <= eval_trigger] = 0\r\n confmat = confusion_matrix(y_testdec, y_predict)\r\n return y_testdec, y_predict, confmat\r\n\r\n## Analysis of classification if only very strong performance is selected\r\ndef model_eval_return(y_test, y_pred, eval_trigger, modeRC, nb_classes, trig_up = 0):\r\n y_testdec = y_test[:,0]\r\n y_predict = y_pred[:,0] * 1\r\n if (modeRC== 'class') & (nb_classes > 2):\r\n if trig_up > 0:\r\n y_testdec = y_test[:,0] + y_test[:,2]\r\n y_predict = y_pred[:,0] + y_pred[:,2]\r\n y_predict[y_predict[:,] >= eval_trigger] = 1 # predicted price > close_price by expected trigger => buy\r\n y_predict[y_predict[:,] < eval_trigger] = 0 # predicted price < close_price by expected trigger => NO buy\r\n confmat = confusion_matrix(y_testdec, y_predict)\r\n if (modeRC== 'class') & (nb_classes > 2):\r\n if trig_up > 0:\r\n y_predict[y_pred[:,2]>eval_trigger] += 1\r\n return y_testdec, y_predict, confmat\r\n\r\n## Analysis of classification if only very strong performance is selected\r\ndef model3D_eval_topreturn(y_test, y_pred, eval_trigger, modeRC, nb_classes, trig_up = 0):\r\n y_testdec = y_test[:,0]\r\n y_predict = y_pred[:,0] * 1\r\n if (modeRC== 'class') & (nb_classes > 2):\r\n if trig_up > 0:\r\n y_testdec = y_test[:,2]\r\n y_predict = y_pred[:,2]\r\n y_predict[y_predict[:,] >= eval_trigger] = 1 # predicted price > close_price by expected trigger => buy\r\n y_predict[y_predict[:,] < eval_trigger] = 0 # predicted price < close_price by expected trigger => NO buy\r\n confmat = confusion_matrix(y_testdec, y_predict)\r\n return y_testdec, y_predict, confmat\r\n\r\n###--- 5. Analyse prediction F1\r\ndef get_F1(confmat): \r\n true_neg = confmat[0,0]\r\n true_pos = confmat[1,1]\r\n false_neg = confmat[1,0]\r\n false_pos = confmat[0,1]\r\n precis = true_pos / (true_pos + false_pos)\r\n recall = true_pos / (true_pos + false_neg)\r\n F1 = 2 * precis * recall / (precis + recall)\r\n \r\n return precis, recall, F1\r\n\r\ndef model_eval_result(y_testdec, y_predict, res_test):\r\n test_result, pred_result = [], []\r\n test_res = np.multiply(y_testdec[:,], res_test[:])\r\n pred_res = np.multiply(res_test[:], y_predict[:,])\r\n test_result = test_res.sum()\r\n pred_result = pred_res.sum()\r\n bhst_result = res_test.sum()\r\n nbDeals_test = y_testdec[y_testdec == 1].sum()\r\n nbDeals_pred = y_predict[y_predict == 1].sum()\r\n nbDeals_bhst = len(y_testdec) \r\n \r\n return (nbDeals_bhst, nbDeals_test, nbDeals_pred), (bhst_result, test_result, pred_result)\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###--- 3. Cleanup X for missing values ---###\r\n\r\ndef LSTM_clean_traintest(X_train, X_test, trigger):\r\n nanc = X_train.isna().sum()\r\n for i in range(len(nanc)):\r\n ananc = nanc.iloc[i]/len(X_train)\r\n if ananc > trigger:\r\n X_train = X_train.drop(columns = i)\r\n X_test = X_test.drop(columns = i)\r\n X_train = X_train.T.reset_index(drop = True).T\r\n X_test = X_test.T.reset_index(drop = True).T\r\n return X_train, X_test\r\n\r\n\r\n\r\n\r\n\r\n###--- 5. Analyse NN efficiency\r\ndef get_stat_NN(y_train, y_test, y_pred, y_testdec) :\r\n #res_train = confusion_matrix(y_train, y_pred)\r\n res_test = confusion_matrix(y_test, y_testdec)\r\n TPt = np.sum(res_test[1:, 1:]) # + res_train[2, 2] + res_train[1, 2] + res_train[2, 1] # true positive includes exact prediction as well as event happening but sooner or later\r\n FPt = np.sum(res_test[0, 1:]) # event announced but not happening\r\n FNt = np.sum(res_test[1:, 0]) # event unannounced\r\n \r\n if ((TPt + FPt)!= 0):\r\n prect = TPt / (TPt + FPt)\r\n recallt = TPt / (TPt + FNt)\r\n F1t = 2 * prect * recallt / (prect + recallt)\r\n testAcc = (res_test[0, 0] + TPt) / np.sum(res_test)\r\n testAccDet = np.trace(res_test) / np.sum(res_test)\r\n else:\r\n prect = 0\r\n recallt = 0\r\n F1t = 0\r\n testAcc = (res_test[0, 0] + TPt) / np.sum(res_test)\r\n testAccDet = np.trace(res_test) / np.sum(res_test)\r\n\r\n return (prect, recallt, F1t), (testAcc, testAccDet)" ]	[ [ "numpy.multiply", "numpy.squeeze", "numpy.trace", "tensorflow.math.scalar_mul", "sklearn.metrics.confusion_matrix", "tensorflow.keras.backend.square", "tensorflow.keras.backend.mean", "tensorflow.keras.backend.switch", "numpy.sum" ] ]
JohnlNguyen/FLSim	[ "a5ed7c0b84499cd9dbc5fe95f8bcb4ba8ab5a5cb" ]	[ "flsim/privacy/tests/test_user_update_clipper.py" ]	[ "#!/usr/bin/env python3\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under the BSD-style license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport pytest\nimport torch\nfrom flsim.common.pytest_helper import (\n assertAlmostEqual,\n assertTrue,\n assertEqual,\n assertFalse,\n)\nfrom flsim.privacy.user_update_clip import UserUpdateClipper\nfrom flsim.tests import utils\n\n\[email protected](scope=\"class\")\ndef prepare_user_update_clipper_test(request) -> None:\n request.cls.user_update_clipper = UserUpdateClipper()\n\n def _init_user_model(param_value):\n user_model = utils.TwoFC()\n user_model.fill_all(param_value) # fill all parameters with a number\n return user_model\n\n request.cls.previous_user_model = _init_user_model(param_value=6.0)\n request.cls.updated_user_model = _init_user_model(param_value=7.0)\n request.cls.original_model_diff = request.cls.user_update_clipper.calc_model_diff(\n request.cls.updated_user_model, request.cls.previous_user_model\n )\n request.cls.original_model_diff_params = [\n p for p in request.cls.original_model_diff.parameters() if p.requires_grad\n ]\n\n\[email protected](\"prepare_user_update_clipper_test\")\nclass TestUserUpdateClipper:\n def _init_clipped_model_diff(self, max_norm):\n clipped_model_diff = utils.TwoFC()\n clipped_model_diff.load_state_dict(self.original_model_diff.state_dict())\n\n self.user_update_clipper.clip(clipped_model_diff, max_norm)\n return clipped_model_diff\n\n def test_calc_clip_factor(self) -> None:\n \"\"\"\n Tests that the clip factor for user updates is calculated correctly.\n \"\"\"\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `user_update_clipper`.\n clip_factor = self.user_update_clipper._calc_clip_factor(\n max_norm=5, per_user_norm=10\n )\n assertAlmostEqual(clip_factor, 0.5, places=3)\n\n clip_factor = self.user_update_clipper._calc_clip_factor(\n max_norm=1, per_user_norm=1\n )\n assertAlmostEqual(clip_factor, 1, places=3)\n\n clip_factor = self.user_update_clipper._calc_clip_factor(\n max_norm=2, per_user_norm=0.8\n )\n assertAlmostEqual(clip_factor, 1, places=3)\n\n def test_calc_user_update_norm(self) -> None:\n \"\"\"\n Tests that the user update l-2 norms are calculated correctly.\n \"\"\"\n model = utils.TwoFC()\n model.fill_all(2.0)\n model_params = model.parameters()\n # norm = sqrt(212^2)=sqrt(84)=9.16515138991168\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `user_update_clipper`.\n norm = self.user_update_clipper._calc_norm(model_params)\n assertTrue(torch.allclose(norm, torch.tensor(9.16515138991168), rtol=1e-06))\n\n model.fill_all(1.0)\n model_params = model.parameters()\n # norm = sqrt(211^2)=sqrt(21)=4.58257569495584\n norm = self.user_update_clipper._calc_norm(model_params)\n assertTrue(torch.allclose(norm, torch.tensor(4.58257569495584), rtol=1e-06))\n\n def test_clipped_updates_are_smaller(self) -> None:\n \"\"\"\n Tests that user updates are clipped and their value is smaller than\n the original updates\n \"\"\"\n\n # assert the parameters of model_diff are all = (7 - 6 = 1)\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `original_model_diff_params`.\n for p in self.original_model_diff_params:\n assertTrue(torch.allclose(p.float(), torch.tensor(1.0)))\n\n clipped_model_diff = self._init_clipped_model_diff(0.0003)\n clipped_model_diff_params = [\n p for p in clipped_model_diff.parameters() if p.requires_grad\n ]\n for original, clipped in zip(\n self.original_model_diff_params, clipped_model_diff_params\n ):\n assertTrue(torch.all(original.gt(clipped)))\n\n def test_clipped_user_updates_non_zero(self) -> None:\n \"\"\"\n Tests that user updates are not zero by clipping\n \"\"\"\n clipped_model_diff = self._init_clipped_model_diff(0.0003)\n clipped_model_diff_params = [\n p for p in clipped_model_diff.parameters() if p.requires_grad\n ]\n for clipped in clipped_model_diff_params:\n allzeros = torch.zeros_like(clipped)\n assertFalse(torch.allclose(clipped, allzeros))\n\n def test_clipping_to_high_value_does_not_clip(self) -> None:\n \"\"\"\n Tests that when clip value is set too high, user\n updates are not clipped\n \"\"\"\n clipped_model_diff = self._init_clipped_model_diff(9999)\n mismatched = utils.verify_models_equivalent_after_training(\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `original_model_diff`.\n self.original_model_diff,\n clipped_model_diff,\n )\n assertEqual(mismatched, \"\")\n" ]	[ [ "torch.allclose", "torch.zeros_like", "torch.tensor" ] ]
KhronosGroup/NNEF-Tools	[ "0295fdedddcb316afd9c8092934c62ca84b39439" ]	[ "nnef_tools/conversion/tflite_to_nnef.py" ]	[ "# Copyright (c) 2020 The Khronos Group Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom __future__ import division, print_function, absolute_import\nfrom .converter import Converter as _Converter, Transform, ConversionError\nfrom .tf_to_nnef import Converter as _TFConverter, _Transforms as _TFTransforms, _RELU6_FRAGMENT\nfrom ..model import Tensor, Operation\nfrom ..utils import types\nfrom ..io.tf.lite import CustomOptionsKey\nimport numpy as np\nimport copy\n\n\n_DETECTION_POSTPROCESS_FRAGMENT = \"\"\"\nfragment TFLite_Detection_PostProcess( \n boxes: tensor<scalar>, \n scores: tensor<scalar>, \n anchors: tensor<scalar>, \n detections_per_class: integer,\n max_classes_per_detection: integer,\n max_detections: integer, \n nms_iou_threshold: scalar, \n nms_score_threshold: scalar, \n num_classes: integer, \n use_regular_nms: logical, \n h_scale: scalar,\n w_scale: scalar, \n x_scale: scalar, \n y_scale: scalar ) \n-> ( \n detection_boxes: tensor<scalar>, \n detection_classes: tensor<scalar>, \n detection_scores: tensor<scalar>, \n num_detections: tensor<scalar> );\n\"\"\"\n\n\nclass Converter(_TFConverter):\n\n _ConvOpTypes = ['CONV_1D', 'CONV_2D', 'CONV_3D', 'TRANSPOSE_CONV', 'DEPTHWISE_CONV_2D']\n\n _ActivationOpTypes = {\n 'ELU': 'elu',\n 'RELU': 'relu',\n 'RELU6': 'relu6',\n 'LOGISTIC': 'sigmoid',\n 'TANH': 'tanh',\n }\n\n @staticmethod\n def defined_operations():\n return {\n 'relu6': _RELU6_FRAGMENT,\n 'TFLite_Detection_PostProcess': _DETECTION_POSTPROCESS_FRAGMENT,\n }\n\n def __init__(self, io_transpose=False, custom_transforms=None, custom_functions=None,\n mirror_unsupported=False, keep_io_names=False):\n _Converter.__init__(self, transforms=self.merge_transforms(_Transforms, custom_transforms),\n functions=custom_functions, mirror_unsupported=mirror_unsupported)\n self._io_transpose = io_transpose\n self._keep_io_names = keep_io_names\n\n def __call__(self, graph):\n graph = _TFConverter.__call__(self, graph)\n self._fix_custom_options(graph)\n return graph\n\n def _global_attribs(self):\n return {'_lite_': True}\n\n def _prepare(self, graph):\n self._fix_quantization_attribs(graph)\n self._fix_quantized_dtypes(graph)\n self._insert_externals_and_constants(graph)\n self._transpose_externals(graph)\n\n def _is_constant(self, tensor):\n return tensor.producer is None and tensor.data is not None\n\n def _read_constant(self, tensor, type=None):\n if tensor.producer is None:\n return types.from_numpy(tensor.data, type=type)\n else:\n raise ConversionError('trying to evaluate non-constant tensor')\n\n def _transpose_externals(self, graph):\n for op in graph.operations:\n if op.type == 'external':\n if self.needs_io_transpose(op.output):\n shape = self.nxc_to_ncx(op.output.shape)\n op.attribs['shape'] = list(shape)\n self._transposes[op.output] = shape\n\n def _fix_quantized_dtypes(self, graph):\n for tensor in graph.tensors:\n if tensor.quant:\n scale = tensor.quant.get('scale')\n if scale:\n tensor.dtype = np.float32\n else:\n tensor.quant = None\n\n def _fix_quantization_attribs(self, graph):\n for tensor in graph.tensors:\n if tensor.quant and tensor.quant.get('scale'):\n if 'min' in tensor.quant:\n del tensor.quant['min']\n if 'max' in tensor.quant:\n del tensor.quant['max']\n tensor.quant['op-name'] = 'zero_point_linear_quantize'\n tensor.quant['bits'] = 32 if self._is_conv_bias(tensor) else 8\n assert tensor.dtype == np.uint8 or tensor.dtype == np.int8 or \\\n tensor.dtype == np.uint32 or tensor.dtype == np.int32, \\\n \"unknown quantized dtype '{}'\".format(tensor.dtype)\n tensor.quant['signed'] = tensor.dtype == np.int8 or tensor.dtype == np.int32\n tensor.quant['symmetric'] = self._is_conv_filter(tensor)\n\n def _fix_custom_options(self, graph):\n for op in graph.operations:\n if op.custom:\n options = op.attribs.get(CustomOptionsKey)\n if options is not None:\n op.attribs[CustomOptionsKey] = options.hex()\n\n def _is_conv_filter(self, tensor):\n tensor = self._tensor_map.get(tensor)\n return tensor and len(tensor.consumers) > 0 and \\\n all(op.type in Converter._ConvOpTypes and op.inputs[1] is tensor for op in tensor.consumers)\n\n def _is_conv_bias(self, tensor):\n tensor = self._tensor_map.get(tensor)\n return tensor and len(tensor.consumers) > 0 and \\\n all(op.type in Converter._ConvOpTypes and op.inputs[2] is tensor for op in tensor.consumers)\n\n def activation(self, output, func):\n if func is None or func == 'NONE':\n return output\n\n if func not in self._ActivationOpTypes:\n raise ConversionError(\"Unsupported fused activation function '{}'\".format(func))\n\n input = Tensor(output.graph, dtype=output.dtype, shape=self._working_shape(output), quant=copy.deepcopy(output.quant))\n Operation(output.graph, type=self._ActivationOpTypes[func], inputs=input, outputs=output)\n return input\n\n def flat_list(self, array):\n return [item for items in array for item in items] if len(array) and isinstance(array[0], (list, tuple)) else array\n\n def flatten(self, input):\n shape = (input.shape[0], int(np.prod(input.shape[1:])))\n output = Tensor(input.graph, dtype=input.dtype, shape=shape, quant=copy.deepcopy(input.quant))\n self._reshape_operation(input, output, shape)\n return output\n\n def same_shape(self, input, output):\n return self._tensor_map[input].shape == self._tensor_map[output].shape\n\n\n_Transforms = Converter.unpack_transforms({\n ('CONV_1D', 'CONV_2D', 'CONV_3D', 'DEPTHWISE_CONV_2D'):\n Transform(\n type='conv',\n using={\n 'depthwise': '!_type_ == \"DEPTHWISE_CONV_2D\"',\n },\n inputs=(\n '!transpose_input(I[0])',\n '!transpose_filter(I[1], format=\"NXC\" if not depthwise else \"CXN\")',\n '!unsqueeze_vector(I[2])',\n ),\n outputs='!activation(transpose_output(O[0]), fused_activation_function)',\n attribs={\n 'stride': '![stride_h, stride_w]',\n 'dilation': '![dilation_h_factor, dilation_w_factor]',\n 'padding': '!convert_padding(padding, I[0].rank - 2)',\n 'groups': '!1 if not depthwise else 0',\n }\n ),\n 'TRANSPOSE_CONV':\n Transform(\n type='deconv',\n using={\n 'depthwise': False,\n },\n inputs=(\n '!transpose_input(I[2])',\n '!transpose_filter(I[1], format=\"CXN\" if not depthwise else \"NXC\")',\n ),\n outputs='!transpose_output(O[0])',\n attribs={\n 'stride': '![stride_h, stride_w]',\n 'padding': '!convert_padding(padding, I[0].rank - 2)',\n 'output_shape': '!nxc_to_ncx(as_const(I[0]))',\n 'groups': '!1 if not depthwise else 0',\n }\n ),\n ('MAX_POOL_2D', 'AVERAGE_POOL_2D'):\n Transform(\n type=('max_pool', 'avg_pool'),\n inputs=(\n '!transpose_input(I[0])',\n ),\n outputs=(\n '!transpose_output(O[0])',\n ),\n attribs={\n 'size': '![1, 1, filter_height, filter_width]',\n 'stride': '![1, 1, stride_h, stride_w]',\n 'padding': '!convert_padding(padding, I[0].rank)',\n }\n ),\n 'RESHAPE':\n Transform(\n type='reshape',\n inputs='!undo_transpose(I[0])',\n outputs='!O[0]',\n attribs={\n 'shape': '!flexible_batch(flat_list(as_const(I[1])) if len(I) > 1 else new_shape, I[0].shape[0])',\n 'dtype': '!I[0].dtype',\n }\n ),\n 'CONCATENATION':\n Transform(\n type='concat',\n inputs=['!I[:]'],\n outputs='!activation(transpose_like(O[0], I[0]), fused_activation_function)',\n attribs={\n 'axis': '!transpose_axis_like(axis, I[0], O[0].rank)',\n }\n ),\n 'FULLY_CONNECTED':\n Transform(\n type='linear',\n cond={\n '!weights_format == \"DEFAULT\"': 'wights_format must be \"DEFAULT\"',\n },\n inputs=(\n '!I[0] if keep_num_dims else flatten(I[0])',\n '!I[1]',\n '!unsqueeze_vector(I[2]) if len(I) > 2 else None',\n ),\n outputs='!activation(O[0], fused_activation_function)',\n ),\n 'L2_NORMALIZATION':\n Transform(\n type='l2_normalization',\n inputs='!I[0]',\n outputs='!transpose_like(O[0], I[0])',\n attribs={\n 'axes': '!list(range(I[0].rank))',\n }\n ),\n 'PRELU':\n Transform(\n type='prelu',\n inputs=('!I[0]', '!I[1]'),\n outputs='!transpose_like(O[0], I[0])',\n ),\n ('PAD', 'MIRROR_PAD'):\n Transform(\n type='pad',\n cond={\n '!mode < 2': 'mode must be 0 or 1',\n },\n defaults={\n 'mode': None,\n },\n using={\n 'paddings': '!transpose_list_like(as_const(I[1]), ref=I[0])',\n },\n inputs='!I[0]',\n outputs='!transpose_like(O[0], I[0])',\n attribs={\n 'padding': '![tuple(item) for item in paddings]',\n 'border': '!\"reflect\" if mode == 0 else \"reflect-even\" if mode == 1 else \"constant\"',\n }\n ),\n 'GATHER':\n Transform(\n type='gather',\n inputs=('!I[0]', '!I[1]'),\n outputs='!transpose_like(O[0], I[0])',\n attribs={\n 'axis': '!transpose_axis_like(axis, I[0])',\n },\n ),\n 'IDENTITY': _TFTransforms['Identity'],\n 'TRANSPOSE': _TFTransforms['Transpose'],\n 'SPLIT': _TFTransforms['Split'],\n 'SPLIT_V': _TFTransforms['SplitV'],\n 'PACK': _TFTransforms['Pack'],\n 'UNPACK': _TFTransforms['Unpack'],\n 'TILE': _TFTransforms['Tile'],\n 'SQUEEZE': _TFTransforms['Squeeze'],\n 'EXPAND_DIMS': _TFTransforms['ExpandDims'],\n 'SLICE': _TFTransforms['Slice'],\n 'STRIDED_SLICE': _TFTransforms['StridedSlice'],\n 'RELU': _TFTransforms['Relu'],\n 'RELU6': _TFTransforms['Relu6'],\n 'ELU': _TFTransforms['Elu'],\n 'LEAKY_RELU': _TFTransforms['LeakyRelu'],\n 'LOGISTIC': _TFTransforms['Sigmoid'],\n 'SIN': _TFTransforms['Sin'],\n 'COS': _TFTransforms['Cos'],\n 'TAN': _TFTransforms['Tan'],\n 'ASIN': _TFTransforms['Asin'],\n 'ACOS': _TFTransforms['Acos'],\n 'ATAN': _TFTransforms['Atan'],\n 'SINH': _TFTransforms['Sinh'],\n 'COSH': _TFTransforms['Cosh'],\n 'TANH': _TFTransforms['Tanh'],\n 'ASINH': _TFTransforms['Asinh'],\n 'ACOSH': _TFTransforms['Acosh'],\n 'ATANH': _TFTransforms['Atanh'],\n 'EXP': _TFTransforms['Exp'],\n 'LOG': _TFTransforms['Log'],\n 'ABS': _TFTransforms['Abs'],\n 'NEG': _TFTransforms['Neg'],\n 'LOGICAL_NOT': _TFTransforms['LogicalNot'],\n 'FLOOR': _TFTransforms['Floor'],\n 'CEIL': _TFTransforms['Ceil'],\n 'ROUND': _TFTransforms['Round'],\n 'SQUARE': _TFTransforms['Square'],\n 'SQRT': _TFTransforms['Sqrt'],\n 'RSQRT': _TFTransforms['Rsqrt'],\n 'ADD': _TFTransforms['Add'],\n 'SUB': _TFTransforms['Sub'],\n 'MUL': _TFTransforms['Mul'],\n 'DIV': _TFTransforms['RealDiv'],\n 'POW': _TFTransforms['Pow'],\n 'MINIMUM': _TFTransforms['Minimum'],\n 'MAXIMUM': _TFTransforms['Maximum'],\n 'LOGICAL_AND': _TFTransforms['LogicalAnd'],\n 'LOGICAL_OR': _TFTransforms['LogicalOr'],\n 'LESS': _TFTransforms['Less'],\n 'LESS_EQUAL': _TFTransforms['LessEqual'],\n 'GREATER': _TFTransforms['Greater'],\n 'GREATER_EQUAL': _TFTransforms['GreaterEqual'],\n 'EQUAL': _TFTransforms['Equal'],\n 'NOT_EQUAL': _TFTransforms['NotEqual'],\n 'SELECT': _TFTransforms['Select'],\n 'REDUCE_MIN': _TFTransforms['Min'],\n 'REDUCE_MAX': _TFTransforms['Max'],\n 'MEAN': _TFTransforms['Mean'],\n 'SUM': _TFTransforms['Sum'],\n 'REDUCE_ANY': _TFTransforms['Any'],\n 'REDUCE_ALL': _TFTransforms['All'],\n 'ARG_MIN': _TFTransforms['ArgMin'],\n 'ARG_MAX': _TFTransforms['ArgMax'],\n 'SOFTMAX': _TFTransforms['Softmax'],\n 'LOCAL_RESPONSE_NORMALIZATION': _TFTransforms['LRN'],\n 'RESIZE_NEAREST_NEIGHBOR': _TFTransforms['ResizeNearestNeighbor'],\n 'RESIZE_BILINEAR': _TFTransforms['ResizeBilinear'],\n 'ADD_N': _TFTransforms['AddN'],\n 'CAST': _TFTransforms['Cast'],\n})\n" ]	[ [ "numpy.prod" ] ]
Barkhausen-Institut/GFDM-PHY-Reference	[ "18296058ce4b3ef2fcbad977dea4bbb758322476" ]	[ "simulation/unittest/test_modulator.py" ]	[ "import unittest\r\nimport sys, os\r\n\r\nimport unittest\r\nimport numpy as np\r\n\r\nimport sys, os\r\nsys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))\r\nimport simulation.modem.util as util\r\nimport sdr_utils\r\n\r\n\r\nclass TestModulator(unittest.TestCase):\r\n \r\n def test_ofdm_modulator_demodulator(self):\r\n modulator = util.Modulator() \r\n modulator.type_ = \"ofdm\"\r\n modulator.K = 1024\r\n modulator.M = 1\r\n data = sdr_utils.get_random(1024)\r\n modulated_data = modulator.modulate(data)\r\n np.testing.assert_array_almost_equal(modulated_data, sdr_utils.norm_complex(np.fft.ifft(data)))\r\n np.testing.assert_array_almost_equal(\r\n sdr_utils.norm_complex(modulator.demodulate(modulated_data)),sdr_utils.norm_complex(data)\r\n ) \r\n def test_ofdm_modulator_demodulator_vertical_data(self):\r\n modulator = util.Modulator() \r\n data = np.array([ [ 1.+0.j],\r\n [-1.+1.j],\r\n [ 3.-1.j],\r\n [-1.-3.j], \r\n [ 3.-1.j],\r\n [-3.+3.j]])\r\n modulated_data = modulator.modulate(data)\r\n np.testing.assert_array_almost_equal(modulated_data,sdr_utils.norm_complex( np.fft.ifft(data)))\r\n np.testing.assert_array_almost_equal(\r\n sdr_utils.norm_complex(modulator.demodulate(modulated_data)),sdr_utils.norm_complex( data)\r\n ) \r\n\r\n def test_gfdm_modulator_demodulator_fd(self):\r\n K, M = 64, 16\r\n\r\n modulator = util.Modulator(K=K, M= M,type_=\"gfdm\")\r\n data = sdr_utils.get_random(K*M).reshape(K,M)\r\n data[:,-1] = 0 + 0j \r\n data[:,1] = 0 + 0j \r\n data[:,0] = 0 + 0j \r\n modulated_data = modulator.modulate(data)\r\n self.assertAlmostEqual(np.abs(modulated_data[K]),0)\r\n self.assertAlmostEqual(np.abs(modulated_data[-K]),0)\r\n self.assertAlmostEqual(np.abs(modulated_data[0]),0)\r\n self.assertAlmostEqual(np.abs(modulated_data[-1]),0,places=3)\r\n\r\n demodulated_data = modulator.demodulate(np.fft.fft(modulated_data))\r\n np.testing.assert_array_almost_equal(data, demodulated_data)\r\n\r\nif __name__ == \"__main__\":\r\n unittest.main()" ]	[ [ "numpy.abs", "numpy.fft.fft", "numpy.fft.ifft", "numpy.array", "numpy.testing.assert_array_almost_equal" ] ]
ZhongxiaYan/ray	[ "b97b8c2be1c7d01e2c93ca97a0b87120bfa2bd1a" ]	[ "python/ray/util/sgd/tests/test_pytorch.py" ]	[ "import os\nimport tempfile\nfrom unittest.mock import patch\n\nimport pytest\nimport time\nimport torch\nimport torch.nn as nn\nimport torch.distributed as dist\n\nimport ray\nfrom ray import tune\nfrom ray.tests.conftest import ray_start_2_cpus # noqa: F401\nfrom ray.util.sgd.pytorch import PyTorchTrainer, PyTorchTrainable\nfrom ray.util.sgd.pytorch.utils import (train, BATCH_COUNT, TEST_MODE,\n SCHEDULER_STEP)\nfrom ray.util.sgd.utils import check_for_failure\n\nfrom ray.util.sgd.pytorch.examples.train_example import (\n model_creator, optimizer_creator, data_creator, LinearDataset)\n\n\ndef test_test_mode(ray_start_2_cpus): # noqa: F811\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n config={TEST_MODE: True},\n num_replicas=1)\n metrics = trainer.train()\n assert metrics[BATCH_COUNT] == 1\n\n val_metrics = trainer.validate()\n assert val_metrics[BATCH_COUNT] == 1\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_train(ray_start_2_cpus, num_replicas): # noqa: F811\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n for i in range(3):\n train_loss1 = trainer.train()[\"train_loss\"]\n validation_loss1 = trainer.validate()[\"validation_loss\"]\n\n for i in range(3):\n train_loss2 = trainer.train()[\"train_loss\"]\n validation_loss2 = trainer.validate()[\"validation_loss\"]\n\n print(train_loss1, train_loss2)\n print(validation_loss1, validation_loss2)\n\n assert train_loss2 <= train_loss1\n assert validation_loss2 <= validation_loss1\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_multi_model(ray_start_2_cpus, num_replicas): # noqa: F811\n def custom_train(config, models, dataloader, criterion, optimizers,\n **kwargs):\n result = {}\n for i, (model, optimizer) in enumerate(zip(models, optimizers)):\n result[\"model_{}\".format(i)] = train(config, model, dataloader,\n criterion, optimizer)\n return result\n\n def multi_model_creator(config):\n return nn.Linear(1, 1), nn.Linear(1, 1)\n\n def multi_optimizer_creator(models, config):\n opts = [\n torch.optim.SGD(model.parameters(), lr=0.0001) for model in models\n ]\n return opts[0], opts[1]\n\n trainer1 = PyTorchTrainer(\n multi_model_creator,\n data_creator,\n multi_optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n train_function=custom_train,\n num_replicas=num_replicas)\n trainer1.train()\n\n filename = os.path.join(tempfile.mkdtemp(), \"checkpoint\")\n trainer1.save(filename)\n\n models1 = trainer1.get_model()\n\n trainer1.shutdown()\n\n trainer2 = PyTorchTrainer(\n multi_model_creator,\n data_creator,\n multi_optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n trainer2.restore(filename)\n\n os.remove(filename)\n\n models2 = trainer2.get_model()\n\n for model_1, model_2 in zip(models1, models2):\n\n model1_state_dict = model_1.state_dict()\n model2_state_dict = model_2.state_dict()\n\n assert set(model1_state_dict.keys()) == set(model2_state_dict.keys())\n\n for k in model1_state_dict:\n assert torch.equal(model1_state_dict[k], model2_state_dict[k])\n\n trainer2.shutdown()\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_multi_model_matrix(ray_start_2_cpus, num_replicas): # noqa: F811\n def custom_train(config, model, dataloader, criterion, optimizer,\n scheduler):\n if config.get(\"models\", 1) > 1:\n assert len(model) == config[\"models\"], config\n\n if config.get(\"optimizers\", 1) > 1:\n assert len(optimizer) == config[\"optimizers\"], config\n\n if config.get(\"schedulers\", 1) > 1:\n assert len(scheduler) == config[\"schedulers\"], config\n return {\"done\": 1}\n\n def multi_model_creator(config):\n models = []\n for i in range(config.get(\"models\", 1)):\n models += [nn.Linear(1, 1)]\n return models[0] if len(models) == 1 else models\n\n def multi_optimizer_creator(models, config):\n optimizers = []\n main_model = models[0] if type(models) is list else models\n for i in range(config.get(\"optimizers\", 1)):\n optimizers += [torch.optim.SGD(main_model.parameters(), lr=0.0001)]\n return optimizers[0] if len(optimizers) == 1 else optimizers\n\n def multi_scheduler_creator(optimizer, config):\n schedulers = []\n main_opt = optimizer[0] if type(optimizer) is list else optimizer\n for i in range(config.get(\"schedulers\", 1)):\n schedulers += [\n torch.optim.lr_scheduler.StepLR(\n main_opt, step_size=30, gamma=0.1)\n ]\n return schedulers[0] if len(schedulers) == 1 else schedulers\n\n for model_count in range(1, 3):\n for optimizer_count in range(1, 3):\n for scheduler_count in range(1, 3):\n trainer = PyTorchTrainer(\n multi_model_creator,\n data_creator,\n multi_optimizer_creator,\n loss_creator=nn.MSELoss,\n scheduler_creator=multi_scheduler_creator,\n train_function=custom_train,\n num_replicas=num_replicas,\n config={\n \"models\": model_count,\n \"optimizers\": optimizer_count,\n \"schedulers\": scheduler_count\n })\n trainer.train()\n trainer.shutdown()\n\n\[email protected](\"scheduler_freq\", [\"epoch\", \"batch\"])\ndef test_scheduler_freq(ray_start_2_cpus, scheduler_freq): # noqa: F811\n def custom_train(config, model, dataloader, criterion, optimizer,\n scheduler):\n assert config[SCHEDULER_STEP] == scheduler_freq\n return {\"done\": 1}\n\n def scheduler_creator(optimizer, config):\n return torch.optim.lr_scheduler.StepLR(\n optimizer, step_size=30, gamma=0.1)\n\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n scheduler_creator=scheduler_creator)\n\n for i in range(3):\n trainer.train()[\"train_loss\"]\n trainer.shutdown()\n\n\ndef test_scheduler_validate(ray_start_2_cpus): # noqa: F811\n def custom_train(config, model, dataloader, criterion, optimizer,\n scheduler):\n return {\"done\": 1}\n\n from torch.optim.lr_scheduler import ReduceLROnPlateau\n\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n scheduler_creator=lambda optimizer, cfg: ReduceLROnPlateau(optimizer))\n trainer.update_scheduler(0.5)\n trainer.update_scheduler(0.5)\n assert all(\n trainer.apply_all_workers(lambda r: r.schedulers[0].last_epoch == 2))\n trainer.shutdown()\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_tune_train(ray_start_2_cpus, num_replicas): # noqa: F811\n\n config = {\n \"model_creator\": model_creator,\n \"data_creator\": data_creator,\n \"optimizer_creator\": optimizer_creator,\n \"loss_creator\": lambda config: nn.MSELoss(),\n \"num_replicas\": num_replicas,\n \"use_gpu\": False,\n \"batch_size\": 512,\n \"backend\": \"gloo\",\n \"config\": {\n \"lr\": 0.001\n }\n }\n\n analysis = tune.run(\n PyTorchTrainable,\n num_samples=2,\n config=config,\n stop={\"training_iteration\": 2},\n verbose=1)\n\n # checks loss decreasing for every trials\n for path, df in analysis.trial_dataframes.items():\n train_loss1 = df.loc[0, \"train_loss\"]\n train_loss2 = df.loc[1, \"train_loss\"]\n validation_loss1 = df.loc[0, \"validation_loss\"]\n validation_loss2 = df.loc[1, \"validation_loss\"]\n\n assert train_loss2 <= train_loss1\n assert validation_loss2 <= validation_loss1\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_save_and_restore(ray_start_2_cpus, num_replicas): # noqa: F811\n trainer1 = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n trainer1.train()\n\n filename = os.path.join(tempfile.mkdtemp(), \"checkpoint\")\n trainer1.save(filename)\n\n model1 = trainer1.get_model()\n\n trainer1.shutdown()\n\n trainer2 = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n trainer2.restore(filename)\n\n os.remove(filename)\n\n model2 = trainer2.get_model()\n\n model1_state_dict = model1.state_dict()\n model2_state_dict = model2.state_dict()\n\n assert set(model1_state_dict.keys()) == set(model2_state_dict.keys())\n\n for k in model1_state_dict:\n assert torch.equal(model1_state_dict[k], model2_state_dict[k])\n\n\ndef test_fail_with_recover(ray_start_2_cpus): # noqa: F811\n if not dist.is_available():\n return\n\n def single_loader(config):\n return LinearDataset(2, 5, size=1000000)\n\n def step_with_fail(self):\n worker_stats = [w.step.remote() for w in self.workers]\n if self._num_failures < 3:\n time.sleep(1) # Make the batch will fail correctly.\n self.workers[0].__ray_kill__()\n success = check_for_failure(worker_stats)\n return success, worker_stats\n\n with patch.object(PyTorchTrainer, \"_train_step\", step_with_fail):\n trainer1 = PyTorchTrainer(\n model_creator,\n single_loader,\n optimizer_creator,\n batch_size=100000,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=2)\n\n with pytest.raises(RuntimeError):\n trainer1.train(max_retries=1)\n\n\ndef test_resize(ray_start_2_cpus): # noqa: F811\n if not dist.is_available():\n return\n\n def single_loader(config):\n return LinearDataset(2, 5, size=1000000)\n\n def step_with_fail(self):\n worker_stats = [w.step.remote() for w in self.workers]\n if self._num_failures < 1:\n time.sleep(1) # Make the batch will fail correctly.\n self.workers[0].__ray_kill__()\n success = check_for_failure(worker_stats)\n return success, worker_stats\n\n with patch.object(PyTorchTrainer, \"_train_step\", step_with_fail):\n trainer1 = PyTorchTrainer(\n model_creator,\n single_loader,\n optimizer_creator,\n batch_size=100000,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=2)\n\n @ray.remote\n def try_test():\n import time\n time.sleep(100)\n\n try_test.remote()\n trainer1.train(max_retries=1)\n assert len(trainer1.workers) == 1\n\n\ndef test_fail_twice(ray_start_2_cpus): # noqa: F811\n if not dist.is_available():\n return\n\n def single_loader(config):\n return LinearDataset(2, 5, size=1000000)\n\n def step_with_fail(self):\n worker_stats = [w.step.remote() for w in self.workers]\n if self._num_failures < 2:\n time.sleep(1)\n self.workers[0].__ray_kill__()\n success = check_for_failure(worker_stats)\n return success, worker_stats\n\n with patch.object(PyTorchTrainer, \"_train_step\", step_with_fail):\n trainer1 = PyTorchTrainer(\n model_creator,\n single_loader,\n optimizer_creator,\n batch_size=100000,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=2)\n\n trainer1.train(max_retries=2)\n" ]	[ [ "torch.optim.lr_scheduler.ReduceLROnPlateau", "torch.equal", "torch.nn.Linear", "torch.distributed.is_available", "torch.nn.MSELoss", "torch.optim.lr_scheduler.StepLR" ] ]
joep-source/minecraft_game	[ "1d2e01f18e029f547cd84913b93eca80254a5c31" ]	[ "play.py" ]	[ "import logging\nimport random\nimport sys\nfrom enum import Enum\nfrom functools import lru_cache\nfrom os import path\nfrom typing import List, Tuple, Union\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom ursina.camera import instance as camera\nfrom ursina.color import color, gray, light_gray\nfrom ursina.entity import Entity\nfrom ursina.models.procedural.grid import Grid\nfrom ursina.mouse import instance as mouse\nfrom ursina.prefabs.button import Button\nfrom ursina.prefabs.first_person_controller import FirstPersonController\nfrom ursina.prefabs.health_bar import HealthBar\nfrom ursina.prefabs.sky import Sky\nfrom ursina.scene import instance as scene\nfrom ursina.texture_importer import load_texture\nfrom ursina.ursinastuff import destroy\nfrom ursina.window import instance as window\n\nimport conf\nfrom block import Biomes\nfrom generate_world import (\n NOISE_HEAT,\n NOISE_HEIGHT_ISLAND,\n Map2D,\n combine_maps,\n convert_to_blocks_map,\n create_circular_map_mask,\n generate_noise_map,\n random_seed,\n world_map_colors,\n)\nfrom main_menu import MainMenuUrsina\nfrom utils import Z_2D, X, Y, Z, points_in_2dcircle, pos_to_xyz, setup_logger, timeit\n\n# from ursina import \n\n\nlogger = logging.getLogger(conf.LOGGER_NAME)\n\n\nclass GameState(Enum):\n MAIN_MENU = 0\n STARTING = 1\n PLAYING = 2\n # PAUSED = 3\n\n\nclass Player(FirstPersonController):\n position: List\n position_previous: List\n\n def __init__(self, position_start, speed, enable_fly=False):\n super().__init__()\n self.enable_fly = enable_fly\n self.set_fly(on=False)\n self.speed = speed\n position_start[Y] += 3 # Let player fall on the map from sky\n self.position = self.position_previous = position_start\n logger.info(f\"Player position start {self.position}\")\n\n def delete(self):\n logger.info(\"Delete Player\")\n self.enabled = False\n self.destroy = True\n\n def input(self, key):\n if key == \"space\":\n self.jump()\n self.set_fly(on=False)\n if key == \"i\":\n logger.debug(f\"Player position is {self.position}, {self.speed=}\")\n if self.enable_fly:\n if key == \"e\":\n self.set_fly(on=True)\n self.y += 1\n if key == \"q\" and self.fly:\n self.y -= 1\n\n def has_new_position(self) -> bool:\n pos_cur = pos_to_xyz(self.position)\n pos_old = pos_to_xyz(self.position_previous)\n if (pos_cur[X], pos_cur[Z]) != (pos_old[X], pos_old[Z]):\n logger.info(f\"Player position new {pos_to_xyz(self.position)}\")\n return True\n return False\n\n def set_fly(self, on: bool):\n self.fly = on\n if self.fly:\n self.gravity = 0\n else:\n self.gravity = 1\n\n\n@lru_cache(maxsize=None)\ndef get_texture(biome: Union[str, None]):\n get_file = lambda name: path.join(\"textures\", name)\n if biome == Biomes.SEA:\n return load_texture(get_file(\"sea.png\"))\n elif biome == Biomes.LAKE:\n return load_texture(get_file(\"water.png\"))\n elif biome == Biomes.DESERT:\n return load_texture(get_file(\"sand.png\"))\n elif biome == Biomes.SAVANNA:\n return load_texture(get_file(\"savanna.png\"))\n elif biome == Biomes.PLANE:\n return load_texture(get_file(\"grass.png\"))\n elif biome == Biomes.HILL:\n return load_texture(get_file(\"grass_stone.png\"))\n elif biome == Biomes.MOUNTAIN:\n return load_texture(get_file(\"stone.png\"))\n elif biome == Biomes.MOUNTAIN_SNOW:\n return load_texture(get_file(\"snow.png\"))\n elif biome == None:\n return load_texture(get_file(\"plank.png\"))\n\n\nclass Block(Button):\n destroyable: bool = False\n destroy: bool = False\n create_position: bool = None\n is_lowest: bool = False\n fix_pos: int\n\n # By setting the parent to scene and the model to 'cube' it becomes a 3d button.\n def __init__(\n self,\n position: List[int],\n biome: str,\n is_lowest=True,\n fix_pos=0.5,\n destroyable=False,\n ):\n self.fix_pos = fix_pos\n self.biome = biome\n self.destroyable = destroyable\n position = list(position)\n position[X] += self.fix_pos\n position[Z] += self.fix_pos\n texture = get_texture(self.biome if not self.create_position else None)\n super().__init__(\n parent=scene,\n position=position,\n model=\"cube\",\n texture=texture,\n scale=1,\n color=color(0, 0, random.uniform(0.95, 1)),\n highlight_color=light_gray,\n )\n if self.biome in [Biomes.LAKE, Biomes.SEA]:\n self.collider = None\n self.is_lowest = is_lowest\n\n def delete(self):\n self.destroy = True\n\n def get_map_position(self) -> Tuple[int, int, int]:\n return (\n int(self.position.x - self.fix_pos),\n int(self.position.y),\n int(self.position.z - self.fix_pos),\n )\n\n def input(self, key):\n if self.hovered:\n if key == \"left mouse down\" and self.biome not in [Biomes.LAKE, Biomes.SEA]:\n self.create_position = self.position + mouse.normal\n if key == \"right mouse down\" and self.destroyable:\n self.delete()\n\n\nclass MiniMap:\n map: Entity\n\n def __init__(self, world_map2d, seed, world_size):\n self.world_map2d = world_map2d\n self.seed = seed\n self.world_size = world_size\n self.save_minimap()\n self.map = self.create_minimap()\n\n def delete(self):\n logger.info(\"Delete MiniMap\")\n destroy(self.map)\n\n def create_minimap(self):\n return Entity(\n parent=camera.ui,\n model=\"quad\",\n scale=(0.25, 0.25),\n x=0.75,\n y=0.35,\n texture=self.get_minimap_path(),\n )\n\n @timeit\n def save_minimap(self):\n \"\"\"Save minimap as PNG image\"\"\"\n path = self.get_minimap_path()\n img = np.array(world_map_colors(self.world_map2d))\n plt.imsave(path, img)\n\n def get_minimap_path(self):\n return path.join(\"maps\", f\"seed_{self.seed}.png\")\n\n\nclass World:\n render_size: int\n blocks: List[Block] = list()\n\n def __init__(self, world_map2d: Map2D, world_size: int, position_start, render_size: int):\n logger.info(\"Initialize World\")\n self.world_map2d = world_map2d\n self.world_size = world_size\n self.render_size = render_size\n self.hidden_floor = Entity(\n model=Grid(1, 1),\n rotation_x=90,\n collider=\"box\",\n scale=self.world_size 2,\n position=(0, -1.9, 0),\n visible=False,\n )\n self.update(position_start, None)\n\n def delete(self):\n logger.info(\"Delete World\")\n for block in self.blocks:\n block.delete()\n self.blocks = list()\n\n def update(self, player_position_new, player_position_old):\n points_wanted_2d = points_in_2dcircle(\n radius=self.render_size,\n x_offset=int(player_position_new[X]),\n y_offset=int(player_position_new[Z]),\n )\n points_current_2d = set()\n if player_position_old:\n points_current_2d = points_in_2dcircle(\n radius=self.render_size,\n x_offset=int(player_position_old[X]),\n y_offset=int(player_position_old[Z]),\n )\n\n points_del_2d = points_current_2d.difference(points_wanted_2d)\n for block in reversed(self.blocks):\n x, _, z = block.get_map_position()\n if any(x == point[X] and z == point[Z_2D] for point in points_del_2d):\n self.blocks.remove(block)\n destroy(block)\n\n points_add_2d = points_wanted_2d.difference(points_current_2d)\n for point in points_add_2d:\n self.render_block(position=[point[X], 0, point[Z_2D]])\n\n self.fill_vertical()\n logger.debug(f\"Total blocks {len(self.blocks)}\")\n\n def render_block(self, position):\n x, y, z = pos_to_xyz(position)\n if all([0 <= pos < self.world_size for pos in (x, z)]):\n biome = self.world_map2d[x][z].biome\n y = self.world_map2d[x][z].world_height\n if biome in [Biomes.LAKE, Biomes.SEA]:\n y -= 0.3\n self.blocks.append(Block(position=(x, y, z), biome=biome))\n\n def fill_vertical(self):\n _start_blocks_count = len(self.blocks)\n self.blocks.sort(key=lambda b: b.position.y, reverse=True)\n for block in self.blocks:\n x = int(block.position.x)\n y = int(block.position.y)\n z = int(block.position.z)\n if not block.is_lowest:\n continue\n for x_diff, z_diff in [[1, 0], [-1, 0], [0, 1], [0, -1]]:\n try:\n block_around = self.world_map2d[x + x_diff][z + z_diff]\n except IndexError:\n continue\n if y - block_around.world_height < 2: # Skip high difference < 2\n continue\n self.blocks.append(Block(position=(x, y - 1, z), biome=block_around.biome))\n block.is_lowest = False\n break\n logger.debug(f\"Fill {len(self.blocks) - _start_blocks_count} blocks\")\n\n def click_handler(self):\n for block in reversed(self.blocks):\n if block.destroy:\n self.blocks.remove(block)\n destroy(block)\n elif block.create_position:\n new_block = Block(\n position=block.create_position,\n biome=None,\n is_lowest=False,\n fix_pos=0,\n destroyable=True,\n )\n self.blocks.append(new_block)\n block.create_position = None\n\n\nclass UrsinaMC(MainMenuUrsina):\n world_map2d: Map2D = None\n world = None\n player = None\n minimap = None\n game_background = None\n loading_step: int = 0\n\n def __init__(self):\n super().__init__()\n self.game_state = GameState.MAIN_MENU\n\n def start_game(self, kwargs):\n self.game_state = GameState.STARTING\n logger.info(\"Game starting\")\n self.seed = kwargs.get(\"seed\", random_seed())\n self.world_size = kwargs.get(\"world_size\", conf.WORLD_SIZE)\n self.world_shape = (self.world_size, self.world_size)\n self.speed = kwargs.get(\"player_speed\", conf.PLAYER_SPEED)\n self.render_size = kwargs.get(\"render_size\", conf.BLOCKS_RENDER_DISTANCE)\n print(f\"Settings: {self.seed=}, {self.world_size=}, {self.speed=}, {self.render_size=}\")\n\n def load_game_sequentially(self):\n if self.loading_step == 0:\n self.game_background = Sky()\n self.loading_bar = HealthBar(\n max_value=100,\n value=1,\n position=(-0.5, -0.35, -2),\n scale_x=1,\n animation_duration=0,\n bar_color=gray,\n )\n elif self.loading_step == 10:\n # Generate map 1/3\n heigth_map = generate_noise_map(self.world_shape, self.seed, NOISE_HEIGHT_ISLAND)\n circulair_map = create_circular_map_mask(self.world_size)\n self._heigth_map_island = combine_maps(heigth_map, circulair_map)\n elif self.loading_step == 20:\n # Generate map 2/3\n self._heat_map = generate_noise_map(self.world_shape, self.seed, **NOISE_HEAT)\n elif self.loading_step == 30:\n # Generate map 3/3\n self.world_map2d = convert_to_blocks_map(self._heigth_map_island, self._heat_map)\n elif self.loading_step == 40:\n self.start_position = self.random_start_position(world_size=self.world_size)\n self.world = World(\n self.world_map2d, self.world_size, self.start_position, self.render_size\n )\n elif self.loading_step == 50:\n self.minimap = MiniMap(self.world_map2d, self.seed, self.world_size)\n self.minimap.map.visible = False\n elif self.loading_step == 90:\n destroy(self.loading_bar)\n self.loading_bar = None\n self.minimap.map.visible = True\n self.player = Player(\n position_start=self.start_position, speed=self.speed, enable_fly=True\n )\n super().start_game()\n self.game_state = GameState.PLAYING\n logger.info(\"Game playing\")\n return\n self.loading_bar.value = self.loading_step\n self.loading_step += 2\n\n def quit_game(self):\n if self.game_state == GameState.MAIN_MENU:\n logger.info(\"Exit game\")\n sys.exit()\n logger.info(\"Quiting game\")\n self.reset_game()\n self.game_state = GameState.MAIN_MENU\n super().quit_game()\n\n def reset_game(self):\n self.world_map2d = None\n self.world.delete()\n self.world = None\n self.player.delete()\n self.player = None\n self.minimap.delete()\n self.minimap = None\n destroy(self.game_background)\n self.game_background = None\n self.loading_step = 0\n\n @timeit\n def random_start_position(self, world_size: int):\n while True:\n x = random.randint(1, world_size - 1)\n z = random.randint(1, world_size - 1)\n biome_block = self.world_map2d[x][z]\n position = [x + 0.5, biome_block.world_height, z + 0.5]\n logger.debug(f\"Random position {position=}\")\n if biome_block.biome not in [Biomes.SEA, Biomes.LAKE]:\n return position\n\n def input(self, key):\n if key == \"escape\":\n self.quit_game()\n super().input(key)\n\n def _update(self, task):\n if self.game_state == GameState.STARTING:\n self.load_game_sequentially()\n elif self.game_state == GameState.PLAYING:\n if self.player.has_new_position():\n self.world.update(self.player.position, self.player.position_previous)\n self.player.position_previous = self.player.position\n self.world.click_handler()\n return super()._update(task)\n\n\nif __name__ == \"__main__\":\n setup_logger(logger=logger)\n app = UrsinaMC()\n\n window.title = \"Mincraft Ursina\"\n window.borderless = True\n window.fullscreen = False\n window.exit_button.visible = False\n window.fps_counter.enabled = True\n\n app.run()\n" ]	[ [ "matplotlib.pyplot.imsave" ] ]
cltl/SDG-tracker	[ "f8730adbf35b01864033cc82333972019d76077a" ]	[ "classify_only/utils.py" ]	[ "import os\r\nimport random\r\nimport glob\r\nimport json\r\nimport nltk\r\nimport re\r\nimport numpy as np\r\nimport pandas as pd\r\n\r\nfrom sentence_transformers import SentenceTransformer\r\n\r\nfrom sklearn import svm\r\nfrom sklearn.svm import LinearSVC\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.model_selection import cross_val_score\r\n\r\n\r\ndef BERT_encode_sentences(texts, mod=0):\r\n '''\r\n takes a list of texts and name of model as input (default model = Bert_large)\r\n returns a list of concatenated BERT embeddings and a list of mean (averaged)\r\n BERT embeddings for input as X in a classifier\r\n\r\n '''\r\n if mod == 0:\r\n model = SentenceTransformer('roberta-large-nli-mean-tokens')\r\n else:\r\n model = SentenceTransformer('bert-large-nli-mean-tokens')\r\n\r\n embedded_texts = []\r\n for text in texts:\r\n sentences = nltk.sent_tokenize(text)\r\n if len(sentences) >= 6:\r\n sentence_embeddings = model.encode(sentences[:6])\r\n else:\r\n for n in range(6-len(sentences)):\r\n sentences.append(sentences[0])\r\n sentence_embeddings = model.encode(sentences[:6])\r\n embedded_texts.append(sentence_embeddings)\r\n\r\n concatenated_X = []\r\n mean_X = []\r\n\r\n for six_embeds in embedded_texts:\r\n new = np.concatenate(six_embeds)\r\n concatenated_X.append(new)\r\n mean_embeds_per_text = np.mean(six_embeds, axis=0)\r\n mean_X.append(mean_embeds_per_text)\r\n\r\n return concatenated_X, mean_X\r\n\r\n\r\ndef prep_baseline(texts):\r\n '''\r\n takes a list of texts and creates a Bag of Words ready model with\r\n lower case characters and punctuation/ symbols removed\r\n '''\r\n\r\n # cleaning the texts for lower case words only\r\n BOW_texts_list = []\r\n\r\n for text in texts:\r\n sentences = nltk.sent_tokenize(text)\r\n\r\n new_text = []\r\n if len(sentences) >= 6:\r\n for sent in sentences[:6]:\r\n # corpus.append(sent)\r\n sent = sent.lower()\r\n sent = re.sub(r'\\W', ' ', sent)\r\n sent = re.sub(r'\\s+', ' ', sent)\r\n new_text.append(sent)\r\n # processed_corpus.append(sent)\r\n\r\n else:\r\n for sent in sentences:\r\n # corpus.append(sent)\r\n sent = sent.lower()\r\n sent = re.sub(r'\\W', ' ', sent)\r\n sent = re.sub(r'\\s+', ' ', sent)\r\n new_text.append(sent)\r\n # processed_corpus.append(sent)\r\n BOW_texts_list.append(new_text)\r\n\r\n # each text is a single string after this\r\n concatenated_sents = [''.join(item)for item in BOW_texts_list]\r\n return concatenated_sents\r\n" ]	[ [ "numpy.concatenate", "numpy.mean" ] ]
TNO/techruption-poc-odessey-hackathon-2019	[ "a7915244f4826fc9954c6b7e87ae10a8c7dbf2a3" ]	[ "data_generation/records.py" ]	[ "# -- coding: utf-8 --\r\n\"\"\"\r\nCreated on Fri Apr 12 19:11:47 2019\r\n\r\n@author: bosmanjw\r\n\"\"\"\r\n\r\nimport numpy as np\r\nimport pandas as pd\r\n# BN id 201.5 pp 52 https://zoek.officielebekendmakingen.nl/blg-784527.pdf\r\n#https://www.prorail.nl/sites/default/files/phs-folder_gevaarlijke_stoffen_web.pdf\r\n\r\ncategories = np.array([\"A\", \"B2\", \"B3\", \"C3\", \"D3\", \"D4\"])\r\nintensities = np.array([32680 ,1365 ,18120 ,2560 ,560 ,101 ,128550 ,10923 ,11820 ,1532 ,5100 ,152])\r\nintensities = np.reshape(intensities,(6,2)).T[1]\r\nprobs = intensities / intensities.sum()\r\ntotalIntensity = intensities.sum()\r\nintensities = pd.DataFrame(data=np.atleast_2d(intensities),columns=categories)\r\nsubstances={\"A\":[\"LPG\", \"propylene\", \"butadiene\", \"ethylene oxide\"],\r\n \"B2\":[\"ammonia\"],\r\n \"B3\":[\"chlorine\"],\r\n \"C3\":[\"gasoline\", \"natural-gas condensate\"],\r\n \"D3\":[\"acrylonitrile\"],\r\n \"D4\":[\"hydrogen fluoride\", \"bromide\"]\r\n }\r\nweights = np.array(\r\n [intensities[cat][0]/len(substanceList) \r\n for cat, substanceList in substances.items() \r\n for substance in substanceList])\r\nprobs = weights / weights.sum()\r\n#inhoud 14000-27000 liter (bron wiki)\r\n\r\ndef generate_container(containerID, minVolume=14, maxVolume=27):\r\n contentsList = []\r\n intensityList = []\r\n for cat, substanceList in substances.items():\r\n intensity = intensities[cat][0]/len(substanceList)\r\n for name in substanceList: \r\n record = {\"Substance category\": cat, \"Name\": name, \"Volume\": \"0\", \"Unit\": \"litre\"}\r\n contentsList.append(record)\r\n intensityList.append(intensity)\r\n intensityList = np.array(intensityList)\r\n probs = intensityList / intensityList.sum()\r\n index = np.random.choice(range(len(probs)),p=probs)\r\n vol = np.random.randint(minVolume,maxVolume+1) * 1000\r\n vol = \"{0:d}\".format(vol)\r\n contentsList[index][\"Volume\"] = vol\r\n return {\"Container ID\": containerID, \"Content\": contentsList}\r\n\r\ndef generate_containers(number, maxIdIncrement = 1):\r\n containerList = []\r\n currId = 0\r\n for i in range(number):\r\n # currId += np.random.randint(1, maxIdIncrement)\r\n # containerId = \"{0:d}\".format(currId)\r\n containerId = str(i)\r\n nextContainer = generate_container(containerId)\r\n containerList.append(nextContainer)\r\n return containerList\r\n\r\ndef generate_ships(number, maxIncrement = 10, minContainers=100, maxContainers=1000):\r\n shipList = []\r\n currId = 0\r\n counts = np.random.randint(minContainers, maxContainers+1, size=number)\r\n counts = np.atleast_1d(counts)\r\n allContainersList = generate_containers(counts.sum())\r\n containerIds = [container[\"Container ID\"] for container in allContainersList]\r\n np.random.permutation(containerIds)\r\n containerLists = np.split(containerIds, counts.cumsum()[:-1])\r\n \r\n for containerList in containerLists:\r\n currId += np.random.randint(1, maxIncrement)\r\n shipId = \"{0:d}\".format(currId)\r\n record = {\"Ship ID\": shipId , \"Container list\": containerList.tolist()}\r\n shipList.append(record)\r\n return shipList, allContainersList\r\n\r\ndef find_ship(shipList, containerId):\r\n return [ship for ship in shipList if containerId in ship[\"Container list\"]]\r\n\r\nif __name__ == \"__main__\":\r\n generate_containers(1000)\r\n \r\n\r\n" ]	[ [ "numpy.reshape", "numpy.atleast_1d", "numpy.atleast_2d", "numpy.random.permutation", "numpy.array", "numpy.random.randint" ] ]
SamsungLabs/ASAM	[ "f156a680171db16d551c0d85cba2514fa3bff6a2" ]	[ "example_cifar.py" ]	[ "import argparse\nimport torch\nimport torchvision\nfrom torch.utils.data import DataLoader\nfrom torchvision import transforms\nfrom torchvision.datasets import CIFAR10, CIFAR100\nfrom timm.loss import LabelSmoothingCrossEntropy\nfrom homura.vision.models.cifar_resnet import wrn28_2, wrn28_10, resnet20, resnet56, resnext29_32x4d\nfrom asam import ASAM, SAM\n\ndef load_cifar(data_loader, batch_size=256, num_workers=2):\n if data_loader == CIFAR10:\n mean = (0.4914, 0.4822, 0.4465)\n std = (0.2023, 0.1994, 0.2010)\n else:\n mean = (0.5071, 0.4867, 0.4408)\n std = (0.2675, 0.2565, 0.2761)\n\n # Transforms\n train_transform = transforms.Compose([transforms.RandomCrop(32, padding=4),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize(mean, std)])\n\n test_transform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize(mean, std)\n ])\n \n # DataLoader\n train_set = data_loader(root='./data', train=True, download=True, transform=train_transform)\n test_set = data_loader(root='./data', train=False, download=True, transform=test_transform)\n train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, \n num_workers=num_workers)\n test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, \n num_workers=num_workers)\n return train_loader, test_loader\n \n\ndef train(args): \n # Data Loader\n train_loader, test_loader = load_cifar(eval(args.dataset), args.batch_size)\n num_classes = 10 if args.dataset == 'CIFAR10' else 100\n\n # Model\n model = eval(args.model)(num_classes=num_classes).cuda()\n\n # Minimizer\n optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, \n momentum=args.momentum, weight_decay=args.weight_decay)\n minimizer = eval(args.minimizer)(optimizer, model, rho=args.rho, eta=args.eta)\n \n # Learning Rate Scheduler\n scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(minimizer.optimizer, args.epochs)\n\n # Loss Functions\n if args.smoothing:\n criterion = LabelSmoothingCrossEntropy(smoothing=args.smoothing)\n else:\n criterion = torch.nn.CrossEntropyLoss()\n\n best_accuracy = 0.\n for epoch in range(args.epochs):\n # Train\n model.train()\n loss = 0.\n accuracy = 0.\n cnt = 0.\n for inputs, targets in train_loader:\n inputs = inputs.cuda()\n targets = targets.cuda()\n\n # Ascent Step\n predictions = model(inputs)\n batch_loss = criterion(predictions, targets)\n batch_loss.mean().backward()\n minimizer.ascent_step()\n\n # Descent Step\n criterion(model(inputs), targets).mean().backward()\n minimizer.descent_step()\n\n with torch.no_grad():\n loss += batch_loss.sum().item()\n accuracy += (torch.argmax(predictions, 1) == targets).sum().item()\n cnt += len(targets)\n loss /= cnt\n accuracy = 100. / cnt\n print(f\"Epoch: {epoch}, Train accuracy: {accuracy:6.2f} %, Train loss: {loss:8.5f}\")\n scheduler.step()\n\n # Test\n model.eval()\n loss = 0.\n accuracy = 0.\n cnt = 0.\n with torch.no_grad():\n for inputs, targets in test_loader:\n inputs = inputs.cuda()\n targets = targets.cuda()\n predictions = model(inputs)\n loss += criterion(predictions, targets).sum().item()\n accuracy += (torch.argmax(predictions, 1) == targets).sum().item()\n cnt += len(targets)\n loss /= cnt\n accuracy = 100. / cnt\n if best_accuracy < accuracy:\n best_accuracy = accuracy\n print(f\"Epoch: {epoch}, Test accuracy: {accuracy:6.2f} %, Test loss: {loss:8.5f}\")\n print(f\"Best test accuracy: {best_accuracy}\")\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--dataset\", default='CIFAR10', type=str, help=\"CIFAR10 or CIFAR100.\")\n parser.add_argument(\"--model\", default='wrn28_10', type=str, help=\"Name of model architecure\")\n parser.add_argument(\"--minimizer\", default='ASAM', type=str, help=\"ASAM or SAM.\")\n parser.add_argument(\"--lr\", default=0.1, type=float, help=\"Initial learning rate.\")\n parser.add_argument(\"--momentum\", default=0.9, type=float, help=\"Momentum.\")\n parser.add_argument(\"--weight_decay\", default=5e-4, type=float, help=\"Weight decay factor.\")\n parser.add_argument(\"--batch_size\", default=128, type=int, help=\"Batch size\")\n parser.add_argument(\"--epochs\", default=200, type=int, help=\"Number of epochs.\")\n parser.add_argument(\"--smoothing\", default=0.1, type=float, help=\"Label smoothing.\")\n parser.add_argument(\"--rho\", default=0.5, type=float, help=\"Rho for ASAM.\")\n parser.add_argument(\"--eta\", default=0.0, type=float, help=\"Eta for ASAM.\")\n args = parser.parse_args()\n assert args.dataset in ['CIFAR10', 'CIFAR100'], \\\n f\"Invalid data type. Please select CIFAR10 or CIFAR100\"\n assert args.minimizer in ['ASAM', 'SAM'], \\\n f\"Invalid minimizer type. Please select ASAM or SAM\"\n train(args)\n" ]	[ [ "torch.nn.CrossEntropyLoss", "torch.optim.lr_scheduler.CosineAnnealingLR", "torch.utils.data.DataLoader", "torch.no_grad", "torch.argmax" ] ]
gibsramen/umap	[ "fbd2f95f6deec70a4105091a4eaeab0e6ccbaf01" ]	[ "umap/tests/test_umap_trustworthiness.py" ]	[ "from umap import UMAP\nfrom sklearn.datasets import make_blobs\nfrom nose.tools import assert_greater_equal\nimport numpy as np\ntry:\n # works for sklearn>=0.22\n from sklearn.manifold import trustworthiness\nexcept ImportError:\n # this is to comply with requirements (scikit-learn>=0.20)\n # More recent versions of sklearn have exposed trustworthiness\n # in top level module API\n # see: https://github.com/scikit-learn/scikit-learn/pull/15337\n from sklearn.manifold.t_sne import trustworthiness\n\n# ===================================================\n# UMAP Trustworthiness Test cases\n# ===================================================\n\n\ndef test_umap_sparse_trustworthiness(sparse_test_data):\n embedding = UMAP(n_neighbors=10).fit_transform(sparse_test_data[:100])\n trust = trustworthiness(sparse_test_data[:100].toarray(), embedding, 10)\n assert_greater_equal(\n trust,\n 0.89,\n \"Insufficiently trustworthy embedding for\"\n \"sparse test dataset: {}\".format(trust),\n )\n\n\ndef test_umap_trustworthiness_fast_approx(nn_data):\n data = nn_data[:50]\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n random_state=42,\n n_epochs=100,\n force_approximation_algorithm=True,\n ).fit_transform(data)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.75,\n \"Insufficiently trustworthy embedding for\" \"nn dataset: {}\".format(trust),\n )\n\n\ndef test_umap_trustworthiness_random_init(nn_data):\n data = nn_data[:50]\n embedding = UMAP(\n n_neighbors=10, min_dist=0.01, random_state=42, init=\"random\"\n ).fit_transform(data)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.75,\n \"Insufficiently trustworthy embedding for\" \"nn dataset: {}\".format(trust),\n )\n\n\ndef test_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n embedding = UMAP(n_neighbors=10, min_dist=0.01, random_state=42).fit_transform(\n data, labels\n )\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.97,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_semisupervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n labels[10:30] = -1\n embedding = UMAP(n_neighbors=10, min_dist=0.01, random_state=42).fit_transform(\n data, labels\n )\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.97,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"l1\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_string_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n labels = np.array([\"this\", \"that\", \"other\"])[labels]\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"string\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_discrete_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"ordinal\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_count_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n labels = (labels ** 2) + 2 * labels\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"count\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n" ]	[ [ "numpy.array", "sklearn.manifold.t_sne.trustworthiness", "sklearn.datasets.make_blobs" ] ]
Islamsed/ai-assisted-annotation-client	[ "313da5177eba7ca94f8d76811c23e462726c978f" ]	[ "py-client/client_api.py" ]	[ "# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions\n# are met:\n# * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n# * Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in the\n# documentation and/or other materials provided with the distribution.\n# * Neither the name of NVIDIA CORPORATION nor the names of its\n# contributors may be used to endorse or promote products derived\n# from this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY\n# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\n# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport cgi\nimport ssl\n\ntry:\n # Python3\n # noinspection PyUnresolvedReferences\n import http.client as httplib\n # noinspection PyUnresolvedReferences,PyCompatibility\n from urllib.parse import quote_plus\n # noinspection PyUnresolvedReferences,PyCompatibility\n from urllib.parse import urlparse\nexcept ImportError as e:\n # Python2\n # noinspection PyUnresolvedReferences\n import httplib\n # noinspection PyUnresolvedReferences\n from urllib import quote_plus\n # noinspection PyUnresolvedReferences\n from urlparse import urlparse\n\nimport json\nimport logging\nimport mimetypes\nimport os\nimport sys\nimport tempfile\n\nimport SimpleITK\nimport numpy as np\n\n\nclass AIAAClient:\n \"\"\"\n The AIAAClient object is constructed with the server information\n\n :param server_url: AIAA Server URL (example: 'http://0.0.0.0:5000')\n \"\"\"\n\n def __init__(self, server_url='http://0.0.0.0:5000'):\n self._server_url = server_url\n\n def get_server_url(self):\n \"\"\"\n Get AIAA Server URL\n\n :return: returns AIAA Server URL\n \"\"\"\n return self._server_url\n\n def set_server_url(self, server_url):\n \"\"\"\n Update AIAA Server URL\n\n :param: server_url: valid url for AIAA server (example: 'http://0.0.0.0:5000')\n \"\"\"\n self._server_url = server_url\n\n def create_session(self, image_in, expiry=0):\n \"\"\"\n Create New Session\n\n :param image_in: valid image which will be stored as part of the new session\n :param expiry: expiry in seconds. min(AIAASessionExpiry, expiry) will be selected by AIAA\n :return: returns json containing session_id and any other details from server\n\n valid session_id from result can be used for future reference\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Create Session Action')\n\n selector = '/session/?expiry=' + str(expiry)\n fields = {}\n files = {'image': image_in}\n\n status, response, _ = AIAAUtils.http_multipart('PUT', self._server_url, selector, fields, files)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def get_session(self, session_id):\n \"\"\"\n Get Session Info\n\n :param session_id: valid session id\n :return: returns json containing session details if session is valid; otherwise None\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Session Details')\n\n if session_id is None:\n return None\n\n selector = '/session/' + AIAAUtils.urllib_quote_plus(session_id)\n status, response = AIAAUtils.http_method('GET', self._server_url, selector)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def close_session(self, session_id):\n \"\"\"\n Close an existing session\n\n :param session_id: valid session id\n :return: returns True if a session is closed, else False\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Session Details')\n\n if session_id is None:\n return False\n\n selector = '/session/' + AIAAUtils.urllib_quote_plus(session_id)\n\n status, response = AIAAUtils.http_method('DELETE', self._server_url, selector)\n logger.debug('Response: {}'.format(response))\n return status is 200\n\n def model(self, model):\n \"\"\"\n Get the model details\n\n :param model: A valid Model Name which exists in AIAA Server\n :return: returns json containing the model details\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Model Details')\n\n selector = '/v1/models'\n if model:\n selector += '?model=' + AIAAUtils.urllib_quote_plus(model)\n\n status, response = AIAAUtils.http_method('GET', self._server_url, selector)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def model_list(self, label=None):\n \"\"\"\n Get the current supported model list\n\n :param label: Filter models which are matching the label\n :return: returns json containing list of models and details\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Model Details')\n\n selector = '/v1/models'\n if label is not None and len(label) > 0:\n selector += '?label=' + AIAAUtils.urllib_quote_plus(label)\n\n status, response = AIAAUtils.http_method('GET', self._server_url, selector)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def segmentation(self, model, image_in, image_out, session_id=None):\n \"\"\"\n 2D/3D image segmentation using segmentation method\n\n :param model: model name according to the output of model_list()\n :param image_in: input 2D/3D image file name\n :param image_out: output mask will be stored\n :param session_id: if session id is provided (not None) then image_in will be ignored\n :return: returns json containing extreme points for the segmentation mask and other info\n\n Output 2D/3D binary mask will be saved to the specified file; Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Segmentation Action')\n\n selector = '/v1/segmentation?model=' + AIAAUtils.urllib_quote_plus(model)\n if session_id:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': '{}'}\n in_files = {'datapoint': image_in} if not session_id else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n if params is None: # v1 backward compatibility\n points = json.loads(form.get('points'))\n params = {'points': (json.loads(points) if isinstance(points, str) else points)}\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n def dextr3d(self, model, point_set, image_in, image_out, pad=20, roi_size='128x128x128',\n pre_process=True,\n session_id=None):\n \"\"\"\n 3D image annotation using DEXTR3D method\n\n :param model: model name according to the output of model_list()\n :param point_set: point set json containing the extreme points' indices\n :param image_in: input 3D image file name\n :param image_out: output mask will be stored\n :param pad: padding size (default is 20)\n :param roi_size: image resize value (default is 128x128x128)\n :param pre_process: pre-process (crop) input volume at client side for DEXTR3D action\n :param session_id: if session_id is not None and pre_process is False then image_in will be ignored\n\n\n Output 3D binary mask will be saved to the specified file; Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Annotation/Dextr3D Action')\n\n # Pre Process\n if pre_process:\n cropped_file = tempfile.NamedTemporaryFile(suffix='.nii.gz').name\n points, crop = AIAAUtils.image_pre_process(image_in, cropped_file, point_set, pad, roi_size)\n else:\n cropped_file = image_in\n points = point_set\n crop = None\n\n selector = '/v1/dextr3d?model=' + AIAAUtils.urllib_quote_plus(model)\n use_session_input = session_id and pre_process is False\n if use_session_input:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': json.dumps({'points': json.dumps(points)})}\n in_files = {'datapoint': cropped_file} if not use_session_input else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n params = json.loads(params) if isinstance(params, str) else params\n\n # Post Process\n if pre_process:\n os.unlink(cropped_file)\n\n cropped_out_file = tempfile.NamedTemporaryFile(suffix='.nii.gz').name\n AIAAUtils.save_result(files, cropped_out_file)\n AIAAUtils.image_post_processing(cropped_out_file, image_out, crop, image_in)\n\n os.unlink(cropped_out_file)\n else:\n AIAAUtils.save_result(files, image_out)\n return params\n\n def deepgrow(self, model, foreground, background, image_in, image_out, session_id=None):\n \"\"\"\n 2D/3D image annotation using DeepGrow method\n\n :param model: model name according to the output of model_list()\n :param foreground: foreground (+ve) clicks/points\n :param background: background (-ve) clicks/points\n :param image_in: input 2D/3D image file name\n :param image_out: output mask will be stored\n :param session_id: if session id is provided (not None) then image_in will be ignored\n\n Output 2D/3D binary mask will be saved to the specified file; Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for DeepGrow Action')\n\n selector = '/v1/deepgrow?model=' + AIAAUtils.urllib_quote_plus(model)\n if session_id:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': json.dumps({'foreground': foreground, 'background': background})}\n in_files = {'datapoint': image_in} if not session_id else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n def inference(self, model, params, image_in, image_out, session_id=None):\n \"\"\"\n Generic Inference for given input image and model\n\n :param model: model name according to the output of model_list()\n :param params: json input consumed by model\n :param image_in: input 2D/3D image file name\n :param image_out: output mask will be stored\n :param session_id: if session id is provided (not None) then image_in will be ignored\n :return: returns json produced by the model inference\n\n Output 2D/3D binary mask will be saved to the specified file; JSON results will be returned;\n Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Inference Action')\n\n selector = '/v1/inference?model=' + AIAAUtils.urllib_quote_plus(model)\n if session_id:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': params if isinstance(params, str) else json.dumps(params)}\n in_files = {'datapoint': image_in} if not session_id else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params') if files else form\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n def mask2polygon(self, image_in, point_ratio):\n \"\"\"\n 3D binary mask to polygon representation conversion\n\n :param image_in: input 3D binary mask image file name\n :param point_ratio: point ratio controlling how many polygon vertices will be generated\n\n :return: A json containing the indices of all polygon vertices slice by slice.\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Mask2Polygon Action')\n\n selector = '/v1/mask2polygon'\n params = dict()\n params['more_points'] = point_ratio\n\n fields = {'params': json.dumps(params)}\n files = {'datapoint': image_in}\n\n status, response, _ = AIAAUtils.http_multipart('POST', self._server_url, selector, fields, files)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n return json.loads(response)\n\n def fixpolygon(self, image_in, image_out, polygons, index, vertex_offset, propagate_neighbor):\n \"\"\"\n 2D/3D polygon update with single point edit\n\n :param image_in: input 2D/3D image file name\n :param image_out: output 2D/3D mask image file name\n :param polygons: list of polygons 2D/3D\n :param index: index of vertex which needs to be updated\n 1) for 2D [polygon_index, vertex_index]\n 2) for 3D [slice_index, polygon_index, vertex_index]\n :param vertex_offset: offset (2D/3D) needs to be added to get the updated vertex in [x,y] format\n :param propagate_neighbor: neighborhood size\n 1) for 2D: single value (polygon_neighborhood_size)\n 2) for 3D: [slice_neighborhood_size, polygon_neighborhood_size]\n :return: A json containing the indices of updated polygon vertices\n\n\n Output binary mask will be saved to the specified name\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for FixPolygon Action')\n\n selector = '/v1/fixpolygon'\n\n dimension = len(index)\n\n params = dict()\n params['poly'] = polygons\n params['vertex_offset'] = vertex_offset\n params['dimension'] = dimension\n\n if dimension == 3:\n params['slice_index'] = index[0]\n params['polygon_index'] = index[1]\n params['vertex_index'] = index[2]\n params['propagate_neighbor_3d'] = propagate_neighbor[0]\n params['propagate_neighbor'] = propagate_neighbor[1]\n else:\n params['polygon_index'] = index[0]\n params['vertex_index'] = index[1]\n params['propagate_neighbor'] = propagate_neighbor\n\n fields = {'params': json.dumps(params)}\n files = {'datapoint': image_in}\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, fields, files)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n\nclass AIAAError:\n SESSION_EXPIRED = 1\n RESULT_NOT_FOUND = 2\n SERVER_ERROR = 3\n UNKNOWN = 4\n\n\nclass AIAAException(Exception):\n def __init__(self, error, msg):\n self.error = error\n self.msg = msg\n\n\nclass AIAAUtils:\n def __init__(self):\n pass\n\n @staticmethod\n def resample_image(itk_image, out_size, linear):\n spacing = list(itk_image.GetSpacing())\n size = list(itk_image.GetSize())\n\n out_spacing = []\n for i in range(len(size)):\n out_spacing.append(float(spacing[i]) * float(size[i]) / float(out_size[i]))\n\n resample = SimpleITK.ResampleImageFilter()\n resample.SetOutputSpacing(out_spacing)\n resample.SetSize(out_size)\n resample.SetOutputDirection(itk_image.GetDirection())\n resample.SetOutputOrigin(itk_image.GetOrigin())\n\n if linear:\n resample.SetInterpolator(SimpleITK.sitkLinear)\n else:\n resample.SetInterpolator(SimpleITK.sitkNearestNeighbor)\n return resample.Execute(itk_image)\n\n @staticmethod\n def image_pre_process(input_file, output_file, point_set, pad, roi_size):\n logger = logging.getLogger(__name__)\n logger.debug('Reading Image from: {}'.format(input_file))\n\n itk_image = SimpleITK.ReadImage(input_file)\n spacing = itk_image.GetSpacing()\n image_size = itk_image.GetSize()\n\n target_size = tuple(map(int, roi_size.split('x')))\n points = np.asanyarray(np.array(point_set).astype(int))\n\n logger.debug('Image Size: {}'.format(image_size))\n logger.debug('Image Spacing: {}'.format(spacing))\n logger.debug('Target Size: {}'.format(target_size))\n logger.debug('Input Points: {}'.format(json.dumps(points.tolist())))\n\n index_min = [sys.maxsize, sys.maxsize, sys.maxsize]\n index_max = [0, 0, 0]\n vx_pad = [0, 0, 0]\n for point in points:\n for i in range(3):\n vx_pad[i] = int((pad / spacing[i]) if spacing[i] > 0 else pad)\n index_min[i] = min(max(int(point[i] - vx_pad[i]), 0), int(index_min[i]))\n index_max[i] = max(min(int(point[i] + vx_pad[i]), int(image_size[i] - 1)), int(index_max[i]))\n\n logger.debug('Voxel Padding: {}'.format(vx_pad))\n logger.debug('Min Index: {}'.format(index_min))\n logger.debug('Max Index: {}'.format(index_max))\n\n crop_index = [0, 0, 0]\n crop_size = [0, 0, 0]\n crop = []\n for i in range(3):\n crop_index[i] = index_min[i]\n crop_size[i] = index_max[i] - index_min[i]\n crop.append([crop_index[i], crop_index[i] + crop_size[i]])\n logger.debug('crop_index: {}'.format(crop_index))\n logger.debug('crop_size: {}'.format(crop_size))\n logger.debug('crop: {}'.format(crop))\n\n # get bounding box\n x1 = crop[0][0]\n x2 = crop[0][1]\n y1 = crop[1][0]\n y2 = crop[1][1]\n z1 = crop[2][0]\n z2 = crop[2][1]\n\n # crop\n points[::, 0] = points[::, 0] - x1\n points[::, 1] = points[::, 1] - y1\n points[::, 2] = points[::, 2] - z1\n\n cropped_image = itk_image[x1:x2, y1:y2, z1:z2]\n cropped_size = cropped_image.GetSize()\n logger.debug('Cropped size: {}'.format(cropped_size))\n\n # resize\n out_image = AIAAUtils.resample_image(cropped_image, target_size, True)\n logger.debug('Cropped Image Size: {}'.format(out_image.GetSize()))\n SimpleITK.WriteImage(out_image, output_file, True)\n\n # pointsROI\n ratio = np.divide(np.asanyarray(target_size, dtype=np.float), np.asanyarray(cropped_size, dtype=np.float))\n points[::, 0] = points[::, 0] * ratio[0]\n points[::, 1] = points[::, 1] * ratio[1]\n points[::, 2] = points[::, 2] * ratio[2]\n return points.astype(int).tolist(), crop\n\n @staticmethod\n def image_post_processing(input_file, output_file, crop, orig_file):\n itk_image = SimpleITK.ReadImage(input_file)\n orig_crop_size = [crop[0][1] - crop[0][0], crop[1][1] - crop[1][0], crop[2][1] - crop[2][0]]\n resize_image = AIAAUtils.resample_image(itk_image, orig_crop_size, False)\n\n orig_image = SimpleITK.ReadImage(orig_file)\n orig_size = orig_image.GetSize()\n\n image = SimpleITK.GetArrayFromImage(resize_image)\n result = np.zeros(orig_size[::-1], np.uint8)\n result[crop[2][0]:crop[2][1], crop[1][0]:crop[1][1], crop[0][0]:crop[0][1]] = image\n\n itk_result = SimpleITK.GetImageFromArray(result)\n itk_result.SetDirection(orig_image.GetDirection())\n itk_result.SetSpacing(orig_image.GetSpacing())\n itk_result.SetOrigin(orig_image.GetOrigin())\n\n SimpleITK.WriteImage(itk_result, output_file, True)\n\n @staticmethod\n def http_method(method, server_url, selector):\n logger = logging.getLogger(__name__)\n logger.debug('{} {}{}'.format(method, server_url, selector))\n\n parsed = urlparse(server_url)\n if parsed.scheme == 'https':\n logger.debug('Using HTTPS mode')\n # noinspection PyProtectedMember\n conn = httplib.HTTPSConnection(parsed.hostname, parsed.port, context=ssl._create_unverified_context())\n else:\n conn = httplib.HTTPConnection(parsed.hostname, parsed.port)\n\n conn.request(method, selector)\n response = conn.getresponse()\n\n logger.debug('HTTP Response Code: {}'.format(response.status))\n logger.debug('HTTP Response Message: {}'.format(response.reason))\n logger.debug('HTTP Response Headers: {}'.format(response.getheaders()))\n return response.status, response.read()\n\n @staticmethod\n def http_multipart(method, server_url, selector, fields, files):\n logger = logging.getLogger(__name__)\n logger.debug('{} {}{}'.format(method, server_url, selector))\n\n parsed = urlparse(server_url)\n if parsed.scheme == 'https':\n logger.debug('Using HTTPS mode')\n # noinspection PyProtectedMember\n conn = httplib.HTTPSConnection(parsed.hostname, parsed.port, context=ssl._create_unverified_context())\n else:\n conn = httplib.HTTPConnection(parsed.hostname, parsed.port)\n\n content_type, body = AIAAUtils.encode_multipart_formdata(fields, files)\n headers = {'content-type': content_type, 'content-length': str(len(body))}\n conn.request(method, selector, body, headers)\n\n response = conn.getresponse()\n logger.debug('HTTP Response Code: {}'.format(response.status))\n logger.debug('HTTP Response Message: {}'.format(response.reason))\n logger.debug('HTTP Response Headers: {}'.format(response.getheaders()))\n\n response_content_type = response.getheader('content-type', content_type)\n logger.debug('HTTP Response Content-Type: {}'.format(response_content_type))\n\n if 'multipart' in response_content_type:\n if response.status == 200:\n form, files = AIAAUtils.parse_multipart(response.fp if response.fp else response, response.msg)\n logger.debug('Response FORM: {}'.format(form))\n logger.debug('Response FILES: {}'.format(files.keys()))\n return response.status, form, files\n else:\n return response.status, response.read(), None\n\n logger.debug('Reading status/content from simple response!')\n return response.status, response.read(), None\n\n @staticmethod\n def save_result(files, result_file):\n logger = logging.getLogger(__name__)\n\n if result_file is None:\n return\n\n if len(files) == 0:\n raise AIAAException(AIAAError.RESULT_NOT_FOUND, \"No result files found in server response!\")\n\n for name in files:\n data = files[name]\n logger.debug('Saving {} to {}; Size: {}'.format(name, result_file, len(data)))\n\n dir_path = os.path.dirname(os.path.realpath(result_file))\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)\n\n with open(result_file, \"wb\") as f:\n if isinstance(data, bytes):\n f.write(data)\n else:\n f.write(data.encode('utf-8'))\n break\n\n @staticmethod\n def encode_multipart_formdata(fields, files):\n limit = '----------lImIt_of_THE_fIle_eW_$'\n lines = []\n for (key, value) in fields.items():\n lines.append('--' + limit)\n lines.append('Content-Disposition: form-data; name=\"%s\"' % key)\n lines.append('')\n lines.append(value)\n for (key, filename) in files.items():\n lines.append('--' + limit)\n lines.append('Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"' % (key, filename))\n lines.append('Content-Type: %s' % AIAAUtils.get_content_type(filename))\n lines.append('')\n with open(filename, mode='rb') as f:\n data = f.read()\n lines.append(data)\n lines.append('--' + limit + '--')\n lines.append('')\n\n body = bytearray()\n for line in lines:\n body.extend(line if isinstance(line, bytes) else line.encode('utf-8'))\n body.extend(b'\\r\\n')\n\n content_type = 'multipart/form-data; boundary=%s' % limit\n return content_type, body\n\n @staticmethod\n def get_content_type(filename):\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'\n\n @staticmethod\n def parse_multipart(fp, headers):\n logger = logging.getLogger(__name__)\n fs = cgi.FieldStorage(\n fp=fp,\n environ={'REQUEST_METHOD': 'POST'},\n headers=headers,\n keep_blank_values=True\n )\n form = {}\n files = {}\n if hasattr(fs, 'list') and isinstance(fs.list, list):\n for f in fs.list:\n logger.debug('FILE-NAME: {}; NAME: {}; SIZE: {}'.format(f.filename, f.name, len(f.value)))\n if f.filename:\n files[f.filename] = f.value\n else:\n form[f.name] = f.value\n return form, files\n\n # noinspection PyUnresolvedReferences\n @staticmethod\n def urllib_quote_plus(s):\n return quote_plus(s)\n" ]	[ [ "numpy.array", "numpy.asanyarray", "numpy.zeros" ] ]
JeongsooHa/handRNN	[ "e289371f030858823cf4f002781fcf3fe5d7decf" ]	[ "online.py" ]	[ "\"\"\"\nRun the online classification system.\n\nCapture an image, classify, do it again.\n\"\"\"\nimport time\nfrom picamera import PiCamera\nfrom picamera.array import PiRGBArray\nimport tensorflow as tf\n\ndef get_labels():\n \"\"\"Get a list of labels so we can see if it's an ad or not.\"\"\"\n with open('../inception/retrained_labels.txt', 'r') as fin:\n labels = [line.rstrip('\\n') for line in fin]\n return labels\n\ndef run_classification(labels):\n \"\"\"Stream images off the camera and process them.\"\"\"\n\n camera = PiCamera()\n camera.resolution = (320, 240)\n camera.framerate = 2\n raw_capture = PiRGBArray(camera, size=(320, 240))\n\n # Warmup...\n time.sleep(2)\n\n # Unpersists graph from file\n with tf.gfile.FastGFile(\"../inception/retrained_graph.pb\", 'rb') as fin:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(fin.read())\n _ = tf.import_graph_def(graph_def, name='')\n\n with tf.Session() as sess:\n # And capture continuously forever.\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\n for _, image in enumerate(\n camera.capture_continuous(\n raw_capture, format='bgr', use_video_port=True\n )\n ):\n # Get the numpy version of the image.\n decoded_image = image.array\n\n # Make the prediction. Big thanks to this SO answer:\n # http://stackoverflow.com/questions/34484148/feeding-image-data-in-tensorflow-for-transfer-learning\n predictions = sess.run(softmax_tensor, {'DecodeJpeg:0': decoded_image})\n prediction = predictions[0]\n\n # Get the highest confidence category.\n prediction = prediction.tolist()\n max_value = max(prediction)\n max_index = prediction.index(max_value)\n predicted_label = labels[max_index]\n\n print(\"%s (%.2f%%)\" % (predicted_label, max_value * 100))\n\n # Reset the buffer so we're ready for the next one.\n raw_capture.truncate(0)\n\nif __name__ == '__main__':\n run_classification(get_labels())\n" ]	[ [ "tensorflow.Session", "tensorflow.GraphDef", "tensorflow.import_graph_def", "tensorflow.gfile.FastGFile" ] ]
omri374/fossa	[ "0ca81ba9cceecdc942832bc46e72075278a08ffe" ]	[ "tests/test_common.py" ]	[ "\"\"\"Test common fossa functionalities.\"\"\"\n\nimport pytest\nimport pandas as pd\n\nfrom fossa import LatestWindowAnomalyDetector\n\n\ndef test_bad_data():\n clf = LatestWindowAnomalyDetector(p_threshold=0.00001)\n # bad df: one-level index\n with pytest.raises(ValueError):\n df = pd.DataFrame([[1], [4]], columns=['value'])\n clf.fit(df)\n # bad df: three-level index (too deep)\n with pytest.raises(ValueError):\n df = pd.DataFrame(\n [[1], [4]], columns=['value'],\n index=pd.MultiIndex.from_tuples([[1, 2, 3], [1, 2, 4]]))\n clf.fit(df)\n # bad df: two-level index (good) by more than one column\n with pytest.raises(ValueError):\n df = pd.DataFrame(\n [[1, 6], [4, 5]], columns=['value', 'foo'],\n index=pd.MultiIndex.from_tuples([[1, 2], [1, 3]]))\n clf.fit(df)\n # bad df: two-level index (good) w/ one column (good) but non-numeric\n with pytest.raises(ValueError):\n df = pd.DataFrame(\n [['foo'], ['bar']], columns=['value'],\n index=pd.MultiIndex.from_tuples([[1, 2], [1, 3]]))\n clf.fit(df)\n" ]	[ [ "pandas.MultiIndex.from_tuples", "pandas.DataFrame" ] ]
IQSS/workshops	[ "f060ee3b883c93cb4eb1410b13c3d9f8509233d8" ]	[ "Other/RCEintro/Python_examples/power1/power.py" ]	[ "import numpy as np\nfrom scipy import stats\n\n## function to simulate data and perform a t.test\ndef sim_ttest(mu1, mu2, sd, n1, n2):\n x = stats.norm.rvs(loc = mu1, scale = sd, size = n1)\n y = stats.norm.rvs(loc = mu2, scale = sd, size = n2)\n return(stats.ttest_ind(x, y)[1])\n\n## run the function 10,000 times\nnsims = 10000\np = [sim_ttest(1, 1.3, 1, 50, 150) for x in range(nsims)]\n## calculate proportion of significant tests\nprint(len([x for x in p if x < .05])/nsims)\n" ]	[ [ "scipy.stats.ttest_ind", "scipy.stats.norm.rvs" ] ]
maruel/ml	[ "39e1883d7ee0c4393ba0b35bd7cc9ac2066e4e72" ]	[ "notebooks/deepdream.py" ]	[ "# Copyright 2021 Marc-Antoine Ruel. All rights reserved.\n# Use of this source code is governed under the Apache License, Version 2.0\n# that can be found in the LICENSE file.\n\n\"\"\"Includes tools to deep dream an image.\n\nInspired by https://www.tensorflow.org/tutorials/generative/deepdream\n\"\"\"\n\nimport logging\nimport os\nimport urllib.parse\n\n# Tell tensorflow to shut up.\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '1' # Between '0' and '3'\n\n# https://www.tensorflow.org/api_docs/python/tf/all_symbols\nimport tensorflow as tf\n# https://numpy.org/doc/stable/user/quickstart.html\nimport numpy as np\n# https://pillow.readthedocs.io/en/stable/reference/Image.html\nimport PIL.Image\n\n\n# Do not run this by default since it slows things down slightly.\n# Reminder to make sure I properly configured my GPU:\n#if not tf.config.list_physical_devices('GPU'):\n# print('WARNING: No GPU detected')\n\n\n_SAVE_INDEX = 0\n_DEEP_DREAM = None\n_DREAM_MODEL = None\n\n\ndef download(url, max_dim=None):\n \"\"\"Opens an images and returns it as a np.array with [0, 255] range.\"\"\"\n if urllib.parse.urlparse(url).scheme:\n url = tf.keras.utils.get_file(url.split('/')[-1], origin=url)\n img = PIL.Image.open(url)\n\t# Convert indexed (gif) or RGBA (png) into RGA with a white background.\n if img.mode != \"RGB\":\n if img.mode == \"P\":\n img = img.convert(\"RGBA\")\n background = PIL.Image.new(\"RGB\", img.size, (255, 255, 255))\n background.paste(img, mask=img.split()[3])\n img = background.convert(\"RGB\")\n if max_dim:\n img.thumbnail((max_dim, max_dim))\n # Convert to numpy array.\n return np.array(img)\n\n\ndef denormalize(img):\n \"\"\"Denormalizes an image from [-1, +1] to [0, 255].\"\"\"\n return tf.cast((255/2.)(img + 1.0), tf.uint8)\n\n\ndef save(img):\n \"\"\"Saves an image represented as a normalized uint8 ft.tensor.\"\"\"\n global _SAVE_INDEX\n _SAVE_INDEX = _SAVE_INDEX + 1\n if not os.path.isdir('out'):\n os.mkdir('out')\n p = os.path.join('out', '%03d.png' % _SAVE_INDEX)\n if os.path.isfile(p):\n os.remove(p)\n PIL.Image.fromarray(np.array(img)).save(p)\n print(\"Saving image %s\" % p)\n\n\ndef calc_loss(img, model):\n \"\"\"Pass forward the image through the model to retrieve the activations.\n\n Converts the image into a batch of size 1.\n\n Returns tf.float32.\n \"\"\"\n layer_activations = model(tf.expand_dims(img, axis=0))\n if len(layer_activations) == 1:\n layer_activations = [layer_activations]\n # Sum of the medians for each layers.\n medians = [tf.math.reduce_mean(tf.cast(act, tf.float32)) for act in layer_activations]\n return tf.math.reduce_sum(medians)\n\n\nclass DeepDream(tf.Module):\n def __init__(self, model):\n self.model = model\n\n @tf.function(\n input_signature=(\n tf.TensorSpec(shape=[None,None,3], dtype=tf.float32),\n tf.TensorSpec(shape=[], dtype=tf.int32),\n tf.TensorSpec(shape=[], dtype=tf.float32),)\n )\n def __call__(self, img, steps, step_size):\n loss = tf.constant(0.0, dtype=tf.float32)\n for n in tf.range(steps):\n with tf.GradientTape() as tape:\n # This needs gradients relative to `img`\n # `GradientTape` only watches `tf.Variable`s by default\n tape.watch(img)\n loss = calc_loss(img, self.model)\n # Calculate the gradient of the loss with respect to the pixels of the\n # input image.\n gradients = tape.gradient(loss, img)\n # Normalize the gradients.\n gradients /= tf.math.reduce_std(gradients) + 1e-8\n # In gradient ascent, the \"loss\" is maximized so that the input image\n # increasingly \"excites\" the layers. You can update the image by\n # directly adding the gradients (because they're the same shape!)\n p = gradientsstep_size\n img = img + p\n img = tf.clip_by_value(img, -1, 1)\n return loss, img\n\n\ndef dream_model():\n \"\"\"Lazy create the deep dream model.\"\"\"\n global _DREAM_MODEL\n if not _DREAM_MODEL:\n # Deepdream model.\n _base_model = tf.keras.applications.InceptionV3(include_top=False, weights='imagenet')\n # Maximize the activations of these layers.\n _layers = [_base_model.get_layer(name).output for name in ['mixed3', 'mixed5']]\n # Create the feature extraction model.\n _DREAM_MODEL = tf.keras.Model(inputs=_base_model.input, outputs=_layers)\n return _DREAM_MODEL\n\n\ndef deepdream(args, kwargs):\n \"\"\"Runs deep dream on an image.\n\n Lazy load the model.\n \"\"\"\n global _DEEP_DREAM\n if not _DEEP_DREAM:\n _DEEP_DREAM = DeepDream(dream_model())\n return _DEEP_DREAM(args, **kwargs)\n\n\ndef run_deep_dream_simple(img, steps, step_size, steps_per_output=100):\n \"\"\"Generates multiple deep dream images.\n\n Args:\n img: np.array\n\n Returns:\n list of normalized [-1, +1] deep dreamed images. Includes the original\n image.\n \"\"\"\n # Convert from uint8 [0, +255] to the range expected by the model, which is\n # float32 [-1, +1].\n # https://www.tensorflow.org/api_docs/python/tf/keras/applications/inception_v3/preprocess_input\n img = tf.keras.applications.inception_v3.preprocess_input(img)\n # https://www.tensorflow.org/api_docs/python/tf/convert_to_tensor\n img = tf.convert_to_tensor(img, dtype=tf.float32)\n step_size = tf.constant(step_size, dtype=tf.float32)\n steps_remaining = steps\n step = 0\n run_steps = tf.constant(steps_per_output)\n out = [img]\n while steps_remaining:\n if steps_remaining < run_steps:\n run_steps = tf.constant(steps_remaining)\n steps_remaining -= run_steps\n loss, img = deepdream(img, run_steps, step_size)\n out.append(img)\n step += run_steps\n logging.info(\"Step {}, loss {:.2f}\".format(step, loss))\n return out\n" ]	[ [ "tensorflow.convert_to_tensor", "tensorflow.clip_by_value", "tensorflow.constant", "tensorflow.range", "tensorflow.cast", "tensorflow.keras.applications.InceptionV3", "tensorflow.expand_dims", "tensorflow.keras.Model", "tensorflow.math.reduce_std", "tensorflow.math.reduce_sum", "numpy.array", "tensorflow.keras.applications.inception_v3.preprocess_input", "tensorflow.TensorSpec", "tensorflow.GradientTape" ] ]
colorfullywonderfully/RS-Inspection	[ "799e1c12a19ee13cd4a1e23760b4d4e43e5f5794" ]	[ "rail_location.py" ]	[ "\r\nimport numpy as np\r\nimport cv2\r\nfrom pylab import *\r\n\r\ndef convolution(Img):\r\n\r\n p = 50\r\n # 计数\r\n count = 0\r\n\r\n #Img = np.array(cv2.imread('1.jpeg',0),dtype= int64)#直接读为灰度图像\r\n #plt.imshow(Img,'gray')\r\n #plt.show()\r\n #print(Img)\r\n rows,cols=Img.shape ## 行列\r\n #print(rows,cols)\r\n window = []\r\n\r\n for col_index in range(cols):\r\n if (col_index + p) > cols:\r\n break\r\n \r\n temp_matrix = Img[:, (col_index) : (col_index + p)]\r\n count = count + 1\r\n M = mean(temp_matrix)\r\n window.append(M)\r\n _argmax = np.argmax(window)\r\n\r\n return _argmax\r\n\r\n" ]	[ [ "numpy.argmax" ] ]
snemistry/spotlight	[ "830a65c462119d8cd47ece104246ff16f67dcea9" ]	[ "experimental/50-3-bpr-MLP-adaptive-lr-001-mom-92-l2-04.py" ]	[ "from spotlight.cross_validation import random_train_test_split\nfrom spotlight.datasets.movielens import get_movielens_dataset\nfrom spotlight.evaluation import mrr_score\nfrom spotlight.factorization.implicit import ImplicitFactorizationModel\nfrom spotlight.interactions import Interactions\nimport pandas as pd\nfrom spotlight.evaluation import \nfrom torch.utils.tensorboard import SummaryWriter\nimport torch\nfrom torch.utils.tensorboard import SummaryWriter\nimport logging\nfrom spotlight.factorization.representations import \n\ntrain_sample = 1.0\nuse_cuda=True\n\ntensorboard_base_dir=\"runs\"\nmodel_alias = \"50-3-bpr-MLP-adaptive-lr-001-mom-92-l2-04\"\nmodel_store_dir=\"models\"\nnet_conf = \"50-3-bpr-MLP\"\nn_iters=30\n#loss=\"adaptive_hinge\"\nloss=\"bpr\"\nlr=1e-3\nl2=1e-4\nbetas=(0.92, 0.999)\nnum_negative_samples=5\nlog_loss_interval=100\nlog_eval_interval=5000\nbatch_size=1024\n#train_data_path = \"s3a://tubi-playground-production/smistry/emb3/train-aug-28-phase1\"\ntrain_data_path = \"data/train-aug-28-phase1\"\n\nlogging.basicConfig(filename=\"logs/\" + model_alias + '.log', \n filemode='w', \n format='%(asctime)s - %(message)s',\n level=logging.INFO)\n\nlogger = logging.getLogger()\nlogger.setLevel(logging.DEBUG)\n\noriginal_train_data = pd.read_parquet(train_data_path)\nlogger.info(\"Data is loaded\")\nwriter = SummaryWriter(log_dir='{}/{}'.format(tensorboard_base_dir, model_alias))\nwriter.add_text('alias', model_alias, 0)\n\ndef notify_loss_completion(epoch_id, batch_id, loss, net, model):\n #print(\"notify_loss_completion\")\n writer.add_scalar(\"Batch/loss\", loss, batch_id)\n logging.info('[Epoch {}] Batch {}, Loss {}'.format(epoch_id, batch_id, loss))\n\ndef notify_batch_eval_completion(epoch_id, batch_id, loss, net, model):\n #print(\"notify_batch_eval_completion\")\n pairs_ndcg = nn_pairs_ndcg_score(net)\n writer.add_scalar(\"Batch/pairs_ndcg\", pairs_ndcg, batch_id)\n logging.info('[Epoch {}] Batch {}, Embs NDCG = {:.4f}'.format(epoch_id, batch_id, pairs_ndcg))\n \ndef notify_epoch_completion(epoch_num, total_loss, net, model):\n #print(\"notify_epoch_completion\")\n writer.add_scalar(\"Epoch/loss\", total_loss, epoch_num)\n pairs_ndcg = nn_pairs_ndcg_score(net)\n writer.add_scalar(\"Epoch/pairs_ndcg\", pairs_ndcg, epoch_num)\n# hit_ratio, ndcg = evaluate_hit_ratio_and_ndcg(model)\n# writer.add_scalar(\"Epoch/HR\", hit_ratio, epoch_num)\n# writer.add_scalar(\"Epoch/NDCG\", ndcg, epoch_num)\n hit_ratio, ndcg = -1,-1\n logging.info('******** [Epoch {}] Embs NDCG {:.4f}, Hit Ratio: {:.4f}, NDCG: {:.4f}'.format(epoch_num,\n pairs_ndcg,\n hit_ratio,\n ndcg))\n torch.save(net, model_store_dir + \"/\" + model_alias + \"-\" + str(epoch_num))\n \nnum_users=len(original_train_data[\"uindex\"].unique())\nnum_items=len(original_train_data[\"vindex\"].unique())\n\ntrain_data = original_train_data.sample(frac=train_sample)\n\ninteractions = Interactions(train_data[\"uindex\"].to_numpy(),\n train_data[\"vindex\"].to_numpy(),\n train_data[\"pct_cvt\"].to_numpy(),\n train_data[\"latest_watch_time\"].to_numpy(),\n num_users=len(original_train_data[\"uindex\"].unique()),\n num_items=len(original_train_data[\"vindex\"].unique()))\n\n\nif \"-\" in net_conf:\n args = net_conf.split(\"-\")\n config = {\n \"factor_size\": int(args[0]),\n \"num_layers\": int(args[1]),\n \"loss_type\": args[2],\n \"model_type\": args[3],\n \"num_users\": num_users,\n \"num_items\": num_items,\n }\n \n num_layers = int(args[1])\n factor_size = int(args[0])\n config[\"layers\"] = [4 * factor_size] + [factor_size * (2 ** i) for i in range(num_layers - 1, -1, -1)]\n config[\"latent_dim\"] = 2 * factor_size\n writer.add_text('config', str(config), 0)\n \n rep = MLP(config)\nelse:\n rep = None\n\nmodel = ImplicitFactorizationModel(n_iter=n_iters,\n loss=loss,\n notify_loss_completion=notify_loss_completion,\n notify_batch_eval_completion=notify_batch_eval_completion,\n notify_epoch_completion=notify_epoch_completion,\n log_loss_interval=log_loss_interval,\n log_eval_interval=log_eval_interval,\n betas=betas,\n learning_rate=lr,\n batch_size=batch_size,\n random_state=np.random.RandomState(2),\n num_negative_samples=num_negative_samples,\n l2=l2,\n use_cuda=use_cuda,\n representation=rep)\nlogger.info(\"Model is initialized, now fitting..\")\nmodel.fit(interactions)" ]	[ [ "pandas.read_parquet" ] ]
DominickZhang/Distillation-Swin-Transformer	[ "6fc7b25bd558edb14e6f15715f53612c37e5166f" ]	[ "models/swin_transformer_distill_jinnian.py" ]	[ "import torch\nimport torch.nn as nn\nfrom timm.models.layers import trunc_normal_, to_2tuple, DropPath\nfrom .swin_transformer import Mlp, window_partition, window_reverse, PatchEmbed, PatchMerging\nimport torch.utils.checkpoint as checkpoint\n\n\nclass WindowAttentionDistill(nn.Module):\n r\"\"\" Window based multi-head self attention (W-MSA) module with relative position bias.\n It supports both of shifted and non-shifted window.\n\n Args:\n dim (int): Number of input channels.\n window_size (tuple[int]): The height and width of the window.\n num_heads (int): Number of attention heads.\n qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float \| None, optional): Override default qk scale of head_dim -0.5 if set\n attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0\n proj_drop (float, optional): Dropout ratio of output. Default: 0.0\n \"\"\"\n\n def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):\n\n super().__init__()\n self.dim = dim\n self.window_size = window_size # Wh, Ww\n self.num_heads = num_heads\n head_dim = dim // num_heads\n self.scale = qk_scale or head_dim -0.5\n\n # define a parameter table of relative position bias\n self.relative_position_bias_table = nn.Parameter(\n torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # 2Wh-1 2Ww-1, nH\n\n # get pair-wise relative position index for each token inside the window\n coords_h = torch.arange(self.window_size[0])\n coords_w = torch.arange(self.window_size[1])\n coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww\n coords_flatten = torch.flatten(coords, 1) # 2, WhWw\n relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, WhWw, WhWw\n relative_coords = relative_coords.permute(1, 2, 0).contiguous() # WhWw, WhWw, 2\n relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0\n relative_coords[:, :, 1] += self.window_size[1] - 1\n relative_coords[:, :, 0] = 2 self.window_size[1] - 1\n relative_position_index = relative_coords.sum(-1) # WhWw, WhWw\n self.register_buffer(\"relative_position_index\", relative_position_index)\n\n self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)\n self.attn_drop = nn.Dropout(attn_drop)\n self.proj = nn.Linear(dim, dim)\n self.proj_drop = nn.Dropout(proj_drop)\n\n trunc_normal_(self.relative_position_bias_table, std=.02)\n self.softmax = nn.Softmax(dim=-1)\n\n def forward(self, x, mask=None):\n \"\"\"\n Args:\n x: input features with shape of (num_windowsB, N, C)\n mask: (0/-inf) mask with shape of (num_windows, WhWw, WhWw) or None\n \"\"\"\n B_, N, C = x.shape\n qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)\n q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)\n\n q = q self.scale\n attn = (q @ k.transpose(-2, -1))\n\n relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(\n self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1) # WhWw,WhWw,nH\n relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, WhWw, WhWw\n attn = attn + relative_position_bias.unsqueeze(0) #B, nHead, WhWw, WhWw\n\n if mask is not None:\n nW = mask.shape[0]\n attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)\n attn = attn.view(-1, self.num_heads, N, N)\n attn_logits = attn\n attn = self.softmax(attn)\n else:\n attn_logits = attn\n attn = self.softmax(attn)\n\n attn = self.attn_drop(attn)\n\n x = (attn @ v).transpose(1, 2).reshape(B_, N, C)\n x = self.proj(x)\n x = self.proj_drop(x)\n return x, attn_logits\n\n def extra_repr(self) -> str:\n return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'\n\n def flops(self, N):\n # calculate flops for 1 window with token length of N\n flops = 0\n # qkv = self.qkv(x)\n flops += N * self.dim * 3 * self.dim\n # attn = (q @ k.transpose(-2, -1))\n flops += self.num_heads * N * (self.dim // self.num_heads) * N\n # x = (attn @ v)\n flops += self.num_heads * N * N * (self.dim // self.num_heads)\n # x = self.proj(x)\n flops += N * self.dim * self.dim\n return flops\n\nclass SwinTransformerBlockDistill(nn.Module):\n r\"\"\" Swin Transformer Block.\n\n Args:\n dim (int): Number of input channels.\n input_resolution (tuple[int]): Input resulotion.\n num_heads (int): Number of attention heads.\n window_size (int): Window size.\n shift_size (int): Shift size for SW-MSA.\n mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.\n qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float \| None, optional): Override default qk scale of head_dim ** -0.5 if set.\n drop (float, optional): Dropout rate. Default: 0.0\n attn_drop (float, optional): Attention dropout rate. Default: 0.0\n drop_path (float, optional): Stochastic depth rate. Default: 0.0\n act_layer (nn.Module, optional): Activation layer. Default: nn.GELU\n norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm\n \"\"\"\n\n def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,\n mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,\n act_layer=nn.GELU, norm_layer=nn.LayerNorm):\n super().__init__()\n self.dim = dim\n self.input_resolution = input_resolution\n self.num_heads = num_heads\n self.window_size = window_size\n self.shift_size = shift_size\n self.mlp_ratio = mlp_ratio\n if min(self.input_resolution) <= self.window_size:\n # if window size is larger than input resolution, we don't partition windows\n self.shift_size = 0\n self.window_size = min(self.input_resolution)\n assert 0 <= self.shift_size < self.window_size, \"shift_size must in 0-window_size\"\n\n self.norm1 = norm_layer(dim)\n self.attn = WindowAttentionDistill(\n dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,\n qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)\n\n self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()\n self.norm2 = norm_layer(dim)\n mlp_hidden_dim = int(dim * mlp_ratio)\n self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)\n\n if self.shift_size > 0:\n # calculate attention mask for SW-MSA\n H, W = self.input_resolution\n img_mask = torch.zeros((1, H, W, 1)) # 1 H W 1\n h_slices = (slice(0, -self.window_size),\n slice(-self.window_size, -self.shift_size),\n slice(-self.shift_size, None))\n w_slices = (slice(0, -self.window_size),\n slice(-self.window_size, -self.shift_size),\n slice(-self.shift_size, None))\n cnt = 0\n for h in h_slices:\n for w in w_slices:\n img_mask[:, h, w, :] = cnt\n cnt += 1\n\n mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1\n mask_windows = mask_windows.view(-1, self.window_size * self.window_size)\n attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)\n attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))\n else:\n attn_mask = None\n\n self.register_buffer(\"attn_mask\", attn_mask)\n\n def forward(self, x):\n H, W = self.input_resolution\n B, L, C = x.shape\n assert L == H * W, \"input feature has wrong size\"\n\n shortcut = x\n x = self.norm1(x)\n x = x.view(B, H, W, C)\n\n # cyclic shift\n if self.shift_size > 0:\n shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))\n else:\n shifted_x = x\n\n # partition windows\n x_windows = window_partition(shifted_x, self.window_size) # nWB, window_size, window_size, C\n x_windows = x_windows.view(-1, self.window_size self.window_size, C) # nWB, window_sizewindow_size, C\n\n # W-MSA/SW-MSA\n attn_windows, attn_matrices = self.attn(x_windows, mask=self.attn_mask) # nWB, window_sizewindow_size, C; B, nHead, WhWw, WhWw\n\n # merge windows\n attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)\n shifted_x = window_reverse(attn_windows, self.window_size, H, W) # B H' W' C\n\n # reverse cyclic shift\n if self.shift_size > 0:\n x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))\n else:\n x = shifted_x\n x = x.view(B, H * W, C)\n\n # FFN\n x = shortcut + self.drop_path(x)\n x = x + self.drop_path(self.mlp(self.norm2(x)))\n\n return x, attn_matrices\n\n def extra_repr(self) -> str:\n return f\"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, \" \\\n f\"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}\"\n\n def flops(self):\n flops = 0\n H, W = self.input_resolution\n # norm1\n flops += self.dim * H * W\n # W-MSA/SW-MSA\n nW = H * W / self.window_size / self.window_size\n flops += nW * self.attn.flops(self.window_size * self.window_size)\n # mlp\n flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio\n # norm2\n flops += self.dim * H * W\n return flops\n\nclass BasicLayerDistill(nn.Module):\n \"\"\" A basic Swin Transformer layer for one stage.\n\n Args:\n dim (int): Number of input channels.\n input_resolution (tuple[int]): Input resolution.\n depth (int): Number of blocks.\n num_heads (int): Number of attention heads.\n window_size (int): Local window size.\n mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.\n qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float \| None, optional): Override default qk scale of head_dim ** -0.5 if set.\n drop (float, optional): Dropout rate. Default: 0.0\n attn_drop (float, optional): Attention dropout rate. Default: 0.0\n drop_path (float \| tuple[float], optional): Stochastic depth rate. Default: 0.0\n norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm\n downsample (nn.Module \| None, optional): Downsample layer at the end of the layer. Default: None\n use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.\n \"\"\"\n\n def __init__(self, dim, input_resolution, depth, num_heads, window_size,\n mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,\n drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False,\n return_midlayer_num=0,\n is_student=False,\n is_return_all_layers=False,\n ):\n\n super().__init__()\n self.dim = dim\n self.input_resolution = input_resolution\n self.depth = depth\n self.use_checkpoint = use_checkpoint\n\n # build blocks\n self.blocks = nn.ModuleList([\n SwinTransformerBlockDistill(dim=dim, input_resolution=input_resolution,\n num_heads=num_heads, window_size=window_size,\n shift_size=0 if (i % 2 == 0) else window_size // 2,\n mlp_ratio=mlp_ratio,\n qkv_bias=qkv_bias, qk_scale=qk_scale,\n drop=drop, attn_drop=attn_drop,\n drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,\n norm_layer=norm_layer)\n for i in range(depth)])\n\n ## Distillation\n self.return_midlayer_num = return_midlayer_num\n self.is_student = is_student\n self.is_return_all_layers = is_return_all_layers\n if self.is_student and self.is_return_all_layers:\n self.return_id_list = list(range(self.return_midlayer_num))\n elif self.is_return_all_layers:\n ## Get uniform distributed indices of the layers to be returned\n interval = float(return_midlayer_num)/depth\n self.return_id_list = []\n count = 0\n while len(self.return_id_list) < return_midlayer_num:\n new_index = int(countinterval)\n if new_index not in self.return_id_list:\n self.return_id_list.append(new_index)\n count += 1\n else:\n self.return_id_list = []\n\n # patch merging layer\n if downsample is not None:\n self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)\n else:\n self.downsample = None\n\n def forward(self, x):\n attn_outputs = []\n hidden_outputs = []\n #hidden_outputs.append(x)\n if self.is_return_all_layers:\n count = 0\n for blk in self.blocks:\n if self.use_checkpoint:\n x, attn = checkpoint.checkpoint(blk, x)\n else:\n x, attn = blk(x)\n if count in self.return_id_list:\n attn_outputs.append(attn)\n hidden_outputs.append(x)\n count += 1\n else:\n for blk in self.blocks:\n if self.use_checkpoint:\n x, attn = checkpoint.checkpoint(blk, x)\n else:\n x, attn = blk(x)\n if self.downsample is not None:\n x = self.downsample(x)\n return x, attn_outputs, hidden_outputs\n\n def extra_repr(self) -> str:\n return f\"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}\"\n\n def flops(self):\n flops = 0\n for blk in self.blocks:\n flops += blk.flops()\n if self.downsample is not None:\n flops += self.downsample.flops()\n return flops\n\n\nclass SwinTransformerDistill(nn.Module):\n r\"\"\" Swin Transformer\n A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` -\n https://arxiv.org/pdf/2103.14030\n\n Args:\n img_size (int \| tuple(int)): Input image size. Default 224\n patch_size (int \| tuple(int)): Patch size. Default: 4\n in_chans (int): Number of input image channels. Default: 3\n num_classes (int): Number of classes for classification head. Default: 1000\n embed_dim (int): Patch embedding dimension. Default: 96\n depths (tuple(int)): Depth of each Swin Transformer layer.\n num_heads (tuple(int)): Number of attention heads in different layers.\n window_size (int): Window size. Default: 7\n mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4\n qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float): Override default qk scale of head_dim * -0.5 if set. Default: None\n drop_rate (float): Dropout rate. Default: 0\n attn_drop_rate (float): Attention dropout rate. Default: 0\n drop_path_rate (float): Stochastic depth rate. Default: 0.1\n norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.\n ape (bool): If True, add absolute position embedding to the patch embedding. Default: False\n patch_norm (bool): If True, add normalization after patch embedding. Default: True\n use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False\n \"\"\"\n\n def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000,\n embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24],\n window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,\n drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,\n norm_layer=nn.LayerNorm, ape=False, patch_norm=True,\n use_checkpoint=False,\n ## The following parameters are for distillation\n is_student = False,\n fit_size_C = 192,\n fit_size_M = 6,\n return_midlayer_num = [2, 2, 6, 2],\n is_return_all_layers = False,\n *kwargs):\n super().__init__()\n\n self.num_classes = num_classes\n self.num_layers = len(depths)\n self.embed_dim = embed_dim\n self.ape = ape\n self.patch_norm = patch_norm\n self.num_features = int(embed_dim 2 ** (self.num_layers - 1))\n self.mlp_ratio = mlp_ratio\n\n # split image into non-overlapping patches\n self.patch_embed = PatchEmbed(\n img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,\n norm_layer=norm_layer if self.patch_norm else None)\n num_patches = self.patch_embed.num_patches\n patches_resolution = self.patch_embed.patches_resolution\n self.patches_resolution = patches_resolution\n\n # absolute position embedding\n if self.ape:\n self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))\n trunc_normal_(self.absolute_pos_embed, std=.02)\n\n self.pos_drop = nn.Dropout(p=drop_rate)\n\n # stochastic depth\n dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule\n\n # build layers\n self.layers = nn.ModuleList()\n for i_layer in range(self.num_layers):\n layer = BasicLayerDistill(dim=int(embed_dim * 2 i_layer),\n input_resolution=(patches_resolution[0] // (2 i_layer),\n patches_resolution[1] // (2 ** i_layer)),\n depth=depths[i_layer],\n num_heads=num_heads[i_layer],\n window_size=window_size,\n mlp_ratio=self.mlp_ratio,\n qkv_bias=qkv_bias, qk_scale=qk_scale,\n drop=drop_rate, attn_drop=attn_drop_rate,\n drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],\n norm_layer=norm_layer,\n downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,\n use_checkpoint=use_checkpoint,\n return_midlayer_num=return_midlayer_num[i_layer],\n is_return_all_layers=is_return_all_layers,\n is_student=is_student)\n self.layers.append(layer)\n\n self.norm = norm_layer(self.num_features)\n self.avgpool = nn.AdaptiveAvgPool1d(1)\n self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()\n\n ## The following sections are for initialization of distillation\n self.is_return_all_layers = is_return_all_layers\n self.is_student = is_student\n self.fit_size_C = fit_size_C\n self.fit_size_M = fit_size_M\n self.return_midlayer_num = return_midlayer_num\n self.fit_dense_C = nn.ModuleList()\n self.fit_dense_M = nn.ModuleList()\n if self.is_student:\n for i_layer in range(self.num_layers):\n self.fit_dense_C.append(nn.Linear(int(embed_dim * 2 ** i_layer), int(fit_size_C* 2 ** i_layer)))\n self.fit_dense_M.append(nn.Linear(num_heads[i_layer], int(fit_size_M* 2 ** i_layer)))\n \n self.apply(self._init_weights)\n\n def _init_weights(self, m):\n if isinstance(m, nn.Linear):\n trunc_normal_(m.weight, std=.02)\n if isinstance(m, nn.Linear) and m.bias is not None:\n nn.init.constant_(m.bias, 0)\n elif isinstance(m, nn.LayerNorm):\n nn.init.constant_(m.bias, 0)\n nn.init.constant_(m.weight, 1.0)\n\n @torch.jit.ignore\n def no_weight_decay(self):\n return {'absolute_pos_embed'}\n\n @torch.jit.ignore\n def no_weight_decay_keywords(self):\n return {'relative_position_bias_table'}\n\n def forward_features(self, x, stage=None):\n if stage is None:\n x = self.patch_embed(x)\n if self.ape:\n x = x + self.absolute_pos_embed \n x = self.pos_drop(x)\n\n for index, layer in enumerate(self.layers):\n x, _, _ = layer(x)\n\n x = self.norm(x) # B L C\n x = self.avgpool(x.transpose(1, 2)) # B C 1\n x = torch.flatten(x, 1)\n return x, [], []\n else:\n if stage > 0:\n with torch.no_grad():\n x = self.patch_embed(x) # self.patch_embed\n if self.ape:\n x = x + self.absolute_pos_embed # self.absolute_pos_embed\n x = self.pos_drop(x)\n else:\n x = self.patch_embed(x) # self.patch_embed\n if self.ape:\n x = x + self.absolute_pos_embed # self.absolute_pos_embed\n x = self.pos_drop(x)\n\n attn_list = []\n hidden_list = []\n for index, layer in enumerate(self.layers):\n if index < stage:\n with torch.no_grad():\n x, _, _ = layer(x)\n else:\n x, attn, hidden = layer(x)\n if self.is_student:\n for i, hidden_ele in enumerate(hidden):\n hidden_list.append(self.fit_dense_C[index](hidden_ele))\n for i, attn_ele in enumerate(attn):\n B, H, W, W = attn_ele.shape\n attn_ele = attn_ele.transpose(-1, -3).reshape(-1, H)\n attn_list.append(self.fit_dense_M[index](attn_ele).reshape(B, W, W, -1).transpose(-1, -3))\n else:\n attn_list += attn\n hidden_list += hidden\n if stage >= 0:\n break\n return [], attn_list, hidden_list\n\n def forward(self, x, stage=None):\n x, attn_outputs, hidden_outputs = self.forward_features(x, stage)\n if stage is None:\n return self.head(x)\n else:\n return attn_outputs, hidden_outputs\n\n def flops(self):\n flops = 0\n flops += self.patch_embed.flops()\n for i, layer in enumerate(self.layers):\n flops += layer.flops()\n flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers)\n flops += self.num_features * self.num_classes\n return flops\n" ]	[ [ "torch.nn.Softmax", "torch.nn.Dropout", "torch.zeros", "torch.nn.init.constant_", "torch.nn.ModuleList", "torch.arange", "torch.nn.Linear", "torch.nn.Identity", "torch.utils.checkpoint.checkpoint", "torch.no_grad", "torch.flatten", "torch.roll", "torch.nn.AdaptiveAvgPool1d", "torch.meshgrid" ] ]
cguevaramorel/ogs6py	[ "f6ed1d3aa694048175f59f4a467097f32332a0c0" ]	[ "ogs6py/log_parser/log_parser.py" ]	[ "#!/usr/bin/env python\n\n# Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org)\n# Distributed under a Modified BSD License.\n# See accompanying file LICENSE.txt or\n# http://www.opengeosys.org/project/license\n\nimport re\nimport sys\nfrom dataclasses import dataclass, field\nimport pandas as pd\nfrom typing import List\n\n@dataclass\nclass ComponentConvergence(object):\n number: int\n dx: float\n x: float\n dx_relative: float\n index_name: str = \"component_convergence/\"\n\n def to_dict(self, prefix):\n yield {\n prefix + self.index_name + \"number\": self.number,\n prefix + self.index_name + \"dx\": self.dx,\n prefix + self.index_name + \"x\": self.x,\n prefix + self.index_name + \"dx_relative\": self.dx_relative,\n }\n\n\n@dataclass\nclass Iteration(object):\n number: int\n assembly_time: float # seconds\n dirichlet_bc_time: float # seconds\n linear_solver_time: float # seconds\n cpu_time: float # seconds\n component_convergence: List[ComponentConvergence] = field(default_factory=list)\n index_name: str = \"iteration/\"\n\n def _dict(self, prefix):\n return {\n prefix + self.index_name + \"number\": self.number,\n prefix + self.index_name + \"assembly_time\": self.assembly_time,\n prefix + self.index_name + \"dirichlet_bc_time\": self.dirichlet_bc_time,\n prefix + self.index_name + \"linear_solver_time\": self.linear_solver_time,\n prefix + self.index_name + \"cpu_time\": self.cpu_time,\n }\n\n def to_dict(self, prefix):\n for c in self.component_convergence:\n for d in c.to_dict(prefix + self.index_name):\n yield self._dict(prefix) \| d\n\n\n@dataclass\nclass TimeStep(object):\n number: int\n t: float # simulation time\n dt: float # simulation time increment\n iterations: List[Iteration] = field(default_factory=list)\n cpu_time: float = None # seconds\n output_time: float = None # seconds\n index_name: str = \"time_step/\"\n\n def _dict(self):\n return {\n self.index_name + \"number\": self.number,\n self.index_name + \"t\": self.t,\n self.index_name + \"dt\": self.dt,\n self.index_name + \"cpu_time\": self.cpu_time,\n self.index_name + \"output_time\": self.output_time,\n }\n\n def to_dict(self, prefix):\n for i in self.iterations:\n for d in i.to_dict(self.index_name):\n yield self._dict() \| d\n\n\n@dataclass\nclass Simulation(object):\n timesteps: List[TimeStep] = field(default_factory=list)\n mesh_read_time: float = None # seconds\n execution_time: float = None # seconds\n\n def __len__(self):\n \"\"\"Number of time steps\"\"\"\n return len(self.timesteps)\n\n def _dict(self):\n return {\n \"execution_time\": self.execution_time,\n }\n\n def __iter__(self):\n for t in self.timesteps:\n for d in t.to_dict(\"\"):\n yield self._dict() \| d\n\n\n_re_iteration = [\n re.compile(\"info: \\[time\\] Iteration #(\\d+) took ([\\d\\.e+s]+) s\"),\n int,\n float,\n]\n_re_time_step_start = [\n re.compile(\n \"info: === Time stepping at step #(\\d+) and time ([\\d\\.e+s]+) with step size (.)\"\n ),\n int,\n float,\n float,\n]\n_re_time_step_output = [\n re.compile(\"info: \\[time\\] Output of timestep (\\d+) took ([\\d\\.e+s]+) s\"),\n int,\n float,\n]\n_re_time_step_solution_time = [\n re.compile(\n \"info: \\[time\\] Solving process #(\\d+) took ([\\d\\.e+s]+) s in time step #(\\d+)\"\n ),\n int,\n float,\n int,\n]\n_re_time_step_finished = [\n re.compile(\"info: \\[time\\] Time step #(\\d+) took ([\\d\\.e+s]+) s\"),\n int,\n float,\n]\n\n_re_assembly_time = [re.compile(\"info: \\[time\\] Assembly took ([\\d\\.e+s]+) s\"), float]\n_re_dirichlet_bc_time = [\n re.compile(\"info: \\[time\\] Applying Dirichlet BCs took ([\\d\\.e+s]+) s\"),\n float,\n]\n_re_linear_solver_time = [\n re.compile(\"info: \\[time\\] Linear solver took ([\\d\\.e+s]+) s\"),\n float,\n]\n# _re_reading_mesh = [re.compile(\".?time.?Reading the mesh took ([\\d\\.e+s]+) s\"), float]\n_re_execution_time = [re.compile(\"info: \\[time\\] Execution took ([\\d\\.e+s]+) s\"), float]\n\n_re_component_convergence = [\n re.compile(\n \"info: Convergence criterion, component (\\d+): \\\|dx\\\|=([\\d\\.e+-]+), \\\|x\\\|=([\\d\\.e+-]+), \\\|dx\\\|/\\\|x\\\|=([\\d\\.e+-]+)$\"\n ),\n int,\n float,\n float,\n float,\n]\n\n\ndef _tryMatch(line: str, regex: re.Pattern, ctors):\n if match := regex.match(line):\n return [ctor(s) for ctor, s in zip(ctors, match.groups())]\n return None\n\n\ndef parse_file(filename, maximum_timesteps=None, maximum_lines=None):\n\n tss = []\n execution_time = None\n mesh_read_time = None\n\n ts = TimeStep(\n number=0,\n t=0.0, # Note: initial time is not set correctly.\n dt=None,\n iterations=[],\n cpu_time=None,\n )\n\n assembly_time = None\n dirichlet_bc_time = None\n linear_solver_time = None\n component_convergence = []\n\n number_of_lines_read = 0\n for line in open(filename):\n number_of_lines_read += 1\n\n if r := _tryMatch(line, _re_iteration):\n ts.iterations.append(\n Iteration(\n number=r[0],\n assembly_time=assembly_time,\n dirichlet_bc_time=dirichlet_bc_time,\n linear_solver_time=linear_solver_time,\n component_convergence=component_convergence,\n cpu_time=r[1],\n )\n )\n # Reset parsed quantities to avoid reusing old values for next iterations\n assembly_time = None\n dirichlet_bc_time = None\n linear_solver_time = None\n component_convergence = []\n continue\n\n if r := _tryMatch(line, _re_assembly_time):\n assembly_time = r[0]\n continue\n\n if r := _tryMatch(line, _re_dirichlet_bc_time):\n dirichlet_bc_time = r[0]\n continue\n\n if r := _tryMatch(line, _re_linear_solver_time):\n linear_solver_time = r[0]\n continue\n\n if r := _tryMatch(line, _re_component_convergence):\n component_convergence.append(\n ComponentConvergence(number=r[0], dx=r[1], x=r[2], dx_relative=r[3])\n )\n continue\n\n if r := _tryMatch(line, _re_time_step_start):\n # print(\"Finished ts\", ts)\n tss.append(ts)\n ts = TimeStep(number=r[0], t=r[1], dt=r[2])\n # print(\"New timestep\", ts, \"\\n\")\n if (\n ts\n and (maximum_timesteps is not None)\n and (ts.number > maximum_timesteps)\n ) or ((maximum_lines is not None) and (number_of_lines_read >\n maximum_lines)):\n break\n continue\n\n if r := _tryMatch(line, _re_time_step_solution_time):\n # r[0] is process number and is ignored for now.\n# if ts.number != r[2]:\n# raise RuntimeError(\n# \"Solution time for wrong time step\", r[2], \"current time step\", ts\n# )\n ts.solution_time = r[1]\n continue\n\n if r := _tryMatch(line, _re_time_step_output):\n# if ts.number != r[0]:\n# raise RuntimeError(\n# \"Output time for wrong time step\", r[0], \"current time step\", ts\n# )\n ts.output_time = r[1]\n continue\n\n if r := _tryMatch(line, _re_time_step_finished):\n# if ts.number != r[0]:\n# raise RuntimeError(\n# \"Total time for wrong time step\", r[0], \"current time step\", ts\n# )\n ts.cpu_time = r[1]\n continue\n\n # if r := _tryMatch(line, _re_reading_mesh):\n # mesh_read_time = r[0]\n # continue\n\n if r := _tryMatch(line, *_re_execution_time):\n execution_time = r[0]\n\n # print(\"Finished ts\", ts)\n tss.append(ts)\n continue\n\n return Simulation(\n timesteps=tss, mesh_read_time=mesh_read_time, execution_time=execution_time\n )\nif __name__ == \"__main__\":\n filename = sys.argv[1]\n data = parse_file(sys.argv[1], maximum_timesteps=None, maximum_lines=None)\n df = pd.DataFrame(data)\n filename_prefix = filename.split('.')[0]\n df.to_csv(f\"{filename_prefix}.csv\")\n" ]	[ [ "pandas.DataFrame" ] ]
jchibane/if-net_texture	[ "989ffdc9afc0296d92a55a7a1f155c1cc3e6e5e4" ]	[ "models/training.py" ]	[ "from __future__ import division\nimport torch\nimport torch.optim as optim\nfrom torch.nn import functional as F\nimport os\nfrom glob import glob\nimport numpy as np\n\n\n\n\nclass Trainer(object):\n\n def __init__(self, model, device, train_dataset, val_dataset, exp_name, optimizer='Adam'):\n self.model = model.to(device)\n self.device = device\n if optimizer == 'Adam':\n self.optimizer = optim.Adam(self.model.parameters(), lr=1e-4)\n if optimizer == 'Adadelta':\n self.optimizer = optim.Adadelta(self.model.parameters())\n if optimizer == 'RMSprop':\n self.optimizer = optim.RMSprop(self.model.parameters(), momentum=0.9)\n\n self.train_dataset = train_dataset\n self.val_dataset = val_dataset\n self.exp_path = os.path.dirname(__file__) + '/../experiments/{}/'.format( exp_name)\n self.checkpoint_path = self.exp_path + 'checkpoints/'\n if not os.path.exists(self.checkpoint_path):\n print(self.checkpoint_path)\n os.makedirs(self.checkpoint_path)\n self.val_min = None\n\n\n def train_step(self,batch):\n self.model.train()\n self.optimizer.zero_grad()\n loss = self.compute_loss(batch)\n loss.backward()\n self.optimizer.step()\n\n return loss.item()\n\n def compute_loss(self,batch):\n device = self.device\n\n p = batch.get('grid_coords').to(device)\n gt_rgb = batch.get('rgb').to(device)\n inputs = batch.get('inputs').to(device)\n\n # print(gt_rgb)\n # p = p.unsqueeze(1).unsqueeze(1)\n # print(F.grid_sample(inputs, p, padding_mode='border'))\n # General points\n\n # print(p[:,:3])\n pred_rgb = self.model(p,inputs)\n pred_rgb = pred_rgb.transpose(-1,-2)\n # print(gt_rgb.shape)\n loss_i = torch.nn.L1Loss(reduction='none')(pred_rgb, gt_rgb) # out = (B,num_points,3)\n\n loss = loss_i.sum(-1).mean() # loss_i summed 3 rgb channels for all #num_samples samples -> out = (B,1) and mean over batch -> out = (1)\n\n return loss\n\n def train_model(self, epochs):\n loss = 0\n start = self.load_checkpoint()\n\n for epoch in range(start, epochs):\n sum_loss = 0\n print('Start epoch {}'.format(epoch))\n train_data_loader = self.train_dataset.get_loader()\n\n if epoch % 1 == 0:\n self.save_checkpoint(epoch)\n val_loss = self.compute_val_loss()\n\n if self.val_min is None:\n self.val_min = val_loss\n\n if val_loss < self.val_min:\n self.val_min = val_loss\n # for path in glob(self.exp_path + 'val_min='):\n # os.remove(path)\n np.save(self.exp_path + 'val_min',[epoch,val_loss])\n\n\n for batch in train_data_loader:\n loss = self.train_step(batch)\n print(\"Current loss: {}\".format(loss))\n sum_loss += loss\n\n\n\n\n def save_checkpoint(self, epoch):\n path = self.checkpoint_path + 'checkpoint_epoch_{}.tar'.format(epoch)\n if not os.path.exists(path):\n torch.save({'epoch':epoch,'model_state_dict': self.model.state_dict(),\n 'optimizer_state_dict': self.optimizer.state_dict()}, path)\n\n def load_checkpoint(self):\n checkpoints = glob(self.checkpoint_path+'/')\n if len(checkpoints) == 0:\n print('No checkpoints found at {}'.format(self.checkpoint_path))\n return 0\n\n checkpoints = [os.path.splitext(os.path.basename(path))[0][17:] for path in checkpoints]\n checkpoints = np.array(checkpoints, dtype=int)\n checkpoints = np.sort(checkpoints)\n path = self.checkpoint_path + 'checkpoint_epoch_{}.tar'.format(checkpoints[-1])\n\n print('Loaded checkpoint from: {}'.format(path))\n checkpoint = torch.load(path)\n self.model.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n epoch = checkpoint['epoch']\n return epoch\n\n def compute_val_loss(self):\n self.model.eval()\n\n sum_val_loss = 0\n num_batches = 15\n for _ in range(num_batches):\n try:\n val_batch = self.val_data_iterator.next()\n except:\n self.val_data_iterator = self.val_dataset.get_loader().__iter__()\n val_batch = self.val_data_iterator.next()\n\n sum_val_loss += self.compute_loss( val_batch).item()\n\n return sum_val_loss / num_batches" ]	[ [ "torch.load", "numpy.save", "numpy.sort", "numpy.array", "torch.nn.L1Loss" ] ]
DiegoCorrea/masters-dissertation	[ "61d6e9c46da6cf1e7d904f98eb1d46d907a74576" ]	[ "src/processing/traditional_recommenders.py" ]	[ "import datetime\nimport gc\nimport logging\nimport multiprocessing\nimport os\nimport time\nfrom copy import deepcopy\n\nimport numpy as np\nimport pandas as pd\n\nfrom src.analises.popularity import count_popularity_item\nfrom src.config.labels import TRANSACTION_VALUE_LABEL, POPULARITY_LABEL, USER_LABEL, ITEM_LABEL, TOTAL_TIMES_LABEL, \\\n TRADITIONAL_RECOMMENDERS\nfrom src.config.language_strings import LANGUAGE_RECOMMENDATION, LANGUAGE_CALCULATING_USER_MODEL_WGENRE_DISTRIBUTION, \\\n LANGUAGE_LOAD_DATA_SET, LANGUAGE_RECOMMENDER_ALGORITHM_START, LANGUAGE_RECOMMENDER_ALGORITHM_STOP\nfrom src.config.path_dir_files import data_results_path\nfrom src.config.variables import K_FOLDS_VALUES, N_CORES, CANDIDATES_LIST_SIZE\nfrom src.conversions.pandas_to_models import user_transactions_df_to_item_mapping\nfrom src.models.item import create_item_mapping\nfrom src.posprocessing.bias import calculating_item_bias\nfrom src.posprocessing.distributions import get_distribution, multiprocess_get_distribution, \\\n big_genre_distribution_with_multiprocessing\nfrom src.posprocessing.step import pos_processing_calibration\nfrom src.preprocessing.load_database import load_db_and_fold, load_blocked_list\nfrom src.processing.merge_results import merge_recommender_results, k_fold_results_concat\nfrom src.processing.recommender_algorithms import split_equally\n\nlogger = logging.getLogger(__name__)\n\n\ndef ncores_traditional_recommendation_process(user_model_df, user_model_genres_distr_df, user_expected_items_df,\n items_mapping_dict, user_blocked_items_df, recommender_label,\n popularity_df, transaction_mean, control_count=None, start_time=None):\n \"\"\"\n A user by time\n Responsible for: the recommender algorithm prediction,\n the models to be used in the pos process\n and the pos processing\n :param start_time:\n :param control_count:\n :param user_blocked_items_df:\n :param transaction_mean: the users transactions mean\n :param popularity_df: DataFrame with items popularity\n :param user_model_df: All user transactions\n :param user_model_genres_distr_df: The user genres distribution\n :param user_expected_items_df: The user expected items in the final recommendation\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :return: None\n \"\"\"\n # Get known items ids by the user\n items_ids = items_mapping_dict.keys()\n know_items_ids = user_model_df[ITEM_LABEL].unique().tolist()\n blocked_items_ids = user_blocked_items_df[ITEM_LABEL].unique().tolist()\n items_ids = set(items_ids) - set(blocked_items_ids)\n # Get unknown items ids by the user\n unknowing_items_ids = list(set(items_ids) - set(know_items_ids))\n\n user_candidate_items_max_df = popularity_df[popularity_df[ITEM_LABEL].isin(unknowing_items_ids)]\n\n user_candidate_items_max_df.sort_values(by=[TRANSACTION_VALUE_LABEL], ascending=False)\n user_candidate_items_max_df = user_candidate_items_max_df[:CANDIDATES_LIST_SIZE]\n\n user_candidate_items_max_dict = user_transactions_df_to_item_mapping(user_candidate_items_max_df,\n items_mapping_dict)\n user_evaluation_results_df = pos_processing_calibration(user_model_genres_distr_df=user_model_genres_distr_df,\n candidates_items_mapping=user_candidate_items_max_dict,\n user_expected_items_ids=user_expected_items_df[\n ITEM_LABEL].tolist(),\n recommender_label=recommender_label,\n transaction_mean=transaction_mean)\n if control_count is not None and control_count % 100 == 0:\n logger.info(' '.join(['PId:', str(os.getpid()), '->', 'Total of users done:', str(control_count),\n '->', 'Total time:', str(datetime.timedelta(seconds=time.time() - start_time))]))\n return user_evaluation_results_df\n\n\ndef ncores_generate_recommendation(users_ids_list, users_model_df, users_model_genres_distr_df, users_expected_items_df,\n items_mapping_dict, users_blocked_items_df, recommender_label, popularity_df,\n transaction_mean, shared_queue):\n \"\"\"\n A user by time\n Responsible for: the recommender algorithm prediction,\n the models to be used in the pos process\n and the post processing\n :param popularity_df:\n :param users_ids_list:\n :param users_blocked_items_df:\n :param transaction_mean: the users transactions mean\n :param users_ids_list: The group of unique users identification\n :param users_model_df: All user transactions\n :param users_model_genres_distr_df: The user genres distribution\n :param users_expected_items_df: The user expected items in the final recommendation\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :param shared_queue: A shared memory to be used for all ncores process\n :return: The user results in the shared memory\n \"\"\"\n start_time = time.time()\n results = pd.concat(\n [ncores_traditional_recommendation_process(users_model_df[users_model_df[USER_LABEL] == user_id],\n users_model_genres_distr_df.loc[user_id],\n users_expected_items_df[\n users_expected_items_df[USER_LABEL] == user_id],\n items_mapping_dict,\n users_blocked_items_df[\n users_blocked_items_df[USER_LABEL] == user_id],\n recommender_label,\n popularity_df,\n transaction_mean,\n control_count, start_time) for\n control_count, user_id in enumerate(users_ids_list)], sort=False)\n finish_time = time.time()\n logger.info(\" \".join(['>', 'Time Execution:', str(datetime.timedelta(seconds=finish_time - start_time)),\n 'Total of users:', str(len(users_ids_list))]))\n shared_queue.put(deepcopy(results))\n\n\ndef ncores_traditional_recommendation(users_genres_distr_df, trainset_df, testset_df, items_mapping_dict,\n blocked_items_df, popularity_df, transaction_mean, recommender_label):\n \"\"\"\n Multiprocessing recommendations to each user do the pos process\n :param blocked_items_df:\n :param popularity_df: DataFrame with items popularity\n :param transaction_mean: the users transactions mean\n :param users_genres_distr_df: A dataframe with the users genres distributions\n :param trainset_df: A dataframe with the train set transactions\n :param testset_df: A dataframe with the test set transactions\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :return: A dataframe with the results of all used metrics\n \"\"\"\n # Preparing: users, results dataframe and shared queue over processes\n users_ids_list = users_genres_distr_df.index.values.tolist()\n # chunk_users_ids = np.array_split(users_ids_list, N_CORES)\n chunk_users_ids = split_equally(trainset_df)\n\n # Print the state of the execution\n i = len(users_ids_list)\n logger.info(str(i) + ' users to finish')\n\n manager = multiprocessing.Manager()\n shared_queue = manager.Queue()\n all_processes = list()\n\n # As long as there are users on the list to process and cores to allocate, do\n while chunk_users_ids:\n # Allocate core and select the user to pos process\n users_ids_list = chunk_users_ids.pop(0)\n\n # Prepare user data\n users_model_df = deepcopy(trainset_df[trainset_df[USER_LABEL].isin(users_ids_list)])\n users_model_genres_distr_df = deepcopy(users_genres_distr_df.loc[list(users_ids_list)])\n users_expected_items_df = deepcopy(testset_df[testset_df[USER_LABEL].isin(users_ids_list)])\n users_blocked_items_df = deepcopy(blocked_items_df[blocked_items_df[USER_LABEL].isin(users_ids_list)])\n\n # Create the process\n p = multiprocessing.Process(target=ncores_generate_recommendation,\n args=(users_ids_list,\n users_model_df, users_model_genres_distr_df, users_expected_items_df,\n items_mapping_dict, users_blocked_items_df, recommender_label, popularity_df,\n transaction_mean, shared_queue,))\n all_processes.append(p)\n # Start all process\n for p in all_processes:\n p.start()\n # Wait and close the all processes\n user_evaluation_results = list()\n for p in all_processes:\n p.join()\n # Get results from all processes\n user_evaluation_results.append(shared_queue.get())\n p.close()\n\n # Concat and resume the results\n evaluation_results_df = pd.concat(user_evaluation_results)\n return evaluation_results_df\n\n\n# #################################################################################################################### #\n# #################################################################################################################### #\n# #################################################################################################################### #\ndef traditional_generate_recommendation(user_model_df, user_model_genres_distr_df, user_expected_items_df,\n items_mapping_dict, user_blocked_items_df, recommender_label, popularity_df,\n transaction_mean,\n shared_queue):\n \"\"\"\n A user by time\n Responsible for: the recommender algorithm prediction,\n the models to be used in the pos process\n and the pos processing\n :param user_blocked_items_df:\n :param transaction_mean: the users transactions mean\n :param popularity_df: DataFrame with items popularity\n :param user_model_df: All user transactions\n :param user_model_genres_distr_df: The user genres distribution\n :param user_expected_items_df: The user expected items in the final recommendation\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :param shared_queue: A shared memory to be used for all ncores process\n :return: None\n \"\"\"\n # Get known items ids by the user\n items_ids = items_mapping_dict.keys()\n know_items_ids = user_model_df[ITEM_LABEL].unique().tolist()\n blocked_items_ids = user_blocked_items_df[ITEM_LABEL].unique().tolist()\n items_ids = set(items_ids) - set(blocked_items_ids)\n # Get unknown items ids by the user\n unknowing_items_ids = list(set(items_ids) - set(know_items_ids))\n\n user_candidate_items_max_df = popularity_df[popularity_df[ITEM_LABEL].isin(unknowing_items_ids)]\n\n user_candidate_items_max_df.sort_values(by=[TRANSACTION_VALUE_LABEL], ascending=False)\n user_candidate_items_max_df = user_candidate_items_max_df[:CANDIDATES_LIST_SIZE]\n\n user_candidate_items_max_dict = user_transactions_df_to_item_mapping(user_candidate_items_max_df,\n items_mapping_dict)\n user_evaluation_results_df = pos_processing_calibration(user_model_genres_distr_df=user_model_genres_distr_df,\n candidates_items_mapping=user_candidate_items_max_dict,\n user_expected_items_ids=user_expected_items_df[\n ITEM_LABEL].tolist(),\n recommender_label=recommender_label,\n transaction_mean=transaction_mean)\n shared_queue.put(deepcopy(user_evaluation_results_df))\n\n\ndef traditional_recommendation_process(users_genres_distr_df, trainset_df, testset_df, items_mapping_dict,\n blocked_items_df,\n popularity_df, transaction_mean, recommender_label):\n \"\"\"\n Multiprocessing recommendations to each user do the pos process\n :param popularity_df: DataFrame with items popularity\n :param transaction_mean: the users transactions mean\n :param users_genres_distr_df: A dataframe with the users genres distributions\n :param trainset_df: A dataframe with the train set transactions\n :param testset_df: A dataframe with the test set transactions\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :return: A dataframe with the results of all used metrics\n \"\"\"\n # Preparing: users, results dataframe and shared queue over processes\n users_ids = users_genres_distr_df.index.values.tolist()\n evaluation_results_df = pd.DataFrame()\n manager = multiprocessing.Manager()\n shared_queue = manager.Queue()\n # While has users to process do in nbeans (ncores)\n while users_ids:\n cores_control = list(range(0, N_CORES))\n all_processes = list()\n\n # Print the state of the execution\n i = len(users_ids)\n print(f'\\r{i} users to finish', end='', flush=True)\n # As long as there are users on the list to process and cores to allocate, do\n while users_ids and cores_control:\n # Allocate core and select the user to pos process\n cores_control.pop(0)\n user_id = users_ids.pop(0)\n # Prepare user data\n user_model_df = deepcopy(trainset_df[trainset_df[USER_LABEL] == user_id])\n user_model_genres_distr_df = deepcopy(users_genres_distr_df.loc[user_id])\n user_expected_items_df = deepcopy(testset_df[testset_df[USER_LABEL] == user_id])\n user_blocked_items_df = deepcopy(blocked_items_df[blocked_items_df[USER_LABEL] == user_id])\n # Create the process\n p = multiprocessing.Process(target=traditional_generate_recommendation,\n args=(\n user_model_df, user_model_genres_distr_df, user_expected_items_df,\n items_mapping_dict, user_blocked_items_df, recommender_label, popularity_df,\n transaction_mean, shared_queue,))\n all_processes.append(p)\n # Start all process\n for p in all_processes:\n p.start()\n # Wait and close the all processes\n user_evaluation_results = list()\n for p in all_processes:\n p.join()\n # Get results from all processes\n user_evaluation_results.append(shared_queue.get())\n p.close()\n\n # Concat and resume the results\n evaluation_results_df = pd.concat([evaluation_results_df, pd.concat(user_evaluation_results)])\n return evaluation_results_df\n\n\ndef start_traditional_recommenders(recommenders_to_use, db):\n \"\"\"\n Start the traditional recommenders (process and post process)\n :param recommenders_to_use:\n :param db: 0 to movielens; 1 to oms;\n :return: None\n \"\"\"\n\n for label in recommenders_to_use:\n logger.info('-' * 50)\n logger.info(\" \".join([LANGUAGE_RECOMMENDER_ALGORITHM_START, \"->\", label]))\n\n # For each dataset fold do process and pos process\n for fold in range(1, K_FOLDS_VALUES + 1):\n gc.collect()\n\n # Load the fold of the dataset\n logger.info(\" \".join([\"+\", LANGUAGE_LOAD_DATA_SET, \"->\", str(fold)]))\n trainset_df, testset_df, items_df = load_db_and_fold(db, fold)\n\n # calculating the user bias\n transaction_mean = trainset_df[TRANSACTION_VALUE_LABEL].mean()\n items_mapping_dict = create_item_mapping(items_df, calculating_item_bias(trainset_df, transaction_mean))\n\n # get the users genres distribution based on they models\n logger.info(\" \".join([\"+\", LANGUAGE_CALCULATING_USER_MODEL_WGENRE_DISTRIBUTION]))\n users_prefs_distr_df = get_distribution(trainset_df, items_mapping_dict)\n\n # Start the recommendation process with the pos processing\n logger.info(\" \".join([\"+\", LANGUAGE_RECOMMENDATION]))\n if label == POPULARITY_LABEL:\n popularity_df = count_popularity_item(trainset_df)\n else:\n popularity_df = pd.DataFrame(\n data=trainset_df.groupby(by=ITEM_LABEL, as_index=False).mean())\n popularity_df.rename(inplace=True, columns={TOTAL_TIMES_LABEL: TRANSACTION_VALUE_LABEL})\n\n results_df = traditional_recommendation_process(users_prefs_distr_df, trainset_df, testset_df,\n items_mapping_dict, popularity_df,\n transaction_mean, label)\n merged_results_df = k_fold_results_concat(results_df)\n # Save the results\n path_to_save = \"\".join([data_results_path(db), label, \"/\"])\n if not os.path.exists(path_to_save):\n os.makedirs(path_to_save)\n merged_results_df.to_csv(os.path.join(path_to_save, str(fold) + \".csv\"),\n index=False)\n # Merge the recommender results into a average based in the configuration\n merge_recommender_results(label, db)\n logger.info(\" \".join([LANGUAGE_RECOMMENDER_ALGORITHM_STOP, \"->\", label]))\n logger.info('-' * 50)\n\n\ndef all_traditional_recommenders(db):\n \"\"\"\n Start all traditioinal recommenders\n :param db: 0 to movielens; 1 to oms;\n :return: None\n \"\"\"\n # Start recommender algorithms that have params\n start_traditional_recommenders(TRADITIONAL_RECOMMENDERS, db)\n\n\n# #################################################################################################################### #\n# #################################################################################################################### #\n# #################################################################################################################### #\n\n\ndef personalized_traditional_recommender(label, db, fold):\n # Load the fold of the dataset\n logger.info(\" \".join([\"+\", LANGUAGE_LOAD_DATA_SET, \"->\", str(fold)]))\n trainset_df, testset_df, items_df = load_db_and_fold(db, fold)\n blocked_items_df = load_blocked_list(db)\n\n # calculating the user bias\n transaction_mean = trainset_df[TRANSACTION_VALUE_LABEL].mean()\n items_mapping_dict = create_item_mapping(items_df, calculating_item_bias(trainset_df, transaction_mean))\n\n # get the users genres distribution based on they models\n logger.info(\" \".join([\"+\", LANGUAGE_CALCULATING_USER_MODEL_WGENRE_DISTRIBUTION]))\n # users_prefs_distr_df = get_distribution(trainset_df, items_mapping_dict)\n # users_prefs_distr_df = multiprocess_get_distribution(trainset_df, items_mapping_dict)\n users_prefs_distr_df = big_genre_distribution_with_multiprocessing(trainset_df, items_mapping_dict)\n\n # Start the recommendation process with the pos processing\n logger.info(\" \".join([\"+\", LANGUAGE_RECOMMENDATION]))\n if label == POPULARITY_LABEL:\n popularity_df = count_popularity_item(trainset_df)\n else:\n popularity_df = pd.DataFrame(\n data=trainset_df.groupby(by=ITEM_LABEL, as_index=False).mean())\n popularity_df.rename(inplace=True, columns={TOTAL_TIMES_LABEL: TRANSACTION_VALUE_LABEL})\n\n results_df = ncores_traditional_recommendation(users_prefs_distr_df, trainset_df, testset_df,\n items_mapping_dict, blocked_items_df, popularity_df,\n transaction_mean, label)\n merged_results_df = k_fold_results_concat(results_df)\n # Save the results\n path_to_save = \"\".join([data_results_path(db), label, \"/\"])\n if not os.path.exists(path_to_save):\n os.makedirs(path_to_save)\n merged_results_df.to_csv(os.path.join(path_to_save, str(fold) + \".csv\"),\n index=False)\n # Merge the recommender results into a average based in the configuration\n # merge_recommender_results(label, db)\n logger.info(\" \".join([LANGUAGE_RECOMMENDER_ALGORITHM_STOP, \"->\", label]))\n logger.info('-' * 50)\n" ]	[ [ "pandas.concat", "pandas.DataFrame" ] ]
bthorne93/freckles	[ "cacb0c3846602f13b371252876f1f8e05dca54ba" ]	[ "src/freckles/separation/components.py" ]	[ "from __future__ import print_function\nfrom numba import jit, float64\nimport numpy as np\nimport inspect\n\nclass Component(object):\n def __init__(self, comp_name):\n \"\"\" SED must be in uK_RJ units.\n \"\"\"\n self.comp_name = comp_name\n self.sed = globals()[comp_name]\n return\n\n def __call__(self, nu, args):\n \"\"\" Method to call the SED with whichi a given instance was initialized.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency or list of frequencies, in GHz, at which to evaluate the\n SED.\n args: tuple\n Tuple containing the positional parameters taken by the SED.\n \"\"\"\n return self.sed(nu, args)\n\n def get_description(self):\n print(\"Component SED name: \", self.comp_name)\n print(self.sed.__doc__, \"\\n --------------- \\n\")\n pass\n\n def get_parameters(self):\n \"\"\" Method to fetch the keywork arguments for the various components\n and return them. This is used to build a list of possible parameters\n that may be varied by MapLike.\n \"\"\"\n sig = inspect.signature(self.sed)\n pars = list(sig.parameters.keys())\n return list(filter(lambda par: par not in ['nu', 'args', 'kwargs'], pars))\n\n\n#@jit(float64[:](float64[:]), cache=True, nopython=True, nogil=True)\ndef cmb(nu):\n \"\"\" Function to compute CMB SED.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency in GHz.\n \"\"\"\n x = 0.0176086761 nu\n ex = np.exp(x)\n sed = ex * (x / (ex - 1)) 2\n return sed\n\n\n#@jit(float64[:](float64[:], float64, float64), cache=True, nopython=True,\n# nogil=True)\ndef syncpl(nu, nu_ref_s, beta_s):\n \"\"\" Function to compute synchrotron power law SED.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency in GHz.\n beta_s: float\n Power law index in RJ units.\n\n Returns\n -------\n array_like(float)\n Synchroton SED relative to reference frequency.\n \"\"\"\n x = nu / nu_ref_s\n sed = x beta_s\n return sed\n\n\n#@jit(float64[:](float64[:], float64, float64, float64), cache=True,\n# nopython=True, nogil=True)\ndef sync_curvedpl(nu, nu_ref_s, beta_s, beta_c):\n \"\"\" Function to compute curved synchrotron power law SED.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency in GHz.\n beta_s: float\n Power law index in RJ units.\n beta_c: float\n Power law index curvature.\n\n Returns\n -------\n array_like(float)\n Synchroton SED relative to reference frequency.\n \"\"\"\n x = nu / nu_ref_s\n sed = x ** (beta_s + beta_c * np.log(nu / nu_ref_s))\n return sed\n\n\n#@jit(float64[:](float64[:], float64, float64, float64), cache=True,\n# nopython=True, nogil=True)\ndef dustmbb(nu, nu_ref_d, beta_d, T_d):\n \"\"\" Function to compute modified blackbody dust SED.\n\n Parameters\n ----------\n nu: float or array_like(float)\n Freuency at which to calculate SED.\n nu_ref_d: float\n Reference frequency in GHz.\n beta_d: float\n Power law index of dust opacity.\n T_d: float\n Temperature of the dust.\n\n Returns\n -------\n array_like(float)\n SED of dust modified black body relative to reference frequency.\n \"\"\"\n x_to = 0.0479924466 * nu / T_d\n x_from = 0.0479924466 * nu_ref_d / T_d\n sed = (nu / nu_ref_d) ** (1. + beta_d) * (np.exp(x_from) - 1) / (np.exp(x_to) - 1)\n return sed\n" ]	[ [ "numpy.log", "numpy.exp" ] ]
davanstrien/flyswot	[ "630aa4f51c4381a7832846a7ef5be7af06a4b47b" ]	[ "src/flyswot/inference.py" ]	[ "\"\"\"Inference functionality\"\"\"\nimport csv\nimport mimetypes\nimport re\nimport string\nimport time\nfrom abc import ABC\nfrom abc import abstractmethod\nfrom collections import defaultdict\nfrom collections import OrderedDict\nfrom dataclasses import asdict\nfrom dataclasses import dataclass\nfrom datetime import datetime\nfrom datetime import timedelta\nfrom functools import singledispatch\nfrom pathlib import Path\nfrom typing import Dict\nfrom typing import Iterable\nfrom typing import List\nfrom typing import Optional\nfrom typing import Union\n\nimport numpy as np\nimport onnxruntime as rt\nimport typer\nfrom PIL import Image # type: ignore\nfrom rich import print\nfrom rich.columns import Columns\nfrom rich.layout import Layout\nfrom rich.markdown import Markdown\nfrom rich.panel import Panel\nfrom rich.table import Table\nfrom rich.text import Text\nfrom toolz import itertoolz\n\nfrom flyswot import core\nfrom flyswot import models\nfrom flyswot.console import console\nfrom flyswot.logo import flyswot_logo\n\napp = typer.Typer()\n\n\n@dataclass\nclass ImagePredictionItem:\n \"\"\"Prediction for an image.\n\n Attributes:\n path: The Path to the image\n predicted_label: The predicted label i.e. the argmax value for the prediction tensor\n confidence: The confidence for `predicted_label` i.e. the max value for prediction tensor\n \"\"\"\n\n path: Path\n predicted_label: str\n confidence: float\n\n def __post_init__(self) -> Union[Path, None]:\n \"\"\"attempt to get absolute path\"\"\"\n try:\n self.path: Path = self.path.absolute()\n except AttributeError:\n pass\n\n\n@dataclass\nclass MultiLabelImagePredictionItem:\n \"\"\"Multiple predictions for a single image\"\"\"\n\n path: Path\n predictions: List[Dict[float, str]]\n\n def _get_top_labels(self) -> List[str]:\n \"\"\"Get top labels\"\"\"\n top_labels = []\n for prediction in self.predictions:\n top_label = sorted(prediction.items(), reverse=True)[0][1]\n top_labels.append(top_label)\n return top_labels\n\n # Post init that gets top prediction label from predictions\n def __post_init__(self):\n \"\"\"Get top prediction label\"\"\"\n self.predicted_labels = self._get_top_labels()\n\n\n@dataclass\nclass PredictionBatch:\n \"\"\"Container for ImagePredictionItems\"\"\"\n\n batch: List[ImagePredictionItem]\n\n def __post_init__(self):\n \"\"\"Returns a iterable of all predicted labels in batch\"\"\"\n self.batch_labels: Iterable[str] = (item.predicted_label for item in self.batch)\n\n\n@dataclass\nclass MultiPredictionBatch:\n \"\"\"Container for MultiLabelImagePredictionItems\"\"\"\n\n batch: List[MultiLabelImagePredictionItem]\n\n def _get_predicted_labels(self) -> Iterable:\n \"\"\"Returns a iterable of all predicted labels in batch\"\"\"\n return (item.predicted_labels for item in self.batch)\n\n def __post_init__(self):\n \"\"\"Returns a iterable of lists containing all predicted labels in batch\"\"\"\n # self.batch_labels: Iterable = (\n # list(itertoolz.pluck(0, pred))\n # for pred in zip([o.predictions for o in self.batch])\n # )\n self.batch_labels = self._get_predicted_labels()\n\n\nimage_extensions = {k for k, v in mimetypes.types_map.items() if v.startswith(\"image/\")}\n\n\[email protected]()\ndef predict_image(\n image: Path = typer.Argument(..., readable=True, resolve_path=True)\n) -> None:\n \"\"\"Predict a single image\"\"\"\n pass # pragma: no cover\n\n\ndef check_files(files: List, pattern: str, directory: Path) -> None:\n \"\"\"Check if files exist and raises error if not\"\"\"\n if not files:\n typer.echo(\n f\"Didn't find any files maching {pattern} in {directory}, please check the inputs to flyswot\"\n )\n raise typer.Exit(code=1)\n\n\[email protected](name=\"directory\")\ndef predict_directory(\n directory: Path = typer.Argument(\n ...,\n readable=True,\n resolve_path=True,\n help=\"Directory to start searching for images from\",\n ),\n csv_save_dir: Path = typer.Argument(\n ...,\n writable=True,\n resolve_path=True,\n help=\"Directory used to store the csv report\",\n ),\n pattern: str = typer.Option(\"fs\", help=\"Pattern used to filter image filenames\"),\n bs: int = typer.Option(16, help=\"Batch Size\"),\n image_format: str = typer.Option(\n \".tif\",\n help=\"Image format for flyswot to use for predictions, defaults to `.tif`\",\n ),\n model_name: str = typer.Option(\n \"latest\", help=\"Which model flyswot should use for making predictions\"\n ),\n model_path: str = None,\n):\n \"\"\"Predicts against all images stored under DIRECTORY which match PATTERN in the filename.\n\n By default searches for filenames containing 'fs'.\n\n Creates a CSV report saved to `csv_save_dir`\n \"\"\"\n start_time = time.perf_counter()\n model_dir = models.ensure_model_dir()\n model = models.ensure_model(model_dir)\n # if model_name != \"latest\" and not model_path:\n # model_parts = models._get_model_parts(Path(model_dir / Path(model_name)))\n # if model_name != \"latest\" and model_path:\n # model_parts = models._get_model_parts(Path(model_path / Path(model_name)))\n onnxinference = OnnxInferenceSession(model.model, model.vocab)\n files = sorted(core.get_image_files_from_pattern(directory, pattern, image_format))\n check_files(files, pattern, directory)\n typer.echo(f\"Found {len(files)} files matching {pattern} in {directory}\")\n csv_fname = create_csv_fname(csv_save_dir)\n with typer.progressbar(length=len(files)) as progress:\n images_checked = 0\n for i, batch in enumerate(itertoolz.partition_all(bs, files)):\n batch_predictions = onnxinference.predict_batch(batch, bs)\n if i == 0: # pragma: no cover\n create_csv_header(batch_predictions, csv_fname)\n write_batch_preds_to_csv(batch_predictions, csv_fname)\n progress.update(len(batch))\n images_checked += len(batch)\n delta = timedelta(seconds=time.perf_counter() - start_time)\n print_inference_summary(\n str(delta), pattern, directory, csv_fname, image_format, images_checked\n )\n\n\ndef print_inference_summary(\n time_delta: str,\n pattern: str,\n directory: Path,\n csv_fname: Path,\n image_format: str,\n matched_file_count: int,\n local_model: Optional[models.LocalModel] = None,\n):\n \"\"\"prints summary report\"\"\"\n print(flyswot_logo())\n print(\n Panel(\n Text(\n f\"CSV report file at: {csv_fname.as_uri()}\",\n ),\n title=\" :clipboard: CSV report :clipboard:\",\n )\n )\n print(\n Panel(\n Text(f\"{time_delta}\", justify=\"center\", style=\"bold green\"),\n title=\":stopwatch: Time taken to run :stopwatch:\",\n )\n )\n print(\n create_file_summary_markdown(\n pattern, matched_file_count, directory, image_format\n )\n )\n inference_summary_columns = get_inference_table_columns(csv_fname)\n print(Panel(inference_summary_columns, title=\"Prediction Summary\"))\n if local_model is not None:\n print(models.show_model_card(localmodel=local_model))\n\n\ndef create_file_summary_markdown(\n pattern: str, matched_file_count: int, directory: Path, image_format: str\n) -> Panel:\n \"\"\"creates Markdown summary containing number of files checked by flyswot vs total images files under directory\"\"\"\n total_image_file_count = core.count_files_with_ext(directory, image_format)\n return Panel(\n Markdown(\n f\"\"\"\n - flyswot searched for image files by matching the patern {pattern}\n - flyswot search inside: `{directory}`\n - In total the directory contained {total_image_file_count} images\n - There were {matched_file_count} files matching the {pattern}* pattern which flyswot checked\n \"\"\"\n ),\n title=\":file_folder: files checked :file_folder:\",\n )\n\n\ndef get_inference_table_columns(csv_fname: Path) -> Columns:\n \"\"\"print_inference_summary from `fname`\"\"\"\n labels_to_print = labels_from_csv(csv_fname)\n tables = [\n print_table(labels, f\"Prediction summary {i+1}\", print=False)\n for i, labels in enumerate(labels_to_print)\n ]\n return Columns(tables)\n\n\nlabel_regex = re.compile(r\"prediction_label_\\D_0\")\n\n\ndef labels_from_csv(fname: Path) -> List[List[str]]:\n \"\"\"Gets top labels from csv `fname`\"\"\"\n columns = defaultdict(list)\n with open(fname, \"r\") as f:\n reader = csv.DictReader(f)\n for row in reader:\n for (k, v) in row.items():\n columns[k].append(v)\n return [columns[k] for k in columns if label_regex.match(k)]\n\n\ndef print_table(\n decoded: list, header: str = \"Prediction summary\", print: bool = True\n) -> Table:\n \"\"\"Prints table summary of predicted labels\"\"\"\n table = Table(show_header=True, title=header)\n table.add_column(\n \"Class\",\n )\n table.add_column(\"Count\")\n table.add_column(\"Percentage\")\n total = len(decoded)\n frequencies = itertoolz.frequencies(decoded)\n for is_last_element, var in core.signal_last(frequencies.items()):\n key, value = var\n count = value\n percentage = round((count / total) * 100, 2)\n if is_last_element:\n table.add_row(key, str(count), f\"{percentage}\", end_section=True)\n table.add_row(\"Total\", str(total), \"\")\n else:\n table.add_row(key, str(count), f\"{percentage}\")\n if print:\n console.print(table)\n return table\n\n\ndef make_layout():\n \"\"\"Define the layout.\"\"\"\n layout = Layout(name=\"root\")\n layout.split(Layout(name=\"header\", size=4), Layout(name=\"main\"))\n layout[\"main\"].split_column(\n Layout(name=\"info\", size=4), Layout(name=\"body\", ratio=2, minimum_size=60)\n )\n layout[\"info\"].split_row(Layout(name=\"time\"), Layout(name=\"files\"))\n return layout\n\n\n# def print_summary(columns, time, files):\n# layout = make_layout()\n# MARKDOWN = \"\"\"\n# # Prediction summary\n# \"\"\"\n# md = Markdown(MARKDOWN)\n# layout[\"header\"].update(md)\n# layout[\"body\"].update(columns)\n# layout[\"time\"].update(time)\n# layout[\"files\"].update(f\"Number of files checked {len(files)}\")\n# print(layout)\n\n\ndef create_csv_fname(csv_directory: Path) -> Path:\n \"\"\"Creates a csv filename\"\"\"\n date_now = datetime.now()\n date_now = date_now.strftime(\"%Y_%m_%d_%H_%M\")\n fname = Path(date_now + \".csv\")\n return Path(csv_directory / fname)\n\n\n@singledispatch\ndef create_csv_header(batch, csv_path) -> None:\n \"\"\"Print csv header\"\"\"\n raise NotImplementedError(f\"Not implemented for type {batch}\")\n\n\n@create_csv_header.register\ndef _(batch: PredictionBatch, csv_path):\n \"\"\"Creates a header for csv `csv_path`\"\"\"\n with open(csv_path, mode=\"w\", newline=\"\") as csv_file:\n field_names = [\"path\", \"directory\", \"prediction\", \"confidence\"]\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n writer.writeheader()\n\n\n@create_csv_header.register\ndef _(batch: MultiPredictionBatch, csv_path: Path, top_n: int = 2):\n item = batch.batch[0]\n pred = OrderedDict()\n pred[\"path\"] = asdict(item)[\"path\"]\n pred[\"directory\"] = asdict(item)[\"path\"].parent\n for i, _ in enumerate(item.predictions):\n for j in range(top_n):\n pred[f\"prediction_label_{string.ascii_letters[i]}_{j}\"] = \"\"\n pred[f\"confidence_label_{string.ascii_letters[i]}_{j}\"] = \"\"\n with open(csv_path, mode=\"w\", newline=\"\") as csv_file:\n field_names = list(pred.keys())\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n writer.writeheader()\n\n\n@singledispatch\ndef write_batch_preds_to_csv(predictions, csv_fpath: Path) -> None:\n \"\"\"print batch preds to csv\"\"\"\n raise NotImplementedError(f\"Not implemented for type {predictions}\")\n\n\n@write_batch_preds_to_csv.register\ndef _(predictions: PredictionBatch, csv_fpath: Path) -> None:\n \"\"\"Appends `predictions` batch to `csv_path`\"\"\"\n with open(csv_fpath, mode=\"a\", newline=\"\") as csv_file:\n field_names = [\"path\", \"directory\", \"predicted_label\", \"confidence\"]\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n for pred in predictions.batch:\n row = asdict(pred)\n row[\"directory\"] = pred.path.parent\n writer.writerow(row)\n\n\n@write_batch_preds_to_csv.register\ndef _(predictions: MultiPredictionBatch, csv_fpath: Path, top_n: int = 2) -> None:\n for pred in predictions.batch:\n row = OrderedDict()\n row[\"path\"] = asdict(pred)[\"path\"]\n row[\"directory\"] = asdict(pred)[\"path\"].parent\n for i, v in enumerate(pred.predictions):\n sorted_predictions = sorted(v.items(), reverse=True)\n for j in range(top_n):\n row[f\"prediction_label_{i}_{j}\"] = sorted_predictions[j][1]\n row[f\"confidence_label_{i}_{j}\"] = sorted_predictions[j][0]\n with open(csv_fpath, mode=\"a\", newline=\"\") as csv_file:\n field_names = list(row.keys())\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n writer.writerow(row)\n\n\nclass InferenceSession(ABC):\n \"\"\"Abstract class for inference sessions\"\"\"\n\n @abstractmethod\n def __init__(self, model: Path, vocab: List): # pragma: no cover\n \"\"\"Inference Sessions should init from a model file and vocab\"\"\"\n self.model = model\n self.vocab = vocab\n\n @abstractmethod\n def predict_image(self, image: Path): # pragma: no cover\n \"\"\"Predict a single image\"\"\"\n pass\n\n @abstractmethod\n def predict_batch(\n self, model: Path, batch: Iterable[Path], bs: int\n ): # pragma: no cover\n \"\"\"Predict a batch\"\"\"\n pass\n\n\ndef softmax(x):\n \"\"\"return softmax of `x`\"\"\"\n x = x.reshape(-1)\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)\n\n\n# class FastaiInferenceModel(InferenceSession):\n# def __init__(self, model):\n# self.model = model\n# self.learn = load_learner(model)\n\n# def predict_image(self, image: Path) -> Any:\n# return self.learn.predict(image)\n\n# def predict_batch(self, batch: Iterable[Path], bs: int) -> PredictionBatch:\n# test_dl = self.learn.dls.test_dl(batch, bs=bs)\n# vocab = dict(enumerate(self.learn.dls.vocab))\n# with self.learn.no_bar():\n# fastai_preds: Any = self.learn.get_preds(dl=test_dl, with_decoded=True)\n# prediction_tensors: Iterable[Any] = fastai_preds[0]\n# prediction_items = []\n# for file, pred in zip(batch, prediction_tensors):\n# arg_max = int(np.array(pred).argmax())\n# predicted_label = vocab[int(arg_max)]\n# confidence = float(np.array(pred).max())\n# prediction_items.append(\n# ImagePredictionItem(file, predicted_label, confidence)\n# )\n# return PredictionBatch(prediction_items)\n\n\nclass OnnxInferenceSession(InferenceSession): # pragma: no cover\n \"\"\"onnx inference session\"\"\"\n\n def __init__(self, model: Path, vocab: Path):\n \"\"\"Create onnx session\"\"\"\n self.model = model\n self.session = rt.InferenceSession(str(model))\n\n self.vocab = models.load_vocab(vocab)\n self.vocab_mappings = [dict(enumerate(v)) for v in self.vocab]\n\n def predict_image(\n self, image: Path\n ) -> Union[ImagePredictionItem, MultiLabelImagePredictionItem]:\n \"\"\"Predict a single image\"\"\"\n img = self._load_image(image)\n output_names = [o.name for o in self.session.get_outputs()]\n raw_result = self.session.run(output_names, {\"image\": img})\n if len(self.vocab) < 2:\n pred = self._postprocess(raw_result)\n arg_max = int(np.array(pred).argmax())\n predicted_label = self.vocab_mappings[0][int(arg_max)]\n confidence = float(np.array(pred).max())\n return ImagePredictionItem(image, predicted_label, confidence)\n else:\n prediction_dicts = []\n for vocab_map, pred in zip(self.vocab_mappings, raw_result):\n predictions = self._postprocess(pred)\n prediction_dict = {\n float(prediction): vocab_map[i]\n for i, prediction in enumerate(predictions)\n }\n prediction_dicts.append(prediction_dict)\n return MultiLabelImagePredictionItem(image, prediction_dicts)\n\n def _preprocess(self, input_data: np.ndarray) -> np.ndarray:\n # converts the input data into the float32 input for onnx\n img_data = input_data.astype(\"float32\")\n\n # normalize\n mean_vec = np.array([0.485, 0.456, 0.406])\n stddev_vec = np.array([0.229, 0.224, 0.225])\n norm_img_data = np.zeros(img_data.shape).astype(\"float32\")\n for i in range(img_data.shape[0]):\n norm_img_data[i, :, :] = (\n img_data[i, :, :] / 255 - mean_vec[i]\n ) / stddev_vec[i]\n\n # add batch channel\n norm_img_data = norm_img_data.reshape(1, 3, 512, 512).astype(\"float32\")\n return norm_img_data\n\n def _load_image(self, file: Path) -> np.ndarray:\n \"\"\"loads image and carries out preprocessing for inference\"\"\"\n image = Image.open(file, mode=\"r\")\n image = image.resize((512, 512), Image.BILINEAR)\n image_data = np.array(image).transpose(2, 0, 1)\n return self._preprocess(image_data)\n\n def _postprocess(self, result: List):\n \"\"\"process results from onnx session\"\"\"\n return softmax(np.array(result)).tolist()\n\n def predict_batch(\n self, batch: Iterable[Path], bs: int\n ) -> Union[PredictionBatch, MultiPredictionBatch]:\n \"\"\"predicts a batch of images\"\"\"\n prediction_items = [self.predict_image(file) for file in batch]\n if len(self.vocab) < 2:\n return PredictionBatch(prediction_items)\n else:\n return MultiPredictionBatch(prediction_items)\n\n\nif __name__ == \"__main__\":\n app() # pragma: no cover\n" ]	[ [ "numpy.max", "numpy.array", "numpy.zeros" ] ]
vicjung/meme-glossary	[ "b502587825f3892f411a66421a7ba789c18d59cb" ]	[ "prepare_memes/xml2vec.py" ]	[ "#!/usr/bin/env python3\n'''\nGenerate .vec voca file from image xml folder. (voca format is KeyedVectors.load_word2vec_format.) [filename : vector]\nUsage : ./xml2vec --model_path=./model.bin --xml_dir=./xml_dir/ --vec_path=./voca.vec\n'''\nimport sys\nimport os\nsys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))\n\nfrom lxml import objectify\nimport numpy as np\nimport argparse\nimport re\nfrom server.nlp.model import EmbedModel\n\n# requires : sentence embedding -- input : model_bin, xml_folder, vec_out_dir\ndef get_args_parser():\n parser = argparse.ArgumentParser(description='Paths for processing')\n parser.add_argument('-m', '--model_path', type=str, default='./model.bin',\n required=True, help='Path of model.')\n parser.add_argument('-x', '--xml_dir', type=str, required=True,\n help='Directory of xml labels. e.g ./4_label_xml/')\n parser.add_argument('-v', '--vec_path', type=str, required=True,\n help='Path of output .vec file. e.g ./5_test_meme_voca.vec')\n parser.add_argument('-l', '--lang', default=None, help='if it is \"ko\", model does additional korean tokenizing')\n parser.add_argument('-n', '--include_no_text', type=bool, default=True, help='include no text images to vector as zeros.')\n \n args = parser.parse_args()\n return args\n\ndef rm_gbg_from_xml(value):\n value = str(value).replace('\\t','').replace('\\n','')\n value = re.search(r'\\s{0,}(.)', value).group(1)\n return value\n\ndef xml2vec(args):\n model_path = os.path.abspath(args.model_path)\n xml_dir = os.path.abspath(args.xml_dir) + '/'\n out_path = os.path.abspath(args.vec_path)\n lang = args.lang\n no_txt_flag = args.include_no_text\n \n print('\\nmodel path : ', model_path)\n model = EmbedModel(lang)\n print('loading model... ')\n model.load_model(model_path)\n \n out_dir = out_path.rsplit('/',1)[0]\n if not os.path.exists(out_dir):\n os.makedirs(out_dir)\n\n # Reads xml file and generating .vec file (gensim format)\n num_word = 0\n vec_size = None\n \n # Writing to .vec file.\n vecfile_content = ''\n flag=True\n episodes = os.listdir(xml_dir)\n\n for episode in episodes:\n xmls = os.listdir(xml_dir+episode)\n print('\\n## Episode : ',episode)\n if episode == '.ipynb_checkpoints':\n continue \n \n for xml_file in xmls:\n path = xml_dir+episode+'/' + xml_file\n rel_path = episode +'/' + xml_file\n\n if not path.lower().endswith(('.xml')):\n continue\n\n # open .xml\n f = open(xml_dir+episode+'/'+str(xml_file))\n xml_string = f.read()\n if not xml_string:\n continue\n\n xml_root = objectify.fromstring(xml_string)\n # label is saved in ['object']['name'].\n q_str = rm_gbg_from_xml(xml_root['object']['name']) \n '''\n q_str = re.sub(r'\\n{1,}', ' ', q_str)\n q_str = re.sub(r'\\n{1,}', ' ', q_str)\n q_str = re.sub(r'\\s{1,}', ' ', q_str)\n q_str = re.search(r'\\s{0,}(.)', q_str).group(1)\n '''\n if q_str or no_txt_flag:\n emb = model.embed_sentence(q_str)\n # if vector is retrieved.\n if np.any(emb) or no_txt_flag:\n if flag:\n vec_size=len(emb[0])\n flag=False\n vecfile_content += rel_path +' '\n\n for vec in emb[0]:\n vecfile_content += (str(vec) + ' ')\n vecfile_content += '\\n'\n num_word+=1\n print(str(xml_file) + ' ' + str(q_str)) \n f.close()\n\n with open(out_path, 'w') as vec_file:\n vec_file.write(str(num_word)+' '+str(vec_size) +'\\n') \n vec_file.write(vecfile_content)\n\ndef main():\n args = get_args_parser()\n xml2vec(args)\n print('\\nInclude none-text meme flag: %s' %(str(args.include_no_text)))\n print('Write done : %s\\n' %(args.vec_path))\n \nif __name__ == \"__main__\":\n main()\n" ]	[ [ "numpy.any" ] ]
jacopofar/sleep-anki-correlation	[ "ac7d152590839b3ff1ae7360d7dfc75b0ade6b41" ]	[ "activities_weekly_heatmap.py" ]	[ "from datetime import datetime\nimport json\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nHOURS = [str(x) for x in range(49)]\nWEEKDAYS = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']\n\n\ndef main():\n counts = np.zeros((len(WEEKDAYS), len(HOURS)))\n with open('activities.jsonl') as f:\n for line in f:\n ts = datetime.fromisoformat(json.loads(line)['timestamp'])\n counts[ts.weekday()][ts.hour * 2 + round(ts.minute / 30)] += 1\n\n fig, ax = plt.subplots()\n im = ax.imshow(counts, cmap=\"magma\")\n\n # We want to show all ticks...\n ax.set_yticks(np.arange(len(WEEKDAYS)))\n ax.set_xticks(np.arange(len(HOURS)))\n # ... and label them with the respective list entries\n ax.set_yticklabels(WEEKDAYS)\n ax.set_xticklabels([int(h)/2 for h in HOURS])\n\n # Rotate the tick labels and set their alignment.\n plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n\n ax.set_title(\"activities per weekday and hour\")\n fig.tight_layout()\n plt.show()\n\n\nif __name__ == '__main__':\n main()\n" ]	[ [ "matplotlib.pyplot.show", "matplotlib.pyplot.subplots" ] ]
bottydim/dginn	[ "c6b638b2df1e1fe57a76961b18c68dceee55ac38" ]	[ "dg_relevance.py" ]	[ "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nif __name__ == '__main__':\n tf.compat.v1.enable_eager_execution()\nfrom matplotlib import pyplot as plt\nfrom dginn.utils import vprint, Timer\nimport math\n\n# this should be only in the call module, all other modules should not have it!!!\n# best keep it in the main fx! \n# tf.compat.v1.enable_eager_execution()\nconfig = tf.compat.v1.ConfigProto()\n# config.gpu_options.visible_device_list = str('1')\n# config.gpu_options.per_process_gpu_memory_fraction = 0.5\nconfig.gpu_options.allow_growth = True\n\nsess = tf.compat.v1.Session(config=config)\n\nglobal verbose\nverbose = False\n\n\n##########COMPUTE##########\n# computes the importance scores of neurons to upper layer neurons \n# different methods \ndef compute_weight(model, fx_modulate=lambda x: x, verbose=False, local=False):\n '''\n model: model analyzed\n fx_module: extra weight processing\n '''\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling/concatenate/flatten \n if l.weights == []:\n vprint(l.name, verbose=verbose)\n omega_val[l] = np.array([])\n continue\n vprint(\"layer:{}\".format(l.name), verbose=verbose)\n # 1. compute values\n vprint(\"w.shape:{}\".format(l.weights[0].shape), verbose=verbose)\n score_val = l.weights[0][:, :]\n score_val = fx_modulate(score_val)\n\n # 2 aggragate across locations\n # if convolutional - check if convolutional using the shape\n # 2.1 4D input (c.f. images)\n if len(score_val.shape) > 3:\n vprint(\"\\tshape:{}\", verbose=verbose)\n vprint(\"\\tscore_val.shape:{}\".format(score_val.shape), verbose=verbose)\n score_val = np.mean(score_val, axis=(0, 1))\n elif len(score_val.shape) > 2:\n # 3D convolutional\n vprint(\"\\tshape:{}\", verbose=verbose)\n vprint(\"\\tscore_val.shape:{}\".format(score_val.shape), verbose=verbose)\n score_val = np.mean(score_val, axis=(0))\n # 3. aggregate across datapoints\n # ===redundant for weights\n # 4. Global Aggregation: tokenize values across upper layer neurons\n if not local:\n score_agg = np.mean(score_val, axis=-1)\n else:\n score_agg = score_val\n vprint(\"\\tomega_val.shape:{}\".format(score_agg.shape), verbose=verbose)\n omega_val[l] = score_agg\n\n return omega_val\n\n\ncompute_weight_abs = lambda x: compute_weight(x, fx_modulate=np.abs)\n\n\ndef compute_weights_gen(data, fx_modulate=lambda x: x, layer_start=None,\n agg_data_points=True,\n verbose=False):\n '''\n\n :param data:\n :param fx_modulate:\n :param layer_start:\n :param agg_data_points: whehter to aggragate across data points\n :param verbose:\n :return: return all neuron importance for all layers starting from layer_start\n '''\n return lambda x: compute_weight(x, fx_modulate=fx_modulate)\n\n\n### ACTIVATIONS\n\n### ACTIVATIONS ALL! \n# LOCAL computaion - rename!\n\n\n### ACTIVATIONS Global\ndef compute_activations_gen(data, fx_modulate=lambda x: x, layer_start=None,\n agg_data_points=True,\n verbose=False):\n \"\"\"\n agg_data_points: whehter to aggragate across data points\n return: return all neuron importance for all layers starting from layer_start\n \n compute_activations = compute_activations_gen(X_test)\n DG_a_mean = relevance_select_mean(compute_activations(model),input_layer=model.layers[0])\n \"\"\"\n\n def compute_activations_(model):\n omega_val = {}\n for l in model.layers[layer_start:]:\n vprint(\"layer:{}\".format(l.name), verbose=verbose)\n # 1. compute values\n # l.output vs l.input\n # l.output => omega_val[l] = NB on the same layer (which makes sense for activations)\n # conv1d_8--(2, 1170, 20) (2,32,32,20)\n # 3D shape:(2, 20)\n # omega_val.shape:(20,)\n # CHALLENGE => it doesn't make sense for the last layer\n # layer:targetPower--(1, 23)\n # omega_val.shape:(23,) => where instead we want the importance\n # l.input => omega_val[l] = NB of the previous layer\n # conv1d_8--(2, 1199, 1) \\\\ shape of previous layer!\n # 3D shape:(2, 1)\n # omega_val.shape:(1,)\n # l.input is NOT working for multi input\n # crash @concatenate\n\n # concetenates the input for concatenate layers \n if type(l) is tf.keras.layers.Concatenate:\n output = tf.keras.layers.concatenate(l.input)\n else:\n output = l.input\n # faster way is to include all layers to the output array! \n model_k = tf.keras.Model(inputs=model.inputs, outputs=[output])\n score_val = model_k.predict(data)\n score_val = fx_modulate(score_val)\n vprint(\"layer:{}--{}\".format(l.name, score_val.shape), verbose=verbose)\n # 2 aggragate across locations\n # 2.1 4D input (c.f. images)\n if len(score_val.shape) > 3:\n\n score_val = np.mean(score_val, axis=(1, 2))\n vprint(\"\\t 4D shape:{}\".format(score_val.shape), verbose=verbose)\n # 2.2 aggregate across 1D-input\n elif len(score_val.shape) > 2:\n score_val = np.mean(score_val, axis=(1))\n vprint(\"\\t 3D shape:{}\".format(score_val.shape), verbose=verbose)\n # 3. aggregate across datapoints\n # ? Why abs? naturally this affect previous experiments\n if agg_data_points:\n score_val = np.mean(np.abs(score_val), axis=0)\n\n # 4. tokenize values\n # ===redundant for activations\n omega_val[l] = score_val\n vprint(\"\\t omega_val.shape:{}\".format(score_val.shape), verbose=verbose)\n\n return omega_val\n\n return compute_activations_\n\n\n### GRADS\n\ndef compute_grads_helper(model, data, loss_, fx_modulate):\n # TODO\n raise NotImplemented\n return omega_val\n\n\ndef compute_grads_gen(data, loss_=lambda x: tf.reduce_sum(x[:, :]), fx_modulate=lambda x: x, verbose=False,\n batch_size=128):\n \"\"\"\n General idea: go through all layers, compute the derivatives of the upper layer neurons wrt current \n \n e.g. \n compute_grads = compute_grads_gen(X_test,loss_fx)\n grads = compute_grads(model)\n \"\"\"\n\n def compute_grads(model):\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n omega_val[l] = np.array([])\n continue\n # 1. compute values\n # \n model_k = tf.keras.Model(inputs=model.inputs, outputs=[l.output])\n # last layer of the new model\n inter_l = model_k.layers[-1]\n\n # NB!\n # make sure to compute gradient correctly for the last layer by chaning the activation fx \n if l == model.layers[-1]:\n activation_temp = l.activation\n if l.activation != tf.keras.activations.linear:\n l.activation = tf.keras.activations.linear\n\n score_val = np.zeros(inter_l.weights[0].shape)\n\n # handle multi-input data\n\n if type(data) is dict:\n key = list(data.keys())[0]\n data_len = data[key].shape[0]\n else:\n data_len = data.shape[0]\n\n # what do we do with multi-input data?!\n # TODO fix strange name change : vs _\n input_names = [l.name.split(\":\")[0] for l in model.inputs]\n # !!!!! FOLLOWING Line not tested\n input_names = [l.split(\"_\")[0] for l in input_names]\n # split the data into batches\n for i in range(0, data_len, batch_size):\n # TODO experiment speed if with device(cpu:0) \n with tf.GradientTape() as t:\n # for some reason requires tensor, otherwise blows up\n # c.f. that for activations we use model.predict\n if type(data) is dict:\n tensor = []\n for k in input_names:\n tensor.append(data[k][i:min(i + batch_size, data_len)].astype('float32'))\n else:\n tensor = tf.convert_to_tensor(data[i:min(i + batch_size, data_len)], dtype=tf.float32)\n current_loss = loss_(model_k(tensor))\n dW, db = t.gradient(current_loss, [inter_l.weights])\n score_val += fx_modulate(dW)\n\n # restor output function! \n if l == model.layers[-1]:\n l.activation = activation_temp\n\n vprint(\"layer:{}--{}\".format(l.name, score_val.shape), verbose=verbose)\n # 2 aggragate across locations\n # 2.1 4D\n if len(score_val.shape) > 3:\n # (3, 3, 3, 64) -> for activations, it is not aggregated across data-points\n score_val = np.mean(score_val, axis=(0, 1))\n vprint(\"\\t 4D shape:{}\".format(score_val.shape), verbose=verbose)\n elif len(score_val.shape) > 2:\n score_val = np.mean(score_val, axis=(0))\n vprint(\"\\t 3D shape:{}\".format(score_val.shape), verbose=verbose)\n # 3. aggregate across datapoints\n\n # already produced by line 230 \n # to include data point analysis, we can use persistant gradient_tape\n # compute point by point or use the loss\n # explore this issue for efficiency gain https://github.com/tensorflow/tensorflow/issues/4897\n\n # 4. tokenize values\n mean = np.mean(score_val, axis=1)\n omega_val[l] = mean\n\n vprint(\"\\t omega_val.shape:{}\".format(mean.shape), verbose=verbose)\n return omega_val\n\n return compute_grads\n\n\n### Weights activations\n\n\ndef compute_weight_activations_gen(data, fx_modulate=lambda x: x, verbose=verbose):\n def compute_weight_activations_(model):\n omega_val = {}\n for l in model.layers:\n\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n omega_val[l] = np.array([])\n\n continue\n\n # 1. compute values\n\n # 1.1 compute activations \n model_k = tf.keras.Model(inputs=model.inputs, outputs=[l.input])\n score_val_a = model_k.predict(data)\n\n score_val_a = fx_modulate(score_val_a)\n\n # 1.2 compute \n\n score_val_w = l.weights[0][:]\n score_val_w = fx_modulate(score_val_w)\n\n # 2 aggragate across locations\n\n # 2.1 Aggregate Across Activations\n # 2.1.1 aggregate across 4D\n if len(score_val_a.shape) > 3:\n score_val_a = np.mean(score_val_a, axis=(1, 2))\n vprint(\"\\t 4D shape:{}\".format(score_val_a.shape), verbose=verbose)\n # 2.1.2 aggregate across 3D(1D-input)\n elif len(score_val_a.shape) > 2:\n score_val_a = np.mean(score_val_a, axis=(1))\n vprint(\"\\t 3D shape:{}\".format(score_val_a.shape), verbose=verbose)\n\n # 2.2.1 aggragate across locations (WEIGHTS)\n if len(score_val_w.shape) > 3:\n vprint(\"\\tshape:{}\", verbose=verbose)\n vprint(\"\\tscore_val.shape:{}\".format(score_val_w.shape), verbose=verbose)\n score_val_w = np.mean(score_val_w, axis=(0, 1))\n elif len(score_val_w.shape) > 2:\n score_val_w = np.mean(score_val_w, axis=(0))\n\n # 3. aggregate across datapoints\n score_agg_a = np.mean(score_val_a, axis=0)\n\n # ===redundant for weights\n # 4. tokenize values\n # ===redundant for activations\n score_agg_w = np.mean(score_val_w, axis=-1)\n omega_val[l] = score_agg_a * score_agg_w\n return omega_val\n\n return compute_weight_activations_\n\n\n##### Increase Granularity: Weights Local\n\ndef compute_weight_per_channel(model, fx_modulate=lambda x: x):\n '''\n equivalent to compute_weight(model,fx_modulate=lambda x:x,verbose=False,local=True)\n '''\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n # print(l.name)\n omega_val[l] = np.array([])\n continue\n # print(\"layer:{}\".format(l.name))\n # 1. compute values\n # print(\"w.shape:{}\".format(l.weights[0].shape))\n score_val = l.weights[0][:, :]\n score_val = fx_modulate(score_val)\n\n # 1.1 aggragate across locations\n if len(score_val.shape) > 3:\n # print(\"\\tshape:{}\")\n # print(\"\\tscore_val.shape:{}\".format(score_val.shape))\n score_val = np.mean(score_val, axis=(0, 1))\n # 2. aggregate across datapoints\n # ===redundant for weights\n # 3. tokenize values across upper layer neurons\n # score_agg = np.mean(score_val,axis=-1)\n score_agg = score_val\n # print(\"\\tomega_val.shape:{}\".format(score_agg.shape))\n omega_val[l] = score_agg\n\n return omega_val\n\n\n######## Combine Compute FX\ndef combine_compute_fx(relevances_a, relevances_b):\n '''\n \n e.g.\n compute_fx = compute_activations_gen(data_set,fx_modulate=np.abs,verbose=False)\n relevances_a = compute_fx(model)\n relevances_w = compute_weight(model,fx_modulate=np.abs)\n\n compute_fx = compute_weight_activations_gen(data_set,fx_modulate=np.abs,verbose=False)\n relevances_wa = compute_fx(model)\n\n compute_fx = compute_grads_gen(data_set,fx_modulate=np.abs,verbose=False)\n relevances_g = compute_fx(model)\n\n relevances_wa_app = combine_compute_fx(relevances_a,relevances_w)\n relevances_ga_app = combine_compute_fx(relevances_a,relevances_g)\n '''\n relevances_ab_app = {}\n for k, v in relevances_a.items():\n # print(k.name,type(relevances_a[k]),type(relevances_b[k]))\n if k.weights == []:\n relevances_ab_app[k] = np.array([])\n continue\n relevances_ab_app[k] = relevances_a[k] * relevances_b[k]\n return relevances_ab_app\n\n\n######### DEPENDENCY\n\n# TODO abstract out as fx!\n# one way to do is to make all computes classes \n# give them interfaces\n\n# COULD be equivalent to compute_weight_per_channel ???!! \ndef compute_dependency_weight(model, fx_modulate=lambda x: x):\n '''\n - does not aggragate across upper layer! \n equivalent to compute_weight(model,fx_modulate=lambda x:x,verbose=False,local=True)\n \n \n '''\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n # print(l.name)\n omega_val[l] = np.array([])\n continue\n # print(\"layer:{}\".format(l.name))\n # 1. compute values\n # print(\"w.shape:{}\".format(l.weights[0].shape))\n score_val = l.weights[0][:, :]\n score_val = fx_modulate(score_val)\n\n # print(\"\\tscore_val.shape:{}\".format(score_val.shape))\n # 2 aggragate across locations\n shape_len = len(score_val.shape)\n # 2.1 4D input (c.f. images)\n if shape_len > 3:\n score_val = np.mean(score_val, axis=(0, 1))\n # 2.2 aggregate across 1D-input\n elif shape_len > 2:\n score_val = np.mean(score_val, axis=(0))\n # 3. aggregate across datapoints\n # ===redundant for weights\n # 4. tokenize values across upper layer neurons\n # score_agg = np.mean(score_val,axis=-1)\n score_agg = score_val\n # print(\"\\tomega_val.shape:{}\".format(score_agg.shape))\n omega_val[l] = score_agg\n\n return omega_val\n\n\n##########GENERATE DG##########\n# tokenize\n\n\n# functions, which handle the neuron relevance selection\ndef percentage_threshold(relevance, t):\n r = np.ravel(relevance)\n # sort args based on val, reverse, take %\n return list(reversed(np.argsort(r)))[:math.ceil(len(r) * t)]\n\n\ndef select_random(relevance, threshold):\n size = len(relevance)\n return np.random.choice(size, threshold)\n\n\ndef relevance_select_(omega_val, input_layer, select_fx_):\n relevant = {}\n\n for l, relevance in omega_val.items():\n if type(input_layer) is list and l in input_layer:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n relevant[l] = [range(relevance.shape[1]) for _ in range(relevance.shape[0])]\n else:\n relevant[l] = range(len(relevance))\n elif l == input_layer:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n relevant[l] = np.array([range(relevance.shape[1]) for _ in range(relevance.shape[0])])\n else:\n relevant[l] = np.array(range(len(relevance)))\n # process layers without weights\n elif l.weights == []:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n relevant[l] = np.array([[] for _ in range(relevance.shape[0])])\n else:\n #in the event of bugs: used to be [] vs np.array([])\n relevant[l] = np.array([])\n\n else:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n # returns an array with the same number of neuron id for each dg\n # the array contains the neuron ids that were selected as relevant\n relevant[l] = np.apply_along_axis(select_fx_, 1, relevance)\n else:\n relevant[l] = []\n idx = select_fx_(relevance)\n relevant[l] = idx\n return relevant\n\n\n\n\n# 3 functions below take\n# omega value: the compute relevances from the previous step\n# input_layer: KEEP ALL neurons LAYER - either list or single layer\n# threshold: varies depending on relevance_select_fx\ndef relevance_select_random(omega_val, input_layer, threshold):\n select_fx_random = lambda relevance: select_random(relevance, threshold)\n return relevance_select_(omega_val, input_layer, select_fx_random)\n\n\ndef relevance_select(omega_val, input_layer, threshold=0.5):\n select_fx_percentage = lambda relevance: percentage_threshold(relevance, threshold)\n return relevance_select_(omega_val, input_layer, select_fx_percentage)\n\n\ndef relevance_select_mean(omega_val, input_layer):\n def select_fx_mean(relevance):\n threshold = np.mean(relevance)\n idx = np.where(relevance > threshold)[0]\n return idx\n\n return relevance_select_(omega_val, input_layer, select_fx_mean)\n\n\n##########EVAL HELPERS##########\ndef get_time_hhmmss(start):\n import time\n end = time.time()\n m, s = divmod(end - start, 60)\n h, m = divmod(m, 60)\n time_str = \"%02d:%02d:%02d\" % (h, m, s)\n return time_str\n\n\n# inverse mask of the Dependency Graph:\n# turn-off all neurons, which are not part of the DG, and execute the network!\n# the same as running just the DG (dependency graph)\ndef get_DG_exec(model, dep_graph):\n temp_store = {}\n for l in model.layers:\n import time\n start = time.time()\n # skip pooling & flatten & concatenate\n if len(l.weights) == 0:\n continue\n # drop irrelevant\n w, b = l.weights\n # this way we create a copy? [:,;]?\n temp_store[l] = w[:, :], b[:]\n # gen all neuron indices in the current layer\n # and subtract from them all relevant indices (neurons in DG)\n # -2 in order to work for both convolutional[-2] & dense layers[0]\n irrelevant = set(range(w.shape[-2])) - set(dep_graph[l])\n neurons = list(irrelevant)\n\n target = w.numpy()\n n = neurons\n # skip layers which do not require any weight changes\n # observe the BUG! \n if len(n) == 0:\n continue\n # 4D convolutional\n if len(w.shape) > 3:\n target[:, :, n, :] = 0\n elif len(w.shape) > 2:\n target[:, n, :] = 0\n target_shape = target.shape\n else:\n target[n, :] = 0\n target_shape = target.shape\n\n tf.assign(w, target)\n # don't touched the bias, as it is like another neuron for the upper layer neuron\n # print(b.shape,n)\n # tf.assign(b[n], np.zeros(b.shape))\n # print(l.name,get_time_hhmmss(start))\n return model, temp_store\n\n\ndef recover_model(model, temp_store):\n for l in model.layers:\n # skip pooling & flatten\n if len(l.weights) == 0:\n continue\n w, b = l.weights\n temp_w, temp_b = temp_store[l]\n tf.assign(w, temp_w)\n return model\n\n\n##########EVAL##########\n\n\n#### EXTREMELY INEFFICIENT WAY TO EVAL!\ndef evaluate_dg_gen(model, data):\n X_, y_ = data\n\n def eval_dep_graph(dep_graph):\n temp_store = {}\n for l in model.layers:\n # skip pooling & flatten\n if len(l.weights) == 0:\n continue\n # drop irrelevant\n w, b = l.weights\n temp_store[l] = w[:, :], b[:]\n # gen all neuron indices and subtract from them all relevant indices\n # -2 in order to work for both convolutional[-2] & dense layers[0]\n irrelevant = set(range(w.shape[-2])) - set(dep_graph[l])\n neurons = list(irrelevant)\n\n # INEFFICIENT!! \n for n in neurons:\n if len(w.shape) > 2:\n target = w[:, :, n, :]\n target_shape = target.shape\n tf.assign(target, np.zeros(target.shape[:], ))\n else:\n tf.assign(w[n, :], np.zeros(w.shape[1]))\n # don't touched the bias, as it is like another neuron for the upper layer neuron\n # print(b.shape,n)\n # tf.assign(b[n], np.zeros(b.shape))\n score = model.evaluate(X_, y_, verbose=0, batch_size=256)\n\n for l in model.layers:\n # skip pooling & flatten\n if len(l.weights) == 0:\n continue\n w, b = l.weights\n temp_w, temp_b = temp_store[l]\n tf.assign(w, temp_w)\n return score\n\n return eval_dep_graph\n\n\nevaluate_dep_graph = lambda model, DG: evaluate_dg_gen(model, (X_test, Y_test))(DG)\nevaluate_dep_graph_train = lambda model, DG: evaluate_dg_gen(model, (X_train, Y_train))(DG)\n\n\n# runs evalaution of the computed dependecy graphs computed with various compute functions across different data-sets.\ndef evaluate_across_classes_with_threshold(model, data_sets, store_DGs=False, t_lim=None, ):\n def loss_fx(x):\n return tf.reduce_mean(x[:, :])\n\n DGs = []\n\n # import pdb; pdb.set_trace()\n train_data_sets, eval_data_sets = data_sets\n print(len(train_data_sets), train_data_sets[0][0].shape)\n print(len(eval_data_sets))\n timer = Timer()\n thresholds = [(i + 1) / 10.0 for i in range(10)][::-1]\n j_len = len(train_data_sets)\n i_len = 3\n k_len = len(eval_data_sets)\n t_len = len(thresholds)\n results = np.zeros((k_len, j_len, i_len, t_len, 2))\n for j, data_set in enumerate(train_data_sets):\n\n X_temp, y_temp = data_set\n # compute_activations = compute_activations_gen(X_temp)\n compute_activations_abs = compute_activations_gen(X_temp, fx_modulate=np.abs)\n # compute_grads = compute_grads_gen(X_temp,loss_fx)\n compute_grads_abs = compute_grads_gen(X_temp, loss_fx, fx_modulate=np.abs)\n # compute_wa = compute_weight_activations_gen(X_temp)\n compute_wa_abs = compute_weight_activations_gen(X_temp, np.abs)\n\n # compute_fxs = [compute_weight, compute_weight_abs,compute_activations,compute_activations_abs,\n # compute_grads,compute_grads_abs,compute_wa,compute_wa_abs]\n compute_fxs = [compute_activations_abs,\n compute_grads_abs, compute_wa_abs]\n # compute_fxs = [compute_wa_abs]\n print(\"Generate Compute FXs-{}\".format(timer.get_time_hhmmss()))\n # eval\n\n DGs.append([])\n for i, compute_fx in enumerate(compute_fxs):\n relevances = compute_fx(model)\n DGs[j].append([])\n print(\"COMPUTATION:\", timer.get_time_hhmmss())\n for t_, t in enumerate(thresholds):\n DG = relevance_select(relevances, input_layer=model.layers[0], threshold=t)\n if store_DGs:\n DGs[j][i].append(DG)\n dg_exec, tmp = get_DG_exec(model, DG)\n for k, eval_ds in enumerate(eval_data_sets):\n eval_dg = evaluate_dg_gen(model, eval_ds)\n score = dg_exec.evaluate(eval_ds, batch_size=256, verbose=0)\n\n results[k, j, i, t_] = score\n assert np.all(results[k, j, i, t_] == score)\n # print(timer.get_time_hhmmss())\n # print info\n recover_model(model, tmp)\n fx = compute_fxs[i]\n name = \"_\".join(str(fx).split(\" \")[1].split(\"_\")[1:2])\n print(\"{}-#{}-{}-ts={}\".format(name, j, i, t))\n print(timer.get_time_hhmmss())\n if store_DGs:\n return results, DGs\n else:\n return results\n\n\n# LEGACY\ndef analyzer_gen(model):\n def analyze_dg(compute_fx, relevance_select_fx):\n\n dg_vals = compute_fx(model)\n value = list(dg_vals.values())\n for i in range(len(value)):\n if len(value[i]) == 0:\n continue\n mean = value[i]\n order = np.flip(np.argsort(np.abs(mean)))\n # plt.figure()\n plt.scatter(np.arange(mean.shape[0]), np.abs(mean[order]))\n DG = relevance_select_fx(compute_fx(model), input_layer=model.layers[0])\n report_eval_dep_graph(model, DG)\n return DG\n\n return analyze_dg\n\n\n######## Data Set Processing\n\n### CIFAR-specific\ndef get_data_sets_cls(X, Y, d_lim=None):\n data_sets = []\n for i in range(Y.shape[1]):\n idx = np.where(Y[:, i] == 1)[0]\n X_cls_i = X[idx]\n y_cls_i = Y[idx]\n # print(X_cls_i.shape,y_cls_i.shape)\n data_sets.append((X_cls_i[0:d_lim], y_cls_i[0:d_lim]))\n return data_sets\n\n\ndef get_data_sets(data_sets, cls_eval=True, d_lim=None):\n '''\n data_sets = [(X_train[0:256],Y_train[0:256]),(X_test[0:256],Y_test[0:256])]\n a,b = get_data_sets(data_sets)\n assert len(a) == 11 and len(b) == 22\n for ds in a:\n assert len(ds)==2\n for ds in b:\n assert len(ds)==2\n '''\n data_sets = data_sets[0:d_lim]\n train_data_sets = data_sets[0:1]\n train_data_cls = cls_eval\n # gen data_sets\n # FIX, these are global vars X_train,Y_train\n if train_data_cls:\n train_data_sets += get_data_sets_cls(X_train, Y_train)\n eval_data_sets = [_ for _ in train_data_sets]\n if len(data_sets) > 1:\n eval_data_sets += [data_sets[1]]\n # data_sets = [(X_train[:100],Y_train[:100]),(X_test[:100],Y_test[:100])]\n\n test_data_cls = cls_eval\n if test_data_cls:\n X_test = data_sets[1][0]\n Y_test = data_sets[1][1]\n for i in range(Y_test.shape[1]):\n idx = np.where(Y_test[:, i] == 1)[0]\n X_cls_i = X_test[idx]\n y_cls_i = Y_test[idx]\n # print(X_cls_i.shape,y_cls_i.shape)\n eval_data_sets.append((X_cls_i, y_cls_i))\n return train_data_sets, eval_data_sets\n\n\ndef merge_data_sets(cls_ds_list, id_list, d_lim=None):\n '''\n data_sets_list: list of (X,Y) typles\n '''\n output_ds = []\n\n for cls_ds in cls_ds_list:\n data_sets_merged = []\n for i in id_list:\n data_sets_merged += cls_ds[i]\n # irrelevant of len(id_list!)\n try:\n # get every second element b.c. there are X & Y\n X_ = np.vstack(data_sets_merged[::2])\n Y_ = np.vstack(data_sets_merged[1::2])\n output_ds.append((X_, Y_))\n except:\n print(X.shape)\n for x in data_sets_merged:\n print(x.shape)\n raise \"ERROR\"\n return output_ds\n\n\n##########UTILS########## \n\n# relabel the key of the Dependency Graphs \ndef relabel(DGs):\n DG_relabelled = {}\n for j in range(shapes[1]):\n for i in range(shapes[2]):\n for t_ in range(shapes[3]):\n DG = DGs[j][i][t_]\n for k, l in enumerate(model.layers):\n try:\n temp = DG[l]\n DG_relabelled[k] = temp\n except:\n print(j, i, t_)\n return\n return DG_relabelled\n\n\n##########COMPUTE UTILS##########\n# c.f. = confer = compare\n\n### counters\ndef cf_dgs(dg_a, dg_b):\n '''\n count number of shared neurons\n '''\n total = 0\n for (k, v) in dg_a.items():\n a = set(v)\n b = set(dg_b[k])\n r = len(a.intersection(b))\n total += r\n return total\n\n\n# count unique!\ndef cf_dgs_unique(dg_a, dg_b):\n total = 0\n for (k, v) in dg_a.items():\n a = set(v)\n b = set(dg_b[k])\n c = a - b\n r = len(c)\n total += r\n return total\n\n\n### DG extractors\ndef cf_dgs_intersect(dgs):\n '''\n dgs: list of dependency graphs\n return: intersection b/t all dgs\n '''\n total = 0\n import copy\n dg_ = copy.copy(dgs[0])\n for dg_b in dgs[1:]:\n for (k, v) in dg_.items():\n a = set(v)\n b = set(dg_b[k])\n c = a.intersection(b)\n dg_[k] = c\n return dg_\n\n\ndef cf_dgs_union(dgs):\n '''\n dgs: list of dependency graphs\n return: union b/t all dgs\n '''\n total = 0\n import copy\n dg_ = copy.copy(dgs[0])\n for dg_b in dgs[1:]:\n for (k, v) in dg_.items():\n a = set(v)\n b = set(dg_b[k])\n c = a.union(b)\n dg_[k] = c\n return dg_\n\n\ndef cf_dgs_diff(dg_a, dg_b, skip_layers=[]):\n '''\n dg_a: minuend\n dg_b: subtrahend\n skip_layers: input layers to skip, if execution of the graph is required! \n '''\n import copy\n dg_ = copy.copy(dg_a)\n for (k, v) in dg_a.items():\n if k in skip_layers:\n continue\n a = set(v)\n b = set(dg_b[k])\n c = a - b\n dg_[k] = c\n return dg_\n\n\ndef report_eval_dep_graph(model, dep_graph):\n print(evaluate_dep_graph(model, dep_graph))\n print(count_dep_graph(model, dep_graph))\n\n\ndef len_dep_graph(DG):\n total = 0\n for l, neurons in DG.items():\n total += len(neurons)\n return total\n\n\ndef count_dep_graph(model, dep_graph):\n total_slct, total_all = 0, 0\n for l in model.layers:\n if len(l.weights) == 0:\n continue\n n_slct = len(dep_graph[l])\n n_total = len(omega_val[l])\n print(\"{}/{}={:2.1f}%\".format(n_slct, n_total, 100 n_slct / float(n_total)))\n total_slct += n_slct\n total_all += n_total\n return total_slct, total_all\n\n\ndef visualise_layers_DG(DG, DG_full, model, percentage=False, skip_layers=[]):\n layer_vals = []\n layer_size = []\n layer_names = []\n for l in model.layers:\n if l.name in skip_layers:\n continue\n layer_vals.append(len(DG[l])) #\n layer_names.append(l.name)\n layer_size.append(len(DG_full[l]))\n if percentage:\n layer_vals = np.array(layer_vals) / np.array(layer_size) * 100\n N = len(layer_vals)\n fig, ax = plt.subplots(figsize=(10, 5))\n ind = np.arange(N) # the x locations for the groups\n width = 0.50 # the width of the bars\n p1 = ax.barh(ind, layer_vals, width, )\n if percentage:\n ax.set_xlim(0, 100)\n ax.set_yticks(range(len(layer_names)))\n ax.set_yticklabels(layer_names)\n\n\n# ax.invert_yaxis()\n\ndef get_input_layers(model, include_adjacent=True):\n if include_adjacent:\n input_layers = []\n for l in model.layers:\n if l.input in model.inputs:\n input_layers.append(l)\n else:\n input_layers = list(filter(lambda x: type(x) == type(model.layers[0]), model.layers))\n return input_layers\n\n\ndef view_input_layers(relevances, input_layers):\n '''\n return: the importance of the input layers\n e.g. \n aggPower [33.246933]\n aggDiffWave [0.05136125]\n aggNoMinWave [0.23131992]\n '''\n for l in input_layers:\n print(l.name, relevances[l])\n\n\ndef view_layer_importance(relevances_a, model, ax=None, logy=True, summary_fx=np.mean):\n '''\n return: the importance of the input layers\n e.g.\n aggPower [33.246933]\n aggDiffWave [0.05136125]\n aggNoMinWave [0.23131992]\n '''\n layer_importance = []\n for l in model.layers:\n layer_importance.append(summary_fx(relevances_a[l]))\n\n layer_names = [l.name for l in model.layers]\n df = pd.DataFrame(zip(layer_importance, layer_names))\n df = df.set_index(df[1])\n ax = df[0].plot(kind=\"bar\", logy=logy, ax=ax)\n\n\ndef visualise_kernel_dependence(importance_kernels_1, sharey=False, log=False):\n n_rows = 10\n n_cols = int(int(importance_kernels_1.shape[-1]) / n_rows)\n fig, axes = plt.subplots(n_rows, n_cols, figsize=(20, 10), sharey=sharey)\n for i in range(n_rows):\n for j in range(n_cols):\n idx = n_cols * i + j\n y_axis_ = np.abs(importance_kernels_1[:, idx])\n line = axes[i, j].bar(np.arange(y_axis_.shape[0]), y_axis_, log=log)\n axes[i, j].set_title(\"Kernel #:{}\".format(idx))\n\n\ndef layer_importance_strategies(model,relevance_strategies, relevance_names, logy=False, sharey=False):\n \"\"\"\n relevance_strategies: a list of \n \"\"\"\n # TODO fix number! to be dynamic based on input\n n_rows = 3\n n_cols = 2\n fig, axes = plt.subplots(n_rows, n_cols, figsize=(20, 10), sharey=sharey)\n for i, r in enumerate(relevance_strategies):\n x = i // n_cols\n y = i % n_cols\n ax = axes[x, y]\n view_layer_importance(r, model, logy=logy, ax=ax)\n ax.set_title(relevance_names[i])\n plt.tight_layout()\n\n\ndef run_dgs(DG_eval, data_sets, model):\n \"\"\"\n return: a list for each DG where each element is the output of the corresponding DG on a particular data_set\n \"\"\"\n results_all = []\n my_timer = Timer()\n for i, DG in enumerate(DG_eval):\n results_list = []\n print(\"DG_{}_{}\".format(i, my_timer.get_time_hhmmss()))\n for j in range(len(data_sets)):\n X_eval = data_sets[j]\n dg_exec, tmp = get_DG_exec(model, DG)\n # FIX: y_eval is a global var! \n # ?? batch_size=WHY? y_eval.shape[0]\n results = dg_exec.predict(X_eval, batch_size=128, verbose=0)\n recover_model(model, tmp)\n\n results_list.append(results)\n results_all.append(results_list)\n return results_all\n\n\n###### Predictions Analysis (potentially INFORMETIS specific)\n\ndef get_overall_predictions(results_list, results_orig):\n pred_orig = argmax_predictions(results_orig)\n pred_dg = argmax_predictions(results_list)\n return pred_dg, pred_orig\n\n\ndef mean_predictions(results_list):\n \"\"\"\n results_list: list of multiple DG run results\n return: mean prediction for each DG\n \"\"\"\n pred = []\n N = len(results_list)\n for i in range(N):\n results_mean = np.mean(results_list[i], axis=0)\n pred.append(np.argmax(results_mean))\n return pred\n\n\ndef argmax_predictions(results_list):\n \"\"\"\n results_list: list of multiple DG run results\n return: argmax prediction per sample for each DG\n \"\"\"\n pred = []\n N = len(results_list)\n for i in range(N):\n results = np.argmax(results_list[i], axis=1)\n bins = np.bincount(results, minlength=results_list[i].shape[1])\n pred.append(np.argmax(bins))\n return pred\n\n\ndef get_pred_dist(results_list):\n \"\"\"\n return: distribution of predictions in hist form c.f. bins\n based on argmax_predictions\n \"\"\"\n pred_dist = []\n N = len(results_list)\n for i in range(N):\n results = np.argmax(results_list[i], axis=1)\n pred_dist.append(np.unique(results, return_counts=True))\n return pred_dist\n\n\ndef total_prediction_count(results_list):\n \"\"\"\n return: counts # predictions for each class across result_list of DGs\n \"\"\"\n num_cls = results_list[0].shape[1]\n acc_array = np.zeros(num_cls)\n N = len(results_list)\n for i in range(N):\n results = np.argmax(results_list[i], axis=1)\n bins = np.bincount(results, minlength=num_cls)\n acc_array += bins\n return acc_array\n\n\ndef count_correct_pred(results_list, current_labels):\n correct_counter = []\n for i in range(len(results_list)):\n results = np.argmax(results_list[i], axis=1)\n bins = np.bincount(results, minlength=results_list[i].shape[1])\n dg_correct = bins[current_labels[i]]\n correct_counter.append(dg_correct)\n return correct_counter\n\n\n#### Secondary Analysis\n\n# un-tested functions\n\ndef plot_input_importance(relevance_list, input_layers, data_set_cls_dict):\n bars = {k.name: [] for k in input_layers}\n for r in relevance_list:\n for l in input_layers:\n bars[l.name].extend(r[l])\n N = len(relevance_list)\n fig, ax = plt.subplots()\n plots = []\n for i, k in enumerate(bars.keys()):\n ind = np.arange(N) * 2 # the x locations for the groups\n width = 0.50 # the width of the bars\n p1 = ax.bar(ind + i * width, bars[k], width, bottom=0)\n plots.append(p1[0])\n ax.set_title('Relevance by input layer and class type')\n ax.set_xticks(ind + width / 3)\n class_names = [cls for cls in data_set_cls_dict.keys()]\n ax.set_xticklabels(class_names)\n input_layer_labels = [l for l in bars.keys()]\n ax.legend(plots, input_layer_labels)\n\n\ndef main():\n from mnist_loader import load_mnist, build_sample_model\n from dataset_utils import filter_dataset\n from core import Activations_Computer\n import os\n\n # Load dataset\n X_train, y_train, X_test, y_test = load_mnist()\n\n # Filter out subset of classes\n selected_classes = [0, 1, 2, 3]\n X_train, y_train = filter_dataset((X_train, y_train), selected_classes)\n X_test, y_test = filter_dataset((X_test, y_test), selected_classes)\n\n # Create model\n input_shape = X_train.shape[1:]\n model = build_sample_model(input_shape)\n\n model_save_path = \"./mnist_model.h5\"\n if not os.path.exists(model_save_path):\n # Train model\n model.fit(x=X_train, y=y_train, epochs=2)\n model.save_weights(model_save_path)\n else:\n model.load_weights(model_save_path)\n\n compute_fx = Activations_Computer(model=model, agg_data_points=False)\n relevances = compute_fx(X_train[0:100, :])\n dgs = relevance_select(relevances, input_layer=compute_fx.model.layers[0], threshold=0.20)\n\n\nif __name__ == '__main__':\n main()" ]	[ [ "tensorflow.reduce_sum", "tensorflow.compat.v1.enable_eager_execution", "numpy.all", "numpy.mean", "numpy.where", "matplotlib.pyplot.tight_layout", "numpy.unique", "numpy.arange", "numpy.argmax", "numpy.apply_along_axis", "numpy.ravel", "numpy.zeros", "numpy.random.choice", "tensorflow.keras.Model", "numpy.argsort", "numpy.array", "tensorflow.GradientTape", "tensorflow.compat.v1.ConfigProto", "numpy.abs", "tensorflow.reduce_mean", "tensorflow.assign", "matplotlib.pyplot.subplots", "tensorflow.keras.layers.concatenate", "tensorflow.compat.v1.Session", "numpy.bincount", "numpy.vstack" ] ]
kazuhitogo/amazon-redshift-police	[ "287e62725f7ef039ee074aaa157952a8448138a2" ]	[ "src/generate_image.py" ]	[ "from random import randint,seed\nfrom PIL import Image,ImageDraw,ImageFont\nfrom os import makedirs, path, listdir\nfrom glob import glob\nimport argparse\nimport numpy as np\nimport matplotlib.font_manager as fm\nseed(1234) # 結果を再現できるようにするために乱数のシードを固定\ndef main(output_dir,check_name_list):\n system_font_list = fm.findSystemFonts()\n system_font_list = [font.replace('\\\\','/') for font in system_font_list]\n # 文字化けするfontを除外\n NG_FONT_LIST = ['BSSYM7.TTF','holomdl2.ttf','marlett.ttf','MTEXTRA.TTF','OUTLOOK.TTF','REFSPCL.TTF','segmdl2.ttf','symbol.ttf','TSPECIAL1.TTF','webdings.ttf','wingding.ttf','WINGDNG2.TTF','WINGDNG3.TTF','Webdings.ttf']\n font_list = []\n for font in system_font_list:\n if font.split('/')[-1] not in NG_FONT_LIST:\n font_list.append(font)\n print(f'found fonts: {len(font_list)}')\n print(font_list)\n tmp_img_dir = './img/'\n makedirs(tmp_img_dir, exist_ok=True)\n seed(1234) # 結果を再現できるようにするために乱数のシードを固定\n pixel_size = (700,50)\n\n for text in check_name_list:\n for i in range(5):\n for font_path in font_list:\n font = ImageFont.truetype(font_path, randint(20,30))\n font = ImageFont.truetype(font_path, 30)\n img = Image.new('L', (pixel_size[0],pixel_size[1]),(255))\n d = ImageDraw.Draw(img)\n d.text((0, 0), text, font=font, fill=(0))\n\n # 描画部分だけ切り出し\n img_array = np.array(img)\n w,h=0,0\n for j in range(pixel_size[0]-1,-1,-1):\n if not (np.all(img_array[:,j]==255)):\n w = j+1\n break\n for j in range(pixel_size[1]-1,-1,-1):\n if not (np.all(img_array[j,:]==255)):\n h = j+1\n break\n img_array = img_array[0:h,0:w]\n max_pad_h = pixel_size[1] - img_array.shape[0]\n max_pad_w = pixel_size[0] - img_array.shape[1]\n pad_h = randint(0,max_pad_h)\n pad_w = randint(0,max_pad_w)\n # 真っ白なキャンバスを作成\n canvas_array = np.ones((pixel_size[1],pixel_size[0]),dtype=np.uint8)255\n # 文字をランダムに移植\n canvas_array[pad_h:pad_h+img_array.shape[0],pad_w:pad_w+img_array.shape[1]] = img_array\n img = Image.fromarray(canvas_array)\n\n file_path = tmp_img_dir + text.replace(' ','') + '_' +font_path.split('/')[-1] + str(i) + '.png'\n img.save(file_path)\n img_file_list = sorted(glob('./img/.png'))\n train_X = np.zeros((len(img_file_list),pixel_size[1],pixel_size[0]),dtype=np.uint8)\n train_y = np.zeros((len(img_file_list)),dtype=np.float32)\n\n for i,img_file in enumerate(img_file_list):\n img = Image.open(img_file)\n img_array = np.array(img)\n train_X[i,:,:] = img_array\n if check_name_list[1].replace(' ','') in img_file:\n train_y[i] = 1\n train_X = ((train_X-127.5)/127.5).astype(np.float32)\n \n makedirs(output_dir, exist_ok=True)\n train_X_path = path.join(output_dir,'train_X.npy')\n train_y_path = path.join(output_dir,'train_y.npy')\n \n print(f'train_x save: {train_X_path}')\n np.save(train_X_path,train_X)\n print(f'train_x save: {train_y_path}')\n np.save(train_y_path,train_y)\n \n\nif __name__=='__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--output-dir', type=str, default='/workspace/data')\n parser.add_argument('--check-names', type=str,default=\"Amazon ElastiCache/Amazon ElasticCache\")\n args, _ = parser.parse_known_args()\n check_name_list = args.check_names.split('/')\n print(check_name_list)\n main(args.output_dir,check_name_list)" ]	[ [ "numpy.save", "numpy.ones", "numpy.all", "numpy.array", "matplotlib.font_manager.findSystemFonts" ] ]
yasudakn/CIHP_PGN	[ "71a1aae3b507cdbf47cab6a12e2e8bdef68273bb" ]	[ "utils/image_reader.py" ]	[ "import os\n\nimport numpy as np\nimport tensorflow as tf\nimport random\n\nIGNORE_LABEL = 255\nIMG_MEAN = np.array((125.0, 114.4, 107.9), dtype=np.float32)\n\ndef image_scaling(img, label, edge):\n \"\"\"\n Randomly scales the images between 0.5 to 1.5 times the original size.\n Args:\n img: Training image to scale.\n label: Segmentation mask to scale.\n \"\"\"\n \n scale = tf.random_uniform([1], minval=0.5, maxval=2.0, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[0]), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[1]), scale))\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(img, new_shape)\n label = tf.image.resize_nearest_neighbor(tf.expand_dims(label, 0), new_shape)\n label = tf.squeeze(label, squeeze_dims=[0])\n edge = tf.image.resize_nearest_neighbor(tf.expand_dims(edge, 0), new_shape)\n edge = tf.squeeze(edge, squeeze_dims=[0])\n \n return img, label, edge\n\ndef only_image_scaling(img):\n \"\"\"\n Randomly scales the images between 0.5 to 1.5 times the original size.\n Args:\n img: Training image to scale.\n label: Segmentation mask to scale.\n \"\"\"\n \n scale = tf.random_uniform([1], minval=0.5, maxval=2.0, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[0]), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[1]), scale))\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(img, new_shape)\n \n return img\n\ndef image_mirroring(img, label, edge):\n \"\"\"\n Randomly mirrors the images.\n Args:\n img: Training image to mirror.\n label: Segmentation mask to mirror.\n \"\"\"\n \n distort_left_right_random = tf.random_uniform([1], 0, 1.0, dtype=tf.float32)[0]\n mirror = tf.less(tf.stack([1.0, distort_left_right_random, 1.0]), 0.5)\n mirror = tf.boolean_mask([0, 1, 2], mirror)\n img = tf.reverse(img, mirror)\n label = tf.reverse(label, mirror)\n edge = tf.reverse(edge, mirror)\n return img, label, edge\n\ndef only_image_mirroring(img):\n \"\"\"\n Randomly mirrors the images.\n Args:\n img: Training image to mirror.\n label: Segmentation mask to mirror.\n \"\"\"\n \n distort_left_right_random = tf.random_uniform([1], 0, 1.0, dtype=tf.float32)[0]\n mirror = tf.less(tf.stack([1.0, distort_left_right_random, 1.0]), 0.5)\n mirror = tf.boolean_mask([0, 1, 2], mirror)\n img = tf.reverse(img, mirror)\n return img\n\ndef random_resize_only_img_labels(image, resized_h, resized_w):\n\n scale = tf.random_uniform([1], minval=0.75, maxval=1.25, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(resized_h), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(resized_w), scale))\n\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(image, new_shape)\n return img\n\ndef random_resize_img_labels(image, label, resized_h, resized_w):\n\n scale = tf.random_uniform([1], minval=0.75, maxval=1.25, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(resized_h), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(resized_w), scale))\n\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(image, new_shape)\n label = tf.image.resize_nearest_neighbor(tf.expand_dims(label, 0), new_shape)\n label = tf.squeeze(label, squeeze_dims=[0])\n return img, label\n\ndef random_resize_only_img_labels(image, resized_h, resized_w):\n\n scale = tf.random_uniform([1], minval=0.75, maxval=1.25, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(resized_h), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(resized_w), scale))\n\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(image, new_shape)\n return img\n\ndef resize_img_labels(image, label, resized_h, resized_w):\n\n new_shape = tf.stack([tf.to_int32(resized_h), tf.to_int32(resized_w)])\n img = tf.image.resize_images(image, new_shape)\n label = tf.image.resize_nearest_neighbor(tf.expand_dims(label, 0), new_shape)\n label = tf.squeeze(label, squeeze_dims=[0])\n return img, label\n\ndef resize_only_img_labels(image, resized_h, resized_w):\n\n new_shape = tf.stack([tf.to_int32(resized_h), tf.to_int32(resized_w)])\n img = tf.image.resize_images(image, new_shape)\n return img\n\ndef random_crop_and_pad_image_and_labels(image, label, edge, crop_h, crop_w, ignore_label=255):\n \"\"\"\n Randomly crop and pads the input images.\n Args:\n image: Training image to crop/ pad.\n label: Segmentation mask to crop/ pad.\n crop_h: Height of cropped segment.\n crop_w: Width of cropped segment.\n ignore_label: Label to ignore during the training.\n \"\"\"\n\n label = tf.cast(label, dtype=tf.float32)\n label = label - ignore_label # Needs to be subtracted and later added due to 0 padding.\n edge = tf.cast(edge, dtype=tf.float32)\n edge = edge - 0\n\n combined = tf.concat([image, label, edge], 2) \n image_shape = tf.shape(image)\n combined_pad = tf.image.pad_to_bounding_box(combined, 0, 0, tf.maximum(crop_h, image_shape[0]), tf.maximum(crop_w, image_shape[1]))\n \n last_image_dim = tf.shape(image)[-1]\n last_label_dim = tf.shape(label)[-1]\n combined_crop = tf.random_crop(combined_pad, [crop_h,crop_w,4+1])\n img_crop = combined_crop[:, :, :last_image_dim]\n label_crop = combined_crop[:, :, last_image_dim:last_image_dim+last_label_dim]\n edge_crop = combined_crop[:, :, last_image_dim+last_label_dim:]\n label_crop = label_crop + ignore_label\n label_crop = tf.cast(label_crop, dtype=tf.uint8)\n edge_crop = edge_crop + 0\n edge_crop = tf.cast(edge_crop, dtype=tf.uint8)\n \n # Set static shape so that tensorflow knows shape at compile time. \n img_crop.set_shape((crop_h, crop_w, 3))\n label_crop.set_shape((crop_h,crop_w, 1))\n edge_crop.set_shape((crop_h, crop_w, 1))\n return img_crop, label_crop, edge_crop\n\n\ndef random_crop_and_pad_image(image, crop_h, crop_w, ignore_label=255):\n \"\"\"\n Randomly crop and pads the input images.\n Args:\n image: Training image to crop/ pad.\n label: Segmentation mask to crop/ pad.\n crop_h: Height of cropped segment.\n crop_w: Width of cropped segment.\n ignore_label: Label to ignore during the training.\n \"\"\"\n# combined = tf.concat([image, label, edge], 2) \n image_shape = tf.shape(image)\n# combined_pad = tf.image.pad_to_bounding_box(combined, 0, 0, tf.maximum(crop_h, image_shape[0]), tf.maximum(crop_w, image_shape[1]))\n image_pad = tf.image.pad_to_bounding_box(image, 0, 0, tf.maximum(crop_h, image_shape[0]), tf.maximum(crop_w, image_shape[1]))\n \n last_image_dim = tf.shape(image)[-1]\n\n# combined_crop = tf.random_crop(combined_pad, [crop_h,crop_w,4+1])\n# img_crop = combined_crop[:, :, :last_image_dim]\n img_crop = tf.random_crop(image_pad, [crop_h,crop_w,4+1])\n# label_crop = combined_crop[:, :, last_image_dim:last_image_dim+last_label_dim]\n# edge_crop = combined_crop[:, :, last_image_dim+last_label_dim:]\n# label_crop = label_crop + ignore_label\n# label_crop = tf.cast(label_crop, dtype=tf.uint8)\n# edge_crop = edge_crop + 0\n# edge_crop = tf.cast(edge_crop, dtype=tf.uint8)\n \n # Set static shape so that tensorflow knows shape at compile time. \n img_crop.set_shape((crop_h, crop_w, 3))\n# label_crop.set_shape((crop_h,crop_w, 1))\n# edge_crop.set_shape((crop_h, crop_w, 1))\n return img_crop\n\ndef read_labeled_image_reverse_list(data_dir, data_list):\n \"\"\"Reads txt file containing paths to images and ground truth masks.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n \n Returns:\n Two lists with all file names for images and masks, respectively.\n \"\"\"\n f = open(data_list, 'r')\n images = []\n masks = []\n masks_rev = []\n for line in f:\n try:\n image, mask, mask_rev = line.strip(\"\\n\").split(' ')\n except ValueError: # Adhoc for test.\n image = mask = mask_rev = line.strip(\"\\n\")\n images.append(data_dir + image)\n masks.append(data_dir + mask)\n masks_rev.append(data_dir + mask_rev)\n return images, masks, masks_rev\n\n\ndef read_labeled_image_list(data_dir, data_list):\n \"\"\"Reads txt file containing paths to images and ground truth masks.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n \n Returns:\n Two lists with all file names for images and masks, respectively.\n \"\"\"\n f = open(data_list, 'r')\n images = []\n masks = []\n for line in f:\n try:\n image, mask = line.strip(\"\\n\").split(' ')\n except ValueError: # Adhoc for test.\n image = mask = line.strip(\"\\n\")\n images.append(data_dir + image)\n masks.append(data_dir + mask)\n return images, masks\n\ndef read_edge_list(data_dir, data_id_list):\n f = open(data_id_list, 'r')\n edges = []\n for line in f:\n edge = line.strip(\"\\n\")\n edges.append(data_dir + '/edges/' + edge + '.png')\n return edges\n\ndef read_images_from_disk(input_queue, input_size, random_scale, random_mirror=False): # optional pre-processing arguments\n \"\"\"Read one image and its corresponding mask with optional pre-processing.\n \n Args:\n input_queue: tf queue with paths to the image and its mask.\n input_size: a tuple with (height, width) values.\n If not given, return images of original size.\n random_scale: whether to randomly scale the images prior\n to random crop.\n random_mirror: whether to randomly mirror the images prior\n to random crop.\n \n Returns:\n Two tensors: the decoded image and its mask.\n \"\"\"\n\n img_contents = tf.read_file(input_queue[0])\n label_contents = tf.read_file(input_queue[1])\n edge_contents = tf.read_file(input_queue[2])\n\n \n img = tf.image.decode_jpeg(img_contents, channels=3)\n img_r, img_g, img_b = tf.split(value=img, num_or_size_splits=3, axis=2)\n img = tf.cast(tf.concat([img_b, img_g, img_r], 2), dtype=tf.float32)\n # Extract mean.\n img -= IMG_MEAN\n label = tf.image.decode_png(label_contents, channels=1)\n edge = tf.image.decode_png(edge_contents, channels=1)\n\n if input_size is not None:\n h, w = input_size\n\n # Randomly scale the images and labels.\n if random_scale:\n img, label, edge = image_scaling(img, label, edge)\n\n # Randomly mirror the images and labels.\n if random_mirror:\n img, label, edge = image_mirroring(img, label, edge)\n\n # Randomly crops the images and labels.\n img, label, edge = random_crop_and_pad_image_and_labels(img, label, edge, h, w, IGNORE_LABEL)\n\n\n return img, label, edge\n\ndef read_only_images_from_disk(input_queue, input_size, random_scale, random_mirror=False): # optional pre-processing arguments\n \"\"\"Read one image and its corresponding mask with optional pre-processing.\n \n Args:\n input_queue: tf queue with paths to the image and its mask.\n input_size: a tuple with (height, width) values.\n If not given, return images of original size.\n random_scale: whether to randomly scale the images prior\n to random crop.\n random_mirror: whether to randomly mirror the images prior\n to random crop.\n \n Returns:\n Two tensors: the decoded image and its mask.\n \"\"\"\n\n img_contents = tf.read_file(input_queue[0])\n\n \n img = tf.image.decode_jpeg(img_contents, channels=3)\n img_r, img_g, img_b = tf.split(value=img, num_or_size_splits=3, axis=2)\n img = tf.cast(tf.concat([img_b, img_g, img_r], 2), dtype=tf.float32)\n # Extract mean.\n img -= IMG_MEAN\n\n if input_size is not None:\n h, w = input_size\n\n # Randomly scale the images and labels.\n if random_scale:\n img = only_image_scaling(img)\n\n # Randomly mirror the images and labels.\n if random_mirror:\n img = only_image_mirroring(img)\n\n # Randomly crops the images and labels.\n img = random_crop_and_pad_image(img, h, w, IGNORE_LABEL)\n\n return img\n\n\nclass ImageReader(object):\n '''Generic ImageReader which reads images and corresponding segmentation\n masks from the disk, and enqueues them into a TensorFlow queue.\n '''\n\n def __init__(self, data_dir, data_list, data_id_list, input_size, random_scale,\n random_mirror, shuffle, coord):\n '''Initialise an ImageReader.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n data_id_list: path to the file of image id.\n input_size: a tuple with (height, width) values, to which all the images will be resized.\n random_scale: whether to randomly scale the images prior to random crop.\n random_mirror: whether to randomly mirror the images prior to random crop.\n coord: TensorFlow queue coordinator.\n '''\n self.data_dir = data_dir\n self.data_list = data_list\n self.data_id_list = data_id_list\n self.input_size = input_size\n self.coord = coord\n\n\n self.image_list, self.label_list = read_labeled_image_list(self.data_dir, self.data_list)\n self.edge_list = read_edge_list(self.data_dir, self.data_id_list)\n self.images = tf.convert_to_tensor(self.image_list, dtype=tf.string)\n self.labels = tf.convert_to_tensor(self.label_list, dtype=tf.string)\n self.edges = tf.convert_to_tensor(self.edge_list, dtype=tf.string)\n self.queue = tf.train.slice_input_producer([self.images, self.labels, self.edges], shuffle=shuffle) \n self.image, self.label, self.edge = read_images_from_disk(self.queue, self.input_size, random_scale, random_mirror) \n\n def dequeue(self, num_elements):\n '''Pack images and labels into a batch.\n \n Args:\n num_elements: the batch size.\n \n Returns:\n Two tensors of size (batch_size, h, w, {3, 1}) for images and masks.'''\n batch_list = [self.image, self.label, self.edge]\n image_batch, label_batch, edge_batch = tf.train.batch([self.image, self.label, self.edge], num_elements)\n return image_batch, label_batch, edge_batch\n\n\nclass ImageReaderInference(object):\n '''Generic ImageReader which reads images and corresponding segmentation\n masks from the disk, and enqueues them into a TensorFlow queue.\n '''\n\n def __init__(self, data_dir, data_list, data_id_list, input_size, random_scale,\n random_mirror, shuffle, coord):\n '''Initialise an ImageReader.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n data_id_list: path to the file of image id.\n input_size: a tuple with (height, width) values, to which all the images will be resized.\n random_scale: whether to randomly scale the images prior to random crop.\n random_mirror: whether to randomly mirror the images prior to random crop.\n coord: TensorFlow queue coordinator.\n '''\n self.data_dir = data_dir\n self.data_list = data_list\n self.data_id_list = data_id_list\n self.input_size = input_size\n self.coord = coord\n\n\n self.image_list, self.label_list = read_labeled_image_list(self.data_dir, self.data_list)\n self.edge_list = read_edge_list(self.data_dir, self.data_id_list)\n self.images = tf.convert_to_tensor(self.image_list, dtype=tf.string)\n# self.labels = tf.convert_to_tensor(self.label_list, dtype=tf.string)\n# self.edges = tf.convert_to_tensor(self.edge_list, dtype=tf.string)\n# self.queue = tf.train.slice_input_producer([self.images, self.labels, self.edges], shuffle=shuffle) \n self.queue = tf.train.slice_input_producer([self.images], shuffle=shuffle) \n self.image = read_only_images_from_disk(self.queue, self.input_size, random_scale, random_mirror) \n\n def dequeue(self, num_elements):\n '''Pack images and labels into a batch.\n \n Args:\n num_elements: the batch size.\n \n Returns:\n Two tensors of size (batch_size, h, w, {3, 1}) for images and masks.'''\n batch_list = [self.image]\n image_batch = tf.train.batch([self.image], num_elements)\n return image_batch\n" ]	[ [ "tensorflow.convert_to_tensor", "tensorflow.concat", "tensorflow.stack", "tensorflow.image.decode_png", "tensorflow.cast", "tensorflow.train.batch", "tensorflow.to_int32", "tensorflow.boolean_mask", "tensorflow.read_file", "tensorflow.squeeze", "tensorflow.to_float", "tensorflow.image.decode_jpeg", "tensorflow.reverse", "tensorflow.shape", "tensorflow.image.resize_images", "tensorflow.split", "numpy.array", "tensorflow.maximum", "tensorflow.expand_dims", "tensorflow.random_crop", "tensorflow.train.slice_input_producer", "tensorflow.random_uniform" ] ]
blueenvelope31/pandas	[ "6e1f41b45a0d08f662b794ed98695b8595f39023" ]	[ "pandas/tests/arrays/categorical/test_subclass.py" ]	[ "# -- coding: utf-8 --\n\nimport pandas.util.testing as tm\nfrom pandas import Categorical\n\n\nclass TestCategoricalSubclassing(object):\n\n def test_constructor(self):\n sc = tm.SubclassedCategorical(['a', 'b', 'c'])\n assert isinstance(sc, tm.SubclassedCategorical)\n tm.assert_categorical_equal(sc, Categorical(['a', 'b', 'c']))\n\n def test_from_codes(self):\n sc = tm.SubclassedCategorical.from_codes([1, 0, 2], ['a', 'b', 'c'])\n assert isinstance(sc, tm.SubclassedCategorical)\n exp = Categorical.from_codes([1, 0, 2], ['a', 'b', 'c'])\n tm.assert_categorical_equal(sc, exp)\n\n def test_map(self):\n sc = tm.SubclassedCategorical(['a', 'b', 'c'])\n res = sc.map(lambda x: x.upper())\n assert isinstance(res, tm.SubclassedCategorical)\n exp = Categorical(['A', 'B', 'C'])\n tm.assert_categorical_equal(res, exp)\n" ]	[ [ "pandas.Categorical.from_codes", "pandas.util.testing.assert_categorical_equal", "pandas.Categorical", "pandas.util.testing.SubclassedCategorical.from_codes", "pandas.util.testing.SubclassedCategorical" ] ]
thunfischtoast/tf_netbuilder	[ "728826ac5e4e58a39ea862cecc86ad249a19e278" ]	[ "tf_netbuilder/activations.py" ]	[ "from typing import Callable\nimport tensorflow as tf\nimport numpy as np\n\n\ndef hard_swish(x: tf.Tensor):\n with tf.name_scope('hard_swish'):\n return x * tf.nn.relu6(x + np.float32(3)) * np.float32(1. / 6.)\n\n\nclass FuncAsLayer:\n \"\"\"\n This wrapper is a common denominator for function activations and layer activations. In tensorflow we have\n the activation PReLU which doesn't have function counterpart\n \"\"\"\n def __init__(self, func: Callable):\n self.func = func\n\n def __call__(self):\n return tf.keras.layers.Activation(self.func)\n\n\nACTIVATION_FUNCS = dict(\n re=tf.keras.layers.ReLU,\n r6=FuncAsLayer(tf.nn.relu6),\n pre=tf.keras.layers.PReLU,\n hs=FuncAsLayer(hard_swish),\n sw=FuncAsLayer(tf.nn.swish)\n)\n" ]	[ [ "tensorflow.keras.layers.Activation", "tensorflow.name_scope", "numpy.float32" ] ]
ChristopherBrix/Debona	[ "f000f3d483b2cc592233d0ba2a1a0327210562c8" ]	[ "src/vnnlib.py" ]	[ "'''\nvnnlib simple utilities\n\nStanley Bak\nJune 2021\n'''\n\nfrom copy import deepcopy\n\nimport numpy as np\nimport re\n\n\ndef read_statements(vnnlib_filename):\n '''process vnnlib and return a list of strings (statements)\n\n useful to get rid of comments and blank lines and combine multi-line statements\n '''\n\n with open(vnnlib_filename, 'r') as f:\n lines = f.readlines()\n\n lines = [line.strip() for line in lines]\n assert len(lines) > 0\n\n # combine lines if case a single command spans multiple lines\n open_parentheses = 0\n statements = []\n current_statement = ''\n\n for line in lines:\n comment_index = line.find(';')\n\n if comment_index != -1:\n line = line[:comment_index].rstrip()\n\n if not line:\n continue\n\n new_open = line.count('(')\n new_close = line.count(')')\n\n open_parentheses += new_open - new_close\n\n assert open_parentheses >= 0, \"mismatched parenthesis in vnnlib file\"\n\n # add space\n current_statement += ' ' if current_statement else ''\n current_statement += line\n\n if open_parentheses == 0:\n statements.append(current_statement)\n current_statement = ''\n\n if current_statement:\n statements.append(current_statement)\n\n # remove repeated whitespace characters\n statements = [\" \".join(s.split()) for s in statements]\n\n # remove space after '('\n statements = [s.replace('( ', '(') for s in statements]\n\n # remove space after ')'\n statements = [s.replace(') ', ')') for s in statements]\n\n return statements\n\n\ndef update_rv_tuple(rv_tuple, op, first, second, num_inputs, num_outputs):\n 'update tuple from rv in read_vnnlib_simple, with the passed in constraint \"(op first second)\"'\n\n if first.startswith(\"X_\"):\n # Input constraints\n index = int(first[2:])\n\n assert not second.startswith(\"X\") and not second.startswith(\"Y\"), \\\n f\"input constraints must be box ({op} {first} {second})\"\n assert 0 <= index < num_inputs\n\n limits = rv_tuple[0][index]\n\n if op == \"<=\":\n limits[1] = min(float(second), limits[1])\n else:\n limits[0] = max(float(second), limits[0])\n\n assert limits[0] <= limits[1], f\"{first} range is empty: {limits}\"\n\n else:\n # output constraint\n if op == \">=\":\n # swap order if op is >=\n first, second = second, first\n\n row = [0.0] * num_outputs\n rhs = 0.0\n\n # assume op is <=\n if first.startswith(\"Y_\") and second.startswith(\"Y_\"):\n index1 = int(first[2:])\n index2 = int(second[2:])\n\n row[index1] = 1\n row[index2] = -1\n elif first.startswith(\"Y_\"):\n index1 = int(first[2:])\n row[index1] = 1\n rhs = float(second)\n else:\n assert second.startswith(\"Y_\")\n index2 = int(second[2:])\n row[index2] = -1\n rhs = -1 * float(first)\n\n mat, rhs_list = rv_tuple[1], rv_tuple[2]\n mat.append(row)\n rhs_list.append(rhs)\n\n\ndef make_input_box_dict(num_inputs):\n 'make a dict for the input box'\n rv = {i: [-np.inf, np.inf] for i in range(num_inputs)}\n\n return rv\n\n\ndef read_vnnlib_simple(vnnlib_filename, num_inputs, num_outputs):\n '''process in a vnnlib file\n\n this is not a general parser, and assumes files are provided in a 'nice' format. Only a single disjunction\n is allowed\n\n output a list containing 2-tuples:\n 1. input ranges (box), list of pairs for each input variable\n 2. specification, provided as a list of pairs (mat, rhs), as in: mat * y <= rhs, where y is the output. \n Each element in the list is a term in a disjunction for the specification.\n '''\n\n # example: \"(declare-const X_0 Real)\"\n regex_declare = re.compile(r\"^\\(declare-const (X\|Y)_(\\S+) Real\\)$\")\n regex_declare_input = re.compile(r\"^\\(declare-const X_(\\S+) Real\\)$\")\n regex_declare_output = re.compile(r\"^\\(declare-const Y_(\\S+) Real\\)$\")\n\n # comparison sub-expression\n # example: \"(<= Y_0 Y_1)\" or \"(<= Y_0 10.5)\"\n comparison_str = r\"\\((<=\|>=) (\\S+) (\\S+)\\)\"\n\n # example: \"(and (<= Y_0 Y_2)(<= Y_1 Y_2))\"\n dnf_clause_str = r\"\\(and (\" + comparison_str + r\")+\\)\"\n\n # example: \"(assert (<= Y_0 Y_1))\"\n regex_simple_assert = re.compile(r\"^\\(assert \" + comparison_str + r\"\\)$\")\n\n # disjunctive-normal-form\n # (assert (or (and (<= Y_3 Y_0)(<= Y_3 Y_1)(<= Y_3 Y_2))(and (<= Y_4 Y_0)(<= Y_4 Y_1)(<= Y_4 Y_2))))\n regex_dnf = re.compile(r\"^\\(assert \\(or (\" + dnf_clause_str + r\")+\\)\\)$\")\n\n rv = [] # list of 3-tuples, (box-dict, mat, rhs)\n rv.append((make_input_box_dict(num_inputs), [], []))\n\n lines = read_statements(vnnlib_filename)\n\n assert num_inputs == sum(len(regex_declare_input.findall(line)) for line in lines)\n assert num_outputs == sum(len(regex_declare_output.findall(line)) for line in lines)\n\n for line in lines:\n #print(f\"Line: {line}\")\n\n if len(regex_declare.findall(line)) > 0:\n continue\n\n groups = regex_simple_assert.findall(line)\n\n if groups:\n assert len(groups[0]) == 3, f\"groups was {groups}: {line}\"\n op, first, second = groups[0]\n\n for rv_tuple in rv:\n update_rv_tuple(rv_tuple, op, first, second, num_inputs, num_outputs)\n\n continue\n\n ################\n groups = regex_dnf.findall(line)\n assert groups, f\"failed parsing line: {line}\"\n\n tokens = line.replace(\"(\", \" \").replace(\")\", \" \").split()\n tokens = tokens[2:] # skip 'assert' and 'or'\n\n conjuncts = \" \".join(tokens).split(\"and\")[1:]\n\n old_rv = rv\n rv = []\n\n for rv_tuple in old_rv:\n for c in conjuncts:\n rv_tuple_copy = deepcopy(rv_tuple)\n rv.append(rv_tuple_copy)\n\n c_tokens = [s for s in c.split(\" \") if len(s) > 0]\n\n count = len(c_tokens) // 3\n\n for i in range(count):\n op, first, second = c_tokens[3 * i:3 * (i + 1)]\n\n update_rv_tuple(rv_tuple_copy, op, first, second, num_inputs, num_outputs)\n\n # merge elements of rv with the same input spec\n merged_rv = {}\n\n for rv_tuple in rv:\n boxdict = rv_tuple[0]\n matrhs = (rv_tuple[1], rv_tuple[2])\n\n key = str(boxdict) # merge based on string representation of input box... accurate enough for now\n\n if key in merged_rv:\n merged_rv[key][1].append(matrhs)\n else:\n merged_rv[key] = (boxdict, [matrhs])\n\n # finalize objects (convert dicts to lists and lists to np.array)\n final_rv = []\n\n for rv_tuple in merged_rv.values():\n box_dict = rv_tuple[0]\n\n box = []\n\n for d in range(num_inputs):\n r = box_dict[d]\n\n assert r[0] != -np.inf and r[1] != np.inf, f\"input X_{d} was unbounded: {r}\"\n box.append(r)\n\n spec_list = []\n\n for matrhs in rv_tuple[1]:\n mat = np.array(matrhs[0], dtype=float)\n rhs = np.array(matrhs[1], dtype=float)\n spec_list.append((mat, rhs))\n\n final_rv.append((box, spec_list))\n\n #for i, (box, spec_list) in enumerate(final_rv):\n # print(f\"-----\\n{i+1}. {box}\\nspec:{spec_list}\")\n\n return final_rv\n" ]	[ [ "numpy.array" ] ]
dewloosh/dewloosh-geom	[ "5c97fbab4b68f4748bf4309184b9e0e877f94cd6" ]	[ "src/dewloosh/geom/tri/triplot.py" ]	[ "# -- coding: utf-8 --\nfrom typing import Callable, Iterable\nimport numpy as np\nfrom functools import partial\n\nfrom dewloosh.core.tools import issequence\n\nfrom .triang import triobj_to_mpl, get_triobj_data, triangulate\nfrom .triutils import offset_tri\nfrom ..utils import cells_coords, explode_mesh_data_bulk\n\nfrom ..config import __hasmatplotlib__\nif __hasmatplotlib__:\n import matplotlib.pyplot as plt\n from matplotlib.patches import Polygon\n from mpl_toolkits.axes_grid1 import make_axes_locatable\n from matplotlib.collections import PatchCollection\n\n\n__all__ = ['triplot']\n\n\ndef triplot(triobj, args, hinton=False, data=None, title=None,\n label=None, fig=None, ax=None, axes=None, kwargs):\n fig, axes = get_fig_axes(args, data=data, ax=ax, axes=axes,\n fig=fig, *kwargs)\n if isinstance(triobj, tuple):\n coords, topo = triobj\n triobj = triangulate(points=coords[:, :2], triangles=topo)[-1]\n coords, topo = None, None\n pdata = partial(triplot_data, triobj)\n pgeom = partial(triplot_geom, triobj)\n phint = partial(triplot_hinton, triobj)\n if data is not None:\n assert len(data.shape) <= 2, \\\n \"Data must be a 1 or 2 dimensional array.\"\n nD = 1 if len(data.shape) == 1 else data.shape[1]\n data = data.reshape((data.shape[0], nD))\n if not issequence(title):\n title = nD (title, )\n if not issequence(label):\n label = nD * (label, )\n pfnc = phint if hinton else pdata\n axobj = [pfnc(ax, data[:, i], args, fig=fig, title=title[i],\n label=label[i], kwargs)\n for i, ax in enumerate(axes)]\n if nD == 1:\n data = data.reshape(data.shape[0])\n else:\n axobj = pgeom(axes[0], args, fig=fig, title=title, *kwargs)\n return axobj\n\n\nclass TriPatchCollection(PatchCollection):\n\n def __init__(self, cellcoords, args, *kwargs):\n pmap = map(lambda i: cellcoords[i], np.arange(len(cellcoords)))\n def fnc(points): return Polygon(points, closed=True)\n patches = list(map(fnc, pmap))\n super().__init__(patches, args, *kwargs)\n\n\ndef triplot_hinton(triobj, ax, data, args, lw=0.5, fcolor='b',\n ecolor='k', title=None, suptitle=None, label=None,\n *kwargs):\n axobj = None\n tri = triobj_to_mpl(triobj)\n points, triangles = get_triobj_data(tri, args, trim2d=True, kwargs)\n cellcoords = offset_tri(points, triangles, data)\n axobj = TriPatchCollection(cellcoords, fc=fcolor, ec=ecolor, lw=lw)\n ax.add_collection(axobj)\n _decorate_(ax=ax, points=points, title=title, suptitle=suptitle,\n label=label, kwargs)\n return axobj\n\n\ndef triplot_geom(triobj, ax, args, lw=0.5, marker='b-',\n zorder=None, fcolor=None, ecolor='k',\n fig=None, title=None, suptitle=None, label=None,\n kwargs):\n axobj = None\n tri = triobj_to_mpl(triobj)\n points, triangles = get_triobj_data(tri, args, trim2d=True, kwargs)\n\n if fcolor is None:\n if zorder is not None:\n axobj = ax.triplot(tri, marker, lw=lw, zorder=zorder, kwargs)\n else:\n axobj = ax.triplot(tri, marker, lw=lw, kwargs)\n else:\n cellcoords = cells_coords(points, triangles)\n axobj = TriPatchCollection(cellcoords, fc=fcolor, ec=ecolor, lw=lw)\n ax.add_collection(axobj)\n _decorate_(fig=fig, ax=ax, points=points, title=title,\n suptitle=suptitle, label=label, kwargs)\n return axobj\n\n\ndef triplot_data(triobj, ax, data, args, cmap='winter', fig=None,\n ecolor='k', lw=0.1, title=None, suptitle=None,\n label=None, kwargs):\n\n axobj = None\n tri = triobj_to_mpl(triobj)\n points, triangles = get_triobj_data(tri, args, trim2d=True, kwargs)\n\n nData = len(data)\n if nData == len(triangles):\n nD = len(data.shape)\n if nD == 1:\n axobj = ax.tripcolor(tri, facecolors=data, cmap=cmap,\n edgecolors=ecolor, lw=lw)\n elif nD == 2 and data.shape[1] == 3:\n nT, nN = data.shape\n points, triangles, data = \\\n explode_mesh_data_bulk(points, triangles, data)\n triobj = triangulate(points=points, triangles=triangles)[-1]\n tri = triobj_to_mpl(triobj)\n axobj = ax.tripcolor(tri, data, cmap=cmap,\n edgecolors=ecolor, lw=lw)\n elif nData == len(points):\n axobj = ax.tripcolor(tri, data, cmap=cmap,\n edgecolors=ecolor, lw=lw)\n\n assert axobj is not None, \"Failed to handle the provided data.\"\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(axobj, cax=cax)\n\n _decorate_(fig=fig, ax=ax, points=points, title=title,\n suptitle=suptitle, label=label, kwargs)\n return axobj\n\n\ndef get_fig_axes(args, data=None, fig=None, axes=None, shape=None,\n horizontal=False, ax=None, kwargs):\n if fig is not None:\n if axes is not None:\n return fig, axes\n elif ax is not None:\n return fig, (ax,)\n else:\n if data is not None:\n nD = 1 if len(data.shape) == 1 else data.shape[1]\n if nD == 1:\n try:\n aspect = kwargs.get('aspect', 'equal')\n args[0].set_aspect(aspect)\n ax = args[0]\n except Exception:\n fig, ax = plt.subplots()\n return fig, (ax,)\n if fig is None or axes is None:\n if shape is not None:\n if isinstance(shape, int):\n shape = (shape, 1) if horizontal else (1, shape)\n assert nD == (shape[0] shape[1]), \\\n \"Mismatch in shape and data.\"\n else:\n shape = (nD, 1) if horizontal else (1, nD)\n fig, axes = plt.subplots(shape)\n if not isinstance(axes, Iterable):\n axes = (axes,)\n return fig, axes\n else:\n try:\n aspect = kwargs.get('aspect', 'equal')\n args[0].set_aspect(aspect)\n ax = args[0]\n except Exception:\n fig, ax = plt.subplots()\n return fig, (ax,)\n return None, None\n\n\ndef _decorate_(args, fig=None, ax=None, aspect='equal', xlim=None,\n ylim=None, axis='on', offset=0.05, points=None,\n axfnc: Callable = None, title=None, suptitle=None,\n label=None, *kwargs):\n assert ax is not None, \"A matplotlib Axes object must be provided as \" \\\n \"keyword argument 'ax'!\"\n if axfnc is not None:\n try:\n axfnc(ax)\n except Exception:\n raise RuntimeError('Something went wrong when calling axfnc.')\n if xlim is None:\n if points is not None:\n xlim = points[:, 0].min(), points[:, 0].max()\n if offset is not None:\n dx = np.abs(xlim[1] - xlim[0])\n xlim = xlim[0] - offsetdx, xlim[1] + offsetdx\n if ylim is None:\n if points is not None:\n ylim = points[:, 1].min(), points[:, 1].max()\n if offset is not None:\n dx = np.abs(ylim[1] - ylim[0])\n ylim = ylim[0] - offsetdx, ylim[1] + offsetdx\n ax.set_aspect(aspect)\n ax.axis(axis)\n if xlim is not None:\n ax.set_xlim(xlim)\n if ylim is not None:\n ax.set_ylim(*ylim)\n if title is not None:\n ax.set_title(title)\n if label is not None:\n ax.set_xlabel(label)\n if fig is not None and suptitle is not None:\n fig.suptitle(suptitle)\n return ax\n\n\nif __name__ == '__main__':\n pass\n" ]	[ [ "numpy.abs", "matplotlib.patches.Polygon", "matplotlib.pyplot.subplots" ] ]
dlinde/disaster_response_pipeline	[ "e1f5f8e3f666830d29351396bb343001d5fe330d" ]	[ "models/title_transformer.py" ]	[ "from sklearn.base import BaseEstimator, TransformerMixin\nimport pandas as pd\n\nclass TitleCount(BaseEstimator, TransformerMixin):\n\n\n def fit(self, x, y=None):\n return self\n\n def transform(self, X):\n X_tagged = pd.Series(X).apply(lambda x: len([\n wrd for wrd in x.split() if wrd.istitle()]))\n X_tagged = X_tagged.map(lambda x: 5 if x>5 else x)\n return pd.DataFrame(X_tagged)\n" ]	[ [ "pandas.Series", "pandas.DataFrame" ] ]
JIC-Image-Analysis/point-picker	[ "b2d94520c2b6ee0a323c4a7021f03709ac9db82a" ]	[ "scripts/point_picker.py" ]	[ "import sys\nimport logging\n\nfrom vispy import scene\nfrom vispy.scene.visuals import Text\nfrom vispy import app\nimport numpy as np\n\nimport pandas as pd\n\nfrom imageio import imread\n\nimport click\n\nfrom skimage.draw import circle\n\ncanvas = scene.SceneCanvas(keys='interactive')\ncanvas.size = 800, 600\ncanvas.show()\n\n# Set up a viewbox to display the image with interactive pan/zoom\nview = canvas.central_widget.add_view()\n\n\[email protected]()\[email protected]('image_fpath')\[email protected]('input_points_fpath')\[email protected]('output_points_fpath', required=False)\ndef main(image_fpath, input_points_fpath, output_points_fpath):\n global canvas\n\n logging.basicConfig(level=logging.INFO)\n\n im = imread(image_fpath)\n logging.info(f\"Loaded image with shape {im.shape}\")\n image = scene.visuals.Image(im, parent=view.scene)\n\n app.current_pos = None\n\n if output_points_fpath:\n df = pd.read_csv(input_points_fpath)\n points = [(p.X, p.Y) for p in df.itertuples()]\n output_fpath = output_points_fpath\n else:\n points = []\n output_fpath = input_points_fpath\n \n\n @canvas.events.mouse_press.connect\n def on_mouse_press(event):\n # print(\"Press pos:\", event.pos)\n # get transform mapping from canvas to image\n tr = view.node_transform(image)\n # print(\"Image pos:\", tr.map(event.pos)[:2])\n x, y = tr.map(event.pos)[:2]\n\n print(\"Click at \", x, y)\n\n # c, r = int(x), int(y)\n\n # points.append(np.array((r, c)))\n\n # rr, cc = circle(r, c, 5)\n # im[rr, cc] = 255, 0, 0\n # image.set_data(im)\n # canvas.update()\n\n @canvas.connect\n def on_mouse_move(event):\n app.current_pos = event.pos\n\n def update_drawing():\n draw_im = im.copy()\n for r, c in points:\n rr, cc = circle(r, c, 3)\n try:\n draw_im[rr, cc] = 255 #, 0, 0\n except IndexError:\n print(f\"Point at {r}, {c} out of bounds\")\n raise\n \n image.set_data(draw_im)\n canvas.update()\n\n @canvas.events.key_press.connect\n def key_event(event):\n\n if event.key.name == 'Escape':\n app.quit()\n\n if event.key.name == 'P':\n print(\"Added point\")\n tr = view.node_transform(image)\n x, y = tr.map(app.current_pos)[:2]\n c, r = int(x), int(y)\n points.append(np.array((r, c)))\n update_drawing()\n\n if event.key.name == 'D':\n tr = view.node_transform(image)\n x, y = tr.map(app.current_pos)[:2]\n c, r = int(x), int(y)\n deltas = np.array(points) - np.array((r, c))\n sq_dists = np.sum(deltas * deltas, axis=1)\n del points[np.argmin(sq_dists)]\n update_drawing()\n\n if event.key.name == 'S':\n df = pd.DataFrame(points, columns=['X', 'Y'])\n df.to_csv(output_fpath, index=False)\n\n # t1 = scene.visuals.Text('Text in root scene (24 pt)', parent=image, color='red', pos=(100,100))\n # t1.font_size = 24\n # Set 2D camera (the camera will scale to the contents in the scene)\n view.camera = scene.PanZoomCamera(aspect=1)\n view.camera.set_range()\n view.camera.flip = (False, True, False)\n\n update_drawing()\n\n app.run()\n\n\nif __name__ == '__main__':\n main()\n" ]	[ [ "pandas.read_csv", "pandas.DataFrame", "numpy.argmin", "numpy.array", "numpy.sum" ] ]
TeaPoly/Conformer-Athena	[ "9919de269ca3074c20f55d72ca8fc975aca8cf7d" ]	[ "athena/layers/commons.py" ]	[ "# coding=utf-8\n# Copyright (C) 2019 ATHENA AUTHORS; Xiangang Li\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n# pylint: disable=too-few-public-methods, invalid-name\n# pylint: disable=no-self-use, missing-function-docstring\n\"\"\"Utils for common layers.\"\"\"\n\nimport tensorflow as tf\nfrom athena.layers.functional import make_positional_encoding, collapse4d, gelu, glu\nfrom athena.layers.functional import splice\nfrom athena.utils.misc import gated_linear_layer\n\n\nclass PositionalEncoding(tf.keras.layers.Layer):\n \"\"\"positional encoding can be used in transformer\"\"\"\n\n def __init__(self, d_model, max_position=800, scale=False):\n super().__init__()\n self.d_model = d_model\n self.scale = scale\n self.pos_encoding = make_positional_encoding(max_position, d_model)\n\n def call(self, x):\n \"\"\" call function \"\"\"\n seq_len = tf.shape(x)[1]\n if self.scale:\n x = tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n x += self.pos_encoding[:, :seq_len, :]\n return x\n\n\nclass RelPositionalEncoding(PositionalEncoding):\n \"\"\"Relative positional encoding can be used in conformer\"\"\"\n\n def __init__(self, d_model, max_position=800):\n super().__init__(d_model, max_position)\n\n def call(self, x):\n \"\"\" call function \"\"\"\n seq_len = tf.shape(x)[1]\n return self.pos_encoding[:, :seq_len, :]\n\n\nclass ScaledPositionalEncoding(PositionalEncoding):\n \"\"\"scaled positional encoding,\n reference: https://arxiv.org/pdf/1809.08895.pdf\"\"\"\n def __init__(self, d_model, max_position=800):\n super().__init__(d_model, max_position, scale=False)\n\n def build(self, _):\n self.alpha = self.add_weight(\n name=\"alpha\", initializer=tf.keras.initializers.constant(1)\n )\n\n def call(self, x):\n seq_len = tf.shape(x)[1]\n x += self.alpha self.pos_encoding[:, :seq_len, :]\n return x\n\n\nclass Collapse4D(tf.keras.layers.Layer):\n \"\"\"collapse4d can be used in cnn-lstm for speech processing\n reshape from [N T D C] -> [N T DC]\n \"\"\"\n\n def call(self, x):\n return collapse4d(x)\n\n\nclass Gelu(tf.keras.layers.Layer):\n \"\"\"Gaussian Error Linear Unit.\n\n This is a smoother version of the RELU. Original paper: https://arxiv.org/abs/1606.08415\n\n Args:\n x: float Tensor to perform activation.\n Returns:\n x: with the GELU activation applied.\n \"\"\"\n\n def call(self, x):\n return gelu(x)\n\n\nclass TdnnLayer(tf.keras.layers.Layer):\n \"\"\"An implementation of Tdnn Layer\n Args:\n context: a int of left and right context, or a list of context indexes, e.g. (-2, 0, 2).\n output_dim: the dim of the linear transform\n \"\"\"\n\n def __init__(self, context, output_dim, use_bias=False, kwargs):\n super().__init__(kwargs)\n\n if hasattr(context, \"__iter__\"):\n self.context_size = len(context)\n self.context_list = context\n else:\n self.context_size = context 2 + 1\n self.context_list = range(-context, context + 1)\n\n self.output_dim = output_dim\n self.linear = tf.keras.layers.Dense(output_dim, use_bias=use_bias)\n\n def call(self, x, training=None, mask=None):\n x = splice(x, self.context_list)\n x = self.linear(x, training=training, mask=mask)\n return x\n\nclass GroupNormalization(tf.keras.layers.Layer):\n def __init__(\n self,\n groups: int = 2,\n axis: int = -1,\n epsilon: float = 1e-3,\n center: bool = True,\n scale: bool = True,\n beta_initializer = \"zeros\",\n gamma_initializer = \"ones\",\n beta_regularizer = None,\n gamma_regularizer = None,\n beta_constraint = None,\n gamma_constraint = None,\n kwargs\n ):\n super().__init__(kwargs)\n self.supports_masking = True\n self.groups = groups\n self.axis = axis\n self.epsilon = epsilon\n self.center = center\n self.scale = scale\n self.beta_initializer = tf.keras.initializers.get(beta_initializer)\n self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)\n self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)\n self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)\n self.beta_constraint = tf.keras.constraints.get(beta_constraint)\n self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)\n self._check_axis()\n\n def build(self, input_shape):\n\n self._check_if_input_shape_is_none(input_shape)\n self._set_number_of_groups_for_instance_norm(input_shape)\n self._check_size_of_dimensions(input_shape)\n self._create_input_spec(input_shape)\n\n self._add_gamma_weight(input_shape)\n self._add_beta_weight(input_shape)\n self.built = True\n super().build(input_shape)\n\n def call(self, inputs):\n\n input_shape = tf.keras.backend.int_shape(inputs)\n tensor_input_shape = tf.shape(inputs)\n\n reshaped_inputs, group_shape = self._reshape_into_groups(\n inputs, input_shape, tensor_input_shape\n )\n\n normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape)\n\n outputs = tf.reshape(normalized_inputs, tensor_input_shape)\n\n return outputs\n\n def get_config(self):\n config = {\n \"groups\": self.groups,\n \"axis\": self.axis,\n \"epsilon\": self.epsilon,\n \"center\": self.center,\n \"scale\": self.scale,\n \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer),\n \"gamma_initializer\": tf.keras.initializers.serialize(\n self.gamma_initializer\n ),\n \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer),\n \"gamma_regularizer\": tf.keras.regularizers.serialize(\n self.gamma_regularizer\n ),\n \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint),\n \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint),\n }\n base_config = super().get_config()\n return {base_config, config}\n\n def compute_output_shape(self, input_shape):\n return input_shape\n\n def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape):\n\n group_shape = [tensor_input_shape[i] for i in range(len(input_shape))]\n group_shape[self.axis] = input_shape[self.axis] // self.groups\n group_shape.insert(self.axis, self.groups)\n group_shape = tf.stack(group_shape)\n reshaped_inputs = tf.reshape(inputs, group_shape)\n return reshaped_inputs, group_shape\n\n def _apply_normalization(self, reshaped_inputs, input_shape):\n\n group_shape = tf.keras.backend.int_shape(reshaped_inputs)\n group_reduction_axes = list(range(1, len(group_shape)))\n axis = -2 if self.axis == -1 else self.axis - 1\n group_reduction_axes.pop(axis)\n\n mean, variance = tf.nn.moments(\n reshaped_inputs, group_reduction_axes, keepdims=True\n )\n\n gamma, beta = self._get_reshaped_weights(input_shape)\n normalized_inputs = tf.nn.batch_normalization(\n reshaped_inputs,\n mean=mean,\n variance=variance,\n scale=gamma,\n offset=beta,\n variance_epsilon=self.epsilon,\n )\n return normalized_inputs\n\n def _get_reshaped_weights(self, input_shape):\n broadcast_shape = self._create_broadcast_shape(input_shape)\n gamma = None\n beta = None\n if self.scale:\n gamma = tf.reshape(self.gamma, broadcast_shape)\n\n if self.center:\n beta = tf.reshape(self.beta, broadcast_shape)\n return gamma, beta\n\n def _check_if_input_shape_is_none(self, input_shape):\n dim = input_shape[self.axis]\n if dim is None:\n raise ValueError(\n \"Axis \" + str(self.axis) + \" of \"\n \"input tensor should have a defined dimension \"\n \"but the layer received an input with shape \" + str(input_shape) + \".\"\n )\n\n def _set_number_of_groups_for_instance_norm(self, input_shape):\n dim = input_shape[self.axis]\n\n if self.groups == -1:\n self.groups = dim\n\n def _check_size_of_dimensions(self, input_shape):\n\n dim = input_shape[self.axis]\n if dim < self.groups:\n raise ValueError(\n \"Number of groups (\" + str(self.groups) + \") cannot be \"\n \"more than the number of channels (\" + str(dim) + \").\"\n )\n\n if dim % self.groups != 0:\n raise ValueError(\n \"Number of groups (\" + str(self.groups) + \") must be a \"\n \"multiple of the number of channels (\" + str(dim) + \").\"\n )\n\n def _check_axis(self):\n\n if self.axis == 0:\n raise ValueError(\n \"You are trying to normalize your batch axis. Do you want to \"\n \"use tf.layer.batch_normalization instead\"\n )\n\n def _create_input_spec(self, input_shape):\n\n dim = input_shape[self.axis]\n self.input_spec = tf.keras.layers.InputSpec(\n ndim=len(input_shape), axes={self.axis: dim}\n )\n\n def _add_gamma_weight(self, input_shape):\n\n dim = input_shape[self.axis]\n shape = (dim,)\n\n if self.scale:\n self.gamma = self.add_weight(\n shape=shape,\n name=\"gamma\",\n initializer=self.gamma_initializer,\n regularizer=self.gamma_regularizer,\n constraint=self.gamma_constraint,\n )\n else:\n self.gamma = None\n\n def _add_beta_weight(self, input_shape):\n\n dim = input_shape[self.axis]\n shape = (dim,)\n\n if self.center:\n self.beta = self.add_weight(\n shape=shape,\n name=\"beta\",\n initializer=self.beta_initializer,\n regularizer=self.beta_regularizer,\n constraint=self.beta_constraint,\n )\n else:\n self.beta = None\n\n def _create_broadcast_shape(self, input_shape):\n broadcast_shape = [1] * len(input_shape)\n broadcast_shape[self.axis] = input_shape[self.axis] // self.groups\n broadcast_shape.insert(self.axis, self.groups)\n return broadcast_shape\n\n\nclass InstanceNormalization(GroupNormalization):\n \"\"\"Instance normalization layer.\n References\n - [Instance Normalization: The Missing Ingredient for Fast Stylization]\n (https://arxiv.org/abs/1607.08022)\n \"\"\"\n\n def __init__(self, kwargs):\n\n kwargs[\"groups\"] = -1\n super().__init__(kwargs)\n\n\nclass DownSampleBlock(tf.keras.layers.Layer):\n \"\"\"conv2d downsample block for stargan, instance norm is used because batch size is 1\n \"\"\"\n def __init__(self, filters, kernel_size, strides):\n super(DownSampleBlock, self).__init__()\n\n self.conv1 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.conv2 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n self.norm2 = InstanceNormalization(epsilon=1e-8)\n\n def call(self, x):\n h1 = self.conv1(x)\n h1_norm = self.norm1(h1)\n h1_gates = self.conv2(x)\n h1_gates_norm = self.norm2(h1_gates)\n h1_glu = gated_linear_layer(inputs=h1_norm, gates=h1_gates_norm)\n return h1_glu\n\n\nclass UpSampleBlock(tf.keras.layers.Layer):\n \"\"\"conv2d upsample block for stargan, instance norm is used because batch size is 1\n \"\"\"\n def __init__(self, filters, kernel_size, strides):\n super(UpSampleBlock, self).__init__()\n self.conv1 = tf.keras.layers.Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.conv2 = tf.keras.layers.Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n self.norm2 = InstanceNormalization(epsilon=1e-8)\n\n def call(self, x):\n h1 = self.conv1(x)\n h1_norm = self.norm1(h1)\n h1_gates = self.conv2(x)\n h1_gates_norm = self.norm2(h1_gates)\n h1_glu = gated_linear_layer(inputs=h1_norm, gates=h1_gates_norm)\n return h1_glu\n\nclass ConditionalInstanceNormalisation(tf.keras.layers.Layer):\n \"\"\"CIN Block.\"\"\"\n def __init__(self, in_channel):\n super(ConditionalInstanceNormalisation, self).__init__()\n\n self.dim_in = in_channel\n self.gamma = tf.keras.layers.Dense(in_channel)\n self.beta = tf.keras.layers.Dense(in_channel)\n\n def call(self, x, c):\n u = tf.math.reduce_mean(x, axis=1, keepdims=True)\n var = tf.math.reduce_mean((x - u) * (x - u), axis=1, keepdims=True)\n std = tf.math.sqrt(var + 1e-8)\n\n gamma = self.gamma(c)\n gamma = tf.reshape(gamma, [-1, 1, self.dim_in])\n beta = self.beta(c)\n beta = tf.reshape(beta, [-1, 1, self.dim_in])\n\n h = (x - u) / std\n h = h * gamma + beta\n\n return h\n\n\nclass ResidualBlock(tf.keras.layers.Layer):\n \"\"\"Residual Block with instance normalization.\"\"\"\n\n def __init__(self, out_channel):\n super(ResidualBlock, self).__init__()\n self.conv_1 = tf.keras.layers.Conv1D(filters=out_channel, kernel_size=3, strides=1, padding=\"same\", use_bias=False)\n self.cin_1 = ConditionalInstanceNormalisation(out_channel)\n\n def call(self, x, c):\n x = self.conv_1(x)\n x = self.cin_1(x, c)\n x = gated_linear_layer(inputs=x, gates=x)\n return x\n\n\nclass Down2d_init(tf.keras.layers.Layer):\n def __init__(self, filters , kernel_size, stride):\n super(Down2d_init, self).__init__()\n self.c1 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=stride, padding=\"same\")\n\n def call(self, x):\n x1 = self.c1(x)\n x1 = gated_linear_layer(inputs=x1, gates=x1)\n return x1\n\nclass Down2d(tf.keras.layers.Layer):\n def __init__(self, filters , kernel_size, stride):\n super(Down2d, self).__init__()\n self.c1 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=stride, padding=\"same\")\n\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n def call(self, x):\n x1 = self.c1(x)\n x1 = self.norm1(x1)\n x1 = gated_linear_layer(inputs=x1, gates=x1)\n return x1\n\n\nclass Up2d(tf.keras.layers.Layer):\n \"\"\"docstring for Up2d.\"\"\"\n\n def __init__(self, filters, kernel_size, stride):\n super(Up2d, self).__init__()\n self.c1 = tf.keras.layers.Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=stride, padding=\"same\")\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n\n def call(self, x):\n x1 = self.c1(x)\n x1 = self.norm1(x1)\n x1 = gated_linear_layer(inputs=x1, gates=x1)\n\n return x1\n\nclass ZoneOutCell(tf.keras.layers.LSTMCell):\n \"\"\"Wrapper for LSTM cell to create ZoneOut Cell\n\n inspired by:\n https://github.com/teganmaharaj/zoneout/blob/master/zoneout_tensorflow.py\n Published by one of 'https://arxiv.org/pdf/1606.01305.pdf' paper writers.\n \"\"\"\n\n def __init__(self, zoneout_rate=0., kwargs):\n super().__init__(kwargs)\n self.zoneout_rate = zoneout_rate\n self.drop_layer = tf.keras.layers.Dropout(self.zoneout_rate)\n\n def call(self, inputs, states, training=False):\n \"\"\"Runs vanilla LSTM Cell and applies zoneout.\n \"\"\"\n # Apply vanilla LSTM\n outputs, new_states = super().call(inputs, states, training=training)\n if self.zoneout_rate == 0:\n return outputs, new_states\n # Apply zoneout\n h = (1 - self.zoneout_rate) * \\\n self.drop_layer(new_states[0] - states[0], training=training) + \\\n states[0]\n c = (1 - self.zoneout_rate) * \\\n self.drop_layer(new_states[1] - states[1], training=training) + \\\n states[1]\n return outputs, [h, c]\n\n def get_config(self):\n config = super().get_config()\n config['zoneout_rate'] = self.zoneout_rate\n return config\n\n\nSUPPORTED_RNNS = {\n \"lstm\": tf.keras.layers.LSTMCell,\n \"gru\": tf.keras.layers.GRUCell,\n \"cudnnlstm\": tf.keras.layers.LSTMCell,\n \"cudnngru\": tf.keras.layers.GRUCell\n}\n\n\nACTIVATIONS = {\n \"relu\": tf.nn.relu,\n \"relu6\": tf.nn.relu6,\n \"elu\": tf.nn.elu,\n \"selu\": tf.nn.selu,\n \"gelu\": gelu,\n \"glu\": glu,\n 'swish': tf.nn.swish,\n \"leaky_relu\": tf.nn.leaky_relu,\n \"sigmoid\": tf.nn.sigmoid,\n \"softplus\": tf.nn.softplus,\n \"softsign\": tf.nn.softsign,\n \"tanh\": tf.nn.tanh,\n}\n" ]	[ [ "tensorflow.keras.constraints.serialize", "tensorflow.stack", "tensorflow.keras.layers.Conv2DTranspose", "tensorflow.cast", "tensorflow.keras.regularizers.serialize", "tensorflow.keras.backend.int_shape", "tensorflow.nn.moments", "tensorflow.keras.layers.Conv2D", "tensorflow.keras.initializers.constant", "tensorflow.keras.initializers.get", "tensorflow.nn.batch_normalization", "tensorflow.shape", "tensorflow.keras.layers.Dense", "tensorflow.keras.initializers.serialize", "tensorflow.math.sqrt", "tensorflow.keras.constraints.get", "tensorflow.keras.layers.Conv1D", "tensorflow.keras.regularizers.get", "tensorflow.reshape", "tensorflow.math.reduce_mean", "tensorflow.keras.layers.Dropout" ] ]
chenyanghungry/person-reid-lib	[ "783e66c9bfedf582e2cf935b9f5be960b543ac3c", "783e66c9bfedf582e2cf935b9f5be960b543ac3c" ]	[ "lib/datamanager/transforms.py", "lib/dataset/dukemtmcreid.py" ]	[ "from torchvision.transforms import ToPILImage, Resize, RandomHorizontalFlip, ToTensor, Normalize, RandomCrop\nimport torchvision.transforms.functional as F\nfrom PIL import Image, ImageOps\nimport numpy as np\nimport random\nimport numbers\nimport torch\nimport math\n\n\n__all__ = ['GroupToTensor',\n 'GroupResize',\n 'GroupRandomHorizontalFlip',\n 'GroupRandomCrop',\n 'GroupToTensor',\n 'GroupNormalize',\n 'StackTensor',\n 'GroupToPILImage',\n 'GroupRandom2DTranslation',\n 'GroupRandomErasing']\n\n\nclass ImageData(object):\n def __init__(self, img, x=None, y=None):\n self.img = img\n self.x = x\n self.y = y\n\n\ndef _group_process(images, func, params):\n if isinstance(images, (tuple, list)):\n return [_group_process(img, func, params) for img in images]\n else:\n return func(images, params)\n\n\nclass GroupOperation(object):\n def _instance_process(self, images, params):\n raise NotImplementedError\n\n def _get_params(self, images):\n return None\n\n def __call__(self, images):\n params = self._get_params(images)\n return _group_process(images, self._instance_process, params)\n\n\nclass GroupToPILImage(GroupOperation, ToPILImage):\n def __init__(self, mode=None, use_flow=False):\n super(GroupToPILImage, self).__init__(mode)\n self.use_flow = use_flow\n\n def _instance_process(self, pic_list, params):\n if isinstance(pic_list, np.ndarray):\n if pic_list.ndim == 3:\n return self.to_pil_image(pic_list)\n elif pic_list.ndim == 4:\n return [self.to_pil_image(pic_i) for pic_i in range(pic_list.shape[0])]\n else:\n raise TypeError\n raise TypeError\n\n def to_pil_image(self, pic):\n if pic.shape[2] == 3:\n return ImageData(F.to_pil_image(pic, self.mode))\n elif pic.shape[2] == 1:\n return ImageData(F.to_pil_image(pic))\n elif pic.shape[2] == 5:\n if self.use_flow:\n pic_rgb = F.to_pil_image(pic[..., :3], self.mode)\n pic_x = F.to_pil_image(pic[..., 3:4])\n pic_y = F.to_pil_image(pic[..., 4:5])\n return ImageData(pic_rgb, pic_x, pic_y)\n else:\n return ImageData(F.to_pil_image(pic[..., :3], self.mode))\n else:\n raise ValueError\n\n\nclass GroupResize(GroupOperation, Resize):\n def _instance_process(self, img, params):\n img.img = F.resize(img.img, self.size, self.interpolation)\n if img.x is not None:\n img.x = F.resize(img.x, self.size, self.interpolation)\n if img.y is not None:\n img.y = F.resize(img.y, self.size, self.interpolation)\n\n return img\n\n\nclass GroupRandomHorizontalFlip(GroupOperation, RandomHorizontalFlip):\n def _get_params(self, images):\n if random.random() < self.p:\n return True\n else:\n return False\n\n def _instance_process(self, img, flip_flag):\n \"\"\"\n Args:\n img (PIL Image): Image to be flipped.\n Returns:\n PIL Image: Randomly flipped image.\n \"\"\"\n if flip_flag:\n img.img = F.hflip(img.img)\n if img.x is not None:\n img.x = ImageOps.invert(img.x)\n return img\n\n\nclass GroupRandomCrop(GroupOperation):\n def __init__(self, size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant'):\n if isinstance(size, numbers.Number):\n self.size = (int(size), int(size))\n else:\n self.size = size\n self.padding = padding\n self.pad_if_needed = pad_if_needed\n self.fill = fill\n self.padding_mode = padding_mode\n\n @staticmethod\n def get_params(img, output_size):\n \"\"\"Get parameters for ``crop`` for a random crop.\n Args:\n img (PIL Image): Image to be cropped.\n output_size (tuple): Expected output size of the crop.\n Returns:\n tuple: params (i, j, h, w) to be passed to ``crop`` for random crop.\n \"\"\"\n w, h = img.size\n th, tw = output_size\n if w == tw and h == th:\n return 0, 0, h, w\n\n i = random.randint(0, h - th)\n j = random.randint(0, w - tw)\n return i, j, th, tw\n\n def pad_func(self, img, params):\n if self.padding is not None:\n img.img = F.pad(img.img, self.padding, self.fill, self.padding_mode)\n if img.x is not None:\n img.x = F.pad(img.x, self.padding, self.fill, self.padding_mode)\n if img.y is not None:\n img.y = F.pad(img.y, self.padding, self.fill, self.padding_mode)\n\n if self.pad_if_needed and img.img.size[0] < self.size[1]:\n img.img = F.pad(img.img, (self.size[1] - img.img.size[0], 0), self.fill, self.padding_mode)\n if img.x is not None:\n img.x = F.pad(img.x, (self.size[1] - img.img.size[0], 0), self.fill, self.padding_mode)\n if img.y is not None:\n img.y = F.pad(img.y, (self.size[1] - img.img.size[0], 0), self.fill, self.padding_mode)\n\n if self.pad_if_needed and img.img.size[1] < self.size[0]:\n img.img = F.pad(img.img, (0, self.size[0] - img.img.size[1]), self.fill, self.padding_mode)\n if img.x is not None:\n img.x = F.pad(img.x, (0, self.size[0] - img.img.size[1]), self.fill, self.padding_mode)\n if img.y is not None:\n img.y = F.pad(img.y, (0, self.size[0] - img.img.size[1]), self.fill, self.padding_mode)\n\n return img\n\n def _get_params(self, images):\n \"\"\"\n Args:\n img (PIL Image) list: Image to be cropped.\n Returns:\n PIL Image list: Cropped image.\n \"\"\"\n while isinstance(images, (tuple, list)):\n images = images[0]\n img = images.img\n\n if self.padding is not None:\n img = F.pad(img, self.padding, self.fill, self.padding_mode)\n\n # pad the width if needed\n if self.pad_if_needed and img.size[0] < self.size[1]:\n img = F.pad(img, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode)\n # pad the height if needed\n if self.pad_if_needed and img.size[1] < self.size[0]:\n img = F.pad(img, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode)\n\n return self.get_params(img, self.size)\n\n def _instance_process(self, images, params):\n i, j, h, w = params\n img = _group_process(images, self.pad_func, None)\n img.img = F.crop(img.img, i, j, h, w)\n\n if img.x is not None:\n img.x = F.crop(img.x, i, j, h, w)\n if img.y is not None:\n img.y = F.crop(img.y, i, j, h, w)\n\n return img\n\n def __repr__(self):\n return self.__class__.__name__ + '(size={0}, padding={1})'.format(self.size, self.padding)\n\n\nclass GroupToTensor(GroupOperation, ToTensor):\n def _instance_process(self, img, params):\n img.img = F.to_tensor(img.img)\n if img.x is not None:\n img.x = F.to_tensor(img.x)\n if img.y is not None:\n img.y = F.to_tensor(img.y)\n\n return img\n\n\nclass GroupNormalize(GroupOperation, Normalize):\n def _instance_process(self, image, params):\n image.img = F.normalize(image.img, self.mean[:3], self.std[:3])\n if image.x is not None:\n image.x = F.normalize(image.x, self.mean[3:4], self.std[3:4])\n if image.y is not None:\n image.y = F.normalize(image.y, self.mean[3:4], self.std[3:4])\n return image\n\n\nclass GroupRandom2DTranslation(GroupOperation):\n \"\"\"\n With a probability, first increase image size to (1 + 1/8), and then perform random crop.\n Args:\n - height (int): target height.\n - width (int): target width.\n - p (float): probability of performing this transformation. Default: 0.5.\n \"\"\"\n\n def __init__(self, height, width, p=0.5, interpolation=Image.BILINEAR):\n self.height = height\n self.width = width\n self.p = p\n self.interpolation = interpolation\n\n def _get_params(self, images):\n if random.uniform(0, 1) > self.p:\n return None\n else:\n new_width, new_height = int(round(self.width * 1.125)), int(round(self.height * 1.125))\n x_maxrange = new_width - self.width\n y_maxrange = new_height - self.height\n x1 = int(round(random.uniform(0, x_maxrange)))\n y1 = int(round(random.uniform(0, y_maxrange)))\n return new_width, new_height, x1, y1\n\n def _instance_process(self, img, params):\n if params is None:\n img.img = img.img.resize((self.width, self.height), self.interpolation)\n\n if img.x is not None:\n img.x = img.x.resize((self.width, self.height), self.interpolation)\n if img.y is not None:\n img.y = img.y.resize((self.width, self.height), self.interpolation)\n\n else:\n new_width, new_height, x1, y1 = params\n img.img = img.img.resize((new_width, new_height), self.interpolation)\n img.img = img.img.crop((x1, y1, x1 + self.width, y1 + self.height))\n\n if img.x is not None:\n img.x = img.x.resize((new_width, new_height), self.interpolation)\n img.x = img.x.crop((x1, y1, x1 + self.width, y1 + self.height))\n\n if img.y is not None:\n img.y = img.y.resize((new_width, new_height), self.interpolation)\n img.y = img.y.crop((x1, y1, x1 + self.width, y1 + self.height))\n\n return img\n\n def __repr__(self):\n return self.__class__.__name__ + '()'\n\n\nclass GroupRandomErasing(GroupOperation):\n \"\"\" Randomly selects a rectangle region in an image and erases its pixels.\n 'Random Erasing Data Augmentation' by Zhong et al.\n See https://arxiv.org/pdf/1708.04896.pdf\n Args:\n probability: The probability that the Random Erasing operation will be performed.\n sl: Minimum proportion of erased area against input image.\n sh: Maximum proportion of erased area against input image.\n r1: Minimum aspect ratio of erased area.\n mean: Erasing value.\n \"\"\"\n\n def __init__(self, probability=0.5, sl=0.02, sh=0.4, r1=0.3, mean=[0.4914, 0.4822, 0.4465]):\n self.probability = probability\n self.mean = mean\n self.sl = sl\n self.sh = sh\n self.r1 = r1\n\n def _instance_process(self, img, params):\n\n if random.uniform(0, 1) > self.probability:\n return img\n\n for attempt in range(100):\n area = img.img.size()[1] * img.img.size()[2]\n\n target_area = random.uniform(self.sl, self.sh) * area\n aspect_ratio = random.uniform(self.r1, 1 / self.r1)\n\n h = int(round(math.sqrt(target_area * aspect_ratio)))\n w = int(round(math.sqrt(target_area / aspect_ratio)))\n\n if w < img.img.size()[2] and h < img.img.size()[1]:\n x1 = random.randint(0, img.img.size()[1] - h)\n y1 = random.randint(0, img.img.size()[2] - w)\n if img.img.size()[0] == 3:\n img.img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n img.img[1, x1:x1 + h, y1:y1 + w] = self.mean[1]\n img.img[2, x1:x1 + h, y1:y1 + w] = self.mean[2]\n else:\n img.img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n if img.x is not None:\n img.x[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n if img.y is not None:\n img.y[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n\n return img\n\n def __repr__(self):\n return self.__class__.__name__ + '()'\n\n\nclass StackTensor(object):\n def __call__(self, tensor_list):\n if isinstance(tensor_list, (tuple, list)):\n rgb_tensor = []\n flow_tensor = []\n for tensor_i in tensor_list:\n rgb_tensor.append(tensor_i.img)\n if tensor_i.x is not None and tensor_i.y is not None:\n flow_tensor.append(torch.cat([tensor_i.x, tensor_i.y], dim=0))\n if len(tensor_list) > 1:\n rgb_tensor = torch.stack(rgb_tensor)\n\n if len(flow_tensor) > 1:\n flow_tensor = torch.stack(flow_tensor)\n return rgb_tensor, flow_tensor\n\n return rgb_tensor\n else:\n if len(flow_tensor) > 0:\n return rgb_tensor[0], flow_tensor[0]\n return rgb_tensor[0]\n raise TypeError\n\n def __repr__(self):\n return self.__class__.__name__ + '()'\n\n\nclass ToSpaceBGR(object):\n\n def __init__(self, is_bgr=True):\n self.is_bgr = is_bgr\n\n def __call__(self, tensor):\n if self.is_bgr:\n new_tensor = tensor.clone()\n new_tensor[0] = tensor[2]\n new_tensor[2] = tensor[0]\n tensor = new_tensor\n return tensor\n\n\nclass ToRange255(object):\n\n def __init__(self, is_255=True):\n self.is_255 = is_255\n\n def __call__(self, tensor):\n if self.is_255:\n tensor.mul_(255)\n return tensor", "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n\nimport numpy as np\nimport glob\nimport re\nimport os.path as osp\nfrom .datasetbase import DataSetBase\nfrom lib.utils.util import unpack_file, remove_folder\n\n\n__all__ = ['DukeMTMCreID']\n\n\nclass DukeMTMCreID(DataSetBase):\n def __init__(self, root_dir, rawfiles_dir, split_id, npr=None, logger=None):\n super().__init__('DukeMTMCreID', split_id, 'h5', root_dir, logger)\n self.zipfiles_dir = rawfiles_dir / 'DukeMTMC-reID.zip'\n\n self.raw_data_folder = self.store_dir / 'DukeMTMC-reID'\n self.train_dir = self.raw_data_folder / 'bounding_box_train'\n self.query_dir = self.raw_data_folder / 'query'\n self.gallery_dir = self.raw_data_folder / 'bounding_box_test'\n\n self.resize_hw = (256, 128)\n self.init()\n\n def check_raw_file(self):\n assert self.zipfiles_dir.exists()\n if not self.raw_data_folder.exists():\n unpack_file(self.zipfiles_dir, self.store_dir, self.logger)\n if (self.store_dir / '__MACOSX').exists():\n remove_folder(self.store_dir / '__MACOSX')\n\n assert self.train_dir.exists()\n assert self.query_dir.exists()\n assert self.gallery_dir.exists()\n\n def _get_dict(self):\n img_list = []\n train_images, train_img_dir = self._process_dir(self.train_dir, 0)\n img_list = img_list + train_img_dir\n probe_images, probe_img_dir = self._process_dir(self.query_dir, len(img_list))\n img_list = img_list + probe_img_dir\n gallery_images, gallery_img_dir = self._process_dir(self.gallery_dir, len(img_list))\n img_list = img_list + gallery_img_dir\n\n train_id = np.unique(train_images[:, 0])\n probe_id = np.unique(probe_images[:, 0])\n gallery_id = np.unique(gallery_images[:, 0])\n assert np.intersect1d(train_id, probe_id).size == 0\n assert np.intersect1d(probe_id, gallery_id).size == probe_id.size\n assert gallery_images[-1, 3] == len(img_list)\n\n data_dict = {}\n data_dict['dir'] = img_list\n\n data_split = {}\n data_split['train'] = train_images\n data_split['probe'] = probe_images\n data_split['gallery'] = gallery_images\n data_split['info'] = 'DukeMTMC-reID dataset. Split ID {:2d}.'.format(0)\n\n data_dict['split'] = [data_split]\n data_dict['info'] = 'DukeMTMCreID Dataset. One Split'\n\n return data_dict\n\n def _process_dir(self, dir_path, begin_id):\n img_paths = glob.glob(osp.join(dir_path, '*.jpg'))\n pattern = re.compile(r'([-\\d]+)_c(\\d)')\n\n dataset = []\n img_dir_list = []\n idx = begin_id\n\n for img_path in img_paths:\n pid, camid = map(int, pattern.search(img_path).groups())\n assert 1 <= camid <= 8\n camid -= 1 # index starts from 0\n img_dir_list.append(img_path)\n dataset.append((pid, camid, idx, idx + 1, 1))\n idx += 1\n\n return np.asarray(dataset, dtype=np.int64), img_dir_list\n" ]	[ [ "torch.stack", "torch.cat" ], [ "numpy.asarray", "numpy.intersect1d", "numpy.unique" ] ]
myepes2/MiSiCgui	[ "a2e76568cf32d00813760e5793d606faf7049701" ]	[ "models/MiSiDC04082020.py" ]	[ "\nfrom tensorflow.keras.models import load_model\nfrom tensorflow.keras.utils import get_file\n\nimport numpy as np\n\nfrom skimage.transform import resize,rescale\nfrom skimage.feature import shape_index\nfrom skimage.util import random_noise\nfrom skimage.io import imread,imsave\n\nimport matplotlib.pyplot as plt\n\nfrom MiSiCgui.utils import \n#from utils_gui import \n\nclass SegModel():\n def __init__(self):\n self.size = 256\n self.scalesvals = [1,1.5,2.0]\n #self.model = load_model(model_name)\n model_path = get_file(\n 'MiSiDC04082020',\n 'https://github.com/pswapnesh/Models/raw/master/MiSiDC04082020.h5', cache_dir='./cache')\n self.model = load_model(model_path,compile=False)\n \n def preprocess(self,im):\n n = len(self.scalesvals)\n sh = np.zeros((im.shape[0],im.shape[1],n))\n \n if np.max(im) ==0:\n return sh\n pw = 15\n im = np.pad(im,pw,'reflect')\n sh = np.zeros((im.shape[0],im.shape[1],n)) \n for i in range(n):\n sh[:,:,i] = shape_index(im,self.scalesvals[i])\n \n return sh[pw:-pw,pw:-pw,:]\n \n def segment(self,im,invert = False):\n im = normalize2max(im) \n pw = 16\n if invert:\n im = 1.0-im\n im = np.pad(im,pw,'reflect')\n sh = self.preprocess(im)\n\n tiles,params = extract_tiles(sh,size = self.size,exclude=12)\n\n yp = self.model.predict(tiles)\n\n return stitch_tiles(yp,params)[pw:-pw,pw:-pw,:]" ]	[ [ "tensorflow.keras.models.load_model", "numpy.pad", "numpy.max", "tensorflow.keras.utils.get_file", "numpy.zeros" ] ]
jan-pavlovsky/Deep-Learning-Tasks	[ "220764d350ae1bbe8e50250b44a5f9e0b3abefe4" ]	[ "09/morpho_dataset.py" ]	[ "import os\nimport sys\nimport urllib.request\nimport zipfile\n\nimport numpy as np\n\n# Loads a morphological dataset in a vertical format.\n# - The data consists of three Datasets\n# - train\n# - dev\n# - test\n# - Each dataset is composed of factors (FORMS, LEMMAS, TAGS), each an\n# object containing the following fields:\n# - word_strings: Strings of the original words.\n# - word_ids: Word ids of the original words (uses <unk> and <pad>).\n# - words_map: String -> word_id map.\n# - words: Word_id -> string list.\n# - alphabet_map: Character -> char_id map.\n# - alphabet: Char_id -> character list.\n# - charseq_ids: Character_sequence ids of the original words.\n# - charseqs_map: String -> character_sequence_id map.\n# - charseqs: Character_sequence_id -> [characters], where character is an index\n# to the dataset alphabet.\nclass MorphoDataset:\n _URL = \"https://ufal.mff.cuni.cz/~straka/courses/npfl114/1819/datasets/\"\n\n class Factor:\n PAD = 0\n UNK = 1\n BOW = 2\n EOW = 3\n\n def __init__(self, characters, train=None):\n self.words_map = train.words_map if train else {\"<pad>\": self.PAD, \"<unk>\": self.UNK}\n self.words = train.words if train else [\"<pad>\", \"<unk>\"]\n self.word_ids = []\n self.word_strings = []\n self.characters = characters\n if characters:\n self.alphabet_map = train.alphabet_map if train else {\n \"<pad>\": self.PAD, \"<unk>\": self.UNK, \"<bow>\": self.BOW, \"<eow>\": self.EOW}\n self.alphabet = train.alphabet if train else [\"<pad>\", \"<unk>\", \"<bow>\", \"<eow>\"]\n self.charseqs_map = {\"<pad>\": self.PAD, \"<unk>\": self.UNK}\n self.charseqs = [[self.PAD], [self.UNK]]\n self.charseq_ids = []\n\n class FactorBatch:\n def __init__(self, word_ids, charseq_ids=None, charseqs=None):\n self.word_ids = word_ids\n self.charseq_ids = charseq_ids\n self.charseqs = charseqs\n\n class Dataset:\n FORMS = 0\n LEMMAS = 1\n TAGS = 2\n FACTORS = 3\n\n def __init__(self, data_file, train=None, shuffle_batches=True, add_bow_eow=False, max_sentences=None, seed=42):\n # Create factors\n self._data = []\n for f in range(self.FACTORS):\n self._data.append(MorphoDataset.Factor(f in [self.FORMS, self.LEMMAS], train._data[f] if train else None))\n\n in_sentence = False\n for line in data_file:\n line = line.decode(\"utf-8\").rstrip(\"\\r\\n\")\n if line:\n columns = line.split(\"\\t\")\n for f in range(self.FACTORS):\n factor = self._data[f]\n if not in_sentence:\n if len(factor.word_ids): factor.word_ids[-1] = np.array(factor.word_ids[-1], np.int32)\n factor.word_ids.append([])\n factor.word_strings.append([])\n if factor.characters: factor.charseq_ids.append([])\n\n word = columns[f]\n factor.word_strings[-1].append(word)\n\n # Character-level information\n if factor.characters:\n if word not in factor.charseqs_map:\n factor.charseqs_map[word] = len(factor.charseqs)\n factor.charseqs.append([])\n if add_bow_eow:\n factor.charseqs[-1].append(MorphoDataset.Factor.BOW)\n for c in word:\n if c not in factor.alphabet_map:\n if train:\n c = \"<unk>\"\n else:\n factor.alphabet_map[c] = len(factor.alphabet)\n factor.alphabet.append(c)\n factor.charseqs[-1].append(factor.alphabet_map[c])\n if add_bow_eow:\n factor.charseqs[-1].append(MorphoDataset.Factor.EOW)\n factor.charseq_ids[-1].append(factor.charseqs_map[word])\n\n # Word-level information\n if word not in factor.words_map:\n if train:\n word = \"<unk>\"\n else:\n factor.words_map[word] = len(factor.words)\n factor.words.append(word)\n factor.word_ids[-1].append(factor.words_map[word])\n\n in_sentence = True\n else:\n in_sentence = False\n if max_sentences is not None and len(self._data[self.FORMS].word_ids) >= max_sentences:\n break\n\n self._size = len(self._data[self.FORMS].word_ids)\n self._shuffler = np.random.RandomState(seed) if shuffle_batches else None\n\n @property\n def data(self):\n return self._data\n\n def size(self):\n return self._size\n\n def batches(self, size=None):\n permutation = self._shuffler.permutation(self._size) if self._shuffler else np.arange(self._size)\n while len(permutation):\n batch_size = min(size or np.inf, len(permutation))\n batch_perm = permutation[:batch_size]\n permutation = permutation[batch_size:]\n\n batch = []\n max_sentence_len = max(len(self._data[self.FORMS].word_ids[i]) for i in batch_perm)\n\n # Word-level data\n for factor in self._data:\n batch.append(MorphoDataset.FactorBatch(np.zeros([batch_size, max_sentence_len], np.int32)))\n for i in range(batch_size):\n batch[-1].word_ids[i, :len(factor.word_ids[batch_perm[i]])] = factor.word_ids[batch_perm[i]]\n\n # Character-level data\n for f, factor in enumerate(self._data):\n if not factor.characters: continue\n\n batch[f].charseq_ids = np.zeros([batch_size, max_sentence_len], np.int32)\n charseqs_map = {\"<pad>\": factor.PAD}\n charseqs = [factor.charseqs[factor.PAD]]\n for i in range(batch_size):\n for j, charseq_id in enumerate(factor.charseq_ids[batch_perm[i]]):\n if charseq_id not in charseqs_map:\n charseqs_map[charseq_id] = len(charseqs)\n charseqs.append(factor.charseqs[charseq_id])\n batch[f].charseq_ids[i, j] = charseqs_map[charseq_id]\n\n max_charseq_len = max(len(charseq) for charseq in charseqs)\n batch[f].charseqs = np.zeros([len(charseqs), max_charseq_len], np.int32)\n for i in range(len(charseqs)):\n batch[f].charseqs[i, :len(charseqs[i])] = charseqs[i]\n\n yield batch\n\n\n def __init__(self, dataset, add_bow_eow=False, max_sentences=None):\n path = \"{}.zip\".format(dataset)\n if not os.path.exists(path):\n print(\"Downloading dataset {}...\".format(dataset), file=sys.stderr)\n urllib.request.urlretrieve(\"{}/{}\".format(self._URL, path), filename=path)\n\n with zipfile.ZipFile(path, \"r\") as zip_file:\n for dataset in [\"train\", \"dev\", \"test\"]:\n with zip_file.open(\"{}_{}.txt\".format(os.path.splitext(path)[0], dataset), \"r\") as dataset_file:\n setattr(self, dataset, self.Dataset(dataset_file,\n train=self.train if dataset != \"train\" else None,\n shuffle_batches=dataset == \"train\",\n add_bow_eow=add_bow_eow,\n max_sentences=max_sentences))\n" ]	[ [ "numpy.arange", "numpy.array", "numpy.random.RandomState", "numpy.zeros" ] ]
Henriksen-Lab/Simple_DAQ	[ "3bd313df4c80340eb367081400cb6d75ba132623" ]	[ "pico_vna_adapt/PicoVNA108.py" ]	[ "#!/usr/bin/python\n# -- coding: utf-8 --\n#\n# author: Shilling Du, revised from https://github.com/picotech/picosdk-picovna-python-examples\n# Feb 22, 2022\n\nimport win32com.client\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nclass Smith():\n def __init__(self,real,imag,logmag,phase,freq):\n self.real = np.array(real)\n self.imag = np.array(imag)\n self.log_mag = np.array(logmag)\n self.phase_rad = np.array(phase)\n self.freqs = np.array(freq)\n\ndef get_picoVNA_smith(port='S21',f_min=0.3,f_max=8500,number_of_points=1001,power=0,bandwidth=1000,Average=1):\n\n picoVNA = win32com.client.gencache.EnsureDispatch(\"PicoControl3.PicoVNA_3_2\")\n try:\n findVNA = picoVNA.FND()\n ans=picoVNA.LoadCal(r'C:\\Users\\ICET\\Documents\\Pico Technology\\PicoVNA3\\FacCal.cal')\n freq_step = np.ceil((f_max-f_min)/number_of_points*1E5)/1E5\n picoVNA.SetFreqPlan(f_min,freq_step,number_of_points,power,bandwidth)\n picoVNA.SetEnhance('Aver',Average)\n\n picoVNA.Measure('ALL');\n\n raw_logmag = picoVNA.GetData(port,\"logmag\",0)\n splitdata_logmag = raw_logmag.split(',')\n freq = np.float64(np.array(splitdata_logmag))[: : 2]\n logmag = np.float64(np.array(splitdata_logmag))[1 : : 2]\n\n raw_real = picoVNA.GetData(port, \"real\", 0)\n splitdata_real = raw_real.split(',')\n real = np.float64(np.array(splitdata_real))[1 : : 2]\n\n raw_imag = picoVNA.GetData(port, \"imag\", 0)\n splitdata_imag = raw_imag.split(',')\n imag = np.float64(np.array(splitdata_imag))[1:: 2]\n\n raw_phase = picoVNA.GetData(port, \"phase\", 0)\n splitdata_phase = raw_phase.split(',')\n phase = np.float64(np.array(splitdata_phase))[1:: 2]\n\n data = Smith(real,imag,logmag,phase,freq)\n return data\n finally:\n picoVNA.CloseVNA()\n\n\n'''\ndata = get_picoVNA_smith()\n\nplt.plot(data.freqs, data.log_mag)\nplt.ylabel(\"S21 LogMag\")\nplt.xlabel(\"Frequency\")\nplt.show()\n\n'''\n" ]	[ [ "numpy.ceil", "numpy.array" ] ]
bene1337/OpenFermion	[ "6187085f2a7707012b68370b625acaeed547e62b" ]	[ "src/openfermion/transforms/repconversions/conversions.py" ]	[ "# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport numpy\n\nfrom openfermion.config import EQ_TOLERANCE\nfrom openfermion.ops.operators import FermionOperator\nfrom openfermion.ops.representations import (DiagonalCoulombHamiltonian,\n InteractionOperator,\n InteractionOperatorError)\nfrom openfermion.transforms.opconversions import (check_no_sympy,\n normal_ordered)\nfrom openfermion.ops.representations.quadratic_hamiltonian import (\n QuadraticHamiltonian, QuadraticHamiltonianError)\n\nfrom openfermion.chem import MolecularData\n\n# for breaking cyclic imports\nfrom openfermion.utils import operator_utils as op_utils\n\n\ndef get_quadratic_hamiltonian(fermion_operator,\n chemical_potential=0.,\n n_qubits=None,\n ignore_incompatible_terms=False):\n r\"\"\"Convert a quadratic fermionic operator to QuadraticHamiltonian.\n\n Args:\n fermion_operator(FermionOperator): The operator to convert.\n chemical_potential(float): A chemical potential to include in\n the returned operator\n n_qubits(int): Optionally specify the total number of qubits in the\n system\n ignore_incompatible_terms(bool): This flag determines the behavior\n of this method when it encounters terms that are not quadratic\n that is, terms that are not of the form a^\\dagger_p a_q.\n If set to True, this method will simply ignore those terms.\n If False, then this method will raise an error if it encounters\n such a term. The default setting is False.\n\n Returns:\n quadratic_hamiltonian: An instance of the QuadraticHamiltonian class.\n\n Raises:\n TypeError: Input must be a FermionOperator.\n TypeError: FermionOperator does not map to QuadraticHamiltonian.\n\n Warning:\n Even assuming that each creation or annihilation operator appears\n at most a constant number of times in the original operator, the\n runtime of this method is exponential in the number of qubits.\n \"\"\"\n if not isinstance(fermion_operator, FermionOperator):\n raise TypeError('Input must be a FermionOperator.')\n\n check_no_sympy(fermion_operator)\n\n if n_qubits is None:\n n_qubits = op_utils.count_qubits(fermion_operator)\n if n_qubits < op_utils.count_qubits(fermion_operator):\n raise ValueError('Invalid number of qubits specified.')\n\n # Normal order the terms and initialize.\n fermion_operator = normal_ordered(fermion_operator)\n constant = 0.\n combined_hermitian_part = numpy.zeros((n_qubits, n_qubits), complex)\n antisymmetric_part = numpy.zeros((n_qubits, n_qubits), complex)\n\n # Loop through terms and assign to matrix.\n for term in fermion_operator.terms:\n coefficient = fermion_operator.terms[term]\n # Ignore this term if the coefficient is zero\n if abs(coefficient) < EQ_TOLERANCE:\n # not testable because normal_ordered kills\n # fermion terms lower than EQ_TOLERANCE\n continue # pragma: no cover\n\n if len(term) == 0:\n # Constant term\n constant = coefficient\n elif len(term) == 2:\n ladder_type = [operator[1] for operator in term]\n p, q = [operator[0] for operator in term]\n\n if ladder_type == [1, 0]:\n combined_hermitian_part[p, q] = coefficient\n elif ladder_type == [1, 1]:\n # Need to check that the corresponding [0, 0] term is present\n conjugate_term = ((p, 0), (q, 0))\n if conjugate_term not in fermion_operator.terms:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n else:\n matching_coefficient = -fermion_operator.terms[\n conjugate_term].conjugate()\n discrepancy = abs(coefficient - matching_coefficient)\n if discrepancy > EQ_TOLERANCE:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n antisymmetric_part[p, q] += .5 * coefficient\n antisymmetric_part[q, p] -= .5 * coefficient\n else:\n # ladder_type == [0, 0]\n # Need to check that the corresponding [1, 1] term is present\n conjugate_term = ((p, 1), (q, 1))\n if conjugate_term not in fermion_operator.terms:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n else:\n matching_coefficient = -fermion_operator.terms[\n conjugate_term].conjugate()\n discrepancy = abs(coefficient - matching_coefficient)\n if discrepancy > EQ_TOLERANCE:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n antisymmetric_part[p, q] -= .5 * coefficient.conjugate()\n antisymmetric_part[q, p] += .5 * coefficient.conjugate()\n elif not ignore_incompatible_terms:\n # Operator contains non-quadratic terms\n raise QuadraticHamiltonianError('FermionOperator does not map '\n 'to QuadraticHamiltonian '\n '(contains non-quadratic terms).')\n\n # Compute Hermitian part\n hermitian_part = (combined_hermitian_part +\n chemical_potential * numpy.eye(n_qubits))\n\n # Check that the operator is Hermitian\n if not op_utils.is_hermitian(hermitian_part):\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n\n # Form QuadraticHamiltonian and return.\n discrepancy = numpy.max(numpy.abs(antisymmetric_part))\n if discrepancy < EQ_TOLERANCE:\n # Hamiltonian conserves particle number\n quadratic_hamiltonian = QuadraticHamiltonian(\n hermitian_part,\n constant=constant,\n chemical_potential=chemical_potential)\n else:\n # Hamiltonian does not conserve particle number\n quadratic_hamiltonian = QuadraticHamiltonian(hermitian_part,\n antisymmetric_part,\n constant,\n chemical_potential)\n\n return quadratic_hamiltonian\n\n\ndef get_diagonal_coulomb_hamiltonian(fermion_operator,\n n_qubits=None,\n ignore_incompatible_terms=False):\n r\"\"\"Convert a FermionOperator to a DiagonalCoulombHamiltonian.\n\n Args:\n fermion_operator(FermionOperator): The operator to convert.\n n_qubits(int): Optionally specify the total number of qubits in the\n system\n ignore_incompatible_terms(bool): This flag determines the behavior\n of this method when it encounters terms that are not represented\n by the DiagonalCoulombHamiltonian class, namely, terms that are\n not quadratic and not quartic of the form\n a^\\dagger_p a_p a^\\dagger_q a_q. If set to True, this method will\n simply ignore those terms. If False, then this method will raise\n an error if it encounters such a term. The default setting is False.\n \"\"\"\n if not isinstance(fermion_operator, FermionOperator):\n raise TypeError('Input must be a FermionOperator.')\n\n check_no_sympy(fermion_operator)\n\n if n_qubits is None:\n n_qubits = op_utils.count_qubits(fermion_operator)\n if n_qubits < op_utils.count_qubits(fermion_operator):\n raise ValueError('Invalid number of qubits specified.')\n\n fermion_operator = normal_ordered(fermion_operator)\n constant = 0.\n one_body = numpy.zeros((n_qubits, n_qubits), complex)\n two_body = numpy.zeros((n_qubits, n_qubits), float)\n\n for term, coefficient in fermion_operator.terms.items():\n # Ignore this term if the coefficient is zero\n if abs(coefficient) < EQ_TOLERANCE:\n # not testable because normal_ordered kills\n # fermion terms lower than EQ_TOLERANCE\n continue # pragma: no cover\n\n if len(term) == 0:\n constant = coefficient\n else:\n actions = [operator[1] for operator in term]\n if actions == [1, 0]:\n p, q = [operator[0] for operator in term]\n one_body[p, q] = coefficient\n elif actions == [1, 1, 0, 0]:\n p, q, r, s = [operator[0] for operator in term]\n if p == r and q == s:\n if abs(numpy.imag(coefficient)) > EQ_TOLERANCE:\n raise ValueError(\n 'FermionOperator does not map to '\n 'DiagonalCoulombHamiltonian (not Hermitian).')\n coefficient = numpy.real(coefficient)\n two_body[p, q] = -.5 * coefficient\n two_body[q, p] = -.5 * coefficient\n elif not ignore_incompatible_terms:\n raise ValueError('FermionOperator does not map to '\n 'DiagonalCoulombHamiltonian '\n '(contains terms with indices '\n '{}).'.format((p, q, r, s)))\n elif not ignore_incompatible_terms:\n raise ValueError('FermionOperator does not map to '\n 'DiagonalCoulombHamiltonian (contains terms '\n 'with action {}.'.format(tuple(actions)))\n\n # Check that the operator is Hermitian\n if not op_utils.is_hermitian(one_body):\n raise ValueError(\n 'FermionOperator does not map to DiagonalCoulombHamiltonian '\n '(not Hermitian).')\n\n return DiagonalCoulombHamiltonian(one_body, two_body, constant)\n\n\ndef get_interaction_operator(fermion_operator, n_qubits=None):\n r\"\"\"Convert a 2-body fermionic operator to InteractionOperator.\n\n This function should only be called on fermionic operators which\n consist of only a_p^\\dagger a_q and a_p^\\dagger a_q^\\dagger a_r a_s\n terms. The one-body terms are stored in a matrix, one_body[p, q], and\n the two-body terms are stored in a tensor, two_body[p, q, r, s].\n\n Returns:\n interaction_operator: An instance of the InteractionOperator class.\n\n Raises:\n TypeError: Input must be a FermionOperator.\n TypeError: FermionOperator does not map to InteractionOperator.\n\n Warning:\n Even assuming that each creation or annihilation operator appears\n at most a constant number of times in the original operator, the\n runtime of this method is exponential in the number of qubits.\n \"\"\"\n if not isinstance(fermion_operator, FermionOperator):\n raise TypeError('Input must be a FermionOperator.')\n\n check_no_sympy(fermion_operator)\n\n if n_qubits is None:\n n_qubits = op_utils.count_qubits(fermion_operator)\n if n_qubits < op_utils.count_qubits(fermion_operator):\n raise ValueError('Invalid number of qubits specified.')\n\n # Normal order the terms and initialize.\n fermion_operator = normal_ordered(fermion_operator)\n constant = 0.\n one_body = numpy.zeros((n_qubits, n_qubits), complex)\n two_body = numpy.zeros((n_qubits, n_qubits, n_qubits, n_qubits), complex)\n\n # Loop through terms and assign to matrix.\n for term in fermion_operator.terms:\n coefficient = fermion_operator.terms[term]\n # Ignore this term if the coefficient is zero\n if abs(coefficient) < EQ_TOLERANCE:\n # not testable because normal_ordered kills\n # fermion terms lower than EQ_TOLERANCE\n continue # pragma: no cover\n\n # Handle constant shift.\n if len(term) == 0:\n constant = coefficient\n\n elif len(term) == 2:\n # Handle one-body terms.\n if [operator[1] for operator in term] == [1, 0]:\n p, q = [operator[0] for operator in term]\n one_body[p, q] = coefficient\n else:\n raise InteractionOperatorError('FermionOperator does not map '\n 'to InteractionOperator.')\n\n elif len(term) == 4:\n # Handle two-body terms.\n if [operator[1] for operator in term] == [1, 1, 0, 0]:\n p, q, r, s = [operator[0] for operator in term]\n two_body[p, q, r, s] = coefficient\n else:\n raise InteractionOperatorError('FermionOperator does not map '\n 'to InteractionOperator.')\n\n else:\n # Handle non-molecular Hamiltonian.\n raise InteractionOperatorError('FermionOperator does not map '\n 'to InteractionOperator.')\n\n # Form InteractionOperator and return.\n interaction_operator = InteractionOperator(constant, one_body, two_body)\n return interaction_operator\n\n\ndef get_molecular_data(interaction_operator,\n geometry=None,\n basis=None,\n multiplicity=None,\n n_electrons=None,\n reduce_spin=True,\n data_directory=None):\n \"\"\"Output a MolecularData object generated from an InteractionOperator\n\n Args:\n interaction_operator(InteractionOperator): two-body interaction\n operator defining the \"molecular interaction\" to be simulated.\n geometry(string or list of atoms):\n basis(string): String denoting the basis set used to discretize the\n system.\n multiplicity(int): Spin multiplicity desired in the system.\n n_electrons(int): Number of electrons in the system\n reduce_spin(bool): True if one wishes to perform spin reduction on\n integrals that are given in interaction operator. Assumes\n spatial (x) spin structure generically.\n\n Returns:\n molecule(MolecularData):\n Instance that captures the\n interaction_operator converted into the format that would come\n from an electronic structure package adorned with some meta-data\n that may be useful.\n \"\"\"\n\n n_spin_orbitals = interaction_operator.n_qubits\n\n # Introduce bare molecular operator to fill\n molecule = MolecularData(geometry=geometry,\n basis=basis,\n multiplicity=multiplicity,\n data_directory=data_directory)\n\n molecule.nuclear_repulsion = interaction_operator.constant\n\n # Remove spin from integrals and put into molecular operator\n if reduce_spin:\n reduction_indices = list(range(0, n_spin_orbitals, 2))\n else:\n reduction_indices = list(range(n_spin_orbitals))\n\n molecule.n_orbitals = len(reduction_indices)\n\n molecule.one_body_integrals = interaction_operator.one_body_tensor[\n numpy.ix_(reduction_indices, reduction_indices)]\n molecule.two_body_integrals = interaction_operator.two_body_tensor[\n numpy.ix_(reduction_indices, reduction_indices, reduction_indices,\n reduction_indices)]\n\n # Fill in other metadata\n molecule.overlap_integrals = numpy.eye(molecule.n_orbitals)\n molecule.n_qubits = n_spin_orbitals\n molecule.n_electrons = n_electrons\n molecule.multiplicity = multiplicity\n\n return molecule\n" ]	[ [ "numpy.ix_", "numpy.imag", "numpy.abs", "numpy.eye", "numpy.real", "numpy.zeros" ] ]
thangth1102/Wikidata2Text	[ "722b528451e92b3072bf57260fdb8f0962a89929" ]	[ "autoencoders.py" ]	[ "from cluster_losses import \r\nfrom cluster_metrics import \r\nfrom corpus_estimation import \r\nfrom cluster_methods import \r\n\r\nfrom sklearn.model_selection import train_test_split\r\n\r\nimport keras\r\nfrom keras.layers import Input, Dense\r\nfrom keras.models import Model\r\nfrom keras.callbacks import TensorBoard\r\nfrom keras.callbacks import EarlyStopping\r\n\r\nimport matplotlib.pyplot as plt\r\n\r\nfrom sklearn.preprocessing import MinMaxScaler\r\n\r\ndef add_noise(x_train, x_test, noise_factor):\r\n x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.5, scale=0.5, size=x_train.shape) \r\n x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.5, scale=0.5, size=x_test.shape) \r\n\r\n x_train_noisy = np.clip(x_train_noisy, 0., 10.)\r\n x_test_noisy = np.clip(x_test_noisy, 0., 10.)\r\n\r\n print('x_test_noisy: ', x_test_noisy)\r\n return x_train_noisy, x_test_noisy\r\n\r\ndef calculate_total_loss(network_loss, cluster_loss, loss_coefficient):\r\n return network_lossloss_coefficient + (1-loss_coefficient)cluster_loss\r\n\r\ndef train_autoencoder(input_dim, encoding_dim, x_train, x_test, x_all, y_train, y_test, y_all, epochs, n_clusters, batch_size=1,\r\n centroids=[], loss_coefficient=0.5, cluster_loss_type='euclidean', network_loss='mean_squared_error',\r\n optimizer='sgd', exit_type='total_val', min_delta=0.001, denoising=False, noise_factor=0.5):\r\n\r\n \"\"\"\r\n x_all = x_true\r\n y_all = y_true\r\n \"\"\"\r\n # denoising autoencoder\r\n x_train_noisy, x_test_noisy = [], []\r\n if (denoising == True):\r\n x_train_noisy, x_test_noisy = add_noise(x_train, x_test, noise_factor)\r\n \r\n input_data = Input(shape=(input_dim,)) # input_dim = 32\r\n\r\n encoded = Dense(encoding_dim)(input_data) \r\n \r\n # set up more hidden layers here\r\n decoded = Dense(input_dim)(encoded) # \"decoded\" is the lossy reconstruction of the input\r\n \r\n autoencoder = Model(input_data, decoded) # this model maps an input to its reconstruction\r\n\r\n encoder = Model(input_data, encoded) # this model maps an input to its encoded representation\r\n encoded_input = Input(shape=(encoding_dim,)) # create a placeholder for an encoded (2-dimensional) input\r\n \r\n decoder_layer = autoencoder.layers[-1] # retrieve the last layer of the autoencoder model\r\n decoder = Model(encoded_input, decoder_layer(encoded_input)) # create the decoder model\r\n\r\n hidden_layer = autoencoder.layers[0] # get hidden layer values\r\n hidden_layer_decoder = Model(encoded_input, hidden_layer(encoded_input))\r\n\r\n autoencoder.compile(loss=network_loss, optimizer=optimizer)\r\n\r\n total_loss_list = [] # total lost\r\n total_val_loss_list = [] # total validation lost\r\n \r\n hidden_layer_data = []\r\n hidden_layer_data_list = []\r\n decoded_data = []\r\n \r\n centroids = []\r\n cluster_loss = 0\r\n \r\n history_list = []\r\n idx = []\r\n for ep in range(epochs):\r\n\r\n print('..................................................')\r\n print('epoch: \\t', ep)\r\n\r\n if (denoising == True):\r\n history = autoencoder.fit(x_train_noisy, x_train,\r\n batch_size=batch_size, epochs=1,\r\n shuffle=True,\r\n validation_data=(x_test_noisy, x_test),\r\n verbose=0)\r\n else:\r\n history = autoencoder.fit(x_train, x_train,\r\n batch_size=batch_size, epochs=1,\r\n shuffle=True,\r\n validation_data=(x_test, x_test),\r\n verbose=0)\r\n #callbacks=[TensorBoard(log_dir='/tmp/autoencoder')])\r\n\r\n history_list.append(history) # add trained values to history in every epoch\r\n\r\n encoded_data = encoder.predict(x_all) # get all data\r\n #print('encoded_data: ', encoded_data)\r\n \r\n decoded_data = decoder.predict(encoded_data) \r\n #print('decoded_data: ', decoded_data)\r\n \r\n hidden_layer_data = hidden_layer_decoder.predict(encoded_data)\r\n #print('hidden_layer_data: ', hidden_layer_data)\r\n hidden_layer_data_list.append(hidden_layer_data)\r\n\r\n # calculate loss\r\n network_loss = autoencoder.history.history['loss'][0]\r\n network_val_loss = autoencoder.history.history['val_loss'][0]\r\n\r\n print('network_loss, network_val_loss: ', network_loss, network_val_loss)\r\n\r\n centroids = []\r\n for x, y in zip(hidden_layer_data, y_all):\r\n if (y == 0): # true labels\r\n centroids.append(x.tolist())\r\n #print('centroids: ', centroids, len(centroids))\r\n\r\n cluster_sum_loss, cluster_mean_loss = 0, 0\r\n\r\n if (cluster_loss_type == 'kmeans'):\r\n cluster_sum_loss, cluster_mean_loss, centroids, idx = kmeans_loss(hidden_layer_data, n_clusters)\r\n elif (cluster_loss_type == 'euclidean'):\r\n # need to have centroids\r\n cluster_sum_loss, cluster_mean_loss = euclidean_distance_mean_loss(hidden_layer_data, centroids)\r\n elif(cluster_loss_type == 'rmse'):\r\n # need to have centroids\r\n cluster_sum_loss, cluster_mean_loss = rmse_loss(hidden_layer_data, centroids)\r\n else:\r\n # similar to kmeans but need to have centroids\r\n cluster_sum_loss, cluster_mean_loss = mse_loss(hidden_layer_data, centroids)\r\n print('cluster_sum_loss, cluster_mean_loss: ', cluster_sum_loss, cluster_mean_loss)\r\n \r\n total_loss = calculate_total_loss(network_loss, cluster_mean_loss, loss_coefficient)\r\n total_loss_list.append(total_loss)\r\n\r\n total_val_loss = calculate_total_loss(network_val_loss, cluster_mean_loss, loss_coefficient)\r\n total_val_loss_list.append(total_val_loss)\r\n\r\n print('total loss, total validation loss: ', total_loss, total_val_loss)\r\n\r\n #if (ep <= 5): continue\r\n\r\n # break condition\r\n\r\n if (exit_type == 'total'):\r\n condition = exit_condition(total_loss_list, min_delta)\r\n if (condition != -1):\r\n if (condition == 0):\r\n return history_list[:-1], total_loss_list[:-1], total_val_loss_list[:-1], hidden_layer_data_list[-2]\r\n break\r\n elif (exit_type == 'total_val'):\r\n condition = exit_condition(total_val_loss_list, min_delta)\r\n if (condition != -1):\r\n if (condition == 0):\r\n return history_list[:-1], total_loss_list[:-1], total_val_loss_list[:-1], hidden_layer_data_list[-2]\r\n break\r\n \r\n return history_list, total_loss_list, total_val_loss_list, hidden_layer_data\r\n\r\n\r\ndef show_loss_plot(history_list, total_loss_list, total_val_loss_list):\r\n plt.plot([h.history['loss'] for h in history_list])\r\n plt.plot([h.history['val_loss'] for h in history_list])\r\n plt.plot(total_loss_list)\r\n plt.plot(total_val_loss_list)\r\n plt.title('Model loss')\r\n plt.ylabel('Loss')\r\n plt.xlabel('Epoch')\r\n plt.legend(['Train', 'Test', 'Total_train', 'Total_test'], loc='upper left')\r\n plt.show()\r\n \r\n\r\ndef exit_condition(loss_list, min_delta):\r\n\r\n # len(lost_list)\r\n count = 0\r\n if (len(loss_list) < 2): return -1\r\n else:\r\n if (len(loss_list) <= 5): return -1\r\n elif (loss_list[-2] - loss_list[-1] < 0):\r\n return 0\r\n elif (loss_list[-2] - loss_list[-1] <= min_delta):\r\n return 1\r\n return -1\r\n" ]	[ [ "matplotlib.pyplot.legend", "matplotlib.pyplot.title", "matplotlib.pyplot.plot", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.show", "matplotlib.pyplot.ylabel" ] ]
yarenty/ludwig	[ "d77aaf8da39f04a353a3a08fb699ae8a96ffea3a" ]	[ "ludwig/data/preprocessing.py" ]	[ "#! /usr/bin/env python\n# Copyright (c) 2019 Uber Technologies, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\nimport logging\nfrom abc import ABC, abstractmethod\nfrom typing import Any, Dict, List, Tuple\n\nimport numpy as np\nimport pandas as pd\n\nfrom ludwig.backend import Backend, LOCAL_BACKEND\nfrom ludwig.constants import (\n BACKFILL,\n BFILL,\n BINARY,\n CHECKSUM,\n COLUMN,\n DROP_ROW,\n FFILL,\n FILL_WITH_CONST,\n FILL_WITH_FALSE,\n FILL_WITH_MEAN,\n FILL_WITH_MODE,\n FULL,\n NAME,\n NUMBER,\n PAD,\n PREPROCESSING,\n PROC_COLUMN,\n SPLIT,\n SRC,\n TEST,\n TEXT,\n TRAINING,\n TYPE,\n VALIDATION,\n)\nfrom ludwig.data.concatenate_datasets import concatenate_df, concatenate_files\nfrom ludwig.data.dataset.base import Dataset\nfrom ludwig.encoders.registry import get_encoder_cls\nfrom ludwig.features.feature_registries import base_type_registry\nfrom ludwig.features.feature_utils import compute_feature_hash\nfrom ludwig.utils import data_utils, strings_utils\nfrom ludwig.utils.data_utils import (\n CACHEABLE_FORMATS,\n CSV_FORMATS,\n DATA_TRAIN_HDF5_FP,\n DATAFRAME_FORMATS,\n DICT_FORMATS,\n EXCEL_FORMATS,\n FEATHER_FORMATS,\n figure_data_format,\n FWF_FORMATS,\n get_split_path,\n HDF5_FORMATS,\n HTML_FORMATS,\n JSON_FORMATS,\n JSONL_FORMATS,\n ORC_FORMATS,\n override_in_memory_flag,\n PARQUET_FORMATS,\n PICKLE_FORMATS,\n read_csv,\n read_excel,\n read_feather,\n read_fwf,\n read_html,\n read_json,\n read_jsonl,\n read_orc,\n read_parquet,\n read_pickle,\n read_sas,\n read_spss,\n read_stata,\n read_tsv,\n SAS_FORMATS,\n save_array,\n split_dataset_ttv,\n SPSS_FORMATS,\n STATA_FORMATS,\n TSV_FORMATS,\n)\nfrom ludwig.utils.defaults import default_preprocessing_parameters, default_random_seed\nfrom ludwig.utils.fs_utils import file_lock, path_exists\nfrom ludwig.utils.misc_utils import get_from_registry, merge_dict, resolve_pointers, set_random_seed\nfrom ludwig.utils.type_utils import Column\nfrom ludwig.utils.types import DataFrame\n\nlogger = logging.getLogger(__name__)\n\n\nclass DataFormatPreprocessor(ABC):\n @staticmethod\n @abstractmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n pass\n\n @staticmethod\n @abstractmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n pass\n\n @staticmethod\n @abstractmethod\n def prepare_processed_data(\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n ):\n pass\n\n\nclass DictPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n num_overrides = override_in_memory_flag(features, True)\n if num_overrides > 0:\n logger.warning(\"Using in_memory = False is not supported \" \"with {} data format.\".format(\"dict\"))\n\n df_engine = backend.df_engine\n if dataset is not None:\n dataset = df_engine.from_pandas(pd.DataFrame(dataset))\n if training_set is not None:\n training_set = df_engine.from_pandas(pd.DataFrame(training_set))\n if validation_set is not None:\n validation_set = df_engine.from_pandas(pd.DataFrame(validation_set))\n if test_set is not None:\n test_set = df_engine.from_pandas(pd.DataFrame(test_set))\n\n return _preprocess_df_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n training_set_metadata=training_set_metadata,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset, training_set_metadata = build_dataset(\n pd.DataFrame(dataset),\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass DataFramePreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n num_overrides = override_in_memory_flag(features, True)\n if num_overrides > 0:\n logger.warning(\"Using in_memory = False is not supported \" \"with {} data format.\".format(\"dataframe\"))\n\n if isinstance(dataset, pd.DataFrame):\n dataset = backend.df_engine.from_pandas(dataset)\n\n return _preprocess_df_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n training_set_metadata=training_set_metadata,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n if isinstance(dataset, pd.DataFrame):\n dataset = backend.df_engine.from_pandas(dataset)\n\n dataset, training_set_metadata = build_dataset(\n dataset,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass CSVPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_csv,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_csv(dataset, df_lib=backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass TSVPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_tsv,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_tsv(dataset, df_lib=backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass JSONPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_json,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_json(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass JSONLPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_jsonl,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_jsonl(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass ExcelPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_excel,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_excel(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass ParquetPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_parquet,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_parquet(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n @staticmethod\n def prepare_processed_data(\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n ):\n test_set = test_set if test_set and path_exists(test_set) else None\n validation_set = validation_set if validation_set and path_exists(validation_set) else None\n return training_set, test_set, validation_set, training_set_metadata\n\n\nclass PicklePreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_pickle,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_pickle(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass FatherPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_feather,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_feather(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass FWFPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_fwf,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_fwf(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass HTMLPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_html,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_html(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass ORCPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_orc,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_orc(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass SASPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_sas,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_sas(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass SPSSPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_spss,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_spss(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass StataPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_stata,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_stata(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass HDF5Preprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return HDF5Preprocessor.prepare_processed_data(\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n training_set_metadata,\n skip_save_processed_input,\n preprocessing_params,\n backend,\n random_seed,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n hdf5_fp = dataset\n dataset = load_hdf5(dataset, features, split_data=False, shuffle_training=False)\n return dataset, training_set_metadata, hdf5_fp\n\n @staticmethod\n def prepare_processed_data(\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n ):\n if dataset is None and training_set is None:\n raise ValueError(\"One of `dataset` or `training_set` must be not None\")\n not_none_set = dataset if dataset is not None else training_set\n\n if not training_set_metadata:\n raise ValueError(\"When providing HDF5 data, \" \"training_set_metadata must not be None.\")\n\n logger.info(\"Using full hdf5 and json\")\n\n if DATA_TRAIN_HDF5_FP not in training_set_metadata:\n logger.warning(\n \"data_train_hdf5_fp not present in training_set_metadata. \"\n \"Adding it with the current HDF5 file path {}\".format(not_none_set)\n )\n training_set_metadata[DATA_TRAIN_HDF5_FP] = not_none_set\n\n elif training_set_metadata[DATA_TRAIN_HDF5_FP] != not_none_set:\n logger.warning(\n \"data_train_hdf5_fp in training_set_metadata is {}, \"\n \"different from the current HDF5 file path {}. \"\n \"Replacing it\".format(training_set_metadata[DATA_TRAIN_HDF5_FP], not_none_set)\n )\n training_set_metadata[DATA_TRAIN_HDF5_FP] = not_none_set\n\n if dataset is not None:\n training_set, test_set, validation_set = load_hdf5(dataset, features, shuffle_training=True)\n\n elif training_set is not None:\n kwargs = dict(features=features, split_data=False)\n training_set = load_hdf5(training_set, shuffle_training=True, kwargs)\n\n if validation_set is not None:\n validation_set = load_hdf5(validation_set, shuffle_training=False, kwargs)\n\n if test_set is not None:\n test_set = load_hdf5(test_set, shuffle_training=False, kwargs)\n\n return training_set, test_set, validation_set, training_set_metadata\n\n\ndata_format_preprocessor_registry = {\n {fmt: DictPreprocessor for fmt in DICT_FORMATS},\n {fmt: DataFramePreprocessor for fmt in DATAFRAME_FORMATS},\n {fmt: CSVPreprocessor for fmt in CSV_FORMATS},\n {fmt: TSVPreprocessor for fmt in TSV_FORMATS},\n {fmt: JSONPreprocessor for fmt in JSON_FORMATS},\n {fmt: JSONLPreprocessor for fmt in JSONL_FORMATS},\n {fmt: ExcelPreprocessor for fmt in EXCEL_FORMATS},\n {fmt: ParquetPreprocessor for fmt in PARQUET_FORMATS},\n {fmt: PicklePreprocessor for fmt in PICKLE_FORMATS},\n {fmt: FWFPreprocessor for fmt in FWF_FORMATS},\n {fmt: FatherPreprocessor for fmt in FEATHER_FORMATS},\n {fmt: HTMLPreprocessor for fmt in HTML_FORMATS},\n {fmt: ORCPreprocessor for fmt in ORC_FORMATS},\n {fmt: SASPreprocessor for fmt in SAS_FORMATS},\n {fmt: SPSSPreprocessor for fmt in SPSS_FORMATS},\n {fmt: StataPreprocessor for fmt in STATA_FORMATS},\n {fmt: HDF5Preprocessor for fmt in HDF5_FORMATS},\n}\n\n\ndef build_dataset(\n dataset_df,\n features,\n global_preprocessing_parameters,\n metadata=None,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n skip_save_processed_input=False,\n callbacks=None,\n mode=None,\n):\n df_engine = backend.df_engine\n dataset_df = df_engine.parallelize(dataset_df)\n\n # If persisting DataFrames in memory is enabled, we want to do this after\n # each batch of parallel ops in order to avoid redundant computation\n dataset_df = backend.df_engine.persist(dataset_df)\n\n global_preprocessing_parameters = merge_dict(default_preprocessing_parameters, global_preprocessing_parameters)\n\n # Get all the unique preprocessing features to compute\n feature_configs = []\n feature_hashes = set()\n for feature in features:\n if PROC_COLUMN not in feature:\n feature[PROC_COLUMN] = compute_feature_hash(feature)\n if feature[PROC_COLUMN] not in feature_hashes:\n feature_configs.append(feature)\n feature_hashes.add(feature[PROC_COLUMN])\n\n logger.debug(\"cast columns\")\n dataset_cols = cast_columns(dataset_df, feature_configs, backend)\n\n for callback in callbacks or []:\n callback.on_build_metadata_start(dataset_df, mode)\n\n logger.debug(\"build metadata\")\n metadata = build_metadata(metadata, dataset_cols, feature_configs, global_preprocessing_parameters, backend)\n\n for callback in callbacks or []:\n callback.on_build_metadata_end(dataset_df, mode)\n\n for callback in callbacks or []:\n callback.on_build_data_start(dataset_df, mode)\n\n logger.debug(\"build data\")\n proc_cols = build_data(dataset_cols, feature_configs, metadata, backend, skip_save_processed_input)\n\n for callback in callbacks or []:\n callback.on_build_data_end(dataset_df, mode)\n\n logger.debug(\"get split\")\n split = get_split(\n dataset_df,\n force_split=global_preprocessing_parameters[\"force_split\"],\n split_probabilities=global_preprocessing_parameters[\"split_probabilities\"],\n stratify=global_preprocessing_parameters[\"stratify\"],\n backend=backend,\n random_seed=random_seed,\n )\n\n if split is not None:\n proc_cols[SPLIT] = split\n\n # TODO ray: this is needed because ray 1.7 doesn't support Dask to RayDataset\n # conversion with Tensor columns. Can remove for 1.8.\n if backend.df_engine.partitioned:\n for feature in features:\n name = feature[NAME]\n proc_column = feature[PROC_COLUMN]\n reshape = metadata[name].get(\"reshape\")\n if reshape is not None:\n proc_cols[proc_column] = backend.df_engine.map_objects(proc_cols[proc_column], lambda x: x.reshape(-1))\n\n dataset = backend.df_engine.df_like(dataset_df, proc_cols)\n\n # At this point, there should be no missing values left in the dataframe, unless\n # the DROP_ROW preprocessing option was selected, in which case we need to drop those\n # rows.\n dataset = dataset.dropna()\n\n return dataset, metadata\n\n\ndef cast_columns(dataset_df, features, backend) -> Dict[str, DataFrame]:\n \"\"\"Copies each column of the dataset to a dataframe, with potential type casting.\"\"\"\n dataset_cols = {}\n for feature in features:\n # todo figure out if additional parameters are needed\n # for the cast_column function\n try:\n dataset_cols[feature[COLUMN]] = get_from_registry(feature[TYPE], base_type_registry).cast_column(\n dataset_df[feature[COLUMN]], backend\n )\n except KeyError as e:\n raise KeyError(\n f\"Feature name {e} specified in the config was not found in dataset with columns: \"\n + f\"{list(dataset_df.columns)}\"\n )\n\n return dataset_cols\n\n\ndef merge_preprocessing(\n feature_config: Dict[str, Any], global_preprocessing_parameters: Dict[str, Any]\n) -> Dict[str, Any]:\n if PREPROCESSING not in feature_config:\n return global_preprocessing_parameters[feature_config[TYPE]]\n\n return merge_dict(global_preprocessing_parameters[feature_config[TYPE]], feature_config[PREPROCESSING])\n\n\ndef build_metadata(\n metadata: Dict[str, Any],\n dataset_cols: Dict[str, Column],\n feature_configs: List[Dict[str, Any]],\n global_preprocessing_parameters: Dict[str, Any],\n backend: Backend,\n) -> Dict[str, Any]:\n for feature_config in feature_configs:\n if feature_config[NAME] in metadata:\n continue\n\n preprocessing_parameters = merge_preprocessing(feature_config, global_preprocessing_parameters)\n\n # deal with encoders that have fixed preprocessing\n if \"encoder\" in feature_config:\n encoder_class = get_encoder_cls(feature_config[TYPE], feature_config[\"encoder\"])\n if hasattr(encoder_class, \"fixed_preprocessing_parameters\"):\n encoder_fpp = encoder_class.fixed_preprocessing_parameters\n\n preprocessing_parameters = merge_dict(\n preprocessing_parameters, resolve_pointers(encoder_fpp, feature_config, \"feature.\")\n )\n\n fill_value = precompute_fill_value(dataset_cols, feature_config, preprocessing_parameters, backend)\n\n if fill_value is not None:\n preprocessing_parameters = {\"computed_fill_value\": fill_value, *preprocessing_parameters}\n\n handle_missing_values(dataset_cols, feature_config, preprocessing_parameters)\n\n column = dataset_cols[feature_config[COLUMN]]\n if column.dtype == object:\n column = column.astype(str)\n\n metadata[feature_config[NAME]] = get_from_registry(feature_config[TYPE], base_type_registry).get_feature_meta(\n column, preprocessing_parameters, backend\n )\n\n metadata[feature_config[NAME]][PREPROCESSING] = preprocessing_parameters\n\n return metadata\n\n\ndef build_data(\n input_cols: DataFrame,\n feature_configs: List[Dict],\n training_set_metadata: Dict,\n backend: Backend,\n skip_save_processed_input: bool,\n) -> Dict[str, DataFrame]:\n \"\"\"Preprocesses the input dataframe columns, handles missing values, and potentially adds metadata to\n training_set_metadata.\n\n Args:\n input_cols: Input dataframe to be processed.\n feature_configs: List of feature configs.\n training_set_metadata: Training set metadata. Additional fields may be added.\n backend: Backend for data processing.\n skip_save_processed_input: (bool) Whether to skip saving the processed input.\n\n Returns:\n Dictionary of (feature name) -> (processed data).\n \"\"\"\n proc_cols = {}\n for feature_config in feature_configs:\n preprocessing_parameters = training_set_metadata[feature_config[NAME]][PREPROCESSING]\n handle_missing_values(input_cols, feature_config, preprocessing_parameters)\n get_from_registry(feature_config[TYPE], base_type_registry).add_feature_data(\n feature_config,\n input_cols,\n proc_cols,\n training_set_metadata,\n preprocessing_parameters,\n backend,\n skip_save_processed_input,\n )\n\n return proc_cols\n\n\ndef balance_data(dataset_df: DataFrame, output_features: List[Dict], preprocessing_parameters: Dict, backend: Backend):\n \"\"\"The purpose of this function is to balance the training dataset using either over-sampling or under-\n sampling.\n\n Args:\n dataset_df: Input dataframe to be over-sampled or under-sampled.\n output_features: List of feature configs.\n preprocessing_parameters: Dictionary of the global preprocessing parameters.\n backend: Backend for data processing.\n\n Returns: An over-sampled or under-sampled training dataset.\n \"\"\"\n\n if len(output_features) != 1:\n raise ValueError(\"Class balancing is only available for datasets with a single output feature\")\n if output_features[0][TYPE] != BINARY:\n raise ValueError(\"Class balancing is only supported for binary output types\")\n\n target = output_features[0][PROC_COLUMN]\n\n if backend.df_engine.partitioned:\n majority_class = backend.df_engine.compute(dataset_df[target].value_counts()).idxmax()\n minority_class = backend.df_engine.compute(dataset_df[target].value_counts()).idxmin()\n else:\n majority_class = dataset_df[target].value_counts().idxmax()\n minority_class = dataset_df[target].value_counts().idxmin()\n majority_df = dataset_df[dataset_df[target] == majority_class]\n minority_df = dataset_df[dataset_df[target] == minority_class]\n\n if preprocessing_parameters[\"oversample_minority\"] and preprocessing_parameters[\"undersample_majority\"]:\n raise ValueError(\n \"Cannot balance data if both oversampling an undersampling are specified in the config. \"\n \"Must specify only one method\"\n )\n\n if preprocessing_parameters[\"oversample_minority\"]:\n sample_fraction = (len(majority_df) preprocessing_parameters[\"oversample_minority\"]) / len(minority_df)\n minority_df = minority_df.sample(frac=sample_fraction, replace=True)\n elif preprocessing_parameters[\"undersample_majority\"]:\n sample_fraction = int(len(minority_df) / preprocessing_parameters[\"undersample_majority\"]) / len(majority_df)\n majority_df = majority_df.sample(frac=sample_fraction, replace=False)\n\n balanced_df = backend.df_engine.concat([minority_df, majority_df])\n\n return balanced_df\n\n\ndef precompute_fill_value(dataset_cols, feature, preprocessing_parameters, backend):\n missing_value_strategy = preprocessing_parameters[\"missing_value_strategy\"]\n if missing_value_strategy == FILL_WITH_CONST:\n return preprocessing_parameters[\"fill_value\"]\n elif missing_value_strategy == FILL_WITH_MODE:\n return dataset_cols[feature[COLUMN]].value_counts().index[0]\n elif missing_value_strategy == FILL_WITH_MEAN:\n if feature[TYPE] != NUMBER:\n raise ValueError(\n f\"Filling missing values with mean is supported \"\n f\"only for numerical types, not for type {feature[TYPE]}.\",\n )\n return backend.df_engine.compute(dataset_cols[feature[COLUMN]].mean())\n elif missing_value_strategy == FILL_WITH_FALSE:\n distinct_values = backend.df_engine.compute(\n dataset_cols[feature[COLUMN]].drop_duplicates().dropna()\n ).values.tolist()\n if len(distinct_values) > 2:\n raise ValueError(\n f\"Missing value strategy `fill_with_false` \"\n f\"for column {feature[COLUMN]} expects 2 distinct values, \"\n f\"found: {distinct_values}\"\n )\n\n # Determine the False label.\n # Distinct values are sorted in reverse to mirror the selection of the default fallback_true_label (in\n # binary_feature.get_feature_meta) for binary columns with unconventional boolean values, \"human\"/\"bot\".\n for v in sorted(distinct_values, reverse=True):\n fallback_true_label = preprocessing_parameters.get(\"fallback_true_label\", \"true\")\n if strings_utils.str2bool(v, fallback_true_label) is False:\n return v\n raise ValueError(\n f\"Unable to determine False value for column {feature[COLUMN]} with distinct values: {distinct_values}.\"\n )\n # Otherwise, we cannot precompute the fill value for this dataset\n return None\n\n\ndef handle_missing_values(dataset_cols, feature, preprocessing_parameters):\n missing_value_strategy = preprocessing_parameters[\"missing_value_strategy\"]\n\n # Check for the precomputed fill value in the metadata\n computed_fill_value = preprocessing_parameters.get(\"computed_fill_value\")\n\n if computed_fill_value is not None:\n dataset_cols[feature[COLUMN]] = dataset_cols[feature[COLUMN]].fillna(\n computed_fill_value,\n )\n elif missing_value_strategy in [BACKFILL, BFILL, PAD, FFILL]:\n dataset_cols[feature[COLUMN]] = dataset_cols[feature[COLUMN]].fillna(\n method=missing_value_strategy,\n )\n elif missing_value_strategy == DROP_ROW:\n # Here we only drop from this series, but after preprocessing we'll do a second\n # round of dropping NA values from the entire output dataframe, which will\n # result in the removal of the rows.\n dataset_cols[feature[COLUMN]] = dataset_cols[feature[COLUMN]].dropna()\n else:\n raise ValueError(\"Invalid missing value strategy\")\n\n\ndef get_split(\n dataset_df,\n force_split=False,\n split_probabilities=(0.7, 0.1, 0.2),\n stratify=None,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n):\n if SPLIT in dataset_df and not force_split:\n split = dataset_df[SPLIT]\n else:\n set_random_seed(random_seed)\n if stratify is None or stratify not in dataset_df:\n if backend.df_engine.partitioned:\n # This approach is very inefficient for partitioned backends, which\n # can split by partition\n return None\n\n split = (\n dataset_df.index.to_series()\n .map(lambda x: np.random.choice(3, 1, p=split_probabilities))\n .astype(np.int8)\n )\n else:\n split = np.zeros(len(dataset_df))\n for val in dataset_df[stratify].unique():\n # TODO dask: find a way to better parallelize this operation\n idx_list = dataset_df.index[dataset_df[stratify] == val].tolist()\n array_lib = backend.df_engine.array_lib\n val_list = array_lib.random.choice(\n 3,\n len(idx_list),\n p=split_probabilities,\n ).astype(np.int8)\n split[idx_list] = val_list\n return split\n\n\ndef load_hdf5(hdf5_file_path, features, split_data=True, shuffle_training=False):\n # TODO dask: this needs to work with DataFrames\n logger.info(f\"Loading data from: {hdf5_file_path}\")\n\n def shuffle(df):\n return df.sample(frac=1).reset_index(drop=True)\n\n dataset = data_utils.load_hdf5(hdf5_file_path)\n if not split_data:\n if shuffle_training:\n dataset = shuffle(dataset)\n return dataset\n\n training_set, test_set, validation_set = split_dataset_ttv(dataset, SPLIT)\n\n if shuffle_training:\n training_set = shuffle(training_set)\n\n return training_set, test_set, validation_set\n\n\ndef load_metadata(metadata_file_path):\n logger.info(f\"Loading metadata from: {metadata_file_path}\")\n return data_utils.load_json(metadata_file_path)\n\n\ndef preprocess_for_training(\n config,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n data_format=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n) -> Tuple[Dataset, Dataset, Dataset, Dict[str, Any]]:\n \"\"\"Returns training, val and test datasets with training set metadata.\"\"\"\n\n # sanity check to make sure some data source is provided\n if dataset is None and training_set is None:\n raise ValueError(\"No training data is provided!\")\n\n # determine data format if not provided or auto\n if not data_format or data_format == \"auto\":\n data_format = figure_data_format(dataset, training_set, validation_set, test_set)\n\n try:\n lock_path = backend.cache.get_cache_directory(dataset)\n except (TypeError, ValueError):\n lock_path = None\n with file_lock(lock_path, lock_file=\".lock_preprocessing\"):\n # if training_set_metadata is a string, assume it's a path to load the json\n training_set_metadata = training_set_metadata or {}\n if training_set_metadata and isinstance(training_set_metadata, str):\n training_set_metadata = load_metadata(training_set_metadata)\n\n # setup\n features = config[\"input_features\"] + config[\"output_features\"]\n\n # in case data_format is one of the cacheable formats,\n # check if there's a cached hdf5 file with the same name,\n # and in case move on with the hdf5 branch.\n cached = False\n cache = backend.cache.get_dataset_cache(config, dataset, training_set, test_set, validation_set)\n if data_format in CACHEABLE_FORMATS:\n cache_results = cache.get()\n if cache_results is not None:\n valid, cache_values = cache_results\n if valid:\n logger.info(\n \"Found cached dataset and meta.json with the same filename \"\n \"of the dataset, using them instead\"\n )\n training_set_metadata, training_set, test_set, validation_set = cache_values\n config[\"data_hdf5_fp\"] = training_set\n data_format = backend.cache.data_format\n cached = True\n dataset = None\n else:\n logger.info(\n \"Found cached dataset and meta.json with the same filename \"\n \"of the dataset, but checksum don't match, \"\n \"if saving of processed input is not skipped \"\n \"they will be overridden\"\n )\n cache.delete()\n\n training_set_metadata[CHECKSUM] = cache.checksum\n data_format_processor = get_from_registry(data_format, data_format_preprocessor_registry)\n\n if cached or data_format == \"hdf5\":\n # Always interpret hdf5 files as preprocessed, even if missing from the cache\n processed = data_format_processor.prepare_processed_data(\n features,\n dataset=dataset,\n training_set=training_set,\n validation_set=validation_set,\n test_set=test_set,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n )\n training_set, test_set, validation_set, training_set_metadata = processed\n else:\n processed = data_format_processor.preprocess_for_training(\n config,\n features,\n dataset=dataset,\n training_set=training_set,\n validation_set=validation_set,\n test_set=test_set,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n training_set, test_set, validation_set, training_set_metadata = processed\n replace_text_feature_level(features, [training_set, validation_set, test_set])\n processed = (training_set, test_set, validation_set, training_set_metadata)\n\n # cache the dataset\n if backend.cache.can_cache(skip_save_processed_input):\n logger.debug(\"cache processed data\")\n processed = cache.put(processed)\n training_set, test_set, validation_set, training_set_metadata = processed\n\n logger.debug(\"create training dataset\")\n training_dataset = backend.dataset_manager.create(training_set, config, training_set_metadata)\n\n validation_dataset = None\n if validation_set is not None:\n logger.debug(\"create validation dataset\")\n validation_dataset = backend.dataset_manager.create(validation_set, config, training_set_metadata)\n\n test_dataset = None\n if test_set is not None:\n logger.debug(\"create test dataset\")\n test_dataset = backend.dataset_manager.create(test_set, config, training_set_metadata)\n\n return (training_dataset, validation_dataset, test_dataset, training_set_metadata)\n\n\ndef _preprocess_file_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n read_fn=read_csv,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n):\n \"\"\"Method to pre-process csv data.\n\n :param features: list of all features (input + output)\n :param dataset: path to the data\n :param training_set: training data\n :param validation_set: validation data\n :param test_set: test data\n :param training_set_metadata: train set metadata\n :param skip_save_processed_input: if False, the pre-processed data is saved\n as .hdf5 files in the same location as the csv files with the same names.\n :param preprocessing_params: preprocessing parameters\n :param random_seed: random seed\n :return: training, test, validation datasets, training metadata\n \"\"\"\n if dataset:\n # Use data and ignore _train, _validation and _test.\n # Also ignore data and train set metadata needs preprocessing\n logger.info(\"Using full raw dataset, no hdf5 and json file \" \"with the same name have been found\")\n logger.info(\"Building dataset (it may take a while)\")\n\n dataset_df = read_fn(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n\n data, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n random_seed=random_seed,\n skip_save_processed_input=skip_save_processed_input,\n callbacks=callbacks,\n mode=\"training\",\n )\n\n # TODO(travis): implement saving split for Ray\n if backend.is_coordinator() and not skip_save_processed_input and SPLIT in data.columns:\n # save split values for use by visualization routines\n split_fp = get_split_path(dataset)\n save_array(split_fp, data[SPLIT])\n\n elif training_set:\n # use data_train (including _validation and _test if they are present)\n # and ignore data and train set metadata\n # needs preprocessing\n logger.info(\"Using training raw csv, no hdf5 and json \" \"file with the same name have been found\")\n logger.info(\"Building dataset (it may take a while)\")\n\n concatenated_df = concatenate_files(training_set, validation_set, test_set, read_fn, backend)\n training_set_metadata[SRC] = training_set\n\n data, training_set_metadata = build_dataset(\n concatenated_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n mode=\"training\",\n )\n\n else:\n raise ValueError(\"either data or data_train have to be not None\")\n\n logger.info(\"Building dataset: DONE\")\n\n data = backend.df_engine.persist(data)\n if SPLIT in data.columns:\n logger.debug(\"split on split column\")\n training_data, test_data, validation_data = split_dataset_ttv(data, SPLIT)\n else:\n logger.debug(\"split randomly by partition\")\n training_data, test_data, validation_data = data.random_split(preprocessing_params[\"split_probabilities\"])\n\n if preprocessing_params[\"oversample_minority\"] or preprocessing_params[\"undersample_majority\"]:\n training_data = balance_data(training_data, config[\"output_features\"], preprocessing_params, backend)\n\n return training_data, test_data, validation_data, training_set_metadata\n\n\ndef _preprocess_df_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n):\n \"\"\"Method to pre-process dataframes.\n\n This doesn't have the option to save the processed data as hdf5 as we don't expect users to do this as the data can\n be processed in memory\n \"\"\"\n if dataset is not None:\n # needs preprocessing\n logger.info(\"Using full dataframe\")\n elif training_set is not None:\n # needs preprocessing\n logger.info(\"Using training dataframe\")\n dataset = concatenate_df(training_set, validation_set, test_set, backend)\n logger.info(\"Building dataset (it may take a while)\")\n\n dataset, training_set_metadata = build_dataset(\n dataset,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n random_seed=random_seed,\n backend=backend,\n callbacks=callbacks,\n mode=\"training\",\n )\n\n logger.info(\"Building dataset: DONE\")\n\n dataset = backend.df_engine.persist(dataset)\n if SPLIT in dataset.columns:\n logger.debug(\"split on split column\")\n training_set, test_set, validation_set = split_dataset_ttv(dataset, SPLIT)\n else:\n logger.debug(\"split randomly by partition\")\n training_set, test_set, validation_set = dataset.random_split(preprocessing_params[\"split_probabilities\"])\n\n if preprocessing_params[\"oversample_minority\"] or preprocessing_params[\"undersample_majority\"]:\n training_set = balance_data(training_set, config[\"output_features\"], preprocessing_params, backend)\n\n return training_set, test_set, validation_set, training_set_metadata\n\n\ndef preprocess_for_prediction(\n config,\n dataset,\n training_set_metadata=None,\n data_format=None,\n split=FULL,\n include_outputs=True,\n backend=LOCAL_BACKEND,\n callbacks=None,\n):\n \"\"\"Preprocesses the dataset to parse it into a format that is usable by the Ludwig core.\n\n :param model_path: The input data that is joined with the model\n hyperparameter file to create the config file\n :param data_csv: The CSV input data file\n :param data_hdf5: The hdf5 data file if there is no csv data file\n :param training_set_metadata: Train set metadata for the input features\n :param split: the split of dataset to return\n :returns: Dataset, Train set metadata\n \"\"\"\n # Sanity Check to make sure some data source is provided\n if dataset is None:\n raise ValueError(\"No training data is provided!\")\n\n if isinstance(dataset, Dataset):\n return dataset, training_set_metadata\n\n # determine data format if not provided or auto\n if not data_format or data_format == \"auto\":\n data_format = figure_data_format(dataset)\n\n # manage the in_memory parameter\n if data_format not in HDF5_FORMATS:\n num_overrides = override_in_memory_flag(config[\"input_features\"], True)\n if num_overrides > 0:\n logger.warning(\"Using in_memory = False is not supported \" \"with {} data format.\".format(data_format))\n\n preprocessing_params = merge_dict(default_preprocessing_parameters, config[PREPROCESSING])\n\n # if training_set_metadata is a string, assume it's a path to load the json\n if training_set_metadata and isinstance(training_set_metadata, str):\n training_set_metadata = load_metadata(training_set_metadata)\n\n # setup\n output_features = []\n if include_outputs:\n output_features += config[\"output_features\"]\n features = config[\"input_features\"] + output_features\n\n # Check the cache for an already preprocessed dataset. This only\n # applies to scenarios where the user wishes to predict on a split\n # of the full dataset, where we preprocess the whole dataset together\n # during training. If the user wishes to predict on the full dataset,\n # it is assumed they are predicting on unseen data. This is done\n # because the cached data is stored in its split form, and would be\n # expensive to recombine, requiring further caching.\n cached = False\n cache = backend.cache.get_dataset_cache(config, dataset)\n training_set = test_set = validation_set = None\n if data_format in CACHEABLE_FORMATS and split != FULL:\n cache_results = cache.get()\n if cache_results is not None:\n valid, cache_values = cache_results\n if valid:\n logger.info(\n \"Found cached dataset and meta.json with the same filename \" \"of the input file, using them instead\"\n )\n training_set_metadata, training_set, test_set, validation_set = cache_values\n config[\"data_hdf5_fp\"] = training_set\n data_format = backend.cache.data_format\n cached = True\n\n data_format_processor = get_from_registry(data_format, data_format_preprocessor_registry)\n\n if cached:\n processed = data_format_processor.prepare_processed_data(\n features,\n dataset=dataset,\n training_set=training_set,\n validation_set=validation_set,\n test_set=test_set,\n training_set_metadata=training_set_metadata,\n preprocessing_params=preprocessing_params,\n backend=backend,\n )\n training_set, test_set, validation_set, training_set_metadata = processed\n else:\n processed = data_format_processor.preprocess_for_prediction(\n dataset, features, preprocessing_params, training_set_metadata, backend, callbacks\n )\n dataset, training_set_metadata, new_hdf5_fp = processed\n training_set_metadata = training_set_metadata.copy()\n\n if new_hdf5_fp:\n training_set_metadata[DATA_TRAIN_HDF5_FP] = new_hdf5_fp\n\n replace_text_feature_level(features, [dataset])\n\n if split != FULL:\n training_set, test_set, validation_set = split_dataset_ttv(dataset, SPLIT)\n\n if split == TRAINING:\n dataset = training_set\n elif split == VALIDATION:\n dataset = validation_set\n elif split == TEST:\n dataset = test_set\n\n config = {\n *config,\n \"output_features\": output_features,\n }\n\n dataset = backend.dataset_manager.create(\n dataset,\n config,\n training_set_metadata,\n )\n\n return dataset, training_set_metadata\n\n\ndef replace_text_feature_level(features, datasets):\n for feature in features:\n if feature[TYPE] == TEXT:\n for dataset in datasets:\n if dataset is not None:\n dataset[feature[PROC_COLUMN]] = dataset[\"{}_{}\".format(feature[PROC_COLUMN], feature[\"level\"])]\n for level in (\"word\", \"char\"):\n name_level = f\"{feature[PROC_COLUMN]}_{level}\"\n if name_level in dataset:\n del dataset[name_level]\n" ]	[ [ "pandas.DataFrame", "numpy.random.choice" ] ]
utiasSTARS/pyslam	[ "5c0de9eaed4ebc7687b6d43079481c9a9336145b" ]	[ "examples/stereo_ba.py" ]	[ "import numpy as np\n\nfrom liegroups import SE3\n\nfrom pyslam.sensors import StereoCamera\nfrom pyslam.residuals import ReprojectionResidual\nfrom pyslam.problem import Options, Problem\nfrom pyslam.utils import invsqrt\n\n# Reproducibility\nnp.random.seed(42)\n\n# Landmarks (world frame is first camera frame)\npts_w_GT = [\n np.array([0., -1., 10.]),\n np.array([1., 1., 5.]),\n np.array([-1., 1., 15.])\n]\n\n# Trajectory\nT_cam_w_GT = [\n SE3.identity(),\n SE3.exp(0.1 * np.ones(6)),\n SE3.exp(0.2 * np.ones(6)),\n SE3.exp(0.3 * np.ones(6))\n]\n\n# Camera\ncamera = StereoCamera(640, 480, 1000, 1000, 0.25, 1280, 960)\n\n# Observations\nobs_var = [1, 1, 2] # [u,v,d]\nobs_stiffness = invsqrt(np.diagflat(obs_var))\n\nobs = [[camera.project(T.dot(p))\n for p in pts_w_GT] for T in T_cam_w_GT]\n\n# Optimize\noptions = Options()\noptions.allow_nondecreasing_steps = True\noptions.max_nondecreasing_steps = 3\n\nproblem = Problem(options)\nfor i, this_pose_obs in enumerate(obs):\n for j, o in enumerate(this_pose_obs):\n residual = ReprojectionResidual(camera, o, obs_stiffness)\n problem.add_residual_block(\n residual, ['T_cam{}_w'.format(i), 'pt{}_w'.format(j)])\n\nparams_true = {}\nparams_init = {}\n\nfor i, pt in enumerate(pts_w_GT):\n pid = 'pt{}_w'.format(i)\n params_true.update({pid: pt})\n params_init.update({pid: camera.triangulate(\n obs[0][i] + 10. * np.random.rand(3))})\n\nfor i, pose in enumerate(T_cam_w_GT):\n pid = 'T_cam{}_w'.format(i)\n params_true.update({pid: pose})\n params_init.update({pid: SE3.identity()})\n\nproblem.initialize_params(params_init)\nproblem.set_parameters_constant('T_cam0_w')\n\n# import ipdb\n# ipdb.set_trace()\nparams_final = problem.solve()\nprint(problem.summary(format='full'))\n\n# Compute errors\nprint(\"Initial Error:\")\nfor key in params_true.keys():\n p_est = params_init[key]\n p_true = params_true[key]\n\n if isinstance(p_est, SE3):\n err = SE3.log(p_est.inv().dot(p_true))\n else:\n err = p_est - p_true\n\n print('{}: {}'.format(key, err))\n\nprint()\n\nprint(\"Final Error:\")\nfor key in params_true.keys():\n p_est = params_final[key]\n p_true = params_true[key]\n\n if isinstance(p_est, SE3):\n err = SE3.log(p_est.inv().dot(p_true))\n else:\n err = p_est - p_true\n\n print('{}: {}'.format(key, err))\n" ]	[ [ "numpy.random.seed", "numpy.diagflat", "numpy.ones", "numpy.random.rand", "numpy.array" ] ]
wangvei/pydefect	[ "e909796c429e16982cefe549d16881039bce89e7" ]	[ "pydefect/cli/main_functions.py" ]	[ "# -- coding: utf-8 --\n\nimport os\nfrom copy import deepcopy\nfrom glob import glob\nfrom pathlib import Path\nfrom typing import Optional\n\nimport numpy as np\n\nfrom pydefect.analysis.defect import Defect\nfrom pydefect.analysis.defect_carrier_concentration import DefectConcentration\nfrom pydefect.analysis.defect_eigenvalues import DefectEigenvalue\nfrom pydefect.analysis.defect_energies import DefectEnergies\nfrom pydefect.analysis.defect_structure import (\n DefectStructure, defect_structure_matcher)\nfrom pydefect.core.complex_defects import ComplexDefects\nfrom pydefect.core.defect_entry import DefectEntry\nfrom pydefect.core.error_classes import StructureError\nfrom pydefect.core.interstitial_site import interstitials_from_charge_density\nfrom pydefect.input_maker.add_interstitials import add_interstitials\nfrom pydefect.core.supercell_calc_results import SupercellCalcResults\nfrom pydefect.core.unitcell_calc_results import UnitcellCalcResults\nfrom pydefect.corrections.corrections import ManualCorrection\nfrom pydefect.corrections.efnv_corrections import ExtendedFnvCorrection, Ewald\nfrom pydefect.corrections.vertical_transition_energy_correction import (\n VerticalTransitionEnergyCorrection)\nfrom pydefect.input_maker.defect_initial_setting import (\n dopant_info, DefectInitialSetting)\nfrom pydefect.input_maker.supercell_maker import Supercell, Supercells\nfrom pydefect.util.logger import get_logger\nfrom pydefect.cli.main_tools import (\n generate_objects_from_json_files)\n\nfrom pymatgen import Structure, Spin\n\nfrom vise.input_set.input_set import ViseInputSet\nfrom vise.cli.main_function import vasp_settings_from_args\nfrom vise.chempotdiag.chem_pot_diag import ChemPotDiag\n\n\nlogger = get_logger(__name__)\n\n\ndef unitcell_calc_results(args):\n if args.print:\n print(UnitcellCalcResults.load_json(filename=args.json_file))\n return\n\n try:\n dft_results = UnitcellCalcResults.load_json(filename=args.json_file)\n except IOError:\n dft_results = UnitcellCalcResults()\n\n if args.band_edge_dir:\n try:\n dft_results.set_band_edge_from_vasp(args.band_edge_dir,\n vasprun_name=args.vasprun,\n outcar_name=args.outcar)\n except IOError:\n raise FileNotFoundError(f\"{args.band_edge_dir} is not appropriate.\")\n\n if args.static_diele:\n dft_results.static_dielectric_tensor = args.static_diele\n elif args.static_diele_dir:\n try:\n dft_results.set_static_dielectric_tensor_from_vasp(\n args.static_diele_dir, outcar_name=args.outcar)\n except IOError:\n raise FileNotFoundError(\n args.static_diele_dir, \"is not appropriate.\")\n except AttributeError as e:\n logger.error(str(e))\n\n if args.ionic_diele:\n dft_results.ionic_dielectric_tensor = args.ionic_diele\n elif args.ionic_diele_dir:\n try:\n dft_results.set_ionic_dielectric_tensor_from_vasp(\n args.ionic_diele_dir, outcar_name=args.outcar)\n except IOError:\n raise FileNotFoundError(args.ionic_diele_dir, \"not appropriate.\")\n\n if args.total_dos_dir:\n try:\n dft_results.set_total_dos_and_volume_from_vasp(\n args.total_dos_dir, vasprun_name=args.vasprun)\n except IOError:\n raise FileNotFoundError(args.total_dos_dir, \"not appropriate.\")\n\n dft_results.to_json_file(args.json_file)\n print(UnitcellCalcResults.load_json(filename=args.json_file))\n\n\ndef initial_setting(args):\n if args.print_dopant:\n print(dopant_info(args.print_dopant))\n return\n\n structure = Structure.from_file(args.poscar)\n\n kwargs = {\"dopants\": args.dopants,\n \"is_antisite\": args.antisite,\n \"en_diff\": args.en_diff,\n \"included\": args.included,\n \"excluded\": args.excluded,\n \"displacement_distance\": args.displacement_distance,\n \"symprec\": args.symprec,\n \"angle_tolerance\": args.angle_tolerance,\n \"interstitial_sites\": args.interstitials,\n \"complex_defect_names\": args.complex_defect_names}\n\n if args.matrix:\n supercell = Supercell(structure=structure,\n trans_mat=args.matrix,\n check_unitcell=True,\n symprec=args.symprec,\n angle_tolerance=args.angle_tolerance)\n supercell.to(poscar=\"DPOSCAR\", uposcar=\"UPOSCAR\")\n\n defect_setting = \\\n DefectInitialSetting.from_basic_settings(\n structure=supercell.structure,\n transformation_matrix=supercell.trans_mat.tolist(),\n cell_multiplicity=supercell.multiplicity, kwargs)\n defect_setting.to()\n return\n\n supercells = Supercells(structure=structure,\n conventional_base=args.conventional_base,\n max_num_atoms=args.max_num_atoms,\n min_num_atoms=args.min_num_atoms,\n criterion=args.isotropy_criterion,\n rhombohedral_angle=args.rhombohedral_angle,\n symprec=args.symprec,\n angle_tolerance=args.angle_tolerance)\n\n if not supercells.supercells:\n logger.critical(\"Any supercell does not satisfy the criterion.\")\n return False\n\n unitcell = supercells.unitcell\n if unitcell != structure:\n logger.warning(\n \"Unitcell is different from input structure. See UPOSCAR.\")\n else:\n logger.info(\"Input structure is the primitive cell.\")\n\n supercells.to_uposcar(uposcar=\"UPOSCAR\")\n\n if not args.supercell_set:\n if args.most_isotropic:\n supercell = supercells.most_isotropic_supercell\n else:\n supercell = supercells.smallest_supercell\n\n supercell.to(\"DPOSCAR\")\n defect_setting = DefectInitialSetting.from_basic_settings(\n structure=supercell.structure,\n transformation_matrix=supercell.trans_mat.tolist(),\n cell_multiplicity=supercell.multiplicity,\n kwargs)\n defect_setting.to()\n\n else:\n logger.info(f\"Number of supercells: {len(supercells.supercells)}\")\n\n for supercell in supercells.supercells:\n # Suffix \"c\" means conventional cell, while \"p\" primitive cell.\n prefix = \"c\" if supercells.conventional_base else \"p\"\n isotropy, _ = supercell.isotropy\n if np.count_nonzero(supercell.trans_mat) == 3:\n mat = \"x\".join(\n [str(supercell.trans_mat[i][i]) for i in range(3)])\n name = f\"{prefix + mat}_{supercell.num_atoms}_{isotropy}\"\n else:\n name = f\"{prefix}_{supercell.num_atoms}_{isotropy}\"\n\n os.mkdir(name)\n p = Path(name)\n supercell.to(poscar=p / \"DPOSCAR\")\n defect_setting = \\\n DefectInitialSetting.from_basic_settings(\n structure=supercell.structure,\n transformation_matrix=supercell.trans_mat.tolist(),\n cell_multiplicity=supercell.multiplicity, *kwargs)\n defect_setting.to(p / \"defect.in\")\n\n\ndef interstitial(args):\n\n if args.chgcar:\n interstitials_from_charge_density(\n chgcar_filename=args.chgcar,\n interstitial_symprec=args.interstitial_symprec,\n angle_tolerance=args.angle_tolerance)\n else:\n add_interstitials(coords_in_unitcell=args.interstitial_coords,\n uposcar=args.uposcar,\n interstitials_yaml=args.yaml,\n vicinage_radius=args.radius,\n defect_symprec=args.defect_symprec,\n angle_tolerance=args.angle_tolerance)\n\n\ndef complex_defects(args):\n try:\n complex_defects_obj = ComplexDefects.from_files(args.dposcar, args.yaml)\n except FileNotFoundError:\n structure = Structure.from_file(args.dposcar)\n complex_defects_obj = ComplexDefects(structure=structure)\n\n if (args.inserted_elements and not args.inserted_coords) or \\\n (not args.inserted_elements and args.inserted_coords):\n raise ValueError(f\"For interstitial sites, both elements and \"\n f\"fractional coordinates need to be entered.\")\n elif args.inserted_elements and args.inserted_coords and \\\n len(args.inserted_elements) 3 != len(args.inserted_coords):\n raise ValueError(f\"The numbers of inserted elements \"\n f\"{args.inserted_elements} and coords \"\n f\"{args.inserted_coords} are inconsistent.\")\n\n inserted_elements = args.inserted_elements or []\n inserted_coords = args.inserted_coords or []\n inserted_atoms = []\n for i, e in enumerate(inserted_elements):\n coords = [inserted_coords[3 * i + j] for j in range(3)]\n inserted_atoms.append({\"element\": e, \"coords\": coords})\n\n # defect_initial_setting = \\\n # DefectInitialSetting.from_defect_in(poscar=args.dposcar,\n # defect_in_file=args.defect_in)\n\n complex_defects_obj.add_defect(\n removed_atom_indices=args.removed_atom_indices,\n inserted_atoms=inserted_atoms,\n name=args.name,\n extreme_charge_state=args.extreme_charge_state,\n annotation=args.annotation,\n symprec=args.defect_symprec,\n angle_tolerance=args.angle_tolerance)\n\n complex_defects_obj.site_set_to_yaml_file(yaml_filename=args.yaml)\n\n\ndef make_dir(dirname: str,\n vis: ViseInputSet,\n force_overwrite: bool,\n defect_entry_obj: Optional[DefectEntry],\n add_neighbor: bool = True) -> None:\n \"\"\"Helper function\"\"\"\n dirname = Path(dirname)\n if force_overwrite and dirname.exists():\n logger.critical(f\"{dirname} is being removed.\")\n dirname.rmdir()\n\n if dirname.exists():\n logger.warning(f\"{dirname} already exists, so nothing is done.\")\n else:\n logger.info(f\"{dirname} is being constructed.\")\n dirname.mkdir()\n vis.write_input(dirname)\n vis.to_json_file(Path(dirname) / \"vise.json\")\n\n if defect_entry_obj is None:\n return\n\n defect_entry_obj.to_json_file(dirname / \"defect_entry.json\")\n\n if add_neighbor and defect_entry_obj.neighboring_sites:\n poscar_name = dirname / \"POSCAR\"\n with open(poscar_name, \"r\") as f:\n lines = f.readlines()\n for index, line in enumerate(lines.copy()):\n if index - 8 in defect_entry_obj.neighboring_sites:\n lines[index] = line.strip() + \" Neighbor\\n\"\n\n with open(poscar_name, \"w\") as f:\n for line in lines:\n f.write(line)\n\n\ndef defect_vasp_set(args):\n\n user_incar_settings, vis_kwargs = vasp_settings_from_args(args)\n user_incar_settings[\"LWAVE\"] = args.wavecar\n vis_kwargs.update(\n {\"xc\": args.xc,\n \"task\": \"defect\",\n \"kpt_density\": args.kpt_density,\n \"kpt_mode\": \"manual_set\",\n \"only_even\": False,\n \"sort_structure\": False,\n \"standardize_structure\": False,\n })\n\n defect_initial_setting = DefectInitialSetting.from_defect_in(\n poscar=args.dposcar, defect_in_file=args.defect_in)\n\n defect_initial_setting.make_defect_set(\n keywords=args.keywords, specified_defects=args.specified_defects)\n\n if not args.specified_defects:\n perfect_incar_setting = deepcopy(user_incar_settings)\n vise_set = ViseInputSet.make_input(\n structure=defect_initial_setting.structure,\n user_incar_settings=perfect_incar_setting,\n vis_kwargs)\n\n make_dir(\"perfect\", vise_set, args.force_overwrite, None)\n\n # set ISPIN = 2 if \"ISPIN\" is not explicitly set.\n if args.spin_polarize and not hasattr(user_incar_settings, \"ISPIN\"):\n user_incar_settings[\"ISPIN\"] = 2\n\n for de in defect_initial_setting.defect_entries:\n defect_name = \"_\".join([de.name, str(de.charge)])\n vise_set = ViseInputSet.make_input(\n structure=de.perturbed_initial_structure,\n charge=de.charge,\n user_incar_settings=user_incar_settings,\n vis_kwargs)\n make_dir(defect_name, vise_set, args.force_overwrite, de)\n\n\ndef vertical_transition_input_maker(args):\n if abs(args.additional_charge) != 1:\n raise ValueError(f\"{args.additional_charge} is invalid.\")\n\n initial_dirname = Path(args.initial_dir_name)\n de_filename = initial_dirname / \"defect_entry.json\"\n de = DefectEntry.load_json(de_filename)\n src_filename = initial_dirname / \"dft_results.json\"\n src = SupercellCalcResults.load_json(src_filename)\n\n new_charge = de.charge + args.additional_charge\n vis = ViseInputSet.from_prev_calc(\n initial_dirname,\n user_incar_settings={\"NSW\": 0},\n parse_calc_results=False,\n contcar_filename=args.contcar,\n charge=new_charge)\n\n de.charge += args.additional_charge\n de.initial_structure = src.final_structure\n de.perturbed_initial_structure = src.final_structure\n de.initial_site_symmetry = src.site_symmetry\n # FIX MAGNETIZATION?\n new_dirname = initial_dirname / f\"add_charge_{args.additional_charge}\"\n make_dir(str(new_dirname), vis, force_overwrite=False, defect_entry_obj=de,\n add_neighbor=False)\n new_de_filename = new_dirname / \"defect_entry.json\"\n de.to_json_file(new_de_filename)\n\n\ndef defect_entry(args):\n if args.print:\n print(DefectEntry.load_json(args.json))\n elif args.make_defect_entry:\n defect_structure = Structure.from_file(args.defect_poscar)\n perfect_structure = Structure.from_file(args.perfect_poscar)\n\n defect_entry_from_yaml = DefectEntry.from_defect_structure(\n defect_structure=defect_structure,\n perfect_structure=perfect_structure,\n displacement_distance=args.displacement_distance,\n defect_name=args.defect_name)\n\n defect_entry_from_yaml.to_json_file(args.json)\n else:\n logger.critical(\"Set make_defect_entry or print option.\")\n\n\ndef supercell_calc_results(args):\n\n if args.print:\n print(SupercellCalcResults.load_json(args.json))\n return\n\n if args.defect_center:\n if len(args.defect_center) != 1 and len(args.defect_center) != 3:\n raise ValueError(\"Length of the defect center is neither 1 or 3\")\n results = SupercellCalcResults.load_json(args.json)\n results.defect_center = args.defect_center\n results.to_json_file(filename=args.json)\n return\n\n if args.dir_all:\n dirs = glob('[0-9]/')\n dirs.insert(0, \"perfect/\")\n else:\n dirs = args.dirs\n\n for d in dirs:\n if os.path.isdir(d):\n logger.info(f\"Parsing data in {d} ...\")\n\n if d in [\"perfect\", \"perfect/\"]:\n try:\n dft_results = SupercellCalcResults.from_vasp_files(\n directory_path=d,\n vasprun=args.vasprun,\n contcar=args.contcar,\n procar=args.procar,\n outcar=args.outcar)\n except IOError:\n raise IOError(\"Parsing data in perfect failed.\")\n else:\n try:\n de = DefectEntry.load_json(Path(d) / args.defect_entry_name)\n dft_results = SupercellCalcResults.from_vasp_files(\n directory_path=d,\n vasprun=args.vasprun,\n contcar=args.contcar,\n outcar=args.outcar,\n procar=args.procar,\n cutoff=args.cutoff,\n defect_entry=de,\n defect_symprec=args.defect_symprec,\n angle_tolerance=args.angle_tolerance)\n except IOError as e:\n logger.warning(f\"Parsing data in {d} failed.\")\n logger.warning(e)\n continue\n\n dft_results.to_json_file(filename=Path(d) / \"dft_results.json\")\n else:\n logger.warning(f\"{d} does not exist, so nothing is done.\")\n\n\ndef efnv_correction(args):\n if args.print:\n print(ExtendedFnvCorrection.load_json(args.json_file))\n return\n\n dirs = glob('[0-9]/') if args.dir_all else args.dirs\n\n if args.plot_potential:\n for directory in dirs:\n d = Path(directory)\n c = ExtendedFnvCorrection.load_json(d / \"correction.json\")\n c.plot_potential(d / \"potential.pdf\", args.y_range)\n return\n\n if args.nocorr:\n for directory in dirs:\n c = ManualCorrection(manual_correction_energy=args.manual)\n c.to_json_file(Path(directory) / \"correction.json\")\n return\n\n try:\n ucr = UnitcellCalcResults.load_json(args.unitcell_json)\n dielectric_tensor = ucr.total_dielectric_tensor\n except IOError:\n raise FileNotFoundError(\"JSON for the unitcell info is not found.\")\n\n try:\n perfect_dft_data = SupercellCalcResults.load_json(args.perfect_json)\n except IOError:\n raise FileNotFoundError(\"JSON for the perfect supercell is not found.\")\n\n # Ewald parameter related\n if not Path(args.ewald_json).is_file():\n logger.info(\"optimizing ewald...\")\n ewald = Ewald.from_optimization(\n structure=perfect_dft_data.final_structure,\n dielectric_tensor=dielectric_tensor,\n initial_ewald_param=args.ewald_initial_param,\n convergence=args.ewald_convergence,\n prod_cutoff_fwhm=args.ewald_accuracy)\n ewald.to_json_file(args.ewald_json)\n\n for directory in dirs:\n d = Path(directory)\n json_to_make = d / \"correction.json\"\n\n if json_to_make.exists() and not args.force_overwrite:\n logger.warning(f\"{json_to_make} already exists, so nothing done.\")\n continue\n\n logger.info(f\"correcting {directory} ...\")\n entry = DefectEntry.load_json(d / \"defect_entry.json\")\n try:\n defect_dft_data = \\\n SupercellCalcResults.load_json(d / \"dft_results.json\")\n except IOError:\n logger.warning(f\"dft_results.json in {directory} does not exist.\")\n continue\n\n c = ExtendedFnvCorrection. \\\n compute_correction(defect_entry=entry,\n defect_dft=defect_dft_data,\n perfect_dft=perfect_dft_data,\n dielectric_tensor=dielectric_tensor,\n defect_center=args.defect_center,\n ewald=args.ewald_json)\n\n c.plot_potential(d / \"potential.pdf\", args.y_range)\n c.to_json_file(d / \"correction.json\")\n\n\ndef vertical_transition_energy(args):\n\n initial_dir = Path(args.initial_dir)\n initial_calc_results = \\\n SupercellCalcResults.load_json(initial_dir / \"dft_results.json\")\n final_dir = Path(args.dir)\n final_calc_results = \\\n SupercellCalcResults.load_json(final_dir / \"dft_results.json\")\n unitcell = UnitcellCalcResults.load_json(args.unitcell_json)\n\n if args.print:\n vtec = VerticalTransitionEnergyCorrection.load_json(args.json)\n vtec.plot_potential()\n print(vtec)\n if vtec.additional_charge == 1:\n cbm = unitcell.band_edge[1]\n print(f\"CBM position (eV): {cbm}\")\n band_edge_related_energy = cbm\n\n else:\n vbm = unitcell.band_edge[0]\n print(f\"VBM position (eV): {vbm}\")\n band_edge_related_energy = -vbm\n\n vte_wo_corr = (final_calc_results.total_energy\n - initial_calc_results.total_energy\n + band_edge_related_energy)\n vte = vte_wo_corr + vtec.correction_energy\n print(f\"Vertical transition energy w/o correction (eV): {vte_wo_corr}\")\n print(f\"Vertical transition energy w/ correction (eV): {vte}\")\n return\n\n dielectric_tensor = unitcell.total_dielectric_tensor\n static_dielectric_tensor = unitcell.static_dielectric_tensor\n\n initial_efnv = \\\n ExtendedFnvCorrection.load_json(initial_dir / \"correction.json\")\n initial_calc_results = \\\n SupercellCalcResults.load_json(initial_dir / \"dft_results.json\")\n\n final_defect_entry = DefectEntry.load_json(final_dir / \"defect_entry.json\")\n\n c = VerticalTransitionEnergyCorrection.from_files(dielectric_tensor,\n static_dielectric_tensor,\n initial_efnv,\n initial_calc_results,\n final_defect_entry,\n final_calc_results)\n c.to_json_file(args.json)\n print(c)\n\n\ndef defects(args):\n\n if args.band_edge:\n if args.band_edge[0] == \"up\":\n spin = Spin.up\n elif args.band_edge[0] == \"down\":\n spin = Spin.down\n else:\n raise ValueError(\"band edge is inadequate (e.g. -be up no_in_gap).\")\n state = args.band_edge[1]\n defect = Defect.load_json(args.json)\n defect.set_band_edge_state(spin=spin, state=state)\n defect.to_json_file(args.json)\n return True\n\n try:\n perfect = SupercellCalcResults.load_json(args.perfect)\n except FileNotFoundError:\n print(f\"{args.perfect} not found.\")\n raise\n\n defects_dirs = args.defect_dirs or glob('[0-9]/')\n for d in defects_dirs:\n filename = os.path.join(d, args.json)\n if args.diagnose:\n print(d.rjust(12), end=\" \")\n try:\n print(Defect.load_json(filename).diagnose)\n except FileNotFoundError:\n logger.warning(\"No supercell results file.\")\n except Exception as e:\n logger.warning(f\"An error {e} is caught.\")\n continue\n\n logger.info(f\"parsing directory {d}...\")\n files = [args.defect_entry, args.dft_results, args.correction]\n classes = [DefectEntry, SupercellCalcResults, ExtendedFnvCorrection]\n input_objects = generate_objects_from_json_files(d, files, classes,\n raise_error=False)\n if input_objects:\n try:\n defect = Defect.from_objects(defect_entry=input_objects[0],\n dft_results=input_objects[1],\n perfect_dft_results=perfect,\n correction=input_objects[2])\n defect.to_json_file(filename)\n except StructureError:\n logger.warning(f\"defect.json is not generated in {d}.\")\n\n else:\n logger.warning(f\"Generating {filename} failed.\")\n continue\n\n\ndef plot_energy(args):\n\n if args.reload_defects:\n os.remove(args.energies)\n\n try:\n defect_energies = DefectEnergies.load_json(args.energies)\n except FileNotFoundError:\n unitcell = UnitcellCalcResults.load_json(args.unitcell)\n perfect = SupercellCalcResults.load_json(args.perfect)\n\n defects_dirs = args.defect_dirs or glob('[0-9]/')\n\n defect_list = []\n for d in defects_dirs:\n filename = Path(d) / 'defect.json'\n logger.info(f\"parsing directory {filename}...\")\n try:\n defect_list.append(Defect.load_json(filename))\n except FileNotFoundError:\n logger.warning(f\"Parsing {filename} failed.\")\n continue\n\n chem_pot = ChemPotDiag.load_json(args.chem_pot_json)\n\n # First construct DefectEnergies class object.\n defect_energies = \\\n DefectEnergies.from_objects(unitcell=unitcell,\n perfect=perfect,\n defects=defect_list,\n chem_pot=chem_pot,\n chem_pot_label=args.chem_pot_label,\n filtering_words=args.filtering,\n system=args.name)\n\n if args.print:\n print(defect_energies)\n return\n\n defect_energies.to_json_file(filename=args.energies)\n\n # if args.concentration:\n # defect_concentration = \\\n # DefectConcentration.from_defect_energies(\n # energies=energies,\n # temperature=args.temperature[0],\n # unitcell=unitcell,\n # num_sites_filename=args.num_site_file)\n\n # # if len(args.temperature) == 2:\n # defect_concentration = \\\n # DefectConcentration.from_defect_energies(\n # energies=energies,\n # temperature=args.temperature[1],\n # unitcell=unitcell,\n # num_sites_filename=args.num_site_file,\n # previous_concentration=defect_concentration)\n # else:\n# defect_concentration = None\n\n # plt = defect_energies.plot_energy(filtering_words=args.filtering,\n # x_range=args.x_range,\n # y_range=args.y_range,\n # show_transition_levels=args.show_tl,\n # show_all_energies=args.show_all)\n plt = defect_energies.plot_energy(\n x_range=args.x_range,\n y_range=args.y_range,\n show_transition_levels=args.show_transition_level,\n show_all_energies=args.show_all)\n\n if args.save_file:\n plt.savefig(args.save_file, format=\"pdf\", transparent=True)\n else:\n plt.show()\n\n\ndef parse_eigenvalues(args):\n unitcell = UnitcellCalcResults.load_json(args.unitcell)\n\n # TODO: Modify here to run w/o correction\n logger.info(f\"parsing directory {args.defect_dir}...\")\n defect = Defect.load_json(Path(args.defect_dir) / \"defect.json\")\n\n defect_eigenvalues = DefectEigenvalue.from_files(unitcell=unitcell,\n defect=defect)\n\n defect_eigenvalues.plot(y_range=args.y_range,\n title=args.title,\n filename=args.save_file)\n\n\ndef vasp_parchg_set(args):\n user_incar_settings = {\"LPARD\": True,\n \"LSEPB\": True,\n \"KPAR\": 1,\n \"IBAND\": args.band_indices}\n\n if args.kpoint_indices:\n user_incar_settings[\"KPUSE\"] = args.kpoint_indices\n\n vasp_set = ViseInputSet.from_prev_calc(\n dirname=args.read_dir,\n parse_calc_results=False,\n parse_incar=True,\n sort_structure=False,\n standardize_structure=False,\n files_to_transfer={\"WAVECAR\": \"L\"},\n user_incar_settings=user_incar_settings,\n contcar_filename=args.contcar)\n\n vasp_set.write_input(args.write_dir)\n\n\ndef local_structure(args):\n defects_dirs = args.defect_dirs or glob('[0-9]/')\n\n d_list = []\n for d in defects_dirs:\n filename = Path(d) / \"defect.json\"\n logger.info(f\"parsing directory {d}...\")\n try:\n defect = Defect.load_json(filename)\n d_list.append(defect)\n except FileNotFoundError:\n logger.warning(f\"Parsing {filename} failed.\")\n print(\"\")\n print(\"\")\n continue\n\n defect_structure = DefectStructure.from_defect(defect)\n print(\"-\" 82)\n print(defect_structure.show_displacements(all_atoms=args.show_all))\n print(\"\")\n print(\"\")\n\n if args.compare_structure:\n print(\"-\" * 82)\n print(defect_structure_matcher(d_list, args.site_tolerance))\n print(\"\")\n\n\ndef concentration(args):\n defect_energies = DefectEnergies.load_json(args.energies).defect_energies\n unitcell = UnitcellCalcResults.load_json(args.unitcell)\n\n defect_concentration = DefectConcentration.from_calc_results(\n defect_energies=defect_energies,\n unitcell=unitcell,\n round_magnetization=args.frac_mag_to_one)\n\n defect_concentration.calc_equilibrium_concentration(\n temperature=args.temperature, verbose=args.verbose)\n\n defect_concentration.calc_quenched_equilibrium_concentration(\n temperature=args.quenched_temperature,\n verbose=args.verbose)\n\n print(defect_concentration)\n defect_concentration.calc_concentrations(args.temperature)\n plt = defect_concentration.plot_carrier_concentrations()\n plt.show()\n\n" ]	[ [ "numpy.count_nonzero" ] ]
priikone/colour	[ "e9c8834178c14dd6d8d0d874191aada18929c211" ]	[ "colour/algebra/common.py" ]	[ "# -- coding: utf-8 --\n\"\"\"\nCommon Utilities\n================\n\nDefines common algebra utilities objects that don't fall in any specific\ncategory.\n\"\"\"\n\nimport functools\nimport numpy as np\n\nfrom colour.utilities import as_float_array, as_float, tsplit\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2021 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = '[email protected]'\n__status__ = 'Production'\n\n__all__ = [\n 'is_spow_enabled', 'set_spow_enable', 'spow_enable', 'spow',\n 'smoothstep_function', 'normalise_maximum', 'vector_dot', 'matrix_dot',\n 'linear_conversion', 'linstep_function', 'is_identity'\n]\n\n_SPOW_ENABLED = True\n\"\"\"\nGlobal variable storing the current Colour safe / symmetrical power function\nenabled state.\n\n_SPOW_ENABLED : bool\n\"\"\"\n\n\ndef is_spow_enabled():\n \"\"\"\n Returns whether Colour safe / symmetrical power function is enabled.\n\n Returns\n -------\n bool\n Whether Colour safe / symmetrical power function is enabled.\n\n Examples\n --------\n >>> with spow_enable(False):\n ... is_spow_enabled()\n False\n >>> with spow_enable(True):\n ... is_spow_enabled()\n True\n \"\"\"\n\n return _SPOW_ENABLED\n\n\ndef set_spow_enable(enable):\n \"\"\"\n Sets Colour safe / symmetrical power function enabled state.\n\n Parameters\n ----------\n enable : bool\n Whether to enable Colour safe / symmetrical power function.\n\n Examples\n --------\n >>> with spow_enable(is_spow_enabled()):\n ... print(is_spow_enabled())\n ... set_spow_enable(False)\n ... print(is_spow_enabled())\n True\n False\n \"\"\"\n\n global _SPOW_ENABLED\n\n _SPOW_ENABLED = enable\n\n\nclass spow_enable:\n \"\"\"\n A context manager and decorator temporarily setting Colour safe /\n symmetrical power function enabled state.\n\n Parameters\n ----------\n enable : bool\n Whether to enable or disable Colour safe / symmetrical power\n function.\n \"\"\"\n\n def __init__(self, enable):\n self._enable = enable\n self._previous_state = is_spow_enabled()\n\n def __enter__(self):\n \"\"\"\n Called upon entering the context manager and decorator.\n \"\"\"\n\n set_spow_enable(self._enable)\n\n return self\n\n def __exit__(self, args):\n \"\"\"\n Called upon exiting the context manager and decorator.\n \"\"\"\n\n set_spow_enable(self._previous_state)\n\n def __call__(self, function):\n \"\"\"\n Calls the wrapped definition.\n \"\"\"\n\n @functools.wraps(function)\n def wrapper(args, *kwargs):\n with self:\n return function(args, *kwargs)\n\n return wrapper\n\n\ndef spow(a, p):\n \"\"\"\n Raises given array :math:`a` to the power :math:`p` as follows:\n :math:`sign(a) \|a\|^p`.\n\n This definition avoids NaNs generation when array :math:`a` is negative and\n the power :math:`p` is fractional. This behaviour can be enabled or\n disabled with the :func:`colour.algebra.set_spow_enable` definition or with\n the :func:`spow_enable` context manager.\n\n Parameters\n ----------------\n a : numeric or array_like\n Array :math:`a`.\n p : numeric or array_like\n Power :math:`p`.\n\n Returns\n -------\n numeric or ndarray\n Array :math:`a` safely raised to the power :math:`p`.\n\n Examples\n --------\n >>> np.power(-2, 0.15)\n nan\n >>> spow(-2, 0.15) # doctest: +ELLIPSIS\n -1.1095694...\n >>> spow(0, 0)\n 0.0\n \"\"\"\n\n if not _SPOW_ENABLED:\n return np.power(a, p)\n\n a = np.atleast_1d(a)\n p = as_float_array(p)\n\n a_p = np.sign(a) * np.abs(a) ** p\n\n a_p[np.isnan(a_p)] = 0\n\n return as_float(a_p)\n\n\ndef normalise_maximum(a, axis=None, factor=1, clip=True):\n \"\"\"\n Normalises given array_like :math:`a` variable values by :math:`a`\n variable maximum value and optionally clip them between.\n\n Parameters\n ----------\n a : array_like\n :math:`a` variable to normalise.\n axis : numeric, optional\n Normalization axis.\n factor : numeric, optional\n Normalization factor.\n clip : bool, optional\n Clip values to domain [0, 'factor'].\n\n Returns\n -------\n ndarray\n Maximum normalised :math:`a` variable.\n\n Examples\n --------\n >>> a = np.array([0.48222001, 0.31654775, 0.22070353])\n >>> normalise_maximum(a) # doctest: +ELLIPSIS\n array([ 1. , 0.6564384..., 0.4576822...])\n \"\"\"\n\n a = as_float_array(a)\n\n maximum = np.max(a, axis=axis)\n a = a * (1 / maximum[..., np.newaxis]) * factor\n\n return np.clip(a, 0, factor) if clip else a\n\n\ndef vector_dot(m, v):\n \"\"\"\n Convenient wrapper around :func:`np.einsum` with the following subscripts:\n '...ij,...j->...i'.\n\n It performs the dot product of two arrays where m parameter is expected\n to be an array of 3x3 matrices and parameter v an array of vectors.\n\n Parameters\n ----------\n m : array_like\n Array of 3x3 matrices.\n v : array_like\n Array of vectors.\n\n Returns\n -------\n ndarray\n\n Examples\n --------\n >>> m = np.array(\n ... [[0.7328, 0.4296, -0.1624],\n ... [-0.7036, 1.6975, 0.0061],\n ... [0.0030, 0.0136, 0.9834]]\n ... )\n >>> m = np.reshape(np.tile(m, (6, 1)), (6, 3, 3))\n >>> v = np.array([0.20654008, 0.12197225, 0.05136952])\n >>> v = np.tile(v, (6, 1))\n >>> vector_dot(m, v) # doctest: +ELLIPSIS\n array([[ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...]])\n \"\"\"\n\n m = as_float_array(m)\n v = as_float_array(v)\n\n return np.einsum('...ij,...j->...i', m, v)\n\n\ndef matrix_dot(a, b):\n \"\"\"\n Convenient wrapper around :func:`np.einsum` with the following subscripts:\n '...ij,...jk->...ik'.\n\n It performs the dot product of two arrays where a parameter is expected\n to be an array of 3x3 matrices and parameter b another array of of 3x3\n matrices.\n\n Parameters\n ----------\n a : array_like\n Array of 3x3 matrices.\n b : array_like\n Array of 3x3 matrices.\n dtype : object\n Type to use for conversion, default to the type defined by the\n :attr:`colour.constant.DEFAULT_FLOAT_DTYPE` attribute.\n\n Returns\n -------\n ndarray\n\n Examples\n --------\n >>> a = np.array(\n ... [[0.7328, 0.4296, -0.1624],\n ... [-0.7036, 1.6975, 0.0061],\n ... [0.0030, 0.0136, 0.9834]]\n ... )\n >>> a = np.reshape(np.tile(a, (6, 1)), (6, 3, 3))\n >>> b = a\n >>> matrix_dot(a, b) # doctest: +ELLIPSIS\n array([[[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]]])\n \"\"\"\n\n a = as_float_array(a)\n b = as_float_array(b)\n\n return np.einsum('...ij,...jk->...ik', a, b)\n\n\ndef linear_conversion(a, old_range, new_range):\n \"\"\"\n Performs a simple linear conversion of given array between the old and new\n ranges.\n\n Parameters\n ----------\n a : array_like\n Array to perform the linear conversion onto.\n old_range : array_like\n Old range.\n new_range : array_like\n New range.\n\n Returns\n -------\n ndarray\n Linear conversion result.\n\n Examples\n --------\n >>> a = np.linspace(0, 1, 10)\n >>> linear_conversion(a, np.array([0, 1]), np.array([1, 10]))\n array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n \"\"\"\n\n a = as_float_array(a)\n\n in_min, in_max = tsplit(old_range)\n out_min, out_max = tsplit(new_range)\n\n return ((a - in_min) / (in_max - in_min)) * (out_max - out_min) + out_min\n\n\ndef linstep_function(x, a=0, b=1, clip=False):\n \"\"\"\n Performs a simple linear interpolation between given array :math:`a` and\n array :math:`b` using :math:`x` array.\n\n Parameters\n ----------\n x : array_like\n Array :math:`x` value to use to interpolate between array :math:`a` and\n array :math:`b`.\n a : array_like\n Array :math:`a`, the start of the range in which to interpolate.\n b : array_like\n Array :math:`b`, the end of the range in which to interpolate.\n clip : bool, optional\n Whether to clip the output values to range [a, b].\n\n Returns\n -------\n ndarray\n Linear interpolation result.\n\n Examples\n --------\n >>> a = 0\n >>> b = 2\n >>> linstep_function(0.5, a, b)\n 1.0\n \"\"\"\n\n x = as_float_array(x)\n a = as_float_array(a)\n b = as_float_array(b)\n\n y = (1 - x) * a + x * b\n\n return np.clip(y, a, b) if clip else y\n\n\nlerp = linstep_function\n\n\ndef smoothstep_function(x, a=0, b=1, clip=False):\n \"\"\"\n Evaluates the smoothstep sigmoid-like function on array :math:`x`.\n\n Parameters\n ----------\n x : numeric or array_like\n Array :math:`x`.\n a : numeric, optional\n Low input domain limit, i.e. the left edge.\n b : numeric, optional\n High input domain limit, i.e. the right edge.\n clip : bool, optional\n Whether to scale, bias and clip input values to domain [0, 1].\n\n Returns\n -------\n array_like\n Array :math:`x` after smoothstep sigmoid-like function evaluation.\n\n Examples\n --------\n >>> x = np.linspace(-2, 2, 5)\n >>> smoothstep_function(x, -2, 2, clip=True)\n array([ 0. , 0.15625, 0.5 , 0.84375, 1. ])\n \"\"\"\n\n x = as_float_array(x)\n\n i = np.clip((x - a) / (b - a), 0, 1) if clip else x\n\n return (i ** 2) * (3 - 2 * i)\n\n\nsmooth = smoothstep_function\n\n\ndef is_identity(a, n=3):\n \"\"\"\n Returns if :math:`a` array is an identity matrix.\n\n Parameters\n ----------\n a : array_like, (N)\n Variable :math:`a` to test.\n n : int, optional\n Matrix dimension.\n\n Returns\n -------\n bool\n Is identity matrix.\n\n Examples\n --------\n >>> is_identity(np.array([1, 0, 0, 0, 1, 0, 0, 0, 1]).reshape(3, 3))\n True\n >>> is_identity(np.array([1, 2, 0, 0, 1, 0, 0, 0, 1]).reshape(3, 3))\n False\n \"\"\"\n\n return np.array_equal(np.identity(n), a)\n" ]	[ [ "numpy.abs", "numpy.einsum", "numpy.power", "numpy.clip", "numpy.isnan", "numpy.atleast_1d", "numpy.max", "numpy.sign", "numpy.identity" ] ]
ztanml/ptpqp	[ "1438a919174b041fb5f36c30bc6825c3748d9a11" ]	[ "MELD/script.py" ]	[ "# -- coding: utf-8 --\n\"\"\"\nCreated on Thu Apr 14 20:24:06 2016\n\n@author: zhaoshiwen\n\"\"\"\n\nimport numpy as np\n\nimport MELD as MELD\nreload(MELD)\n\n\nn = 1000\nY = np.loadtxt('../data/CTp20Yn' + str(n) + '.txt')\n(p,n) = Y.shape\n\nYt = np.array([0]*p) \n# the type of the variables\n# 0: categorical\n# 1: non-categorical with non-restrictive mean\n# 2: non-categorical with positive mean\n\n\nk = 3 # the number of components\nS = 100 # maximum number of iterations\n\n\n# --------------------------------\n# --------------------------------\n# Parameter estimation using second moment matrices\n\n# create an object of MELD class\nmyMELD = MELD.MELD(Y,Yt,k)\n\n# calculate second moment matrices\nmyMELD.calM2()\nmyMELD.calM2_bar()\n\n# ------------- first stage\n# initialize weight matrices to identity\nmyMELD.initializeWeight_M2()\n\n# start to perform first stage estimation\nResult = myMELD.estimatePhiGrad_M2(S)\n\n# ------------- second stage\n# recalculate weight matrix\nmyMELD.updateWeight_M2()\n\n# start to perform second stage estimation\nResults = myMELD.estimatePhiGrad_M2(S,step = 0.1)\n\n# --------------------------------\n# --------------------------------\n# Parameter estimation using second moment matrices\n\n# create an object of MELD class\nmyMELD = MELD.MELD(Y,Yt,k)\n\n# calculate third moment tensors\nmyMELD.calM3()\nmyMELD.calM3_bar()\n\n# ------------ first stage\n# initialize weight matrices to identity\nmyMELD.initializeWeight_M3()\n\n# start to perform first stage estimation\nResult = myMELD.estimatePhiGrad_M2M3(S)\n\n# ------------ second stage\n# recalculate weight matrix\nmyMELD.updateWeight_M2()\nmyMELD.updateWeight_M3()\n\n# start to performo second stage estimation\nResults = myMELD.estimatePhiGrad_M2M3(S,step = 0.1)\n" ]	[ [ "numpy.array" ] ]
CosimoRulli/VMRProject_K_D	[ "3dc3f7276b7c9ad67404b2b10de4fc42dbffcaf8" ]	[ "lib/model/faster_rcnn/alexnet_caffe.py" ]	[ "import torch\nimport torch.nn as nn\n\n\nclass AlexNet_caffe(nn.Module):\n\n def __init__(self, num_classes=1000):\n super(AlexNet_caffe, self).__init__()\n self.features = nn.Sequential(\n nn.Conv2d(3, 96, kernel_size=11, stride=4),\n nn.ReLU(),\n nn.LocalResponseNorm(size=5, alpha=0.0001, beta=0.75, k=1),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n nn.Conv2d(96, 256, kernel_size=5, padding=2, groups=2),\n nn.ReLU(inplace=True),\n nn.LocalResponseNorm(size=5, alpha=0.0001, beta=0.75, k=1),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n nn.Conv2d(256, 384, kernel_size=3, padding=1),\n nn.ReLU(),\n nn.Conv2d(384, 384, kernel_size=3, padding=1, groups=2),\n nn.ReLU(),\n nn.Conv2d(384, 256, kernel_size=3, padding=1, groups=2),\n nn.ReLU(),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n )\n self.classifier = nn.Sequential(\n nn.Linear(256 * 6 * 6, 4096),\n nn.ReLU(),\n nn.Dropout(),\n nn.Linear(4096, 4096),\n nn.ReLU(),\n nn.Dropout(),\n nn.Linear(4096, num_classes),\n )\n\n def forward(self, x):\n x = self.features(x)\n x = x.view(x.size(0), 256 * 6 * 6)\n x = self.classifier(x)\n return x\n\n\ndef alexnet(pretrained=False, kwargs):\n r\"\"\"AlexNet model architecture from the\n `\"One weird trick...\" <https://arxiv.org/abs/1404.5997>`_ paper.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n \"\"\"\n model = AlexNet_caffe(kwargs)\n return model\n" ]	[ [ "torch.nn.Dropout", "torch.nn.LocalResponseNorm", "torch.nn.Conv2d", "torch.nn.MaxPool2d", "torch.nn.Linear", "torch.nn.ReLU" ] ]
felipeescallon/lux	[ "1dbbcb9967f0e7413675626ce080c1059e214e74" ]	[ "lux/executor/PandasExecutor.py" ]	[ "# Copyright 2019-2020 The Lux Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport pandas as pd\nfrom lux.vis.VisList import VisList\nfrom lux.vis.Vis import Vis\nfrom lux.core.frame import LuxDataFrame\nfrom lux.executor.Executor import Executor\nfrom lux.utils import utils\nfrom lux.utils.date_utils import is_datetime_series\nfrom lux.utils.utils import check_import_lux_widget, check_if_id_like, is_numeric_nan_column\nimport warnings\nimport lux\n\n\nclass PandasExecutor(Executor):\n \"\"\"\n Given a Vis objects with complete specifications, fetch and process data using Pandas dataframe operations.\n \"\"\"\n\n def __init__(self):\n self.name = \"PandasExecutor\"\n warnings.formatwarning = lux.warning_format\n\n def __repr__(self):\n return f\"<PandasExecutor>\"\n\n @staticmethod\n def execute_sampling(ldf: LuxDataFrame):\n # General Sampling for entire dataframe\n SAMPLE_FLAG = lux.config.sampling\n SAMPLE_START = lux.config.sampling_start\n SAMPLE_CAP = lux.config.sampling_cap\n SAMPLE_FRAC = 0.75\n\n if SAMPLE_FLAG and len(ldf) > SAMPLE_CAP:\n if ldf._sampled is None: # memoize unfiltered sample df\n ldf._sampled = ldf.sample(n=SAMPLE_CAP, random_state=1)\n ldf._message.add_unique(\n f\"Large dataframe detected: Lux is only visualizing a random sample capped at {SAMPLE_CAP} rows.\",\n priority=99,\n )\n elif SAMPLE_FLAG and len(ldf) > SAMPLE_START:\n if ldf._sampled is None: # memoize unfiltered sample df\n ldf._sampled = ldf.sample(frac=SAMPLE_FRAC, random_state=1)\n ldf._message.add_unique(\n f\"Large dataframe detected: Lux is only visualizing a random sample of {len(ldf._sampled)} rows.\",\n priority=99,\n )\n else:\n ldf._sampled = ldf\n\n @staticmethod\n def execute(vislist: VisList, ldf: LuxDataFrame):\n \"\"\"\n Given a VisList, fetch the data required to render the vis.\n 1) Apply filters\n 2) Retrieve relevant attribute\n 3) Perform vis-related processing (aggregation, binning)\n 4) return a DataFrame with relevant results\n\n Parameters\n ----------\n vislist: list[lux.Vis]\n vis list that contains lux.Vis objects for visualization.\n ldf : lux.core.frame\n LuxDataFrame with specified intent.\n\n Returns\n -------\n None\n \"\"\"\n PandasExecutor.execute_sampling(ldf)\n for vis in vislist:\n # The vis data starts off being original or sampled dataframe\n vis._vis_data = ldf._sampled\n filter_executed = PandasExecutor.execute_filter(vis)\n # Select relevant data based on attribute information\n attributes = set([])\n for clause in vis._inferred_intent:\n if clause.attribute != \"Record\":\n attributes.add(clause.attribute)\n # TODO: Add some type of cap size on Nrows ?\n vis._vis_data = vis.data[list(attributes)]\n\n if vis.mark == \"bar\" or vis.mark == \"line\" or vis.mark == \"geographical\":\n PandasExecutor.execute_aggregate(vis, isFiltered=filter_executed)\n elif vis.mark == \"histogram\":\n PandasExecutor.execute_binning(ldf, vis)\n elif vis.mark == \"scatter\":\n HBIN_START = 5000\n if lux.config.heatmap and len(ldf) > HBIN_START:\n vis._postbin = True\n ldf._message.add_unique(\n f\"Large scatterplots detected: Lux is automatically binning scatterplots to heatmaps.\",\n priority=98,\n )\n # vis._mark = \"heatmap\"\n # PandasExecutor.execute_2D_binning(vis) # Lazy Evaluation (Early pruning based on interestingness)\n vis.data.clear_intent() # Ensure that intent is not propogated to the vis data\n\n @staticmethod\n def execute_aggregate(vis: Vis, isFiltered=True):\n \"\"\"\n Aggregate data points on an axis for bar or line charts\n\n Parameters\n ----------\n vis: lux.Vis\n lux.Vis object that represents a visualization\n ldf : lux.core.frame\n LuxDataFrame with specified intent.\n\n Returns\n -------\n None\n \"\"\"\n import numpy as np\n\n x_attr = vis.get_attr_by_channel(\"x\")[0]\n y_attr = vis.get_attr_by_channel(\"y\")[0]\n has_color = False\n groupby_attr = \"\"\n measure_attr = \"\"\n attr_unique_vals = []\n if x_attr.aggregation is None or y_attr.aggregation is None:\n return\n if y_attr.aggregation != \"\":\n groupby_attr = x_attr\n measure_attr = y_attr\n agg_func = y_attr.aggregation\n if x_attr.aggregation != \"\":\n groupby_attr = y_attr\n measure_attr = x_attr\n agg_func = x_attr.aggregation\n if groupby_attr.attribute in vis.data.unique_values.keys():\n attr_unique_vals = vis.data.unique_values.get(groupby_attr.attribute)\n # checks if color is specified in the Vis\n if len(vis.get_attr_by_channel(\"color\")) == 1:\n color_attr = vis.get_attr_by_channel(\"color\")[0]\n color_attr_vals = vis.data.unique_values[color_attr.attribute]\n color_cardinality = len(color_attr_vals)\n # NOTE: might want to have a check somewhere to not use categorical variables with greater than some number of categories as a Color variable----------------\n has_color = True\n else:\n color_cardinality = 1\n if measure_attr != \"\":\n if measure_attr.attribute == \"Record\":\n # need to get the index name so that we can rename the index column to \"Record\"\n # if there is no index, default to \"index\"\n index_name = vis.data.index.name\n if index_name == None:\n index_name = \"index\"\n\n vis._vis_data = vis.data.reset_index()\n # if color is specified, need to group by groupby_attr and color_attr\n\n if has_color:\n vis._vis_data = (\n vis.data.groupby(\n [groupby_attr.attribute, color_attr.attribute], dropna=False, history=False\n )\n .count()\n .reset_index()\n .rename(columns={index_name: \"Record\"})\n )\n vis._vis_data = vis.data[[groupby_attr.attribute, color_attr.attribute, \"Record\"]]\n else:\n vis._vis_data = (\n vis.data.groupby(groupby_attr.attribute, dropna=False, history=False)\n .count()\n .reset_index()\n .rename(columns={index_name: \"Record\"})\n )\n vis._vis_data = vis.data[[groupby_attr.attribute, \"Record\"]]\n else:\n # if color is specified, need to group by groupby_attr and color_attr\n if has_color:\n groupby_result = vis.data.groupby(\n [groupby_attr.attribute, color_attr.attribute], dropna=False, history=False\n )\n else:\n groupby_result = vis.data.groupby(\n groupby_attr.attribute, dropna=False, history=False\n )\n groupby_result = groupby_result.agg(agg_func)\n intermediate = groupby_result.reset_index()\n vis._vis_data = intermediate.__finalize__(vis.data)\n result_vals = list(vis.data[groupby_attr.attribute])\n # create existing group by attribute combinations if color is specified\n # this is needed to check what combinations of group_by_attr and color_attr values have a non-zero number of elements in them\n if has_color:\n res_color_combi_vals = []\n result_color_vals = list(vis.data[color_attr.attribute])\n for i in range(0, len(result_vals)):\n res_color_combi_vals.append([result_vals[i], result_color_vals[i]])\n # For filtered aggregation that have missing groupby-attribute values, set these aggregated value as 0, since no datapoints\n if isFiltered or has_color and attr_unique_vals:\n N_unique_vals = len(attr_unique_vals)\n if len(result_vals) != N_unique_vals * color_cardinality:\n columns = vis.data.columns\n if has_color:\n df = pd.DataFrame(\n {\n columns[0]: attr_unique_vals * color_cardinality,\n columns[1]: pd.Series(color_attr_vals).repeat(N_unique_vals),\n }\n )\n vis._vis_data = vis.data.merge(\n df,\n on=[columns[0], columns[1]],\n how=\"right\",\n suffixes=[\"\", \"_right\"],\n )\n for col in columns[2:]:\n vis.data[col] = vis.data[col].fillna(0) # Triggers __setitem__\n assert len(list(vis.data[groupby_attr.attribute])) == N_unique_vals * len(\n color_attr_vals\n ), f\"Aggregated data missing values compared to original range of values of `{groupby_attr.attribute, color_attr.attribute}`.\"\n\n # Keep only the three relevant columns not the *_right columns resulting from merge\n vis._vis_data = vis.data.iloc[:, :3]\n\n else:\n df = pd.DataFrame({columns[0]: attr_unique_vals})\n\n vis._vis_data = vis.data.merge(\n df, on=columns[0], how=\"right\", suffixes=[\"\", \"_right\"]\n )\n\n for col in columns[1:]:\n vis.data[col] = vis.data[col].fillna(0)\n assert (\n len(list(vis.data[groupby_attr.attribute])) == N_unique_vals\n ), f\"Aggregated data missing values compared to original range of values of `{groupby_attr.attribute}`.\"\n\n vis._vis_data = vis._vis_data.dropna(subset=[measure_attr.attribute])\n try:\n vis._vis_data = vis._vis_data.sort_values(by=groupby_attr.attribute, ascending=True)\n except TypeError:\n warnings.warn(\n f\"\\nLux detects that the attribute '{groupby_attr.attribute}' maybe contain mixed type.\"\n + f\"\\nTo visualize this attribute, you may want to convert the '{groupby_attr.attribute}' into a uniform type as follows:\"\n + f\"\\n\\tdf['{groupby_attr.attribute}'] = df['{groupby_attr.attribute}'].astype(str)\"\n )\n vis._vis_data[groupby_attr.attribute] = vis._vis_data[groupby_attr.attribute].astype(str)\n vis._vis_data = vis._vis_data.sort_values(by=groupby_attr.attribute, ascending=True)\n vis._vis_data = vis._vis_data.reset_index()\n vis._vis_data = vis._vis_data.drop(columns=\"index\")\n\n @staticmethod\n def execute_binning(ldf, vis: Vis):\n \"\"\"\n Binning of data points for generating histograms\n\n Parameters\n ----------\n vis: lux.Vis\n lux.Vis object that represents a visualization\n ldf : lux.core.frame\n LuxDataFrame with specified intent.\n\n Returns\n -------\n None\n \"\"\"\n import numpy as np\n\n bin_attribute = list(filter(lambda x: x.bin_size != 0, vis._inferred_intent))[0]\n bin_attr = bin_attribute.attribute\n series = vis.data[bin_attr]\n\n if series.hasnans:\n ldf._message.add_unique(\n f\"The column <code>{bin_attr}</code> contains missing values, not shown in the displayed histogram.\",\n priority=100,\n )\n series = series.dropna()\n if pd.api.types.is_object_dtype(series):\n series = series.astype(\"float\", errors=\"ignore\")\n\n counts, bin_edges = np.histogram(series, bins=bin_attribute.bin_size)\n # bin_edges of size N+1, so need to compute bin_start as the bin location\n bin_start = bin_edges[0:-1]\n binned_result = np.array([bin_start, counts]).T\n vis._vis_data = pd.DataFrame(binned_result, columns=[bin_attr, \"Number of Records\"])\n\n @staticmethod\n def execute_filter(vis: Vis):\n assert (\n vis.data is not None\n ), \"execute_filter assumes input vis.data is populated (if not, populate with LuxDataFrame values)\"\n filters = utils.get_filter_specs(vis._inferred_intent)\n\n if filters:\n # TODO: Need to handle OR logic\n for filter in filters:\n vis._vis_data = PandasExecutor.apply_filter(\n vis.data, filter.attribute, filter.filter_op, filter.value\n )\n return True\n else:\n return False\n\n @staticmethod\n def apply_filter(df: pd.DataFrame, attribute: str, op: str, val: object) -> pd.DataFrame:\n \"\"\"\n Helper function for applying filter to a dataframe\n\n Parameters\n ----------\n df : pandas.DataFrame\n Dataframe to filter on\n attribute : str\n Filter attribute\n op : str\n Filter operation, '=', '<', '>', '<=', '>=', '!='\n val : object\n Filter value\n\n Returns\n -------\n df: pandas.DataFrame\n Dataframe resulting from the filter operation\n \"\"\"\n # Handling NaN filter values\n if utils.like_nan(val):\n if op != \"=\" and op != \"!=\":\n warnings.warn(\"Filter on NaN must be used with equality operations (i.e., `=` or `!=`)\")\n else:\n if op == \"=\":\n return df[df[attribute].isna()]\n elif op == \"!=\":\n return df[~df[attribute].isna()]\n # Applying filter in regular, non-NaN cases\n if op == \"=\":\n return df[df[attribute] == val]\n elif op == \"<\":\n return df[df[attribute] < val]\n elif op == \">\":\n return df[df[attribute] > val]\n elif op == \"<=\":\n return df[df[attribute] <= val]\n elif op == \">=\":\n return df[df[attribute] >= val]\n elif op == \"!=\":\n return df[df[attribute] != val]\n return df\n\n @staticmethod\n def execute_2D_binning(vis: Vis):\n pd.reset_option(\"mode.chained_assignment\")\n with pd.option_context(\"mode.chained_assignment\", None):\n x_attr = vis.get_attr_by_channel(\"x\")[0].attribute\n y_attr = vis.get_attr_by_channel(\"y\")[0].attribute\n\n vis._vis_data[\"xBin\"] = pd.cut(vis._vis_data[x_attr], bins=lux.config.heatmap_bin_size)\n vis._vis_data[\"yBin\"] = pd.cut(vis._vis_data[y_attr], bins=lux.config.heatmap_bin_size)\n\n color_attr = vis.get_attr_by_channel(\"color\")\n if len(color_attr) > 0:\n color_attr = color_attr[0]\n groups = vis._vis_data.groupby([\"xBin\", \"yBin\"], history=False)[color_attr.attribute]\n if color_attr.data_type == \"nominal\":\n # Compute mode and count. Mode aggregates each cell by taking the majority vote for the category variable. In cases where there is ties across categories, pick the first item (.iat[0])\n result = groups.agg(\n [\n (\"count\", \"count\"),\n (color_attr.attribute, lambda x: pd.Series.mode(x).iat[0]),\n ]\n ).reset_index()\n elif color_attr.data_type == \"quantitative\" or color_attr.data_type == \"temporal\":\n # Compute the average of all values in the bin\n result = groups.agg(\n [(\"count\", \"count\"), (color_attr.attribute, \"mean\")]\n ).reset_index()\n result = result.dropna()\n else:\n groups = vis._vis_data.groupby([\"xBin\", \"yBin\"], history=False)[x_attr]\n result = groups.count().reset_index(name=x_attr)\n result = result.rename(columns={x_attr: \"count\"})\n result = result[result[\"count\"] != 0]\n\n # convert type to facilitate weighted correlation interestingess calculation\n result[\"xBinStart\"] = result[\"xBin\"].apply(lambda x: x.left).astype(\"float\")\n result[\"xBinEnd\"] = result[\"xBin\"].apply(lambda x: x.right)\n\n result[\"yBinStart\"] = result[\"yBin\"].apply(lambda x: x.left).astype(\"float\")\n result[\"yBinEnd\"] = result[\"yBin\"].apply(lambda x: x.right)\n\n vis._vis_data = result.drop(columns=[\"xBin\", \"yBin\"])\n\n #######################################################\n ############ Metadata: data type, model #############\n #######################################################\n def compute_dataset_metadata(self, ldf: LuxDataFrame):\n ldf._data_type = {}\n self.compute_data_type(ldf)\n\n def compute_data_type(self, ldf: LuxDataFrame):\n from pandas.api.types import is_datetime64_any_dtype as is_datetime\n\n for attr in list(ldf.columns):\n if attr in ldf._type_override:\n ldf._data_type[attr] = ldf._type_override[attr]\n else:\n temporal_var_list = [\"month\", \"year\", \"day\", \"date\", \"time\", \"weekday\"]\n if is_datetime(ldf[attr]):\n ldf._data_type[attr] = \"temporal\"\n elif self._is_datetime_string(ldf[attr]):\n ldf._data_type[attr] = \"temporal\"\n elif isinstance(attr, pd._libs.tslibs.timestamps.Timestamp):\n ldf._data_type[attr] = \"temporal\"\n elif str(attr).lower() in temporal_var_list:\n ldf._data_type[attr] = \"temporal\"\n elif self._is_datetime_number(ldf[attr]):\n ldf._data_type[attr] = \"temporal\"\n elif self._is_geographical_attribute(ldf[attr]):\n ldf._data_type[attr] = \"geographical\"\n elif pd.api.types.is_float_dtype(ldf.dtypes[attr]):\n\n if ldf.cardinality[attr] != len(ldf) and (ldf.cardinality[attr] < 20):\n ldf._data_type[attr] = \"nominal\"\n else:\n ldf._data_type[attr] = \"quantitative\"\n elif pd.api.types.is_integer_dtype(ldf.dtypes[attr]):\n # See if integer value is quantitative or nominal by checking if the ratio of cardinality/data size is less than 0.4 and if there are less than 10 unique values\n if ldf.pre_aggregated:\n if ldf.cardinality[attr] == len(ldf):\n ldf._data_type[attr] = \"nominal\"\n if ldf.cardinality[attr] / len(ldf) < 0.4 and ldf.cardinality[attr] < 20:\n ldf._data_type[attr] = \"nominal\"\n else:\n ldf._data_type[attr] = \"quantitative\"\n if check_if_id_like(ldf, attr):\n ldf._data_type[attr] = \"id\"\n # Eliminate this clause because a single NaN value can cause the dtype to be object\n elif pd.api.types.is_string_dtype(ldf.dtypes[attr]):\n # Check first if it's castable to float after removing NaN\n is_numeric_nan, series = is_numeric_nan_column(ldf[attr])\n if is_numeric_nan:\n # int columns gets coerced into floats if contain NaN\n ldf._data_type[attr] = \"quantitative\"\n # min max was not computed since object type, so recompute here\n ldf._min_max[attr] = (\n series.min(),\n series.max(),\n )\n elif check_if_id_like(ldf, attr):\n ldf._data_type[attr] = \"id\"\n else:\n ldf._data_type[attr] = \"nominal\"\n # check if attribute is any type of datetime dtype\n elif is_datetime_series(ldf.dtypes[attr]):\n ldf._data_type[attr] = \"temporal\"\n else:\n ldf._data_type[attr] = \"nominal\"\n if not pd.api.types.is_integer_dtype(ldf.index) and ldf.index.name:\n ldf._data_type[ldf.index.name] = \"nominal\"\n\n non_datetime_attrs = []\n for attr in ldf.columns:\n if ldf._data_type[attr] == \"temporal\" and not is_datetime(ldf[attr]):\n non_datetime_attrs.append(attr)\n warn_msg = \"\"\n if len(non_datetime_attrs) == 1:\n warn_msg += f\"\\nLux detects that the attribute '{non_datetime_attrs[0]}' may be temporal.\\n\"\n elif len(non_datetime_attrs) > 1:\n warn_msg += f\"\\nLux detects that attributes {non_datetime_attrs} may be temporal.\\n\"\n if len(non_datetime_attrs) > 0:\n warn_msg += \"To display visualizations for these attributes accurately, please convert temporal attributes to Pandas Datetime objects using the pd.to_datetime function and provide a 'format' parameter to specify the datetime format of the attribute.\\nFor example, you can convert a year-only attribute (e.g., 1998, 1971, 1982) to Datetime type by specifying the `format` as '%Y'.\\n\\nHere is a starter template that you can use for converting the temporal fields:\\n\"\n for attr in non_datetime_attrs:\n warn_msg += f\"\\tdf['{attr}'] = pd.to_datetime(df['{attr}'], format='<replace-with-datetime-format>')\\n\"\n warn_msg += \"\\nSee more at: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html\"\n warn_msg += f\"\\nIf {attr} is not a temporal attribute, please use override Lux's automatically detected type:\"\n warn_msg += f\"\\n\\tdf.set_data_type({{'{attr}':'quantitative'}})\"\n warnings.warn(warn_msg, stacklevel=2)\n\n @staticmethod\n def _is_datetime_string(series):\n if series.dtype == object:\n not_numeric = False\n try:\n pd.to_numeric(series)\n except Exception as e:\n not_numeric = True\n\n datetime_col = None\n if not_numeric:\n try:\n datetime_col = pd.to_datetime(series)\n except Exception as e:\n return False\n if datetime_col is not None:\n return True\n return False\n\n @staticmethod\n def _is_geographical_attribute(series):\n # run detection algorithm\n name = str(series.name).lower()\n return utils.like_geo(name)\n\n @staticmethod\n def _is_datetime_number(series):\n is_int_dtype = pd.api.types.is_integer_dtype(series.dtype)\n if is_int_dtype:\n try:\n temp = series.astype(str)\n pd.to_datetime(temp)\n return True\n except Exception:\n return False\n return False\n\n def compute_stats(self, ldf: LuxDataFrame):\n # precompute statistics\n ldf.unique_values = {}\n ldf._min_max = {}\n ldf.cardinality = {}\n ldf._length = len(ldf)\n\n for attribute in ldf.columns:\n\n if isinstance(attribute, pd._libs.tslibs.timestamps.Timestamp):\n # If timestamp, make the dictionary keys the _repr_ (e.g., TimeStamp('2020-04-05 00.000')--> '2020-04-05')\n attribute_repr = str(attribute._date_repr)\n else:\n attribute_repr = attribute\n\n ldf.unique_values[attribute_repr] = list(ldf[attribute].unique())\n ldf.cardinality[attribute_repr] = len(ldf.unique_values[attribute_repr])\n\n if pd.api.types.is_float_dtype(ldf.dtypes[attribute]) or pd.api.types.is_integer_dtype(\n ldf.dtypes[attribute]\n ):\n ldf._min_max[attribute_repr] = (\n ldf[attribute].min(),\n ldf[attribute].max(),\n )\n\n if not pd.api.types.is_integer_dtype(ldf.index):\n index_column_name = ldf.index.name\n ldf.unique_values[index_column_name] = list(ldf.index)\n ldf.cardinality[index_column_name] = len(ldf.index)\n" ]	[ [ "pandas.reset_option", "pandas.to_numeric", "pandas.api.types.is_object_dtype", "pandas.to_datetime", "pandas.api.types.is_float_dtype", "pandas.Series", "pandas.api.types.is_datetime64_any_dtype", "pandas.option_context", "pandas.DataFrame", "pandas.Series.mode", "pandas.cut", "pandas.api.types.is_integer_dtype", "pandas.api.types.is_string_dtype", "numpy.array", "numpy.histogram" ] ]
Anomaly-Detection-Research/arma-arima	[ "c5e025641aca41f6b47f9df01573ef956fb8d5df" ]	[ "python_scripts/ARIMA.py" ]	[ "import warnings\nimport itertools\nimport pandas\nimport math\nimport sys\nimport numpy as np\nfrom plotly.offline import download_plotlyjs, init_notebook_mode, plot\n# init_notebook_mode(connected=True)\n\n# dataframe = pandas.read_csv('./data/realTraffic/speed_6005.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/speed_7578.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/speed_t4013.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/TravelTime_387.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/TravelTime_451.csv')\ndataframe = pandas.read_csv('../data/international-airline-passengers.csv')\ntime = dataframe[list(dataframe)[0]]\nvalues = dataframe[list(dataframe)[1]]\ntraining_ratio = 0.5\nvalidation_ratio = 0.5\n\n# Deviding the data set to training, validation, testing parts\ntraining_end = int(math.floor(len(values)training_ratio))\ntraining_set_values = np.array(values[0:training_end])\ntraining_set_time = np.array(time[0:training_end])\n\nvalidation_start = training_end + 1\nvalidation_end = validation_start + int(math.floor(len(values)(1-training_ratio)validation_ratio))\nvalidation_set_values = np.array(values[validation_start:validation_end])\nvalidation_set_time = np.array(time[validation_start:validation_end])\n\ntesting_start = validation_end + 1\ntesting_end = len(values)\ntesting_set_values = np.array(values[testing_start:testing_end])\ntesting_set_time = np.array(time[testing_start:testing_end])\n\nclass ARIMA:\n def __init__(self, p,d,q):\n self.p = p\n self.d = d\n self.q = q\n \n # Setters\n def set_p(self,p):\n self.p=p \n \n def set_d(self,d):\n self.d=d\n \n def set_q(self,q):\n self.q=q\n \n def set_training_data_time(self, time):\n self.training_data_time = time\n \n def set_validation_data_time(self, time):\n self.validation_data_time = time\n \n def set_testing_data_time(self, time):\n self.testing_data_time = time\n \n def set_validation_data_set(self,data):\n self.validation_data_set = data\n \n def set_testing_data_set(self,data):\n self.testing_data_set = data\n \n def set_training_data_set(self,data):\n self.training_data = data\n data.shape = (max(data.shape),1)\n data = self.get_differance(data, self.d)\n self.Z = data - np.mean(data)\n self.Z.shape = (len(data),1)\n \n # Model\n def shock(self,mean,std):\n if std != std:\n return np.random.normal(mean, 0.001, 1)\n return np.random.normal(mean, std, 1)\n# return 0\n \n def get_differance(self,data_set,d):\n if d == 0:\n return data_set\n else:\n differance = np.zeros(len(data_set)-1)\n for i in range(0,len(data_set)-1):\n differance[i] = data_set[i]-data_set[i+1]\n return self.get_differance(differance,d-1)\n \n def plot_differance(self,data_set,d):\n differance = self.get_differance(data_set,d)\n x = np.arange(len(data_set))\n trace = {\"x\": x,\n \"y\": differance,\n \"mode\": 'lines',\n \"name\": 'value'}\n traces = [trace]\n layout = dict(title = \"Differance with d = \"+str(d),\n xaxis = dict(title = 'X'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n return differance\n \n def calculate_AR_normal_matrix_x_row(self,data,t,mean,std):\n row = np.zeros((1,self.p+1))\n j = 0\n for i in range(t-self.p,t):\n if i < 0:\n row[0][j] = 0\n else:\n row[0][j] = data[i]\n j+=1\n row[0][-1] = self.shock(mean,std)\n return row\n \n def calculate_AR_weights(self):\n self.training_data.shape = (max(self.training_data.shape),1)\n differance = self.get_differance(self.training_data, self.d)\n normal_matrix = np.zeros((len(differance),self.p+1))\n mean = np.mean(self.Z)\n std = np.std(self.Z, ddof=1)\n for i in range(0,len(differance)):\n normal_matrix[i] = self.calculate_AR_normal_matrix_x_row(self.Z,i,mean,std)\n \n normal_matrix_tanspose = normal_matrix.transpose()\n self.AR_weights = np.dot(np.dot(np.linalg.pinv(np.dot(normal_matrix_tanspose,normal_matrix)),normal_matrix_tanspose),self.Z)\n\n \n def get_AR_prediction(self,data_set):\n self.calculate_AR_weights()\n self.AR_prediction = np.zeros((np.max(data_set.shape),1))\n mean = np.mean(data_set)\n std = np.std(data_set, ddof=1)\n Z = np.array(data_set)\n Z.shape = (np.max(Z.shape),1)\n Z = Z - mean\n for i in range(0,np.max(Z.shape)):\n self.AR_prediction[i] = np.dot(self.calculate_AR_normal_matrix_x_row(Z, i, mean, std), self.AR_weights)\n \n self.AR_prediction = self.AR_prediction.transpose()[0] + mean\n return self.AR_prediction\n \n def get_previous_q_values(self,data,t):\n previous_q = np.zeros(self.q)\n j = 0\n for i in range(t-self.q,t):\n if i < 0:\n previous_q[j] = 0\n else:\n previous_q[j] = data[i]\n j+=1\n return previous_q\n \n def get_MA_prediction(self,data_set):\n self.MA_prediction = np.zeros(np.max(data_set.shape))\n Z = np.array(data_set)\n Z.shape = (np.max(Z.shape),1)\n for i in range(0,np.max(Z.shape)):\n self.MA_prediction[i] = np.average(self.get_previous_q_values(Z, i))\n \n return self.MA_prediction\n \n def calculate_AR_MA_normal_matrix_x_row(self,t):\n row = np.zeros((1,2))\n row[0][0] = self.MA_prediction[t]\n row[0][1] = self.AR_prediction[t]\n return row\n \n def calculate_AR_MA_weights(self):\n self.training_data.shape = (max(self.training_data.shape),1)\n differance = self.get_differance(self.training_data, self.d)\n self.get_MA_prediction(differance)\n self.get_AR_prediction(differance)\n normal_matrix = np.zeros((len(differance),2))\n \n for i in range(0,len(differance)):\n normal_matrix[i] = self.calculate_AR_MA_normal_matrix_x_row(i)\n \n normal_matrix_tanspose = normal_matrix.transpose()\n self.weights = np.dot(np.dot(np.linalg.pinv(np.dot(normal_matrix_tanspose,normal_matrix)),normal_matrix_tanspose),differance)\n \n# print(self.weights)\n# #normalizing weigts\n# total = self.weights[0] + self.weights[1]\n# self.weights[0] = self.weights[0]/total\n# self.weights[1] = self.weights[1]/total\n# print(self.weights)\n \n def get_prediction(self, data_set):\n data_set.shape = (max(data_set.shape),1)\n differance = self.get_differance(data_set,self.d)\n self.calculate_AR_MA_weights()\n self.get_MA_prediction(differance)\n self.get_AR_prediction(differance)\n Z = np.array(differance)\n Z.shape = (np.max(Z.shape),1)\n self.prediction = np.zeros((np.max(Z.shape),1))\n for i in range(0,np.max(Z.shape)):\n self.prediction[i] = np.dot(self.calculate_AR_MA_normal_matrix_x_row(i), self.weights)\n \n self.prediction = self.prediction.transpose()[0]\n return self.prediction\n \n # Diagnostics and identification messures\n def mse(self,values,pridicted):\n error = 0.0\n for i in range(0,len(values)):\n error += (values[i] - pridicted[i])2\n return error/len(values)\n \n def get_mse(self, data, prediction):\n return self.mse(data,prediction)\n \n def plot_autocorrelation(self, data_set, lag):\n autocorrelations = np.zeros(lag)\n autocorrelations_x = np.arange(lag)\n autocorrelations[0] = 1.0\n for i in range(1,lag):\n autocorrelations[i] = np.corrcoef(data_set[i:],data_set[:-i])[0,1]\n \n trace = {\"x\": autocorrelations_x,\n \"y\": autocorrelations,\n 'type': 'bar',\n \"name\": 'Autocorrelation', \n }\n \n traces = [trace]\n layout = dict(title = \"Autocorrelation\",\n xaxis = dict(title = 'Lag'),\n yaxis = dict(title = 'Autocorrelation')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n def plot_partial_autocorrelation(self, data_set, lag):\n pac = np.zeros(lag)\n pac_x = np.arange(lag)\n \n residualts = data_set\n slope, intercept = np.polyfit(data_set,residualts,1)\n estimate = intercept + slopedata_set\n residualts = residualts - estimate\n pac[0] = 1\n for i in range(1,lag):\n pac[i] = np.corrcoef(data_set[:-i],residualts[i:])[0,1]\n \n slope, intercept = np.polyfit(data_set[:-i],residualts[i:],1)\n estimate = intercept + slopedata_set[:-i]\n \n residualts[i:] = residualts[i:] - estimate\n \n trace = {\"x\": pac_x,\n \"y\": pac,\n 'type': 'bar',\n \"name\": 'Partial Autocorrelation', \n }\n\n traces = [trace]\n layout = dict(title = \"Partial Autocorrelation\",\n xaxis = dict(title = 'Lag'),\n yaxis = dict(title = 'Partial Autocorrelation')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n def plot_residuals(self, data_set, prediction):\n x = np.arange(len(data_set))\n residual = data_set - prediction\n mean = np.ones(len(data_set))np.mean(residual)\n \n trace = {\"x\": x,\n \"y\": residual,\n \"mode\": 'markers',\n \"name\": 'Residual'}\n\n trace_mean = {\"x\": x,\n \"y\": mean,\n \"mode\": 'lines',\n \"name\": 'Mean'}\n traces = [trace,trace_mean]\n layout = dict(title = \"Residual\",\n xaxis = dict(title = 'X'),\n yaxis = dict(title = 'Residual')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n print(\"Standard Deviation of Residuals : \" + str(np.std(residual, ddof=1)))\n print(\"Mean of Residuals : \" + str(np.mean(residual)))\n\n \n \n def plot_data(self, data_set, time):\n mean = np.mean(data_set)\n means = np.ones(len(data_set))*mean\n trace_value = {\"x\": time,\n \"y\": data_set,\n \"mode\": 'lines',\n \"name\": 'value'}\n\n trace_mean = {\"x\": time,\n \"y\": means,\n \"mode\": 'lines',\n \"name\": 'mean'}\n traces = [trace_value,trace_mean]\n layout = dict(title = \"Values with mean\",\n xaxis = dict(title = 'Time'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n normalized_data = data_set - mean\n trace_value = {\"x\": time,\n \"y\": normalized_data,\n \"mode\": 'lines',\n \"name\": 'value'}\n traces = [trace_value]\n layout = dict(title = \"After removing mean\",\n xaxis = dict(title = 'Time'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n \n def print_stats(self,data,prediction):\n print(\"Mean Square Error : \" + str(self.mse(data,prediction)))\n print(\"Mean of real values : \" + str(np.mean(data)))\n print(\"Standard Deviation of real values : \" + str(np.std(data, ddof=1)))\n print(\"Mean of predicted values : \" + str(np.mean(prediction)))\n print(\"Standard Deviation of predicted values : \" + str(np.std(prediction, ddof=1)))\n print(\"Number of data points : \" + str(len(data)))\n \n def plot_result(self, time, data, prediction):\n data.shape = (1,np.max(data.shape))\n data = data[0]\n data = self.get_differance(data, self.d)\n trace_real = {\"x\": time,\n \"y\": data,\n \"mode\": 'lines',\n \"name\": 'Real value'}\n trace_predicted = {\"x\": time,\n \"y\": prediction,\n \"mode\": 'lines',\n \"name\": 'Predicted value'}\n traces = [trace_real,trace_predicted]\n layout = dict(title = \"Training Data Set with ARIMA(\"+str(self.p)+\",\"+str(self.d)+\",\"+str(self.q)+\")\",\n xaxis = dict(title = 'Time'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n self.print_stats(data,prediction)\n self.plot_residuals(data,prediction)\n\n\narima_model = ARIMA(2,1,2)\narima_model.plot_differance(training_set_values,0)\ndifferance = arima_model.plot_differance(training_set_values,1)\n\narima_model.plot_autocorrelation(differance, 30)\narima_model.plot_partial_autocorrelation(differance, 30)\n\narma_model = ARIMA(2,1,4)\narma_model.set_training_data_set(training_set_values)\narma_model.set_training_data_time(training_set_time)\n\narma_model.set_testing_data_set(testing_set_values)\narma_model.set_testing_data_time(testing_set_time)\n\narma_model.set_validation_data_set(validation_set_values)\narma_model.set_validation_data_time(validation_set_time)\n\n# prediction = arma_model.get_prediction(arma_model.testing_data_set)\n# prediction = arma_model.get_prediction(arma_model.validation_data_set)\nprediction = arma_model.get_prediction(arma_model.training_data)\n\n\n# arma_model.plot_result(arma_model.testing_data_time, arma_model.testing_data_set, prediction)\n# arma_model.plot_result(arma_model.validation_data_time, arma_model.validation_data_set, prediction)\narma_model.plot_result(arma_model.training_data_time, arma_model.training_data, prediction)" ]	[ [ "numpy.dot", "numpy.polyfit", "pandas.read_csv", "numpy.arange", "numpy.max", "numpy.random.normal", "numpy.std", "numpy.mean", "numpy.corrcoef", "numpy.array", "numpy.zeros" ] ]
LilYuuu/transformers	[ "795c9d2de2ec9e3844dc4c2cdf2e0bc9251597f7" ]	[ "src/transformers/data/processors/glue.py" ]	[ "# coding=utf-8\n# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.\n# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\" GLUE processors and helpers \"\"\"\n\nimport logging\nimport os\nimport json\n\nfrom ...file_utils import is_tf_available\nfrom .utils import DataProcessor, InputExample, InputFeatures\n\n\nif is_tf_available():\n import tensorflow as tf\n\nlogger = logging.getLogger(__name__)\n\n\ndef glue_convert_examples_to_features(\n examples,\n tokenizer,\n max_length=512,\n task=None,\n label_list=None,\n output_mode=None,\n pad_on_left=False,\n pad_token=0,\n pad_token_segment_id=0,\n mask_padding_with_zero=True,\n):\n \"\"\"\n Loads a data file into a list of ``InputFeatures``\n\n Args:\n examples: List of ``InputExamples`` or ``tf.data.Dataset`` containing the examples.\n tokenizer: Instance of a tokenizer that will tokenize the examples\n max_length: Maximum example length\n task: GLUE task\n label_list: List of labels. Can be obtained from the processor using the ``processor.get_labels()`` method\n output_mode: String indicating the output mode. Either ``regression`` or ``classification``\n pad_on_left: If set to ``True``, the examples will be padded on the left rather than on the right (default)\n pad_token: Padding token\n pad_token_segment_id: The segment ID for the padding token (It is usually 0, but can vary such as for XLNet where it is 4)\n mask_padding_with_zero: If set to ``True``, the attention mask will be filled by ``1`` for actual values\n and by ``0`` for padded values. If set to ``False``, inverts it (``1`` for padded values, ``0`` for\n actual values)\n\n Returns:\n If the ``examples`` input is a ``tf.data.Dataset``, will return a ``tf.data.Dataset``\n containing the task-specific features. If the input is a list of ``InputExamples``, will return\n a list of task-specific ``InputFeatures`` which can be fed to the model.\n\n \"\"\"\n is_tf_dataset = False\n if is_tf_available() and isinstance(examples, tf.data.Dataset):\n is_tf_dataset = True\n\n if task is not None:\n processor = glue_processors[task]()\n if label_list is None:\n label_list = processor.get_labels()\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\n if output_mode is None:\n output_mode = glue_output_modes[task]\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n len_examples = 0\n if is_tf_dataset:\n example = processor.get_example_from_tensor_dict(example)\n example = processor.tfds_map(example)\n len_examples = tf.data.experimental.cardinality(examples)\n else:\n len_examples = len(examples)\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d/%d\" % (ex_index, len_examples))\n\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length,)\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\n len(attention_mask), max_length\n )\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\n len(token_type_ids), max_length\n )\n\n if output_mode == \"classification\":\n label = label_map[example.label]\n elif output_mode == \"regression\":\n label = float(example.label)\n else:\n raise KeyError(output_mode)\n\n if ex_index < 5:\n logger.info(\"* Example *\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in attention_mask]))\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in token_type_ids]))\n logger.info(\"label: %s (id = %d)\" % (example.label, label))\n\n features.append(\n InputFeatures(\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label=label\n )\n )\n\n if is_tf_available() and is_tf_dataset:\n\n def gen():\n for ex in features:\n yield (\n {\n \"input_ids\": ex.input_ids,\n \"attention_mask\": ex.attention_mask,\n \"token_type_ids\": ex.token_type_ids,\n },\n ex.label,\n )\n\n return tf.data.Dataset.from_generator(\n gen,\n ({\"input_ids\": tf.int32, \"attention_mask\": tf.int32, \"token_type_ids\": tf.int32}, tf.int64),\n (\n {\n \"input_ids\": tf.TensorShape([None]),\n \"attention_mask\": tf.TensorShape([None]),\n \"token_type_ids\": tf.TensorShape([None]),\n },\n tf.TensorShape([]),\n ),\n )\n\n return features\n\n'''HW4: New code added here'''\n\nclass BoolqProcessor(DataProcessor):\n \"\"\"Processor for the BoolQ data set.\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"passage\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"question\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n logger.info(\"LOOKING AT {}\".format(os.path.join(data_dir, \"train.jsonl\")))\n# with open(os.path.join(data_dir, \"train.jsonl\"), \"r\", encoding=\"utf-8-sig\") as f:\n# with open(os.path.join(data_dir, \"val.jsonl\"), \"r\") as f:\n# lines = json.loads(json.dumps([f.read()]))\n with open(os.path.join(data_dir, \"train.jsonl\"), \"r\") as f:\n lines = f.read().splitlines()\n data = []\n for line in lines:\n data.append(json.loads(line))\n return self._create_examples(data, \"train\")\n\n def get_val_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n# with open(os.path.join(data_dir, \"val.jsonl\"), \"r\", encoding=\"utf-8-sig\") as f:\n# with open(os.path.join(data_dir, \"val.jsonl\"), \"r\") as f:\n# lines = json.loads(json.dumps([f.read()]))\n with open(os.path.join(data_dir, \"val.jsonl\"), \"r\") as f:\n lines = f.read().splitlines()\n data = []\n for line in lines:\n data.append(json.loads(line))\n return self._create_examples(data, \"val\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [True, False]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[\"question\"]\n text_b = line[\"passage\"]\n label = line[\"label\"]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass MrpcProcessor(DataProcessor):\n \"\"\"Processor for the MRPC data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n logger.info(\"LOOKING AT {}\".format(os.path.join(data_dir, \"train.tsv\")))\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n text_b = line[4]\n label = line[0]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass MnliProcessor(DataProcessor):\n \"\"\"Processor for the MultiNLI data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"premise\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"hypothesis\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev_matched.tsv\")), \"dev_matched\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"contradiction\", \"entailment\", \"neutral\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[8]\n text_b = line[9]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass MnliMismatchedProcessor(MnliProcessor):\n \"\"\"Processor for the MultiNLI Mismatched data set (GLUE version).\"\"\"\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev_mismatched.tsv\")), \"dev_matched\")\n\n\nclass ColaProcessor(DataProcessor):\n \"\"\"Processor for the CoLA data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence\"].numpy().decode(\"utf-8\"),\n None,\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples\n\n\nclass Sst2Processor(DataProcessor):\n \"\"\"Processor for the SST-2 data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence\"].numpy().decode(\"utf-8\"),\n None,\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[0]\n label = line[1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples\n\n\nclass StsbProcessor(DataProcessor):\n \"\"\"Processor for the STS-B data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [None]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[7]\n text_b = line[8]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass QqpProcessor(DataProcessor):\n \"\"\"Processor for the QQP data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"question1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"question2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n try:\n text_a = line[3]\n text_b = line[4]\n label = line[5]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass QnliProcessor(DataProcessor):\n \"\"\"Processor for the QNLI data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"question\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev_matched\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"entailment\", \"not_entailment\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass RteProcessor(DataProcessor):\n \"\"\"Processor for the RTE data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"entailment\", \"not_entailment\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass WnliProcessor(DataProcessor):\n \"\"\"Processor for the WNLI data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nglue_tasks_num_labels = {\n \"cola\": 2,\n \"mnli\": 3,\n \"mrpc\": 2,\n \"sst-2\": 2,\n \"sts-b\": 1,\n \"qqp\": 2,\n \"qnli\": 2,\n \"rte\": 2,\n \"wnli\": 2,\n \"boolq\": 2,\n}\n\nglue_processors = {\n \"cola\": ColaProcessor,\n \"mnli\": MnliProcessor,\n \"mnli-mm\": MnliMismatchedProcessor,\n \"mrpc\": MrpcProcessor,\n \"sst-2\": Sst2Processor,\n \"sts-b\": StsbProcessor,\n \"qqp\": QqpProcessor,\n \"qnli\": QnliProcessor,\n \"rte\": RteProcessor,\n \"wnli\": WnliProcessor,\n \"boolq\": BoolqProcessor,\n}\n\nglue_output_modes = {\n \"cola\": \"classification\",\n \"mnli\": \"classification\",\n \"mnli-mm\": \"classification\",\n \"mrpc\": \"classification\",\n \"sst-2\": \"classification\",\n \"sts-b\": \"regression\",\n \"qqp\": \"classification\",\n \"qnli\": \"classification\",\n \"rte\": \"classification\",\n \"wnli\": \"classification\",\n \"boolq\": \"classification\",\n}\n" ]	[ [ "tensorflow.TensorShape", "tensorflow.data.experimental.cardinality" ] ]
vdorobantu/lyapy	[ "485e8490ef77f2286a804b2bd506cc3f46b74c6d" ]	[ "lyapy/systems/system.py" ]	[ "\"\"\"Base class for dynamical systems of the form x_dot = f(t, x).\"\"\"\n\nfrom scipy.integrate import solve_ivp\n\nclass System:\n \"\"\"Base class for dynamical systems of the form x_dot = f(t, x).\n\n Override dx.\n\n Let n be number of states.\n \"\"\"\n\n def dx(self, t, x):\n \"\"\"Evaluate state derivative at a time and state.\n\n Outputs a numpy array (n,).\n\n Inputs:\n Time, t: float\n State, x: numpy array (n,)\n \"\"\"\n\n pass\n\n def simulate(self, x_0, t_eval, rtol=1e-6, atol=1e-6):\n \"\"\"Simulate closed-loop system using Runge-Kutta 4,5.\n\n Solution is evaluated at N time steps. Outputs times and corresponding\n solutions as numpy array (N,) * numpy array (N, n).\n\n Inputs:\n Initial condition, x_0: numpy array (n,)\n Solution times, t_eval: numpy array (N,)\n RK45 relative tolerance, rtol: float\n RK45 absolute tolerance, atol: float\n \"\"\"\n\n t_span = [t_eval[0], t_eval[-1]]\n sol = solve_ivp(self.dx, t_span, x_0, t_eval=t_eval, rtol=rtol, atol=atol)\n return sol.t, sol.y.T\n" ]	[ [ "scipy.integrate.solve_ivp" ] ]
gorogoroyasu/captum	[ "e4e27c537e86deca6ed841432be2f11459d6795a" ]	[ "tests/attr/neuron/test_neuron_gradient.py" ]	[ "#!/usr/bin/env python3\n\nimport unittest\n\nimport torch\nfrom captum.attr._core.saliency import Saliency\nfrom captum.attr._core.neuron.neuron_gradient import NeuronGradient\nfrom captum.attr._utils.gradient import _forward_layer_eval\n\nfrom ..helpers.basic_models import (\n BasicModel_ConvNet,\n BasicModel_MultiLayer,\n BasicModel_MultiLayer_MultiInput,\n)\nfrom ..helpers.utils import assertArraysAlmostEqual, BaseTest\n\n\nclass Test(BaseTest):\n def test_simple_gradient_input_linear2(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 100.0, 0.0]], requires_grad=True)\n self._gradient_input_test_assert(net, net.linear2, inp, (0,), [4.0, 4.0, 4.0])\n\n def test_simple_gradient_input_linear1(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 100.0, 0.0]])\n self._gradient_input_test_assert(net, net.linear1, inp, (0,), [1.0, 1.0, 1.0])\n\n def test_simple_gradient_input_relu_inplace(self):\n net = BasicModel_MultiLayer(inplace=True)\n inp = torch.tensor([[0.0, 5.0, 4.0]])\n self._gradient_input_test_assert(\n net, net.relu, inp, (0,), [1.0, 1.0, 1.0], attribute_to_neuron_input=True\n )\n\n def test_simple_gradient_input_linear1_inplace(self):\n net = BasicModel_MultiLayer(inplace=True)\n inp = torch.tensor([[0.0, 5.0, 4.0]])\n self._gradient_input_test_assert(net, net.linear1, inp, (0,), [1.0, 1.0, 1.0])\n\n def test_simple_gradient_input_relu(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 5.0, 4.0]], requires_grad=True)\n self._gradient_input_test_assert(net, net.relu, inp, 0, [0.0, 0.0, 0.0])\n\n def test_simple_gradient_input_relu2(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 5.0, 4.0]])\n self._gradient_input_test_assert(net, net.relu, inp, 1, [1.0, 1.0, 1.0])\n\n def test_simple_gradient_multi_input_linear2(self):\n net = BasicModel_MultiLayer_MultiInput()\n inp1 = torch.tensor([[0.0, 100.0, 0.0]])\n inp2 = torch.tensor([[0.0, 100.0, 0.0]])\n inp3 = torch.tensor([[0.0, 100.0, 0.0]])\n self._gradient_input_test_assert(\n net,\n net.model.linear2,\n (inp1, inp2, inp3),\n (0,),\n ([12.0, 12.0, 12.0], [12.0, 12.0, 12.0], [12.0, 12.0, 12.0]),\n (3,),\n )\n\n def test_simple_gradient_multi_input_linear1(self):\n net = BasicModel_MultiLayer_MultiInput()\n inp1 = torch.tensor([[0.0, 100.0, 0.0]])\n inp2 = torch.tensor([[0.0, 100.0, 0.0]])\n inp3 = torch.tensor([[0.0, 100.0, 0.0]])\n self._gradient_input_test_assert(\n net,\n net.model.linear1,\n (inp1, inp2),\n (0,),\n ([5.0, 5.0, 5.0], [5.0, 5.0, 5.0]),\n (inp3, 5),\n )\n\n def test_matching_output_gradient(self):\n net = BasicModel_ConvNet()\n inp = torch.randn(2, 1, 10, 10, requires_grad=True)\n self._gradient_matching_test_assert(net, net.softmax, inp)\n\n def test_matching_intermediate_gradient(self):\n net = BasicModel_ConvNet()\n inp = torch.randn(3, 1, 10, 10)\n self._gradient_matching_test_assert(net, net.relu2, inp)\n\n def _gradient_input_test_assert(\n self,\n model,\n target_layer,\n test_input,\n test_neuron,\n expected_input_gradient,\n additional_input=None,\n attribute_to_neuron_input=False,\n ):\n grad = NeuronGradient(model, target_layer)\n attributions = grad.attribute(\n test_input,\n test_neuron,\n additional_forward_args=additional_input,\n attribute_to_neuron_input=attribute_to_neuron_input,\n )\n if isinstance(expected_input_gradient, tuple):\n for i in range(len(expected_input_gradient)):\n assertArraysAlmostEqual(\n attributions[i].squeeze(0).tolist(),\n expected_input_gradient[i],\n delta=0.1,\n )\n else:\n assertArraysAlmostEqual(\n attributions.squeeze(0).tolist(), expected_input_gradient, delta=0.1\n )\n\n def _gradient_matching_test_assert(self, model, output_layer, test_input):\n out = _forward_layer_eval(model, test_input, output_layer)\n gradient_attrib = NeuronGradient(model, output_layer)\n for i in range(out.shape[1]):\n neuron = (i,)\n while len(neuron) < len(out.shape) - 1:\n neuron = neuron + (0,)\n input_attrib = Saliency(\n lambda x: _forward_layer_eval(model, x, output_layer)[\n (slice(None), *neuron)\n ]\n )\n sal_vals = input_attrib.attribute(test_input, abs=False)\n grad_vals = gradient_attrib.attribute(test_input, neuron)\n # Verify matching sizes\n self.assertEqual(grad_vals.shape, sal_vals.shape)\n self.assertEqual(grad_vals.shape, test_input.shape)\n assertArraysAlmostEqual(\n sal_vals.reshape(-1).tolist(),\n grad_vals.reshape(-1).tolist(),\n delta=0.001,\n )\n\n\nif __name__ == \"__main__\":\n unittest.main()\n" ]	[ [ "torch.randn", "torch.tensor" ] ]
GregTheRick/Deep-Learning-for-Fast-Low-Light-Imaging	[ "c2a3f869f9e9a4691900962a0541b41fc17f2f0c" ]	[ "experiment_trainer_flip.py" ]	[ "from __future__ import division\nimport numpy as np\nimport tensorflow as tf\nfrom SIDLoader import SIDLoader\nfrom ModelBuilder import ModelBuilder\nfrom Experiment import Experiment\nimport time,datetime,os,glob\n\npath_prefix = '.'\ncheckpoint_dir = path_prefix+'/chk'\ndataset_dir = path_prefix+'/dataset'\nvalid_freq = 20\nseed = 1337\ntensorboard_dir = path_prefix+'/tensorboard'\n#Set initial seed\nnp.random.seed(seed)\n#Set up experiments\nexpList = []\nexpList.append(Experiment(name='cchen_sony_flip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp},device=\"/device:GPU:0\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='unet_s_sony_flip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp},device=\"/device:GPU:1\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='deep_isp_flip',model_fn={'fn':ModelBuilder.build_deep_isp_exp},device=\"/device:GPU:2\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='cchen_resize_sony_flip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp_resize},device=\"/device:GPU:3\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='unet_s_resize_sony_flip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp_resize},device=\"/device:GPU:4\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\n\n\n#Load flat matrix\ndataset = SIDLoader(dataset_dir, patch_fn=SIDLoader.patch_flip_unprocessed_sony,keep_raw=True,keep_gt=True)\nvalidSet = None\n#Get epoch from first experiment\nepoch = expList[0].epoch\ndataset.writeEpoch = epoch\ndataset.readEpoch = epoch\ndataset.start()\nlearning_rate = 1e-4\ntry:\n #train loop\n for exp in expList:\n exp.begin_train_cycle()\n while(epoch < 300):\n if(epoch >= 149):\n learning_rate = 1e-5\n #Get batch from batchloader\n (x,y,r) = dataset.get_batch()\n #start running training step on each GPU\n for exp in expList:\n exp.train_action(x,y,r,learning_rate)\n #Wait for all to finish\n for exp in expList:\n exp.finish_train_action()\n epoch = dataset.readEpoch\n\n if(dataset.readC == 0): #It is the end of the epoch\n for exp in expList:\n exp.end_of_epoch_train(epoch)\n #Validate\n if(epoch%valid_freq == 0):\n if(validSet == None):\n validSet = SIDLoader(dataset_dir, patch_fn=None,keep_raw=True,keep_gt=True, set_id='valid')\n validSet.start()\n validSet.readEpoch = dataset.readEpoch-1\n validSet.writeEpoch = dataset.readEpoch-1\n vepoch = validSet.readEpoch\n for exp in expList:\n exp.begin_valid_cycle(epoch)\n while(vepoch < epoch):\n (x,y,r) = validSet.get_batch()\n for exp in expList:\n exp.valid_action(x,y,r)\n for exp in expList:\n exp.finish_valid_action()\n vepoch = validSet.readEpoch\n if(validSet.readC == 0):\n #get validation epoch summaries\n for exp in expList:\n exp.end_of_epoch_valid(epoch)\n \nexcept KeyboardInterrupt:\n print('Keyboard interrupt accepted. Shutting down')\nfinally:\n dataset.stop()\n if(validSet is not None):\n validSet.stop()\n for exp in expList:\n exp.finish_train_cycle()\n exp.model['sess'].close()" ]	[ [ "numpy.random.seed" ] ]
gwdgithubnom/monkey-clever	[ "05290c33f7f2cf1de752e68f99464b92c02a9faf" ]	[ "arithmetic4py/src/kmeans/ref/wire3d.py" ]	[ "#http://matplotlib.org/examples/mplot3d/wire3d_demo.html\nfrom mpl_toolkits.mplot3d import axes3d\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nX, Y, Z = axes3d.get_test_data(0.05)\nax.plot_wireframe(X, Y, Z, rstride=10, cstride=10)\n\nplt.show()" ]	[ [ "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ] ]
vvanirudh/deluca	[ "673e66038547db90a7b23335cfe7508728076a4d" ]	[ "tests/utils/test_experiment.py" ]	[ "# Copyright 2020 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"deluca/tests/utils/test_experiment.py\"\"\"\nimport jax\nimport numpy as np\nimport pytest\n\nfrom deluca.utils import Random\nfrom deluca.utils.experiment import experiment\n\nrandom = Random()\n\n\[email protected](\"shape\", [(), (1,), (1, 2), (1, 2, 3)])\[email protected](\"num_args\", [1, 2, 10])\ndef test_experiment(shape, num_args):\n \"\"\"Test normal experiment behavior\"\"\"\n args = [\n (\n jax.random.uniform(random.generate_key(), shape=shape),\n jax.random.uniform(random.generate_key(), shape=shape),\n )\n for _ in range(num_args)\n ]\n\n @experiment(\"a,b\", args)\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n results = dummy.run()\n print(results)\n for i in range(len(results)):\n np.testing.assert_array_almost_equal(results[i], np.sum(args[i], axis=0))\n\n\[email protected](\"times\", [1, 2, 10])\ndef test_experiment_call(times):\n \"\"\"Tests repeated decorator calls\"\"\"\n\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n for _ in range(times):\n dummy = experiment(\"a,b\", [(1, 2)])(dummy)\n dummy._func(1, 2)\n assert isinstance(dummy, experiment)\n\n\ndef test_experiment_duplicated_argname():\n \"\"\"Tests duplicated arguments\"\"\"\n with pytest.raises(ValueError):\n\n @experiment(\"a\", [1])\n @experiment(\"a,b\", [(1, 2)])\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n dummy._func(1, 2)\n dummy._validate()\n\n\ndef test_experiment_missing_argument():\n \"\"\"Test missing arguments\"\"\"\n with pytest.raises(ValueError):\n\n @experiment(\"a\", [1])\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n dummy._func(1, 2)\n dummy._validate()\n\n\ndef test_experiment_unused_arguments():\n \"\"\"Testing unused arguments\"\"\"\n with pytest.raises(ValueError):\n\n @experiment(\"a,b,c\", [(1, 2, 3)])\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n dummy._func(1, 2)\n dummy._validate()\n\n\ndef test_experiment_list_args():\n \"\"\"Testing args as list\"\"\"\n\n @experiment([\"a\", \"b\"], [(1, 2)])\n def dummy(a, b):\n \"\"\"dummmy\"\"\"\n return a + b\n\n dummy.run()\n\n\ndef test_experiment_list_atoms():\n \"\"\"Testing atoms\"\"\"\n\n @experiment([\"a\"], [1])\n def dummy(a):\n \"\"\"dummy\"\"\"\n return a\n\n assert 1 == dummy.run()[0]\n" ]	[ [ "numpy.sum" ] ]
sachsanjoy/ezmist	[ "68afd231bd1323b33cd70ceff8a724b87e81cefa" ]	[ "ezmist/simpletable.py" ]	[ "\"\"\" This file implements a Table class\n that is designed to be the basis of any format\n\nRequirements\n------------\n\n* FIT format:\n * astropy:\n provides a replacement to pyfits\n pyfits can still be used instead but astropy is now the default\n\n* HDF5 format:\n * pytables\n\nRuntimeError will be raised when writing to a format associated with missing\npackage.\n\n\n.. code-block::python\n\n >>> t = SimpleTable('path/mytable.csv')\n # get a subset of columns only\n >>> s = t.get('M_* logTe logLo U B V I J K')\n # set some aliases\n >>> t.set_alias('logT', 'logTe')\n >>> t.set_alias('logL', 'logLLo')\n # make a query on one or multiple column\n >>> q = s.selectWhere('logT logL', '(J > 2) & (10 ** logT > 5000)')\n # q is also a table object\n >>> q.Plotter.plot('logT', 'logL', ',')\n # makes a simple plot (see :module:`plotter`)\n >>> s.write('newtable.fits')\n # export the initial subtable to a new file\n\"\"\"\nfrom __future__ import (absolute_import, division, print_function)\n\n__version__ = '3.0'\n__all__ = ['AstroHelpers', 'AstroTable', 'SimpleTable', 'stats']\n\nimport sys\nimport math\nfrom copy import deepcopy\nimport re\nimport itertools\nfrom functools import wraps, partial\nimport numpy as np\nfrom numpy import deg2rad, rad2deg, sin, cos, sqrt, arcsin, arctan2\nfrom numpy.lib import recfunctions\nimport types\n\ntry:\n from astropy.io import fits as pyfits\nexcept ImportError:\n import pyfits\nexcept:\n pyfits = None\n\ntry:\n import tables\nexcept ImportError:\n tables = None\n\ntry:\n import pandas as _pd\nexcept ImportError:\n _pd = None\n\ntry:\n from astropy.table import Table as _astropytable\nexcept ImportError:\n _astropytable = None\n\ntry:\n from .plotter import Plotter\nexcept ImportError:\n Plotter = None\n\n# ==============================================================================\n# Python 3 compatibility behavior\n# ==============================================================================\n# remap some python 2 built-ins on to py3k behavior or equivalent\n# Most of them become generators\nimport operator\n\nPY3 = sys.version_info[0] > 2\n\nif PY3:\n iteritems = operator.methodcaller('items')\n itervalues = operator.methodcaller('values')\n basestring = (str, bytes)\nelse:\n range = xrange\n from itertools import izip as zip\n iteritems = operator.methodcaller('iteritems')\n itervalues = operator.methodcaller('itervalues')\n basestring = (str, unicode)\n\n\n# ==============================================================================\n# Specials -- special functions\n# ==============================================================================\n\ndef pretty_size_print(num_bytes):\n \"\"\"\n Output number of bytes in a human readable format\n\n keywords\n --------\n num_bytes: int\n number of bytes to convert\n\n returns\n -------\n output: str\n string representation of the size with appropriate unit scale\n \"\"\"\n if num_bytes is None:\n return\n\n KiB = 1024\n MiB = KiB * KiB\n GiB = KiB * MiB\n TiB = KiB * GiB\n PiB = KiB * TiB\n EiB = KiB * PiB\n ZiB = KiB * EiB\n YiB = KiB * ZiB\n\n if num_bytes > YiB:\n output = '%.3g YB' % (num_bytes / YiB)\n elif num_bytes > ZiB:\n output = '%.3g ZB' % (num_bytes / ZiB)\n elif num_bytes > EiB:\n output = '%.3g EB' % (num_bytes / EiB)\n elif num_bytes > PiB:\n output = '%.3g PB' % (num_bytes / PiB)\n elif num_bytes > TiB:\n output = '%.3g TB' % (num_bytes / TiB)\n elif num_bytes > GiB:\n output = '%.3g GB' % (num_bytes / GiB)\n elif num_bytes > MiB:\n output = '%.3g MB' % (num_bytes / MiB)\n elif num_bytes > KiB:\n output = '%.3g KB' % (num_bytes / KiB)\n else:\n output = '%.3g Bytes' % (num_bytes)\n\n return output\n\n\ndef _fits_read_header(hdr):\n \"\"\"\n Convert pyfits header into dictionary with relevant values\n\n Parameters\n ----------\n\n hdr: pyftis.Header\n fits unit\n\n Returns\n -------\n header: dict\n header dictionary\n\n alias: dict\n aliases\n\n units: dict\n units\n\n comments: dict\n comments/description of keywords\n \"\"\"\n header = {}\n alias = {}\n units = {}\n comments = {}\n\n # generic cards\n genTerms = ['XTENSION', 'BITPIX', 'NAXIS', 'NAXIS1',\n 'NAXIS2', 'PCOUNT', 'GCOUNT', 'TFIELDS',\n 'EXTNAME']\n fieldTerms = ['TTYPE', 'TFORM', 'TUNIT', 'ALIAS']\n\n # read col comments\n # for k, name, comment in hdr.ascard['TTYPE']:\n try:\n for card in hdr.cards['TTYPE']:\n name = card.value\n comments[name] = card.comment\n u = hdr.get(card.keyword.replace('TYPE', 'UNIT'), None)\n if u is not None:\n units[name] = u\n\n # for k, val, _ in hdr.ascard['ALIAS']:\n for card in hdr.cards['ALIAS']:\n k = card.keyword\n val = card.value\n al, orig = val.split('=')\n alias[al] = orig\n except: #pyfits stsci\n for card in hdr.ascard['TTYPE']:\n name = card.value\n comments[name] = card.comment\n u = hdr.get(card.key.replace('TYPE', 'UNIT'), None)\n if u is not None:\n units[name] = u\n\n # for k, val, _ in hdr.ascard['ALIAS']:\n for card in hdr.ascard['ALIAS']:\n k = card.key\n val = card.value\n al, orig = val.split('=')\n alias[al] = orig\n\n # other specific keywords: COMMENT, HISTORY\n header_comments = []\n header_history = []\n for k, v in hdr.items():\n if (k not in genTerms) and (k[:5] not in fieldTerms):\n if (k == 'COMMENT'):\n header_comments.append(v)\n elif (k == 'HISTORY'):\n header_history.append(v)\n else:\n header[k] = v\n\n # COMMENT, HISTORY polish\n if len(header_comments) > 0:\n header['COMMENT'] = '\\n'.join(header_comments)\n if len(header_history) > 0:\n header['HISTORY'] = '\\n'.join(header_history)\n\n if 'EXTNAME' in hdr:\n header['NAME'] = hdr['EXTNAME']\n\n return header, alias, units, comments\n\n\ndef _fits_generate_header(tab):\n \"\"\" Generate the corresponding fits Header that contains all necessary info\n\n Parameters\n ----------\n\n tab: SimpleTable instance\n table\n\n Returns\n -------\n hdr: pyfits.Header\n header instance\n \"\"\"\n # get column cards\n\n cards = []\n\n # names units and comments\n for e, k in enumerate(tab.keys()):\n cards.append(('TTYPE{0:d}'.format(e + 1), k, tab._desc.get(k, '')))\n u = tab._units.get(k, '')\n if u not in ['', 'None', None]:\n cards.append(('TUNIT{0:d}'.format(e + 1), tab._units.get(k, ''),\n 'unit of {0:s}'.format(k)))\n\n # add aliases\n for e, v in enumerate(tab._aliases.items()):\n cards.append( ('ALIAS{0:d}'.format(e + 1), '='.join(v), '') )\n\n if tab.header['NAME'] not in ['', 'None', None, 'No Name']:\n cards.append(('EXTNAME', tab.header['NAME'], ''))\n\n hdr = pyfits.Header(cards)\n\n for k, v in tab.header.items():\n if (v not in ['', 'None', None]) & (k != 'NAME'):\n if (k != 'COMMENT') & (k != 'HISTORY'):\n hdr.update(k, v)\n else:\n txt = v.split('\\n')\n for j in txt:\n if k == 'COMMENT':\n hdr.add_comment(j)\n elif k == 'HISTORY':\n hdr.add_history(j)\n return hdr\n\n\ndef _fits_writeto(filename, data, header=None, output_verify='exception',\n clobber=False, checksum=False):\n \"\"\"\n Create a new FITS file using the supplied data/header.\n Patched version of pyfits to correctly include provided header\n\n Parameters\n ----------\n filename : file path, file object, or file like object\n File to write to. If opened, must be opened in a writeable binary\n mode such as 'wb' or 'ab+'.\n\n data : array, record array, or groups data object\n data to write to the new file\n\n header : `Header` object, optional\n the header associated with ``data``. If `None`, a header\n of the appropriate type is created for the supplied data. This\n argument is optional.\n\n output_verify : str\n Output verification option. Must be one of ``\"fix\"``, ``\"silentfix\"``,\n ``\"ignore\"``, ``\"warn\"``, or ``\"exception\"``. May also be any\n combination of ``\"fix\"`` or ``\"silentfix\"`` with ``\"+ignore\"``,\n ``+warn``, or ``+exception\" (e.g. ``\"fix+warn\"``). See :ref:`verify`\n for more info.\n\n clobber : bool, optional\n If `True`, and if filename already exists, it will overwrite\n the file. Default is `False`.\n\n checksum : bool, optional\n If `True`, adds both ``DATASUM`` and ``CHECKSUM`` cards to the\n headers of all HDU's written to the file\n \"\"\"\n\n hdu = pyfits.convenience._makehdu(data, header)\n hdu.header.update(header.cards)\n if hdu.is_image and not isinstance(hdu, pyfits.PrimaryHDU):\n hdu = pyfits.PrimaryHDU(data, header=header)\n hdu.writeto(filename, clobber=clobber, output_verify=output_verify,\n checksum=checksum)\n\n\ndef _fits_append(filename, data, header=None, checksum=False, verify=True,\n kwargs):\n \"\"\"\n Append the header/data to FITS file if filename exists, create if not.\n\n If only ``data`` is supplied, a minimal header is created.\n Patched version of pyfits to correctly include provided header\n\n Parameters\n ----------\n filename : file path, file object, or file like object\n File to write to. If opened, must be opened for update (rb+) unless it\n is a new file, then it must be opened for append (ab+). A file or\n `~gzip.GzipFile` object opened for update will be closed after return.\n\n data : array, table, or group data object\n the new data used for appending\n\n header : `Header` object, optional\n The header associated with ``data``. If `None`, an appropriate header\n will be created for the data object supplied.\n\n checksum : bool, optional\n When `True` adds both ``DATASUM`` and ``CHECKSUM`` cards to the header\n of the HDU when written to the file.\n\n verify : bool, optional\n When `True`, the existing FITS file will be read in to verify it for\n correctness before appending. When `False`, content is simply appended\n to the end of the file. Setting ``verify`` to `False` can be much\n faster.\n\n kwargs\n Any additional keyword arguments to be passed to\n `astropy.io.fits.open`.\n \"\"\"\n\n name, closed, noexist_or_empty = pyfits.convenience._stat_filename_or_fileobj(filename)\n\n if noexist_or_empty:\n #\n # The input file or file like object either doesn't exits or is\n # empty. Use the writeto convenience function to write the\n # output to the empty object.\n #\n _fits_writeto(filename, data, header, checksum=checksum, kwargs)\n else:\n hdu = pyfits.convenience._makehdu(data, header)\n hdu.header.update(header.cards)\n\n if isinstance(hdu, pyfits.PrimaryHDU):\n hdu = pyfits.ImageHDU(data, header)\n\n if verify or not closed:\n f = pyfits.convenience.fitsopen(filename, mode='append')\n f.append(hdu)\n\n # Set a flag in the HDU so that only this HDU gets a checksum when\n # writing the file.\n hdu._output_checksum = checksum\n f.close(closed=closed)\n else:\n f = pyfits.convenience._File(filename, mode='append')\n hdu._output_checksum = checksum\n hdu._writeto(f)\n f.close()\n\n\ndef _ascii_read_header(fname, comments='#', delimiter=None, commentedHeader=True,\n args, kwargs):\n \"\"\"\n Read ASCII/CSV header\n\n Parameters\n ----------\n fname: str or stream\n File, filename, or generator to read.\n Note that generators should return byte strings for Python 3k.\n\n comments: str, optional\n The character used to indicate the start of a comment;\n default: '#'.\n\n delimiter: str, optional\n The string used to separate values. By default, this is any\n whitespace.\n\n commentedHeader: bool, optional\n if set, the last line of the header is expected to be the column titles\n\n Returns\n -------\n nlines: int\n number of lines from the header\n\n header: dict\n header dictionary\n\n alias: dict\n aliases\n\n units: dict\n units\n\n comments: dict\n comments/description of keywords\n\n names: sequence\n sequence or str, first data line after header, expected to be the column\n names.\n \"\"\"\n if hasattr(fname, 'read'):\n stream = fname\n else:\n stream = open(fname, 'r')\n\n header = {}\n alias = {}\n units = {}\n desc = {}\n\n def parseStrNone(v):\n \"\"\" robust parse \"\"\"\n _v = v.split()\n if (len(_v) == 0):\n return None\n else:\n _v = ' '.join(_v)\n if (_v.lower()) == 'none' or (_v.lower() == 'null'):\n return None\n else:\n return _v\n\n done = False\n oldline = None\n lasthdr = None\n nlines = 0\n header.setdefault('COMMENT', '')\n header.setdefault('HISTORY', '')\n while done is False:\n line = stream.readline()[:-1] # getting rid of '\\n'\n nlines += 1\n if (line[0] == comments): # header part\n if (len(line) > 2):\n if line[1] == comments: # column meta data\n # column meta is expected to start with ##\n k = line[2:].split('\\t')\n colname = k[0].strip()\n colunit = None\n colcomm = None\n if len(k) > 1:\n colunit = parseStrNone(k[1])\n if len(k) > 2:\n colcomm = parseStrNone(k[2])\n\n if colunit is not None:\n units[colname] = colunit\n if colcomm is not None:\n desc[colname] = colcomm\n else:\n # header is expected as \"# key \\t value\"\n k = line[1:].split('\\t')\n if len(k) > 1:\n key = k[0].strip() # remove trainling spaces\n val = ' '.join(k[1:]).strip()\n\n if key in ('', None, 'None', 'NONE', 'COMMENT'):\n header['COMMENT'] = header['COMMENT'] + '\\n' + val\n if key in ('HISTORY', ):\n header['HISTORY'] = header['HISTORY'] + '\\n' + val\n elif 'alias' in key.lower():\n # take care of aliases\n al, orig = val.split('=')\n alias[al] = orig\n else:\n header[key] = val\n lasthdr = key\n else:\n header['COMMENT'] = header['COMMENT'] + '\\n' + line[1:]\n else:\n done = True\n if commentedHeader and (oldline is not None):\n names = oldline.split(delimiter)\n nlines -= 1\n if lasthdr == names[0]:\n header.pop(lasthdr)\n else:\n names = line.split(delimiter)\n oldline = line[1:]\n\n if not hasattr(fname, 'read'):\n stream.close()\n else:\n stream.seek(stream.tell() - len(line))\n nlines = 0 # make sure the value is set to the current position\n\n return nlines, header, units, desc, alias, names\n\n\ndef _hdf5_write_data(filename, data, tablename=None, mode='w', append=False,\n header={}, units={}, comments={}, aliases={}, kwargs):\n \"\"\" Write table into HDF format\n\n Parameters\n ----------\n filename : file path, or tables.File instance\n File to write to. If opened, must be opened and writable (mode='w' or 'a')\n\n data: recarray\n data to write to the new file\n\n tablename: str\n path of the node including table's name\n\n mode: str\n in ('w', 'a') mode to open the file\n\n append: bool\n if set, tends to append data to an existing table\n\n header: dict\n table header\n\n units: dict\n dictionary of units\n\n alias: dict\n aliases\n\n comments: dict\n comments/description of keywords\n\n .. note::\n other keywords are forwarded to :func:`tables.open_file`\n \"\"\"\n\n if hasattr(filename, 'read'):\n raise Exception(\"HDF backend does not implement stream\")\n\n if append is True:\n mode = 'a'\n silent = kwargs.pop('silent', False)\n\n if isinstance(filename, tables.File):\n if (filename.mode != mode) & (mode != 'r'):\n raise tables.FileModeError('The file is already opened in a different mode')\n hd5 = filename\n else:\n hd5 = tables.open_file(filename, mode=mode)\n\n # check table name and path\n tablename = tablename or header.get('NAME', None)\n if tablename in ('', None, 'Noname', 'None'):\n tablename = '/data'\n\n w = tablename.split('/')\n where = '/'.join(w[:-1])\n name = w[-1]\n if where in ('', None):\n where = '/'\n if where[0] != '/':\n where = '/' + where\n\n if append:\n try:\n t = hd5.get_node(where + name)\n t.append(data.astype(t.description._v_dtype))\n t.flush()\n except tables.NoSuchNodeError:\n if not silent:\n print((\"Warning: Table {0} does not exists. \\n A new table will be created\").format(where + name))\n append = False\n\n if not append:\n t = hd5.createTable(where, name, data, *kwargs)\n\n # update header\n for k, v in header.items():\n if (k == 'FILTERS') & (float(t.attrs['VERSION']) >= 2.0):\n t.attrs[k.lower()] = v\n else:\n t.attrs[k] = v\n if 'TITLE' not in header:\n t.attrs['TITLE'] = name\n\n # add column descriptions and units\n for e, colname in enumerate(data.dtype.names):\n _u = units.get(colname, None)\n _d = comments.get(colname, None)\n if _u is not None:\n t.attrs['FIELD_{0:d}_UNIT'] = _u\n if _d is not None:\n t.attrs['FIELD_{0:d}_DESC'] = _d\n\n # add aliases\n for i, (k, v) in enumerate(aliases.items()):\n t.attrs['ALIAS{0:d}'.format(i)] = '{0:s}={1:s}'.format(k, v)\n\n t.flush()\n\n if not isinstance(filename, tables.File):\n hd5.flush()\n hd5.close()\n\n\ndef _hdf5_read_data(filename, tablename=None, silent=False, args, *kwargs):\n \"\"\" Generate the corresponding ascii Header that contains all necessary info\n\n Parameters\n ----------\n filename: str\n file to read from\n\n tablename: str\n node containing the table\n\n silent: bool\n skip verbose messages\n\n Returns\n -------\n hdr: str\n string that will be be written at the beginning of the file\n \"\"\"\n source = tables.open_file(filename, args, *kwargs)\n\n if tablename is None:\n node = source.listNodes('/')[0]\n tablename = node.name\n else:\n if tablename[0] != '/':\n node = source.get_node('/' + tablename)\n else:\n node = source.get_node(tablename)\n if not silent:\n print(\"\\tLoading table: {0}\".format(tablename))\n\n hdr = {}\n aliases = {}\n\n # read header\n exclude = ['NROWS', 'VERSION', 'CLASS', 'EXTNAME', 'TITLE']\n for k in node.attrs._v_attrnames:\n if (k not in exclude):\n if (k[:5] != 'FIELD') & (k[:5] != 'ALIAS'):\n hdr[k] = node.attrs[k]\n elif k[:5] == 'ALIAS':\n c0, c1 = node.attrs[k].split('=')\n aliases[c0] = c1\n\n empty_name = ['', 'None', 'Noname', None]\n if node.attrs['TITLE'] not in empty_name:\n hdr['NAME'] = node.attrs['TITLE']\n else:\n hdr['NAME'] = '{0:s}/{1:s}'.format(filename, node.name)\n\n # read column meta\n units = {}\n desc = {}\n\n for (k, colname) in enumerate(node.colnames):\n _u = getattr(node.attrs, 'FIELD_{0:d}_UNIT'.format(k), None)\n _d = getattr(node.attrs, 'FIELD_{0:d}_DESC'.format(k), None)\n if _u is not None:\n units[colname] = _u\n if _d is not None:\n desc[colname] = _d\n\n data = node[:]\n\n source.close()\n\n return hdr, aliases, units, desc, data\n\n\ndef _ascii_generate_header(tab, comments='#', delimiter=' ',\n commentedHeader=True):\n \"\"\" Generate the corresponding ascii Header that contains all necessary info\n\n Parameters\n ----------\n\n tab: SimpleTable instance\n table\n\n comments: str\n string to prepend header lines\n\n delimiter: str, optional\n The string used to separate values. By default, this is any\n whitespace.\n\n commentedHeader: bool, optional\n if set, the last line of the header is expected to be the column titles\n\n Returns\n -------\n hdr: str\n string that will be be written at the beginning of the file\n \"\"\"\n hdr = []\n\n if comments is None:\n comments = ''\n\n # table header\n length = max(map(len, tab.header.keys()))\n fmt = '{{0:s}} {{1:{0:d}s}}\\t{{2:s}}'.format(length)\n for k, v in tab.header.items():\n for vk in v.split('\\n'):\n if len(vk) > 0:\n hdr.append(fmt.format(comments, k.upper(), vk.strip()))\n\n # column metadata\n hdr.append(comments) # add empty line\n length = max(map(len, tab.keys()))\n fmt = '{{0:s}}{{0:s}} {{1:{0:d}s}}\\t{{2:s}}\\t{{3:s}}'.format(length)\n for colname in tab.keys():\n unit = tab._units.get(colname, 'None')\n desc = tab._desc.get(colname, 'None')\n hdr.append(fmt.format(comments, colname, unit, desc))\n\n # aliases\n if len(tab._aliases) > 0:\n hdr.append(comments) # add empty line\n for k, v in tab._aliases.items():\n hdr.append('{0:s} alias\\t{1:s}={2:s}'.format(comments, k, v))\n\n # column names\n hdr.append(comments)\n if commentedHeader:\n hdr.append('{0:s} {1:s}'.format(comments, delimiter.join(tab.keys())))\n else:\n hdr.append('{0:s}'.format(delimiter.join(tab.keys())))\n\n return '\\n'.join(hdr)\n\n\ndef _latex_writeto(filename, tab, comments='%'):\n \"\"\" Write the data into a latex table format\n\n Parameters\n ----------\n filename: str\n file or unit to write into\n\n tab: SimpleTable instance\n table\n\n comments: str\n string to prepend header lines\n\n delimiter: str, optional\n The string used to separate values. By default, this is any\n whitespace.\n\n commentedHeader: bool, optional\n if set, the last line of the header is expected to be the column titles\n \"\"\"\n txt = \"\\\\begin{table}\\n\\\\begin{center}\\n\"\n\n # add caption\n tabname = tab.header.get('NAME', None)\n if tabname not in ['', None, 'None']:\n txt += \"\\\\caption{{{0:s}}}\\n\".format(tabname)\n\n # tabular\n txt += '\\\\begin{{tabular}}{{{0:s}}}\\n'.format('c' tab.ncols)\n txt += tab.pprint(delim=' & ', fields='MAG', headerChar='', endline='\\\\\\\\\\n', all=True, ret=True)\n txt += '\\\\end{tabular}\\n'\n\n # end table\n txt += \"\\\\end{center}\\n\"\n\n # add notes if any\n if len(tab._desc) > 0:\n txt += '\\% notes \\n\\\\begin{scriptsize}\\n'\n for e, (k, v) in enumerate(tab._desc.items()):\n if v not in (None, 'None', 'none', ''):\n txt += '{0:d} {1:s}: {2:s} \\\\\\\\\\n'.format(e, k, v)\n txt += '\\\\end{scriptsize}\\n'\n txt += \"\\\\end{table}\\n\"\n if hasattr(filename, 'write'):\n filename.write(txt)\n else:\n with open(filename, 'w') as unit:\n unit.write(txt)\n\n\ndef _convert_dict_to_structured_ndarray(data):\n \"\"\"convert_dict_to_structured_ndarray\n\n Parameters\n ----------\n\n data: dictionary like object\n data structure which provides iteritems and itervalues\n\n returns\n -------\n tab: structured ndarray\n structured numpy array\n \"\"\"\n newdtype = []\n try:\n for key, dk in iteritems(data):\n _dk = np.asarray(dk)\n dtype = _dk.dtype\n # unknown type is converted to text\n if dtype.type == np.object_:\n if len(data) == 0:\n longest = 0\n else:\n longest = len(max(_dk, key=len))\n _dk = _dk.astype('\|%iS' % longest)\n if _dk.ndim > 1:\n newdtype.append((str(key), _dk.dtype, (_dk.shape[1],)))\n else:\n newdtype.append((str(key), _dk.dtype))\n tab = np.rec.fromarrays(itervalues(data), dtype=newdtype)\n except AttributeError: # not a dict\n # hope it's a tuple ((key, value),) pairs.\n from itertools import tee\n d1, d2 = tee(data)\n for key, dk in d1:\n _dk = np.asarray(dk)\n dtype = _dk.dtype\n # unknown type is converted to text\n if dtype.type == np.object_:\n if len(data) == 0:\n longest = 0\n else:\n longest = len(max(_dk, key=len))\n _dk = _dk.astype('\|%iS' % longest)\n if _dk.ndim > 1:\n newdtype.append((str(key), _dk.dtype, (_dk.shape[1],)))\n else:\n newdtype.append((str(key), _dk.dtype))\n tab = np.rec.fromarrays((dk for (_, dk) in d2), dtype=newdtype)\n\n return tab\n\n\ndef __indent__(rows, header=None, units=None, headerChar='-',\n delim=' \| ', endline='\\n', kwargs):\n \"\"\"Indents a table by column.\n\n Parameters\n ----------\n rows: sequences of rows\n one sequence per row.\n\n header: sequence of str\n row consists of the columns' names\n\n units: sequence of str\n Sequence of units\n\n headerChar: char\n Character to be used for the row separator line\n\n delim: char\n The column delimiter.\n\n returns\n -------\n txt: str\n string represation of rows\n \"\"\"\n length_data = list(map(max, zip([list(map(len, k)) for k in rows])))\n length = length_data[:]\n\n if (header is not None):\n length_header = list(map(len, header))\n length = list(map(max, zip(length_data, length_header)))\n\n if (units is not None):\n length_units = list(map(len, units))\n length = list(map(max, zip(length_data, length_units)))\n\n if headerChar not in (None, '', ' '):\n rowSeparator = headerChar * (sum(length) + len(delim) * (len(length) - 1)) + endline\n else:\n rowSeparator = ''\n\n # make the format\n fmt = ['{{{0:d}:{1:d}s}}'.format(k, l) for (k, l) in enumerate(length)]\n fmt = delim.join(fmt) + endline\n # write the string\n txt = rowSeparator\n if header is not None:\n txt += fmt.format(header) # + endline\n txt += rowSeparator\n if units is not None:\n txt += fmt.format(units) # + endline\n txt += rowSeparator\n for r in rows:\n txt += fmt.format(r) # + endline\n txt += rowSeparator\n return txt\n\n\ndef pprint_rec_entry(data, num=0, keys=None):\n \"\"\" print one line with key and values properly to be readable\n\n Parameters\n ----------\n data: recarray\n data to extract entry from\n\n num: int, slice\n indice selection\n\n keys: sequence or str\n if str, can be a regular expression\n if sequence, the sequence of keys to print\n \"\"\"\n if (keys is None) or (keys == ''):\n _keys = data.dtype.names\n elif type(keys) in basestring:\n _keys = [k for k in data.dtype.names if (re.match(keys, k) is not None)]\n else:\n _keys = keys\n\n length = max(map(len, _keys))\n fmt = '{{0:{0:d}s}}: {{1}}'.format(length)\n data = data[num]\n\n for k in _keys:\n print(fmt.format(k, data[k]))\n\n\ndef pprint_rec_array(data, idx=None, fields=None, ret=False, all=False,\n headerChar='-', delim=' \| ', endline='\\n' ):\n \"\"\" Pretty print the table content\n you can select the table parts to display using idx to\n select the rows and fields to only display some columns\n (ret is only for insternal use)\n\n Parameters\n ----------\n data: array\n array to show\n\n idx: sequence, slide\n sub selection to print\n\n fields: str, sequence\n if str can be a regular expression, and/or list of fields separated\n by spaces or commas\n\n ret: bool\n if set return the string representation instead of printing the result\n\n all: bool\n if set, force to show all rows\n\n headerChar: char\n Character to be used for the row separator line\n\n delim: char\n The column delimiter.\n \"\"\"\n if (fields is None) or (fields == ''):\n _keys = data.dtype.names\n elif type(fields) in basestring:\n if ',' in fields:\n _fields = fields.split(',')\n elif ' ' in fields:\n _fields = fields.split()\n else:\n _fields = [fields]\n lbls = data.dtype.names\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (re.match(_fk, k) is not None)]\n else:\n lbls = data.dtype.names\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (re.match(_fk, k) is not None)]\n\n nfields = len(_keys)\n nrows = len(data)\n fields = list(_keys)\n\n if idx is None:\n if (nrows < 10) or (all is True):\n rows = [ [ str(data[k][rk]) for k in _keys ] for rk in range(nrows)]\n else:\n _idx = range(6)\n rows = [ [ str(data[k][rk]) for k in _keys ] for rk in range(5) ]\n if nfields > 1:\n rows += [ ['...' for k in range(nfields) ] ]\n else:\n rows += [ ['...' for k in range(nfields) ] ]\n rows += [ [ str(data[k][rk]) for k in fields ] for rk in range(-5, 0)]\n elif isinstance(idx, slice):\n _idx = range(idx.start, idx.stop, idx.step or 1)\n rows = [ [ str(data[k][rk]) for k in fields ] for rk in _idx]\n else:\n rows = [ [ str(data[k][rk]) for k in fields ] for rk in idx]\n\n out = __indent__(rows, header=_keys, units=None, delim=delim,\n headerChar=headerChar, endline=endline)\n if ret is True:\n return out\n else:\n print(out)\n\n\ndef elementwise(func):\n \"\"\"\n Quick and dirty elementwise function decorator it provides a quick way\n to apply a function either on one element or a sequence of elements\n \"\"\"\n @wraps(func)\n def wrapper(it, kwargs):\n if hasattr(it, '__iter__') & (type(it) not in basestring):\n _f = partial(func, kwargs)\n return map(_f, it)\n else:\n return func(it, kwargs)\n return wrapper\n\n\nclass AstroHelpers(object):\n \"\"\" Helpers related to astronomy data \"\"\"\n\n @staticmethod\n @elementwise\n def hms2deg(_str, delim=':'):\n \"\"\" Convert hex coordinates into degrees\n\n Parameters\n ----------\n str: string or sequence\n string to convert\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n deg: float\n angle in degrees\n \"\"\"\n if _str[0] == '-':\n neg = -1\n _str = _str[1:]\n else:\n neg = 1\n _str = _str.split(delim)\n return neg ((((float(_str[-1]) / 60. +\n float(_str[1])) / 60. +\n float(_str[0])) / 24. * 360.))\n\n @staticmethod\n @elementwise\n def deg2dms(val, delim=':'):\n \"\"\" Convert degrees into hex coordinates\n\n Parameters\n ----------\n deg: float\n angle in degrees\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n str: string or sequence\n string to convert\n \"\"\"\n if val < 0:\n sign = -1\n else:\n sign = 1\n d = int( sign * val )\n m = int( (sign * val - d) * 60. )\n s = (( sign * val - d) * 60. - m) * 60.\n return '{0}{1}{2}{3}{4}'.format( sign * d, delim, m, delim, s)\n\n @staticmethod\n @elementwise\n def deg2hms(val, delim=':'):\n \"\"\" Convert degrees into hex coordinates\n\n Parameters\n ----------\n deg: float\n angle in degrees\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n str: string or sequence\n string to convert\n \"\"\"\n if val < 0:\n sign = -1\n else:\n sign = 1\n h = int( sign * val / 45. * 3.) # * 24 / 360\n m = int( (sign * val / 45. * 3. - h) * 60. )\n s = (( sign * val / 45. * 3. - h) * 60. - m) * 60.\n return '{0}{1}{2}{3}{4}'.format( sign * h, delim, m, delim, s)\n\n @staticmethod\n @elementwise\n def dms2deg(_str, delim=':'):\n \"\"\" Convert hex coordinates into degrees\n\n Parameters\n ----------\n str: string or sequence\n string to convert\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n deg: float\n angle in degrees\n \"\"\"\n if _str[0] == '-':\n neg = -1\n _str = _str[1:]\n else:\n neg = 1\n _str = _str.split(delim)\n return (neg * ((float(_str[-1]) / 60. + float(_str[1])) / 60. + float(_str[0])))\n\n @staticmethod\n @elementwise\n def euler(ai_in, bi_in, select, b1950=False, dtype='f8'):\n \"\"\"\n Transform between Galactic, celestial, and ecliptic coordinates.\n Celestial coordinates (RA, Dec) should be given in equinox J2000\n unless the b1950 is True.\n\n +-------+--------------+------------+----------+----------+-----------+\n \|select \| From \| To \| select \| From \| To \|\n +-------+--------------+------------+----------+----------+-----------+\n \|1 \|RA-Dec (2000) \| Galactic \| 4 \| Ecliptic \| RA-Dec \|\n +-------+--------------+------------+----------+----------+-----------+\n \|2 \|Galactic \| RA-DEC \| 5 \| Ecliptic \| Galactic \|\n +-------+--------------+------------+----------+----------+-----------+\n \|3 \|RA-Dec \| Ecliptic \| 6 \| Galactic \| Ecliptic \|\n +-------+--------------+------------+----------+----------+-----------+\n\n Parameters\n ----------\n\n long_in: float, or sequence\n Input Longitude in DEGREES, scalar or vector.\n\n lat_in: float, or sequence\n Latitude in DEGREES\n\n select: int\n Integer from 1 to 6 specifying type of coordinate transformation.\n\n b1950: bool\n set equinox set to 1950\n\n\n Returns\n -------\n long_out: float, seq\n Output Longitude in DEGREES\n\n lat_out: float, seq\n Output Latitude in DEGREES\n\n\n .. note::\n\n Written W. Landsman, February 1987\n Adapted from Fortran by Daryl Yentis NRL\n Converted to IDL V5.0 W. Landsman September 1997\n Made J2000 the default, added /FK4 keyword W. Landsman December 1998\n Add option to specify SELECT as a keyword W. Landsman March 2003\n Converted from IDL to numerical Python: Erin Sheldon, NYU, 2008-07-02\n \"\"\"\n\n # Make a copy as an array. ndmin=1 to avoid messed up scalar arrays\n ai = np.array(ai_in, ndmin=1, copy=True, dtype=dtype)\n bi = np.array(bi_in, ndmin=1, copy=True, dtype=dtype)\n\n PI = math.pi\n # HALFPI = PI / 2.0\n D2R = PI / 180.0\n R2D = 1.0 / D2R\n\n twopi = 2.0 * PI\n fourpi = 4.0 * PI\n\n # J2000 coordinate conversions are based on the following constants\n # (see the Hipparcos explanatory supplement).\n # eps = 23.4392911111d Obliquity of the ecliptic\n # alphaG = 192.85948d Right Ascension of Galactic North Pole\n # deltaG = 27.12825d Declination of Galactic North Pole\n # lomega = 32.93192d Galactic longitude of celestial equator\n # alphaE = 180.02322d Ecliptic longitude of Galactic North Pole\n # deltaE = 29.811438523d Ecliptic latitude of Galactic North Pole\n # Eomega = 6.3839743d Galactic longitude of ecliptic equator\n # Parameters for all the different conversions\n if b1950:\n # equinox = '(B1950)'\n psi = np.array([ 0.57595865315, 4.9261918136,\n 0.00000000000, 0.0000000000,\n 0.11129056012, 4.7005372834], dtype=dtype)\n stheta = np.array([ 0.88781538514, -0.88781538514,\n 0.39788119938, -0.39788119938,\n 0.86766174755, -0.86766174755], dtype=dtype)\n ctheta = np.array([ 0.46019978478, 0.46019978478,\n 0.91743694670, 0.91743694670,\n 0.49715499774, 0.49715499774], dtype=dtype)\n phi = np.array([ 4.9261918136, 0.57595865315,\n 0.0000000000, 0.00000000000,\n 4.7005372834, 0.11129056012], dtype=dtype)\n else:\n # equinox = '(J2000)'\n psi = np.array([ 0.57477043300, 4.9368292465,\n 0.00000000000, 0.0000000000,\n 0.11142137093, 4.71279419371], dtype=dtype)\n stheta = np.array([ 0.88998808748, -0.88998808748,\n 0.39777715593, -0.39777715593,\n 0.86766622025, -0.86766622025], dtype=dtype)\n ctheta = np.array([ 0.45598377618, 0.45598377618,\n 0.91748206207, 0.91748206207,\n 0.49714719172, 0.49714719172], dtype=dtype)\n phi = np.array([ 4.9368292465, 0.57477043300,\n 0.0000000000, 0.00000000000,\n 4.71279419371, 0.11142137093], dtype=dtype)\n\n # zero offset\n i = select - 1\n a = ai * D2R - phi[i]\n\n b = bi * D2R\n sb = sin(b)\n cb = cos(b)\n cbsa = cb * sin(a)\n b = -stheta[i] * cbsa + ctheta[i] * sb\n w, = np.where(b > 1.0)\n if w.size > 0:\n b[w] = 1.0\n bo = arcsin(b) * R2D\n a = arctan2( ctheta[i] * cbsa + stheta[i] * sb, cb * cos(a) )\n ao = ( (a + psi[i] + fourpi) % twopi) * R2D\n return ao, bo\n\n @staticmethod\n def sphdist(ra1, dec1, ra2, dec2):\n \"\"\"measures the spherical distance between 2 points\n\n Parameters\n ----------\n ra1: float or sequence\n first right ascensions in degrees\n\n dec1: float or sequence\n first declination in degrees\n ra2: float or sequence\n second right ascensions in degrees\n dec2: float or sequence\n first declination in degrees\n\n Returns\n -------\n Outputs: float or sequence\n returns a distance in degrees\n \"\"\"\n dec1_r = deg2rad(dec1)\n dec2_r = deg2rad(dec2)\n return 2. * rad2deg(arcsin(sqrt((sin((dec1_r - dec2_r) / 2)) ** 2 +\n cos(dec1_r) * cos(dec2_r) * (\n sin((deg2rad(ra1 - ra2)) / 2)) *\n 2)))\n\n @staticmethod\n def conesearch(ra0, dec0, ra, dec, r, outtype=0):\n \"\"\" Perform a cone search on a table\n\n Parameters\n ----------\n ra0: ndarray[ndim=1, dtype=float]\n column name to use as RA source in degrees\n\n dec0: ndarray[ndim=1, dtype=float]\n column name to use as DEC source in degrees\n\n ra: float\n ra to look for (in degree)\n\n dec: float\n ra to look for (in degree)\n\n r: float\n distance in degrees\n\n outtype: int\n type of outputs\n 0 -- minimal, indices of matching coordinates\n 1 -- indices and distances of matching coordinates\n 2 -- full, boolean filter and distances\n\n Returns\n -------\n t: tuple\n if outtype is 0:\n only return indices from ra0, dec0\n elif outtype is 1:\n return indices from ra0, dec0 and distances\n elif outtype is 2:\n return conditional vector and distance to all ra0, dec0\n \"\"\"\n @elementwise\n def getDist( pk ):\n \"\"\" get spherical distance between 2 points \"\"\"\n return AstroHelpers.sphdist(pk[0], pk[1], ra, dec)\n\n dist = np.array(list(getDist(zip(ra0, dec0))))\n v = (dist <= r)\n\n if outtype == 0:\n return np.ravel(np.where(v))\n elif outtype == 1:\n return np.ravel(np.where(v)), dist[v]\n else:\n return v, dist\n\n\n# ==============================================================================\n# SimpleTable -- provides table manipulations with limited storage formats\n# ==============================================================================\nclass SimpleTable(object):\n \"\"\" Table class that is designed to be the basis of any format wrapping\n around numpy recarrays\n\n Attributes\n ----------\n\n fname: str or object\n if str, the file to read from. This may be limited to the format\n currently handled automatically. If the format is not correctly handled,\n you can try by providing an object.__\n\n if object with a structure like dict, ndarray, or recarray-like\n the data will be encapsulated into a Table\n\n caseless: bool\n if set, column names will be caseless during operations\n\n aliases: dict\n set of column aliases (can be defined later :func:`set_alias`)\n\n units: dict\n set of column units (can be defined later :func:`set_unit`)\n\n desc: dict\n set of column description or comments (can be defined later :func:`set_comment`)\n\n header: dict\n key, value pair corresponding to the attributes of the table\n \"\"\"\n\n def __init__(self, fname, args, kwargs):\n\n dtype = kwargs.pop('dtype', None)\n dtype = kwargs.pop('format', dtype)\n self.caseless = kwargs.get('caseless', False)\n self._aliases = kwargs.get('aliases', {})\n self._units = kwargs.get('units', {})\n self._desc = kwargs.get('desc', {})\n\n if (isinstance(fname, (dict, tuple, list, types.GeneratorType))) or (dtype in [dict, 'dict']):\n try:\n self.header = fname.pop('header', {})\n except (AttributeError, TypeError):\n self.header = kwargs.pop('header', {})\n self.data = _convert_dict_to_structured_ndarray(fname)\n elif (type(fname) in basestring) or (dtype is not None):\n if (type(fname) in basestring):\n extension = fname.split('.')[-1]\n else:\n extension = None\n if (extension == 'csv') or dtype == 'csv':\n kwargs.setdefault('delimiter', ',')\n commentedHeader = kwargs.pop('commentedHeader', False)\n n, header, units, comments, aliases, names = _ascii_read_header(fname, commentedHeader=commentedHeader, kwargs)\n if 'names' in kwargs:\n n -= 1\n kwargs.setdefault('names', names)\n if _pd is not None: # pandas is faster\n kwargs.setdefault('comment', '#')\n kwargs.setdefault('skiprows', n)\n self.data = _pd.read_csv(fname, args, kwargs).to_records()\n else:\n kwargs.setdefault('skip_header', n)\n kwargs.setdefault('comments', '#')\n self.data = np.recfromcsv(fname, args, kwargs)\n self.header = header\n self._units.update(units)\n self._desc.update(comments)\n self._aliases.update(aliases)\n kwargs.setdefault('names', True)\n elif (extension in ('tsv', 'dat', 'txt')) or (dtype in ('tsv', 'dat', 'txt')):\n commentedHeader = kwargs.pop('commentedHeader', True)\n n, header, units, comments, aliases, names = _ascii_read_header(fname, commentedHeader=commentedHeader, *kwargs)\n kwargs.setdefault('names', names)\n if _pd is not None: # pandas is faster\n kwargs.setdefault('delimiter', '\\s+')\n kwargs.setdefault('comment', '#')\n self.data = _pd.read_csv(fname, args, *kwargs).to_records()\n else:\n kwargs.setdefault('delimiter', None)\n kwargs.setdefault('comments', '#')\n kwargs.setdefault('skip_header', n)\n self.data = np.recfromtxt(fname, args, kwargs)\n self.header = header\n self._units.update(units)\n self._desc.update(comments)\n self._aliases.update(aliases)\n elif (extension == 'fits') or dtype == 'fits':\n if pyfits is None:\n raise RuntimeError('Cannot read this format, Astropy or pyfits not found')\n if ('extname' not in kwargs) and ('ext' not in kwargs) and (len(args) == 0):\n args = (1, )\n self.data = np.array(pyfits.getdata(fname, args, kwargs))\n header, aliases, units, comments = _fits_read_header(pyfits.getheader(fname, args, kwargs))\n self.header = header\n self._desc.update(comments)\n self._units.update(units)\n self._aliases.update(aliases)\n elif (extension in ('hdf5', 'hd5', 'hdf')) or (dtype in ('hdf5', 'hd5', 'hdf')):\n if tables is None:\n raise RuntimeError('Cannot read this format, pytables not found')\n hdr, aliases, units, desc, data = _hdf5_read_data(fname, args, kwargs)\n self.data = data\n self.header = hdr\n self._units.update(units)\n self._desc.update(desc)\n self._aliases.update(aliases)\n elif (extension in ('vot', 'votable')) or (dtype in ('vot', 'votable')):\n # Votable case\n if _astropytable is None:\n raise RuntimeError('Cannot read this votable format, astropy not found')\n data = _astropytable.read(fname, format='votable', args, *kwargs)\n units = [(k, data[k].unit.name) for k in data.keys()]\n desc = [(k, data[k].description) for k in data.keys()]\n self.data = data.as_array()\n self.header = {}\n self._units.update(units)\n self._desc.update(desc)\n else:\n raise Exception('Format {0:s} not handled'.format(extension))\n elif type(fname) == np.ndarray:\n self.data = fname\n self.header = {}\n elif type(fname) == pyfits.FITS_rec:\n self.data = np.array(fname)\n self.header = {}\n elif isinstance(fname, SimpleTable):\n cp = kwargs.pop('copy', True)\n if cp:\n self.data = deepcopy(fname.data)\n self.header = deepcopy(fname.header)\n self._aliases = deepcopy(fname._aliases)\n self._units = deepcopy(fname._units)\n self._desc = deepcopy(fname._desc)\n else:\n self.data = fname.data\n self.header = fname.header\n self._aliases = fname._aliases\n self._units = fname._units\n self._desc = fname._desc\n elif hasattr(fname, 'dtype'):\n self.data = np.array(fname)\n self.header = {}\n else:\n raise Exception('Type {0!s:s} not handled'.format(type(fname)))\n if 'NAME' not in self.header:\n if type(fname) not in basestring:\n self.header['NAME'] = 'No Name'\n else:\n self.header['NAME'] = fname\n\n def pprint_entry(self, num, keys=None):\n \"\"\" print one line with key and values properly to be readable\n\n Parameters\n ----------\n num: int, slice\n indice selection\n\n keys: sequence or str\n if str, can be a regular expression\n if sequence, the sequence of keys to print\n \"\"\"\n if (keys is None) or (keys == ''):\n _keys = self.keys()\n elif type(keys) in basestring:\n _keys = [k for k in (self.keys() + tuple(self._aliases.keys()))\n if (re.match(keys, k) is not None)]\n else:\n _keys = keys\n\n length = max(map(len, _keys))\n fmt = '{{0:{0:d}s}}: {{1}}'.format(length)\n data = self[num]\n\n for k in _keys:\n print(fmt.format(k, data[self.resolve_alias(k)]))\n\n def pprint(self, idx=None, fields=None, ret=False, all=False,\n full_match=False, headerChar='-', delim=' \| ', endline='\\n',\n *kwargs):\n \"\"\" Pretty print the table content\n you can select the table parts to display using idx to\n select the rows and fields to only display some columns\n (ret is only for insternal use)\n\n Parameters\n ----------\n\n idx: sequence, slide\n sub selection to print\n\n fields: str, sequence\n if str can be a regular expression, and/or list of fields separated\n by spaces or commas\n\n ret: bool\n if set return the string representation instead of printing the result\n\n all: bool\n if set, force to show all rows\n\n headerChar: char\n Character to be used for the row separator line\n\n delim: char\n The column delimiter.\n \"\"\"\n if full_match is True:\n fn = re.fullmatch\n else:\n fn = re.match\n\n if (fields is None) or (fields == ''):\n _keys = self.keys()\n elif type(fields) in basestring:\n if ',' in fields:\n _fields = fields.split(',')\n elif ' ' in fields:\n _fields = fields.split()\n else:\n _fields = [fields]\n lbls = self.keys() + tuple(self._aliases.keys())\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (fn(_fk, k) is not None)]\n else:\n lbls = self.keys() + tuple(self._aliases.keys())\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (fn(_fk, k) is not None)]\n\n nfields = len(_keys)\n\n fields = list(map( self.resolve_alias, _keys ))\n\n if idx is None:\n if (self.nrows < 10) or all:\n rows = [ [ str(self[k][rk]) for k in _keys ] for rk in range(self.nrows)]\n else:\n _idx = range(6)\n rows = [ [ str(self[k][rk]) for k in _keys ] for rk in range(5) ]\n if nfields > 1:\n rows += [ ['...' for k in range(nfields) ] ]\n else:\n rows += [ ['...' for k in range(nfields) ] ]\n rows += [ [ str(self[k][rk]) for k in fields ] for rk in range(-5, 0)]\n elif isinstance(idx, slice):\n _idx = range(idx.start, idx.stop, idx.step or 1)\n rows = [ [ str(self[k][rk]) for k in fields ] for rk in _idx]\n else:\n rows = [ [ str(self[k][rk]) for k in fields ] for rk in idx]\n\n if len(self._units) == 0:\n units = None\n else:\n units = [ '(' + str( self._units.get(k, None) or '') + ')' for k in fields ]\n\n out = __indent__(rows, header=_keys, units=units, delim=delim,\n headerChar=headerChar, endline=endline)\n if ret is True:\n return out\n else:\n print(out)\n\n def write(self, fname, kwargs):\n \"\"\" write table into file\n\n Parameters\n ----------\n fname: str\n filename to export the table into\n\n .. note::\n additional keywords are forwarded to the corresponding libraries\n :func:`pyfits.writeto` or :func:`pyfits.append`\n :func:`np.savetxt`\n \"\"\"\n extension = kwargs.pop('extension', None)\n if extension is None:\n extension = fname.split('.')[-1]\n if (extension == 'csv'):\n comments = kwargs.pop('comments', '#')\n delimiter = kwargs.pop('delimiter', ',')\n commentedHeader = kwargs.pop('commentedHeader', False)\n hdr = _ascii_generate_header(self, comments=comments, delimiter=delimiter,\n commentedHeader=commentedHeader)\n header = kwargs.pop('header', hdr)\n np.savetxt(fname, self.data, delimiter=delimiter, header=header,\n comments='', kwargs)\n elif (extension in ['txt', 'dat']):\n comments = kwargs.pop('comments', '#')\n delimiter = kwargs.pop('delimiter', ' ')\n commentedHeader = kwargs.pop('commentedHeader', True)\n hdr = _ascii_generate_header(self, comments=comments, delimiter=delimiter,\n commentedHeader=commentedHeader)\n header = kwargs.pop('header', hdr)\n np.savetxt(fname, self.data, delimiter=delimiter, header=header,\n comments='', kwargs)\n elif (extension == 'fits'):\n hdr0 = kwargs.pop('header', None)\n append = kwargs.pop('append', False)\n hdr = _fits_generate_header(self)\n if hdr0 is not None:\n hdr.update(hdr0)\n if append:\n _fits_append(fname, self.data, hdr, kwargs)\n else:\n # patched version to correctly include the header\n _fits_writeto(fname, self.data, hdr, kwargs)\n elif (extension in ('hdf', 'hdf5', 'hd5')):\n _hdf5_write_data(fname, self.data, header=self.header,\n units=self._units, comments=self._desc,\n aliases=self._aliases, kwargs)\n else:\n raise Exception('Format {0:s} not handled'.format(extension))\n\n def to_records(self, kwargs):\n \"\"\" Construct a numpy record array from this dataframe \"\"\"\n return self.data\n\n def to_pandas(self, kwargs):\n \"\"\" Construct a pandas dataframe\n\n Parameters\n ----------\n data : ndarray \n (structured dtype), list of tuples, dict, or DataFrame\n keys: sequence, optional\n ordered subset of columns to export\n index : string, list of fields, array-like\n Field of array to use as the index, alternately a specific set of\n input labels to use\n exclude : sequence, default None\n Columns or fields to exclude\n columns : sequence, default None\n Column names to use. If the passed data do not have names\n associated with them, this argument provides names for the\n columns. Otherwise this argument indicates the order of the columns\n in the result (any names not found in the data will become all-NA\n columns)\n coerce_float : boolean, default False\n Attempt to convert values to non-string, non-numeric objects (like\n decimal.Decimal) to floating point, useful for SQL result sets\n\n Returns\n -------\n df : DataFrame\n \"\"\"\n try:\n from pandas import DataFrame\n keys = kwargs.pop('keys', None)\n return DataFrame.from_dict(self.to_dict(keys=keys), kwargs)\n except ImportError as error:\n print(\"Pandas import error\")\n raise error\n\n def to_dict(self, keys=None, contiguous=False):\n \"\"\" Construct a dictionary from this dataframe with contiguous arrays\n\n Parameters\n ----------\n keys: sequence, optional\n ordered subset of columns to export\n\n contiguous: boolean\n make sure each value is a contiguous numpy array object\n (C-aligned)\n\n Returns\n -------\n data: dict\n converted data\n \"\"\"\n if keys is None:\n keys = self.keys()\n if contiguous:\n return {k: np.ascontiguousarray(self[k]) for k in keys}\n return {k: self[k] for k in keys}\n\n def to_xarray(self, kwargs):\n \"\"\" Construct an xarray dataset\n\n Each column will be converted into an independent variable in the\n Dataset. If the dataframe's index is a MultiIndex, it will be expanded\n into a tensor product of one-dimensional indices (filling in missing\n values with NaN). This method will produce a Dataset very similar to\n that on which the 'to_dataframe' method was called, except with\n possibly redundant dimensions (since all dataset variables will have\n the same dimensionality).\n \"\"\"\n try:\n from xarray import Dataset\n return Dataset.from_dataframe(self.to_pandas(kwargs))\n except ImportError as error:\n print(\"xray import error\")\n raise error\n\n def to_vaex(self, kwargs):\n \"\"\"\n Create an in memory Vaex dataset\n\n Parameters\n ----------\n name: str\n unique for the dataset\n keys: sequence, optional\n ordered subset of columns to export\n\n Returns\n -------\n df: vaex.DataSetArrays\n vaex dataset\n \"\"\"\n try:\n import vaex\n return vaex.from_arrays(self.to_dict(contiguous=True, kwargs))\n except ImportError as error:\n print(\"Vaex import error\")\n raise error\n\n def to_dask(self, kwargs):\n \"\"\" Construct a Dask DataFrame\n\n This splits an in-memory Pandas dataframe into several parts and constructs\n a dask.dataframe from those parts on which Dask.dataframe can operate in\n parallel.\n\n Note that, despite parallelism, Dask.dataframe may not always be faster\n than Pandas. We recommend that you stay with Pandas for as long as\n possible before switching to Dask.dataframe.\n\n Parameters\n ----------\n keys: sequence, optional\n ordered subset of columns to export\n npartitions : int, optional\n The number of partitions of the index to create. Note that depending on\n the size and index of the dataframe, the output may have fewer\n partitions than requested.\n chunksize : int, optional\n The size of the partitions of the index.\n sort: bool\n Sort input first to obtain cleanly divided partitions or don't sort and\n don't get cleanly divided partitions\n name: string, optional\n An optional keyname for the dataframe. Defaults to hashing the input\n\n Returns\n -------\n dask.DataFrame or dask.Series\n A dask DataFrame/Series partitioned along the index\n \"\"\"\n try:\n from dask import dataframe\n keys = kwargs.pop('keys', None)\n return dataframe.from_pandas(self.to_pandas(keys=keys), kwargs)\n except ImportError as error:\n print(\"Dask import error\")\n raise error\n\n def to_astropy_table(self, kwargs):\n \"\"\"\n A class to represent tables of heterogeneous data.\n\n `astropy.table.Table` provides a class for heterogeneous tabular data,\n making use of a `numpy` structured array internally to store the data\n values. A key enhancement provided by the `Table` class is the ability\n to easily modify the structure of the table by adding or removing\n columns, or adding new rows of data. In addition table and column\n metadata are fully supported.\n\n Parameters\n ----------\n masked : bool, optional\n Specify whether the table is masked.\n names : list, optional\n Specify column names\n dtype : list, optional\n Specify column data types\n meta : dict, optional\n Metadata associated with the table.\n copy : bool, optional\n Copy the input data (default=True).\n rows : numpy ndarray, list of lists, optional\n Row-oriented data for table instead of ``data`` argument\n copy_indices : bool, optional\n Copy any indices in the input data (default=True)\n kwargs : dict, optional\n Additional keyword args when converting table-like object\n\n Returns\n -------\n df: astropy.table.Table\n dataframe\n \"\"\"\n try:\n from astropy.table import Table\n keys = kwargs.pop('keys', None)\n return Table(self.to_records(keys=keys), kwargs)\n except ImportError as e:\n print(\"Astropy import error\")\n raise e\n\n def _repr_html_(self):\n return self.to_pandas().head()._repr_html_()\n\n def set_alias(self, alias, colname):\n \"\"\"\n Define an alias to a column\n\n Parameters\n ----------\n alias: str\n The new alias of the column\n\n colname: str\n The column being aliased\n \"\"\"\n if (colname not in self.keys()):\n raise KeyError(\"Column {0:s} does not exist\".format(colname))\n self._aliases[alias] = colname\n\n def reverse_alias(self, colname):\n \"\"\"\n Return aliases of a given column.\n\n Given a colname, return a sequence of aliases associated to this column\n Aliases are defined by using .define_alias()\n \"\"\"\n _colname = self.resolve_alias(colname)\n if (_colname not in self.keys()):\n raise KeyError(\"Column {0:s} does not exist\".format(colname))\n\n return tuple([ k for (k, v) in self._aliases.iteritems() if (v == _colname) ])\n\n def resolve_alias(self, colname):\n \"\"\"\n Return the name of an aliased column.\n\n Given an alias, return the column name it aliases. This\n function is a no-op if the alias is a column name itself.\n\n Aliases are defined by using .define_alias()\n \"\"\"\n # User aliases\n if hasattr(colname, '__iter__') & (type(colname) not in basestring):\n return [ self.resolve_alias(k) for k in colname ]\n else:\n if self.caseless is True:\n maps = dict( [ (k.lower(), v) for k, v in self._aliases.items() ] )\n maps.update( (k.lower(), k) for k in self.keys() )\n return maps.get(colname.lower(), colname)\n else:\n return self._aliases.get(colname, colname)\n\n def set_unit(self, colname, unit):\n \"\"\" Set the unit of a column referenced by its name\n\n Parameters\n ----------\n colname: str\n column name or registered alias\n\n unit: str\n unit description\n \"\"\"\n if isinstance(unit, basestring) and isinstance(colname, basestring):\n self._units[self.resolve_alias(colname)] = str(unit)\n else:\n for k, v in zip(colname, unit):\n self._units[self.resolve_alias(k)] = str(v)\n\n def set_comment(self, colname, comment):\n \"\"\" Set the comment of a column referenced by its name\n\n Parameters\n ----------\n colname: str\n column name or registered alias\n\n comment: str\n column description\n \"\"\"\n if isinstance(comment, basestring) and isinstance(colname, basestring):\n self._desc[self.resolve_alias(colname)] = str(comment)\n else:\n for k, v in zip(colname, comment):\n self._desc[self.resolve_alias(k)] = str(v)\n\n def keys(self, regexp=None, full_match=False):\n \"\"\"\n Return the data column names or a subset of it\n\n Parameters\n ----------\n regexp: str\n pattern to filter the keys with\n\n full_match: bool\n if set, use :func:`re.fullmatch` instead of :func:`re.match`\n\n Try to apply the pattern at the start of the string, returning\n a match object, or None if no match was found.\n\n returns\n -------\n seq: sequence\n sequence of keys\n \"\"\"\n if (regexp is None) or (regexp == ''):\n return self.colnames\n elif type(regexp) in basestring:\n if full_match is True:\n fn = re.fullmatch\n else:\n fn = re.match\n\n if regexp.count(',') > 0:\n _re = regexp.split(',')\n elif regexp.count(' ') > 0:\n _re = regexp.split()\n else:\n _re = [regexp]\n\n lbls = self.colnames + tuple(self._aliases.keys())\n _keys = []\n for _rk in _re:\n _keys += [k for k in lbls if (fn(_rk, k) is not None)]\n\n return _keys\n elif hasattr(regexp, '__iter__'):\n _keys = []\n for k in regexp:\n _keys += self.keys(k)\n return _keys\n else:\n raise ValueError('Unexpected type {0} for regexp'.format(type(regexp)))\n\n @property\n def name(self):\n \"\"\" name of the table given by the Header['NAME'] attribute \"\"\"\n return self.header.get('NAME', None)\n\n @property\n def colnames(self):\n \"\"\" Sequence of column names \"\"\"\n return self.data.dtype.names\n\n @property\n def ncols(self):\n \"\"\" number of columns \"\"\"\n return len(self.colnames)\n\n @property\n def nrows(self):\n \"\"\" number of lines \"\"\"\n return len(self.data)\n\n @property\n def nbytes(self):\n \"\"\" number of bytes of the object \"\"\"\n n = sum(k.nbytes if hasattr(k, 'nbytes') else sys.getsizeof(k)\n for k in self.__dict__.values())\n return n\n\n def __len__(self):\n \"\"\" number of lines \"\"\"\n return self.nrows\n\n @property\n def shape(self):\n \"\"\" shape of the data \"\"\"\n return self.data.shape\n\n @property\n def dtype(self):\n \"\"\" dtype of the data \"\"\"\n return self.data.dtype\n\n @property\n def Plotter(self):\n \"\"\" Plotter instance related to this dataset.\n Requires plotter add-on to work \"\"\"\n if Plotter is None:\n raise AttributeError('the add-on was not found, this property is not available')\n else:\n return Plotter(self, label=self.name)\n\n def __getitem__(self, v):\n return np.asarray(self.data.__getitem__(self.resolve_alias(v)))\n\n def take(self, indices, axis=None, out=None, mode='raise'):\n \"\"\"\n Take elements from an array along an axis.\n\n This function does the same thing as \"fancy\" indexing (indexing arrays\n using arrays); however, it can be easier to use if you need elements\n along a given axis.\n\n Parameters\n ----------\n indices : array_like\n The indices of the values to extract.\n Also allow scalars for indices.\n\n axis : int, optional\n The axis over which to select values. By default, the flattened\n input array is used.\n\n out : ndarray, optional\n If provided, the result will be placed in this array. It should\n be of the appropriate shape and dtype.\n\n mode : {'raise', 'wrap', 'clip'}, optional\n Specifies how out-of-bounds indices will behave.\n\n 'raise' -- raise an error (default)\n * 'wrap' -- wrap around\n * 'clip' -- clip to the range\n\n 'clip' mode means that all indices that are too large are replaced\n by the index that addresses the last element along that axis. Note\n that this disables indexing with negative numbers.\n\n Returns\n -------\n subarray : ndarray\n The returned array has the same type as `a`.\n \"\"\"\n return self.data.take(indices, axis, out, mode)\n\n def compress(self, condition, axis=None, out=None):\n \"\"\"\n Return selected slices of an array along given axis.\n\n When working along a given axis, a slice along that axis is returned in\n `output` for each index where `condition` evaluates to True. When\n working on a 1-D array, `compress` is equivalent to `extract`.\n\n Parameters\n ----------\n condition : 1-D array of bools\n Array that selects which entries to return. If len(condition)\n is less than the size of `a` along the given axis, then output is\n truncated to the length of the condition array.\n\n axis : int, optional\n Axis along which to take slices. If None (default), work on the\n flattened array.\n\n out : ndarray, optional\n Output array. Its type is preserved and it must be of the right\n shape to hold the output.\n\n Returns\n -------\n compressed_array : ndarray\n A copy of `a` without the slices along axis for which `condition`\n is false.\n \"\"\"\n return self.data.compress(condition, axis, out)\n\n def get(self, v, full_match=False):\n \"\"\" returns a table from columns given as v\n\n this function is equivalent to :func:`__getitem__` but preserve the\n Table format and associated properties (units, description, header)\n\n Parameters\n ----------\n v: str\n pattern to filter the keys with\n\n full_match: bool\n if set, use :func:`re.fullmatch` instead of :func:`re.match`\n\n \"\"\"\n new_keys = self.keys(v)\n t = self.__class__(self[new_keys])\n t.header.update(*self.header)\n t._aliases.update((k, v) for (k, v) in self._aliases.items() if v in new_keys)\n t._units.update((k, v) for (k, v) in self._units.items() if v in new_keys)\n t._desc.update((k, v) for (k, v) in self._desc.items() if v in new_keys)\n return t\n\n def __setitem__(self, k, v):\n if k in self:\n return self.data.__setitem__(self.resolve_alias(k), v)\n else:\n object.__setitem__(self, k, v)\n\n def __getattr__(self, k):\n try:\n return self.data.__getitem__(self.resolve_alias(k))\n except:\n return object.__getattribute__(self, k)\n\n def __iter__(self):\n newtab = self.select('', [0])\n for d in self.data:\n newtab.data[0] = d\n yield newtab\n # return self.data.__iter__()\n\n def iterkeys(self):\n \"\"\" Iterator over the columns of the table \"\"\"\n for k in self.colnames:\n yield k\n\n def itervalues(self):\n \"\"\" Iterator over the lines of the table \"\"\"\n for l in self.data:\n yield l\n\n def items(self):\n \"\"\" Iterator on the (key, value) pairs \"\"\"\n for k in self.colnames:\n yield k, self[k]\n\n def info(self):\n \"\"\" prints information on the table \"\"\"\n s = \"\\nTable: {name:s}\\n nrows={s.nrows:d}, ncols={s.ncols:d}, mem={size:s}\"\n s = s.format(name=self.header.get('NAME', 'Noname'), s=self,\n size=pretty_size_print(self.nbytes))\n\n s += '\\n\\nHeader:\\n'\n vals = list(self.header.items())\n length = max(map(len, self.header.keys()))\n fmt = '\\t{{0:{0:d}s}} {{1}}\\n'.format(length)\n for k, v in vals:\n s += fmt.format(k, v)\n\n vals = [(k, self._units.get(k, ''), self._desc.get(k, ''))\n for k in self.colnames]\n lengths = [(len(k), len(self._units.get(k, '')), len(self._desc.get(k, '')))\n for k in self.colnames]\n lengths = list(map(max, (zip(lengths))))\n\n s += '\\nColumns:\\n'\n\n fmt = '\\t{{0:{0:d}s}} {{1:{1:d}s}} {{2:{2:d}s}}\\n'.format((k + 1 for k in lengths))\n for k, u, c in vals:\n s += fmt.format(k, u, c)\n\n print(s)\n\n if len(self._aliases) > 0:\n print(\"\\nTable contains alias(es):\")\n for k, v in self._aliases.items():\n print('\\t{0:s} --> {1:s}'.format(k, v))\n\n def __repr__(self):\n s = object.__repr__(self)\n s += \"\\nTable: {name:s}\\n nrows={s.nrows:d}, ncols={s.ncols:d}, mem={size:s}\"\n return s.format(name=self.header.get('NAME', 'Noname'), s=self,\n size=pretty_size_print(self.nbytes))\n\n def __getslice__(self, i, j):\n return self.data.__getslice__(i, j)\n\n def __contains__(self, k):\n if hasattr(k, 'decode'):\n _k = k.decode('utf8')\n else:\n _k = k\n return (_k in self.colnames) or (_k in self._aliases)\n\n def __array__(self):\n return self.data\n\n def __call__(self, args, kwargs):\n if (len(args) > 0) or (len(kwargs) > 0):\n return self.evalexpr(args, *kwargs)\n else:\n return self.info()\n\n def sort(self, keys, copy=False):\n \"\"\"\n Sort the table inplace according to one or more keys. This operates on\n the existing table (and does not return a new table).\n\n Parameters\n ----------\n\n keys: str or seq(str)\n The key(s) to order by\n\n copy: bool\n if set returns a sorted copy instead of working inplace\n \"\"\"\n if not hasattr(keys, '__iter__'):\n keys = [keys]\n\n if copy is False:\n self.data.sort(order=keys)\n else:\n t = self.__class__(self, copy=True)\n t.sort(keys, copy=False)\n return t\n\n def match(self, r2, key):\n \"\"\" Returns the indices at which the tables match\n matching uses 2 columns that are compared in values\n\n Parameters\n ----------\n r2: Table\n second table to use\n\n key: str\n fields used for comparison.\n\n Returns\n -------\n indexes: tuple\n tuple of both indices list where the two columns match.\n \"\"\"\n return np.where( np.equal.outer( self[key], r2[key] ) )\n\n def stack(self, r, args, *kwargs):\n \"\"\"\n Superposes arrays fields by fields inplace\n\n t.stack(t1, t2, t3, default=None, inplace=True)\n\n Parameters\n ----------\n r: Table\n \"\"\"\n if not hasattr(r, 'data'):\n raise AttributeError('r should be a Table object')\n defaults = kwargs.get('defaults', None)\n inplace = kwargs.get('inplace', False)\n\n data = [self.data, r.data] + [k.data for k in args]\n sdata = recfunctions.stack_arrays(data, defaults, usemask=False,\n asrecarray=True)\n\n if inplace:\n self.data = sdata\n else:\n t = self.__class__(self)\n t.data = sdata\n return t\n\n def join_by(self, r2, key, jointype='inner', r1postfix='1', r2postfix='2',\n defaults=None, asrecarray=False, asTable=True):\n \"\"\"\n Join arrays `r1` and `r2` on key `key`.\n\n The key should be either a string or a sequence of string corresponding\n to the fields used to join the array.\n An exception is raised if the `key` field cannot be found in the two input\n arrays.\n Neither `r1` nor `r2` should have any duplicates along `key`: the presence\n of duplicates will make the output quite unreliable. Note that duplicates\n are not looked for by the algorithm.\n\n Parameters\n ----------\n key: str or seq(str)\n corresponding to the fields used for comparison.\n\n r2: Table\n Table to join with\n\n jointype: str in {'inner', 'outer', 'leftouter'}\n 'inner' : returns the elements common to both r1 and r2.\n * 'outer' : returns the common elements as well as the elements of r1 not in r2 and the elements of not in r2.\n * 'leftouter' : returns the common elements and the elements of r1 not in r2.\n\n r1postfix: str\n String appended to the names of the fields of r1 that are present in r2\n\n r2postfix: str\n String appended to the names of the fields of r2 that are present in r1\n\n defaults: dict\n Dictionary mapping field names to the corresponding default values.\n\n Returns\n -------\n tab: Table\n joined table\n\n .. note::\n\n * The output is sorted along the key.\n\n * A temporary array is formed by dropping the fields not in the key\n for the two arrays and concatenating the result. This array is\n then sorted, and the common entries selected. The output is\n constructed by filling the fields with the selected entries.\n Matching is not preserved if there are some duplicates...\n \"\"\"\n arr = recfunctions.join_by(key, self.data, r2.data, jointype=jointype,\n r1postfix=r1postfix, r2postfix=r2postfix,\n defaults=defaults, usemask=False,\n asrecarray=True)\n\n return SimpleTable(arr)\n\n @property\n def empty_row(self):\n \"\"\" Return an empty row array respecting the table format \"\"\"\n return np.rec.recarray(shape=(1,), dtype=self.data.dtype)\n\n def add_column(self, name, data, dtype=None, unit=None, description=None):\n \"\"\"\n Add one or multiple columns to the table\n\n Parameters\n ----------\n name: str or sequence(str)\n The name(s) of the column(s) to add\n\n data: ndarray, or sequence of ndarray\n The column data, or sequence of columns\n\n dtype: dtype\n numpy dtype for the data to add\n\n unit: str\n The unit of the values in the column\n\n description: str\n A description of the content of the column\n \"\"\"\n\n _data = np.array(data, dtype=dtype)\n dtype = _data.dtype\n\n # unknown type is converted to text\n if dtype.type == np.object_:\n if len(data) == 0:\n longest = 0\n else:\n longest = len(max(data, key=len))\n _data = np.asarray(data, dtype='\|%iS' % longest)\n\n dtype = _data.dtype\n\n if len(self.data.dtype) > 0:\n # existing data in the table\n if type(name) in basestring:\n # _name = name.encode('utf8')\n _name = str(name)\n else:\n # _name = [k.encode('utf8') for k in name]\n _name = [str(k) for k in name]\n\n self.data = recfunctions.append_fields(self.data, _name, _data,\n dtypes=dtype, usemask=False,\n asrecarray=True)\n\n else:\n if _data.ndim > 1:\n newdtype = (str(name), _data.dtype, (_data.shape[1],))\n else:\n newdtype = (str(name), _data.dtype)\n self.data = np.array(_data, dtype=[newdtype])\n\n if unit is not None:\n self.set_unit(name, unit)\n\n if description is not None:\n self.set_comment(name, description)\n\n def append_row(self, iterable):\n \"\"\"\n Append one row in this table.\n\n see also: :func:`stack`\n\n Parameters\n ----------\n iterable: iterable\n line to add\n \"\"\"\n if (len(iterable) != self.ncols):\n raise AttributeError('Expecting as many items as columns')\n r = self.empty_row\n for k, v in enumerate(iterable):\n r[0][k] = v\n self.stack(r)\n\n def remove_columns(self, names):\n \"\"\"\n Remove several columns from the table\n\n Parameters\n ----------\n names: sequence\n A list containing the names of the columns to remove\n \"\"\"\n self.pop_columns(names)\n\n def pop_columns(self, names):\n \"\"\"\n Pop several columns from the table\n\n Parameters\n ----------\n\n names: sequence\n A list containing the names of the columns to remove\n\n Returns\n -------\n\n values: tuple\n list of columns\n \"\"\"\n\n if not hasattr(names, '__iter__') or type(names) in basestring:\n names = [names]\n\n p = [self[k] for k in names]\n\n _names = set([ self.resolve_alias(k) for k in names ])\n self.data = recfunctions.drop_fields(self.data, _names)\n for k in names:\n self._aliases.pop(k, None)\n self._units.pop(k, None)\n self._desc.pop(k, None)\n\n return p\n\n def find_duplicate(self, index_only=False, values_only=False):\n \"\"\"Find duplication in the table entries, return a list of duplicated\n elements Only works at this time is 2 lines are the same entry not if\n 2 lines have the same values\n \"\"\"\n dup = []\n idd = []\n for i in range(len(self.data)):\n if (self.data[i] in self.data[i + 1:]):\n if (self.data[i] not in dup):\n dup.append(self.data[i])\n idd.append(i)\n if index_only:\n return idd\n elif values_only:\n return dup\n else:\n return zip(idd, dup)\n\n def evalexpr(self, expr, exprvars=None, dtype=float):\n \"\"\" evaluate expression based on the data and external variables\n all np function can be used (log, exp, pi...)\n\n Parameters\n ----------\n expr: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n exprvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n dtype: dtype definition\n dtype of the output array\n\n Returns\n -------\n out : NumPy array\n array of the result\n \"\"\"\n _globals = {}\n for k in ( list(self.colnames) + list(self._aliases.keys()) ):\n if k in expr:\n _globals[k] = self[k]\n\n if exprvars is not None:\n if (not (hasattr(exprvars, 'keys') & hasattr(exprvars, '__getitem__' ))):\n raise AttributeError(\"Expecting a dictionary-like as condvars\")\n for k, v in ( exprvars.items() ):\n _globals[k] = v\n\n # evaluate expression, to obtain the final filter\n r = np.empty( self.nrows, dtype=dtype)\n r[:] = eval(expr, _globals, np.__dict__)\n\n return r\n\n def where(self, condition, condvars=None, args, kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n\n Parameters\n ----------\n condition: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n condvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n Returns\n -------\n out: ndarray/ tuple of ndarrays\n result equivalent to :func:`np.where`\n\n \"\"\"\n ind = np.where(self.evalexpr(condition, condvars, dtype=bool ), args, kwargs)\n return ind\n\n def select(self, fields, indices=None, kwargs):\n \"\"\"\n Select only a few fields in the table\n\n Parameters\n ----------\n fields: str or sequence\n fields to keep in the resulting table\n\n indices: sequence or slice\n extract only on these indices\n\n returns\n -------\n tab: SimpleTable instance\n resulting table\n \"\"\"\n _fields = self.keys(fields)\n\n if fields == '':\n if indices is None:\n return self\n else:\n tab = self.__class__(self[indices])\n for k in self.__dict__.keys():\n if k not in ('data', ):\n setattr(tab, k, deepcopy(self.__dict__[k]))\n return tab\n else:\n d = {}\n for k in _fields:\n _k = self.resolve_alias(k)\n if indices is not None:\n d[k] = self[_k][indices]\n else:\n d[k] = self[_k]\n d['header'] = deepcopy(self.header)\n tab = self.__class__(d)\n for k in self.__dict__.keys():\n if k not in ('data', ):\n setattr(tab, k, deepcopy(self.__dict__[k]))\n return tab\n\n def selectWhere(self, fields, condition, condvars=None, kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n\n Parameters\n ----------\n fields: str or sequence\n fields to keep in the resulting table\n\n condition: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n condvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n Returns\n -------\n tab: SimpleTable instance\n resulting table\n \"\"\"\n if condition in [True, 'True', None]:\n ind = None\n else:\n ind = self.where(condition, condvars, kwargs)[0]\n\n tab = self.select(fields, indices=ind)\n\n return tab\n\n def groupby(self, key):\n \"\"\"\n Create an iterator which returns (key, sub-table) grouped by each value\n of key(value)\n\n Parameters\n ----------\n key: str\n expression or pattern to filter the keys with\n\n Returns\n -------\n key: str or sequence\n group key\n\n tab: SimpleTable instance\n sub-table of the group\n header, aliases and column metadata are preserved (linked to the\n master table).\n \"\"\"\n _key = self.keys(key)\n getter = operator.itemgetter(_key)\n\n for k, grp in itertools.groupby(self.data, getter):\n t = self.__class__(np.dstack(grp))\n t.header = self.header\n t._aliases = self._aliases\n t._units = self._units\n t._desc = self._desc\n yield (k, t)\n\n def stats(self, fn=None, fields=None, fill=None):\n \"\"\" Make statistics on columns of a table\n\n Parameters\n ----------\n fn: callable or sequence of callables\n functions to apply to each column\n default: (np.mean, np.std, np.nanmin, np.nanmax)\n\n fields: str or sequence\n any key or key expression to subselect columns\n default is all columns\n\n fill: value\n value when not applicable\n default np.nan\n\n returns\n -------\n tab: Table instance\n collection of statistics, one column per function in fn and 1 ligne\n per column in the table\n \"\"\"\n from collections import OrderedDict\n\n if fn is None:\n fn = (stats.mean, stats.std,\n stats.min, stats.max,\n stats.has_nan)\n\n d = OrderedDict()\n d.setdefault('FIELD', [])\n for k in fn:\n d.setdefault(k.__name__, [])\n\n if fields is None:\n fields = self.colnames\n else:\n fields = self.keys(fields)\n\n if fill is None:\n fill = np.nan\n\n for k in fields:\n d['FIELD'].append(k)\n for fnk in fn:\n try:\n val = fnk(self[k])\n except:\n val = fill\n d[fnk.__name__].append(val)\n\n return self.__class__(d, dtype=dict)\n\n # method aliases\n remove_column = remove_columns\n\n # deprecated methods\n addCol = add_column\n addLine = append_row\n setComment = set_comment\n setUnit = set_unit\n delCol = remove_columns\n\n\nclass AstroTable(SimpleTable):\n \"\"\"\n Derived from the Table, this class add implementations of common astro\n tools especially conesearch\n \"\"\"\n def __init__(self, args, *kwargs):\n super(self.__class__, self).__init__(args, *kwargs)\n self._ra_name, self._dec_name = self.__autoRADEC__()\n if (len(args) > 0):\n if isinstance(args[0], AstroTable):\n self._ra_name = args[0]._ra_name\n self._dec_name = args[0]._dec_name\n self._ra_name = kwargs.get('ra_name', self._ra_name)\n self._dec_name = kwargs.get('dec_name', self._dec_name)\n\n def __autoRADEC__(self):\n \"\"\" Tries to identify the columns containing RA and DEC coordinates \"\"\"\n if 'ra' in self:\n ra_name = 'ra'\n elif 'RA' in self:\n ra_name = 'RA'\n else:\n ra_name = None\n if 'dec' in self:\n dec_name = 'dec'\n elif 'DEC' in self:\n dec_name = 'DEC'\n else:\n dec_name = None\n return ra_name, dec_name\n\n def set_RA(self, val):\n \"\"\" Set the column that defines RA coordinates \"\"\"\n assert(val in self), 'column name {} not found in the table'.format(val)\n self._ra_name = val\n\n def set_DEC(self, val):\n \"\"\" Set the column that defines DEC coordinates \"\"\"\n assert(val in self), 'column name {} not found in the table'.format(val)\n self._dec_name = val\n\n def get_RA(self, degree=True):\n \"\"\" Returns RA, converted from hexa/sexa into degrees \"\"\"\n if self._ra_name is None:\n return None\n if (not degree) or (self.dtype[self._ra_name].kind != 'S'):\n return self[self._ra_name]\n else:\n if (len(str(self[0][self._ra_name]).split(':')) == 3):\n return np.asarray(AstroHelpers.hms2deg(self[self._ra_name],\n delim=':'))\n elif (len(str(self[0][self._ra_name]).split(' ')) == 3):\n return np.asarray(AstroHelpers.hms2deg(self[self._ra_name],\n delim=' '))\n else:\n raise Exception('RA Format not understood')\n\n def get_DEC(self, degree=True):\n \"\"\" Returns RA, converted from hexa/sexa into degrees \"\"\"\n if self._dec_name is None:\n return None\n if (not degree) or (self.dtype[self._dec_name].kind != 'S'):\n return self[self._dec_name]\n else:\n if (len(str(self[0][self._dec_name]).split(':')) == 3):\n return np.asarray(AstroHelpers.dms2deg(self[self._dec_name],\n delim=':'))\n elif (len(str(self[0][self._dec_name]).split(' ')) == 3):\n return np.asarray(AstroHelpers.dms2deg(self[self._dec_name],\n delim=' '))\n else:\n raise Exception('RA Format not understood')\n\n def info(self):\n s = \"\\nTable: {name:s}\\n nrows={s.nrows:d}, ncols={s.ncols:d}, mem={size:s}\"\n s = s.format(name=self.header.get('NAME', 'Noname'), s=self,\n size=pretty_size_print(self.nbytes))\n\n s += '\\n\\nHeader:\\n'\n vals = list(self.header.items())\n length = max(map(len, self.header.keys()))\n fmt = '\\t{{0:{0:d}s}} {{1}}\\n'.format(length)\n for k, v in vals:\n s += fmt.format(k, v)\n\n vals = [(k, self._units.get(k, ''), self._desc.get(k, ''))\n for k in self.colnames]\n lengths = [(len(k), len(self._units.get(k, '')), len(self._desc.get(k, '')))\n for k in self.colnames]\n lengths = list(map(max, (zip(lengths))))\n\n if (self._ra_name is not None) & (self._dec_name is not None):\n s += \"\\nPosition coordinate columns: {0}, {1}\\n\".format(self._ra_name,\n self._dec_name)\n\n s += '\\nColumns:\\n'\n\n fmt = '\\t{{0:{0:d}s}} {{1:{1:d}s}} {{2:{2:d}s}}\\n'.format((k + 1 for k in lengths))\n for k, u, c in vals:\n s += fmt.format(k, u, c)\n\n print(s)\n\n if len(self._aliases) > 0:\n print(\"\\nTable contains alias(es):\")\n for k, v in self._aliases.items():\n print('\\t{0:s} --> {1:s}'.format(k, v))\n\n def coneSearch(self, ra, dec, r, outtype=0):\n \"\"\" Perform a cone search on a table\n\n Parameters\n ----------\n ra0: ndarray[ndim=1, dtype=float]\n column name to use as RA source in degrees\n\n dec0: ndarray[ndim=1, dtype=float]\n column name to use as DEC source in degrees\n\n ra: float\n ra to look for (in degree)\n\n dec: float\n ra to look for (in degree)\n\n r: float\n distance in degrees\n\n outtype: int\n type of outputs\n 0 -- minimal, indices of matching coordinates\n 1 -- indices and distances of matching coordinates\n 2 -- full, boolean filter and distances\n\n Returns\n -------\n t: tuple\n if outtype is 0:\n only return indices from ra0, dec0\n elif outtype is 1:\n return indices from ra0, dec0 and distances\n elif outtype is 2:\n return conditional vector and distance to all ra0, dec0\n \"\"\"\n if (self._ra_name is None) or (self._dec_name is None):\n raise AttributeError('Coordinate columns not set.')\n\n ra0 = self.get_RA()\n dec0 = self.get_DEC()\n return AstroHelpers.conesearch(ra0, dec0, ra, dec, r, outtype=outtype)\n\n def zoneSearch(self, ramin, ramax, decmin, decmax, outtype=0):\n \"\"\" Perform a zone search on a table, i.e., a rectangular selection\n\n Parameters\n ----------\n ramin: float\n minimal value of RA\n\n ramax: float\n maximal value of RA\n\n decmin: float\n minimal value of DEC\n\n decmax: float\n maximal value of DEC\n\n outtype: int\n type of outputs\n 0 or 1 -- minimal, indices of matching coordinates\n 2 -- full, boolean filter and distances\n\n Returns\n -------\n r: sequence\n indices or conditional sequence of matching values\n \"\"\"\n\n assert( (self._ra_name is not None) & (self._dec_name is not None) ), 'Coordinate columns not set.'\n\n ra0 = self.get_RA()\n dec0 = self.get_DEC()\n ind = (ra0 >= ramin) & (ra0 <= ramax) & (dec0 >= decmin) & (dec0 <= decmax)\n if outtype <= 2:\n return ind\n else:\n return np.where(ind)\n\n def where(self, condition=None, condvars=None, cone=None, zone=None, kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n\n Parameters\n ----------\n condition: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n condvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n Returns\n -------\n out: ndarray/ tuple of ndarrays\n result equivalent to :func:`np.where`\n \"\"\"\n if cone is not None:\n if len(cone) != 3:\n raise ValueError('Expecting cone keywords as a triplet (ra, dec, r)')\n if zone is not None:\n if len(zone) != 4:\n raise ValueError('Expecting zone keywords as a tuple of 4 elements (ramin, ramax, decmin, decmax)')\n\n if condition is not None:\n ind = super(self.__class__, self).where(condition, kwargs)\n if ind is None:\n if (cone is None) & (zone is None):\n return None\n else:\n ind = True\n\n blobs = []\n if (cone is not None) and (zone is not None): # cone + zone\n ra, dec, r = cone\n ind, d = self.coneSearch(ra, dec, r, outtype=2)\n ind = ind & self.zoneSearch(zone[0], zone[1], zone[2], zone[3], outtype=2)\n d = d[ind]\n blobs.append(d)\n elif (cone is not None):\n ra, dec, r = cone\n _ind, d = self.coneSearch(ra, dec, r, outtype=2)\n ind = ind & _ind.astype(bool)\n blobs.append(d[ind])\n elif (zone is not None):\n _ind = self.zoneSearch(zone[0], zone[1], zone[2], zone[3], outtype=1)\n ind = ind & _ind\n\n ind = np.where(ind)[0]\n\n return ind, blobs\n\n def selectWhere(self, fields, condition=None, condvars=None, cone=None, zone=None, kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n conesearch is also possible through the keyword cone formatted as (ra, dec, r)\n zonesearch is also possible through the keyword zone formatted as (ramin, ramax, decmin, decmax)\n\n Combination of multiple selections is also available.\n \"\"\"\n ind, blobs = self.where(condition, condvars, cone, zone, kwargs)\n tab = self.select(fields, indices=ind)\n\n if cone is not None:\n tab.add_column('separation', np.squeeze(blobs), unit='degree')\n\n if self._ra_name in tab:\n tab.set_RA(self._ra_name)\n\n if self._dec_name in tab:\n tab.set_DEC(self._dec_name)\n\n return tab\n\n\nclass stats(object):\n @classmethod\n def has_nan(s, v):\n return (True in np.isnan(v))\n\n @classmethod\n def mean(s, v):\n return np.nanmean(v)\n\n @classmethod\n def max(s, v):\n return np.nanmax(v)\n\n @classmethod\n def min(s, v):\n return np.nanmin(v)\n\n @classmethod\n def std(s, v):\n return np.nanstd(v)\n\n @classmethod\n def var(s, v):\n return np.var(v)\n\n @classmethod\n def p16(s, v):\n try:\n return np.nanpercentile(v, 16)\n except AttributeError:\n return np.percentile(v, 16)\n\n @classmethod\n def p84(s, v):\n try:\n return np.nanpercentile(v, 84)\n except AttributeError:\n return np.percentile(v, 84)\n\n @classmethod\n def p50(s, v):\n try:\n return np.nanmedian(v)\n except AttributeError:\n return np.percentile(v, 50)\n\n\n'''\n# =============================================================================\n# Adding some plotting functions\n# =============================================================================\n\ntry:\n import pylab as plt\n\n def plot_function(tab, fn, args, *kwargs):\n \"\"\" Generate a plotting method of tab from a given function\n\n Parameters\n ----------\n tab: SimpleTable instance\n table instance\n\n fn: str or callable\n if str, will try a function in matplotlib\n if callable, calls the function directly\n\n xname: str\n expecting a column name from the table\n\n yname: str, optional\n if provided, another column to use for the plot\n\n onlywhere: sequence or str, optional\n if provided, selects only data with this condition\n the condition can be a ndarray slice or a string.\n When a string is given, the evaluation calls :func:`SimpleTable.where`\n\n ax: matplotlib.Axes instance\n if provided make sure it uses the axis to do the plots if a mpl\n function is used.\n\n Returns\n -------\n r: object\n anything returned by the called function\n \"\"\"\n if not hasattr(fn, '__call__'):\n ax = kwargs.pop('ax', None)\n if ax is None:\n ax = plt.gca()\n _fn = getattr(ax, fn, None)\n if _fn is None:\n raise AttributeError('function neither callable or found in matplotlib')\n else:\n _fn = fn\n\n onlywhere = kwargs.pop('onlywhere', None)\n if type(onlywhere) in basestring:\n select = tab.where(onlywhere)\n else:\n select = onlywhere\n\n _args = ()\n for a in args:\n if (hasattr(a, '__iter__')):\n try:\n b = tab[a]\n if select is not None:\n b = b.compress(select)\n if (len(b.dtype) > 1):\n b = list((b[k] for k in b.dtype.names))\n _args += (b, )\n except Exception as e:\n print(e)\n _args += (a, )\n else:\n _args += (a, )\n\n return _fn(_args, *kwargs)\n\n def attached_function(fn, doc=None, errorlevel=0):\n \"\"\" eclare a function as a method to the class table\"\"\"\n\n def _fn(self, args, *kwargs):\n try:\n return plot_function(self, fn, args, **kwargs)\n except Exception as e:\n if errorlevel < 1:\n pass\n else:\n raise e\n\n if doc is not None:\n _fn.__doc__ = doc\n\n return _fn\n\n SimpleTable.plot_function = plot_function\n SimpleTable.plot = attached_function('plot', plt.plot.__doc__)\n SimpleTable.hist = attached_function('hist', plt.hist.__doc__)\n SimpleTable.hist2d = attached_function('hist2d', plt.hist2d.__doc__)\n SimpleTable.hexbin = attached_function('hexbin', plt.hexbin.__doc__)\n SimpleTable.scatter = attached_function('scatter', plt.scatter.__doc__)\n\n # newer version of matplotlib\n if hasattr(plt, 'violinplot'):\n SimpleTable.violinplot = attached_function('violinplot', plt.violinplot.__doc__)\n if hasattr(plt, 'boxplot'):\n SimpleTable.boxplot = attached_function('boxplot', plt.boxplot.__doc__)\n\nexcept Exception as e:\n print(e)\n'''\n" ]	[ [ "numpy.nanmax", "numpy.nanmedian", "numpy.asarray", "numpy.squeeze", "numpy.nanmin", "numpy.nanmean", "numpy.var", "numpy.nanstd", "numpy.where", "numpy.equal.outer", "pandas.read_csv", "numpy.arcsin", "numpy.sin", "numpy.lib.recfunctions.drop_fields", "numpy.lib.recfunctions.append_fields", "numpy.recfromtxt", "numpy.rec.recarray", "numpy.isnan", "numpy.ascontiguousarray", "numpy.deg2rad", "numpy.savetxt", "numpy.lib.recfunctions.join_by", "numpy.array", "numpy.nanpercentile", "numpy.lib.recfunctions.stack_arrays", "numpy.rec.fromarrays", "numpy.cos", "numpy.dstack", "numpy.percentile", "numpy.recfromcsv", "numpy.empty" ] ]
cypherix/ssd.pytorch	[ "0529c61bb945973d29a416487046d4aae63360fc" ]	[ "data/__init__.py" ]	[ "from .voc0712 import VOCDetection, VOCAnnotationTransform, VOC_CLASSES, VOC_ROOT\n\nfrom .coco import COCOAnnotationTransform\nfrom .config import *\nimport torch\nimport cv2\nimport numpy as np\n\ndef detection_collate(batch):\n \"\"\"Custom collate fn for dealing with batches of images that have a different\n number of associated object annotations (bounding boxes).\n\n Arguments:\n batch: (tuple) A tuple of tensor images and lists of annotations\n\n Return:\n A tuple containing:\n 1) (tensor) batch of images stacked on their 0 dim\n 2) (list of tensors) annotations for a given image are stacked on\n 0 dim\n \"\"\"\n targets = []\n imgs = []\n for sample in batch:\n imgs.append(sample[0])\n targets.append(torch.FloatTensor(sample[1]))\n return torch.stack(imgs, 0), targets\n\n\ndef base_transform(image, size, mean):\n x = cv2.resize(image, (size, size)).astype(np.float32)\n x -= mean\n x = x.astype(np.float32)\n return x\n\n\nclass BaseTransform:\n def __init__(self, size, mean):\n self.size = size\n self.mean = np.array(mean, dtype=np.float32)\n\n def __call__(self, image, boxes=None, labels=None):\n return base_transform(image, self.size, self.mean), boxes, labels\n" ]	[ [ "torch.stack", "numpy.array", "torch.FloatTensor" ] ]
blzheng/pytorch-YOLOv4	[ "8956c4801c4e1ae4b0c2fadf807a0356f0bfe058" ]	[ "test_inference.py" ]	[ "import torch\nimport argparse\nimport os\nimport random\nimport shutil\nimport time\nimport warnings\nfrom torch import nn\nimport torch.nn.functional as F\nfrom tool.torch_utils import *\nfrom tool.yolo_layer import YoloLayer\nfrom yolo_loss import Yolo_loss\nfrom torch.utils import mkldnn as mkldnn_utils\nfrom models import Yolov4\nfrom dataset import Yolo_dataset\n\nparser = argparse.ArgumentParser(description='PyTorch Yolov4 Training')\nparser.add_argument('-N', '--n_classes', default=80, type=int, metavar='n_classes',\n help='num classes')\nparser.add_argument('-w', '--weightfile', type=str, default='./yolov4.pth',\n help='weight file')\nparser.add_argument('-i', '--imgfile', type=str, default='./data/dog.jpg',\n help='image file')\nparser.add_argument('--height', default=320, type=int, help='height')\nparser.add_argument('--width', default=320, type=int, help='width')\nparser.add_argument('-n', '--namesfile', type=str, help='names file')\nparser.add_argument('-j', '--workers', default=4, type=int, metavar='N',\n help='number of data loading workers (default: 4)')\nparser.add_argument('--ipex', action='store_true', default=False,\n help='use intel pytorch extension')\nparser.add_argument('--int8', action='store_true', default=False,\n help='enable ipex int8 path')\nparser.add_argument('--bf16', action='store_true', default=False,\n help='enable ipex bf16 path')\nparser.add_argument('--jit', action='store_true', default=False,\n help='enable ipex jit fusionpath')\nparser.add_argument('--calibration', action='store_true', default=False,\n help='doing calibration step for int8 path')\nparser.add_argument('--configure-dir', default='configure.json', type=str, metavar='PATH',\n help = 'path to int8 configures, default file name is configure.json')\nparser.add_argument(\"--dummy\", action='store_true',\n help=\"using dummu data to test the performance of inference\")\nparser.add_argument('--warmup', default=30, type=int, metavar='N',\n help='number of warmup iterati ons to run')\nparser.add_argument('-b', '--batch-size', default=64, type=int, metavar='N',\n help='mini-batch size (default: 64), this is the total '\n 'batch size of all GPUs on the current node when '\n 'using Data Parallel or Distributed Data Parallel')\n\ndef fp32_imperative_stock_pytorch(model, images):\n model = model.to(memory_format=torch.channels_last)\n images = images.to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef fp32_jit_stock_pytorch(model, images, args):\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width))\n model = torch.jit.freeze(model)\n images = images.to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef bf16_imperative_stock_pytorch(model, images):\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n with torch.cpu.amp.autocast():\n images = images.to(torch.bfloat16).to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef bf16_jit_stock_pytorch(model, images, args):\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n with torch.no_grad():\n with torch.cpu.amp.autocast():\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width))\n model = torch.jit.freeze(model)\n with torch.cpu.amp.autocast():\n images = images.to(torch.bfloat16).to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef fp32_imperative_stock_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n model = model.to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.float32, level=\"O0\")\n images = images.to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef fp32_jit_stock_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n model = model.to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.float32, level=\"O0\")\n model = torch.jit.trace(model, torch.rand(args.batch_size, 3, args.height, args.width).to(memory_format=torch.channels_last))\n model = torch.jit.freeze(model)\n images = images.contiguous(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef bf16_imperative_stock_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.bfloat16, level=\"O0\")\n conf = ipex.AmpConf(torch.bfloat16)\n with ipex.amp.autocast(enabled=True, configure=conf), torch.no_grad():\n output=model(images)\n print(output)\n\ndef bf16_jit_stock_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n with torch.no_grad():\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.bfloat16, level=\"O0\")\n conf = ipex.AmpConf(torch.bfloat16)\n images = images.to(torch.bfloat16)\n with ipex.amp.autocast(enabled=True, configure=conf), torch.no_grad():\n model = torch.jit.trace(model, torch.rand(args.batch_size, 3, args.height, args.width).to(memory_format=torch.channels_last))\n model = torch.jit.freeze(model)\n output=model(images)\n print(output)\n\ndef fp32_imperative_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n output=model(images)\n print(output)\n\ndef fp32_jit_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n with torch.no_grad():\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width).to(ipex.DEVICE))\n output=model(images)\n print(output)\n\ndef bf16_imperative_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n ipex.enable_auto_mixed_precision(mixed_dtype = torch.bfloat16)\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n output=model(images)\n print(output)\n\ndef bf16_jit_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n ipex.enable_auto_mixed_precision(mixed_dtype = torch.bfloat16)\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n with torch.no_grad():\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width).to(ipex.DEVICE))\n output=model(images)\n print(output)\n\ndef get_data(args):\n if args.dummy:\n images = torch.randn(args.batch_size, 3, args.height, args.width)\n return images\n else:\n import sys\n import cv2\n img = cv2.imread(args.imgfile)\n sized = cv2.resize(img, (args.width, args.height))\n img = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)\n if type(img) == np.ndarray and len(img.shape) == 3: # cv2 image\n img = torch.from_numpy(img.transpose(2, 0, 1)).float().div(255.0).unsqueeze(0)\n elif type(img) == np.ndarray and len(img.shape) == 4:\n img = torch.from_numpy(img.transpose(0, 3, 1, 2)).float().div(255.0)\n else:\n print(\"unknow image type\")\n exit(-1)\n img = torch.autograd.Variable(img)\n return img\n\nif __name__ == \"__main__\":\n args = parser.parse_args()\n print(args)\n n_classes = args.n_classes\n weightfile = args.weightfile\n \n model = Yolov4(yolov4conv137weight=None, n_classes=n_classes, inference=True)\n pretrained_dict = torch.load(weightfile, map_location=torch.device('cpu'))\n model.load_state_dict(pretrained_dict)\n img = get_data(args)\n \n model.eval()\n fp32_imperative_stock_pytorch(model, img)\n fp32_jit_stock_pytorch(model, img, args)\n bf16_imperative_stock_pytorch(model, img)\n bf16_jit_stock_pytorch(model, img, args)\n fp32_imperative_stock_pytorch_ipex(model, img)\n fp32_jit_stock_pytorch_ipex(model, img, args)\n bf16_imperative_stock_pytorch_ipex(model, img)\n bf16_jit_stock_pytorch_ipex(model, img, args)\n fp32_imperative_pytorch_ipex(model, img)\n fp32_jit_pytorch_ipex(model, img, args)\n bf16_imperative_pytorch_ipex(model, img)\n bf16_jit_pytorch_ipex(model, img, args)\n\n" ]	[ [ "torch.jit.freeze", "torch.randn", "torch.no_grad", "torch.rand", "torch.device", "torch.cpu.amp.autocast", "torch.autograd.Variable" ] ]
ChristosT/meshio	[ "de0ced0cc19fa40389764514328874dce8afdbec" ]	[ "meshio/medit/_medit.py" ]	[ "\"\"\"\nI/O for Medit's format/Gamma Mesh Format,\nLatest official up-to-date documentation and a reference C implementation at\n<https://github.com/LoicMarechal/libMeshb>\n\"\"\"\nimport logging\nimport struct\nfrom ctypes import c_double, c_float\n\nimport numpy as np\n\nfrom .._common import _pick_first_int_data\nfrom .._exceptions import ReadError\nfrom .._files import open_file\nfrom .._helpers import register\nfrom .._mesh import Mesh\nfrom ._medit_internal import medit_codes\n\n\ndef read(filename):\n with open_file(filename) as f:\n if str(filename)[-1] == \"b\":\n mesh = read_binary_buffer(f)\n else:\n mesh = read_ascii_buffer(f)\n return mesh\n\n\ndef _produce_dtype(string_type, dim, itype, ftype):\n \"\"\"\n convert a medit_code to a dtype appropriate for building a numpy array\n \"\"\"\n res = \"\"\n c = 0\n while c < len(string_type):\n s = string_type[c]\n if s == \"i\":\n res += itype\n elif s == \"r\":\n res += ftype\n elif s == \"d\":\n res += str(dim)\n c += 1\n continue\n else:\n raise ReadError(\"Invalid string type\")\n c += 1\n if c != len(string_type):\n res += \",\"\n return res\n\n\ndef read_binary_buffer(f):\n\n meshio_from_medit = {\n \"GmfVertices\": (\"point\", None),\n \"GmfEdges\": (\"line\", 2),\n \"GmfTriangles\": (\"triangle\", 3),\n \"GmfQuadrilaterals\": (\"quad\", 4),\n \"GmfTetrahedra\": (\"tetra\", 4),\n \"GmfPrisms\": (\"wedge\", 6),\n \"GmfPyramids\": (\"pyramid\", 5),\n \"GmfHexahedra\": (\"hexahedron\", 8),\n }\n\n dim = 0\n points = None\n cells = []\n point_data = {}\n cell_data = {\"medit:ref\": []}\n itype = \"\"\n ftype = \"\"\n postype = \"\"\n # the file version\n keytype = \"i4\"\n\n code = np.fromfile(f, count=1, dtype=keytype).item()\n\n if code != 1 and code != 16777216:\n raise ReadError(\"Invalid code\")\n\n if code == 16777216:\n # swap endianess\n swapped = \">\" if struct.unpack(\"=l\", struct.pack(\"<l\", 1))[0] == 1 else \"<\"\n itype += swapped\n ftype += swapped\n postype += swapped\n keytype = swapped + keytype\n\n version = np.fromfile(f, count=1, dtype=keytype).item()\n\n if version < 1 or version > 4:\n raise ReadError(\"Invalid version\")\n\n if version == 1:\n itype += \"i4\"\n ftype += \"f4\"\n postype += \"i4\"\n elif version == 2:\n itype += \"i4\"\n ftype += \"f8\"\n postype += \"i4\"\n elif version == 3:\n itype += \"i4\"\n ftype += \"f8\"\n postype += \"i8\"\n else:\n itype += \"i8\"\n ftype += \"f8\"\n postype += \"i8\"\n\n field = np.fromfile(f, count=1, dtype=keytype).item()\n\n if field != 3: # = GmfDimension\n raise ReadError(\"Invalid dimension code : \" + str(field) + \" it should be 3\")\n\n np.fromfile(f, count=1, dtype=postype)\n\n dim = np.fromfile(f, count=1, dtype=keytype).item()\n\n if dim != 2 and dim != 3:\n raise ReadError(\"Invalid mesh dimension : \" + str(dim))\n\n while True:\n field = np.fromfile(f, count=1, dtype=keytype)\n\n if field.size == 0:\n msg = \"End-of-file reached before GmfEnd keyword\"\n logging.warning(msg)\n break\n\n field = field.item()\n if field not in medit_codes.keys():\n raise ReadError(\"Unsupported field\")\n\n field_code = medit_codes[field]\n\n if field_code[0] == \"GmfEnd\":\n break\n\n if field_code[0] == \"GmfReserved\":\n continue\n\n np.fromfile(f, count=1, dtype=postype)\n\n nitems = 1\n if field_code[1] == \"i\":\n nitems = np.fromfile(f, count=1, dtype=itype).item()\n\n field_template = field_code[2]\n dtype = np.dtype(_produce_dtype(field_template, dim, itype, ftype))\n out = np.asarray(np.fromfile(f, count=nitems, dtype=dtype))\n if field_code[0] not in meshio_from_medit.keys():\n msg = (\"meshio doesn't know {} type. Skipping.\").format(field_code[0])\n logging.warning(msg)\n continue\n\n elif field_code[0] == \"GmfVertices\":\n points = out[\"f0\"]\n point_data[\"medit:ref\"] = out[\"f1\"]\n else:\n meshio_type, ncols = meshio_from_medit[field_code[0]]\n # transform the structured array to integer array which suffices\n # for the cell connectivity\n out_view = out.view(itype).reshape(nitems, ncols + 1)\n cells.append((meshio_type, out_view[:, :ncols] - 1))\n cell_data[\"medit:ref\"].append(out_view[:, -1])\n\n return Mesh(points, cells, point_data=point_data, cell_data=cell_data)\n\n\ndef read_ascii_buffer(f):\n dim = 0\n cells = []\n point_data = {}\n cell_data = {\"medit:ref\": []}\n\n meshio_from_medit = {\n \"Edges\": (\"line\", 2),\n \"Triangles\": (\"triangle\", 3),\n \"Quadrilaterals\": (\"quad\", 4),\n \"Tetrahedra\": (\"tetra\", 4),\n \"Prisms\": (\"wedge\", 6),\n \"Pyramids\": (\"pyramid\", 5),\n \"Hexahedra\": (\"hexahedron\", 8), # Frey\n \"Hexaedra\": (\"hexahedron\", 8), # Dobrzynski\n }\n points = None\n dtype = None\n\n while True:\n line = f.readline()\n if not line:\n # EOF\n break\n\n line = line.strip()\n if len(line) == 0 or line[0] == \"#\":\n continue\n\n items = line.split()\n\n if not items[0].isalpha():\n raise ReadError()\n\n if items[0] == \"MeshVersionFormatted\":\n version = items[1]\n dtype = {\"1\": c_float, \"2\": c_double}[version]\n elif items[0] == \"Dimension\":\n if len(items) >= 2:\n dim = int(items[1])\n else:\n dim = int(\n int(f.readline())\n ) # e.g. Dimension\\n3, where the number of dimensions is on the next line\n elif items[0] == \"Vertices\":\n if dim <= 0:\n raise ReadError()\n if dtype is None:\n raise ReadError(\"Expected `MeshVersionFormatted` before `Vertices`\")\n num_verts = int(f.readline())\n out = np.fromfile(\n f, count=num_verts * (dim + 1), dtype=dtype, sep=\" \"\n ).reshape(num_verts, dim + 1)\n points = out[:, :dim]\n point_data[\"medit:ref\"] = out[:, dim].astype(int)\n elif items[0] in meshio_from_medit:\n meshio_type, points_per_cell = meshio_from_medit[items[0]]\n # The first value is the number of elements\n num_cells = int(f.readline())\n\n out = np.fromfile(\n f, count=num_cells * (points_per_cell + 1), dtype=int, sep=\" \"\n ).reshape(num_cells, points_per_cell + 1)\n\n # adapt for 0-base\n cells.append((meshio_type, out[:, :points_per_cell] - 1))\n cell_data[\"medit:ref\"].append(out[:, -1])\n elif items[0] == \"Corners\":\n # those are just discarded\n num_corners = int(f.readline())\n np.fromfile(f, count=num_corners, dtype=dtype, sep=\" \")\n elif items[0] == \"Normals\":\n # those are just discarded\n num_normals = int(f.readline())\n np.fromfile(f, count=num_normals * dim, dtype=dtype, sep=\" \").reshape(\n num_normals, dim\n )\n elif items[0] == \"NormalAtVertices\":\n # those are just discarded\n num_normal_at_vertices = int(f.readline())\n np.fromfile(\n f, count=num_normal_at_vertices * 2, dtype=int, sep=\" \"\n ).reshape(num_normal_at_vertices, 2)\n else:\n if items[0] != \"End\":\n raise ReadError(f\"Unknown keyword '{items[0]}'.\")\n\n if points is None:\n raise ReadError(\"Expected `Vertices`\")\n return Mesh(points, cells, point_data=point_data, cell_data=cell_data)\n\n\ndef write(filename, mesh, float_fmt=\".16e\"):\n if str(filename)[-1] == \"b\":\n write_binary_file(filename, mesh)\n else:\n write_ascii_file(filename, mesh, float_fmt)\n\n\ndef write_ascii_file(filename, mesh, float_fmt=\".16e\"):\n with open_file(filename, \"wb\") as fh:\n version = {np.dtype(c_float): 1, np.dtype(c_double): 2}[mesh.points.dtype]\n # N. B.: PEP 461 Adding % formatting to bytes and bytearray\n fh.write(b\"MeshVersionFormatted %d\\n\" % version)\n\n n, d = mesh.points.shape\n\n fh.write(b\"Dimension %d\\n\" % d)\n\n # vertices\n fh.write(b\"\\nVertices\\n\")\n fh.write(f\"{n}\\n\".encode(\"utf-8\"))\n\n # pick out point data\n labels_key, other = _pick_first_int_data(mesh.point_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one point data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n labels = mesh.point_data[labels_key] if labels_key else np.ones(n, dtype=int)\n\n fmt = \" \".join([\"{:\" + float_fmt + \"}\"] * d) + \" {:d}\\n\"\n for x, label in zip(mesh.points, labels):\n fh.write(fmt.format(x, label).encode(\"utf-8\"))\n\n medit_from_meshio = {\n \"line\": (\"Edges\", 2),\n \"triangle\": (\"Triangles\", 3),\n \"quad\": (\"Quadrilaterals\", 4),\n \"tetra\": (\"Tetrahedra\", 4),\n \"wedge\": (\"Prisms\", 6),\n \"pyramid\": (\"Pyramids\", 5),\n \"hexahedron\": (\"Hexahedra\", 8),\n }\n\n # pick out cell_data\n labels_key, other = _pick_first_int_data(mesh.cell_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one cell data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n\n for k, (cell_type, data) in enumerate(mesh.cells):\n try:\n medit_name, num = medit_from_meshio[cell_type]\n except KeyError:\n msg = (\"MEDIT's mesh format doesn't know {} cells. Skipping.\").format(\n cell_type\n )\n logging.warning(msg)\n continue\n fh.write(b\"\\n\")\n fh.write(f\"{medit_name}\\n\".encode(\"utf-8\"))\n fh.write(f\"{len(data)}\\n\".encode(\"utf-8\"))\n\n # pick out cell data\n labels = (\n mesh.cell_data[labels_key][k]\n if labels_key\n else np.ones(len(data), dtype=data.dtype)\n )\n\n fmt = \" \".join([\"{:d}\"] (num + 1)) + \"\\n\"\n # adapt 1-base\n for d, label in zip(data + 1, labels):\n fh.write(fmt.format(d, label).encode(\"utf-8\"))\n\n fh.write(b\"\\nEnd\\n\")\n\n\ndef write_binary_file(f, mesh):\n with open_file(f, \"wb\") as fh:\n\n version = 3\n itype = \"i4\"\n postype = \"i8\"\n ftype = \"f8\"\n # according to manual keywords are always written as i4 independently of\n # the file version\n keytype = \"i4\"\n\n # if we store internally 64bit integers upgrade file version\n has_big_ints = False\n for _, data in mesh.cells:\n if data.dtype.itemsize == 8:\n has_big_ints = True\n break\n\n if has_big_ints:\n itype = \"i8\"\n version = 4\n\n itype_size = np.dtype(itype).itemsize\n ftype_size = np.dtype(ftype).itemsize\n postype_size = np.dtype(postype).itemsize\n keyword_size = np.dtype(keytype).itemsize\n\n code = 1\n field = 3 # GmfDimension\n pos = 4 keyword_size + postype_size\n\n num_verts, dim = mesh.points.shape\n\n header_type = np.dtype(\",\".join([keytype, keytype, keytype, postype, keytype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = code\n tmp_array[\"f1\"] = version\n tmp_array[\"f2\"] = field\n tmp_array[\"f3\"] = pos\n tmp_array[\"f4\"] = dim\n tmp_array.tofile(fh)\n\n # write points\n field = 4 # GmfVertices\n field_code = medit_codes[field]\n\n pos += num_verts * dim * ftype_size\n pos += num_verts * itype_size\n pos += keyword_size + postype_size + itype_size\n header_type = np.dtype(\",\".join([keytype, postype, itype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = field\n tmp_array[\"f1\"] = pos\n tmp_array[\"f2\"] = num_verts\n tmp_array.tofile(fh)\n\n field_template = field_code[2]\n dtype = np.dtype(_produce_dtype(field_template, dim, itype, ftype))\n\n labels_key, other = _pick_first_int_data(mesh.point_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one point data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n labels = (\n mesh.point_data[labels_key]\n if labels_key\n else np.ones(num_verts, dtype=itype)\n )\n\n tmp_array = np.empty(num_verts, dtype=dtype)\n tmp_array[\"f0\"] = mesh.points\n tmp_array[\"f1\"] = labels\n tmp_array.tofile(fh)\n\n labels_key, other = _pick_first_int_data(mesh.cell_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one cell data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n\n # first component is medit keyword id see _medit_internal.py\n medit_from_meshio = {\n \"line\": 5,\n \"triangle\": 6,\n \"quad\": 7,\n \"tetra\": 8,\n \"wedge\": 9,\n \"pyramid\": 49,\n \"hexahedron\": 10,\n }\n for k, (cell_type, data) in enumerate(mesh.cells):\n try:\n medit_key = medit_from_meshio[cell_type]\n except KeyError:\n msg = (\"MEDIT's mesh format doesn't know {} cells. Skipping.\").format(\n cell_type\n )\n logging.warning(msg)\n continue\n\n num_cells, num_verts = data.shape\n\n pos += num_cells * (num_verts + 1) * itype_size\n pos += keyword_size + postype_size + itype_size\n\n header_type = np.dtype(\",\".join([keytype, postype, itype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = medit_key\n tmp_array[\"f1\"] = pos\n tmp_array[\"f2\"] = num_cells\n tmp_array.tofile(fh)\n\n # pick out cell data\n labels = (\n mesh.cell_data[labels_key][k]\n if labels_key\n else np.ones(len(data), dtype=data.dtype)\n )\n field_template = medit_codes[medit_key][2]\n dtype = np.dtype(_produce_dtype(field_template, dim, itype, ftype))\n\n tmp_array = np.empty(num_cells, dtype=dtype)\n i = 0\n for col_type in dtype.names[:-1]:\n tmp_array[col_type] = data[:, i] + 1\n i += 1\n\n tmp_array[dtype.names[-1]] = labels\n tmp_array.tofile(fh)\n\n pos = 0\n field = 54 # GmfEnd\n header_type = np.dtype(\",\".join([keytype, postype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = field\n tmp_array[\"f1\"] = pos\n tmp_array.tofile(fh)\n\n\nregister(\"medit\", [\".mesh\", \".meshb\"], read, {\"medit\": write})\n" ]	[ [ "numpy.dtype", "numpy.fromfile", "numpy.empty", "numpy.ones" ] ]
mleshen/pytorch	[ "314a578154d9f0981bc08397aaaeaf50d8233730" ]	[ "torch/fx/graph_module.py" ]	[ "import torch\nimport torch.nn as nn\nimport torch.overrides\nfrom torch.nn.modules.module import _addindent\nfrom torch.package import PackageImporter, PackageExporter\nimport linecache\nfrom typing import Type, Dict, List, Any, Union, Optional, Set\nfrom .graph import Graph, _is_from_torch, _custom_builtins, PythonCode\nfrom torch.package import Importer, sys_importer\nimport copy\nimport itertools\nimport sys\nimport traceback\nfrom pathlib import Path\nimport os\nimport warnings\n\n# normal exec loses the source code, however we can patch\n# the linecache module to still recover it.\n# using exec_with_source will add it to our local cache\n# and then tools like TorchScript will be able to get source info.\n_next_id = 0\ndef exec_with_source(src: str, globals: Dict[str, Any]):\n global _next_id\n key = f'<eval_with_key_{_next_id}>'\n _next_id += 1\n _eval_cache[key] = [line + '\\n' for line in src.splitlines()]\n exec(compile(src, key, 'exec'), globals)\n\n# patch linecache so that any code we exec using exec_with_source\n# works with inspect\n_eval_cache : Dict[str, List[str]] = {}\n_orig_getlines = linecache.getlines\ndef patched_getline(args, kwargs):\n if args[0] in _eval_cache:\n return _eval_cache[args[0]]\n return _orig_getlines(args, *kwargs)\nlinecache.getlines = patched_getline\n\n\ndef _forward_from_src(src: str, globals: Dict[str, Any]):\n # avoid mutating the passed in dict\n globals_copy = globals.copy()\n exec_with_source(src, globals_copy)\n forward_fn = globals_copy['forward']\n del globals_copy['forward']\n return forward_fn\n\n\ndef _format_import_statement(name: str, obj: Any, importer: Importer) -> str:\n if name in _custom_builtins:\n return _custom_builtins[name].import_str\n if _is_from_torch(name):\n return 'import torch'\n\n module_name, attr_name = importer.get_name(obj)\n return f'from {module_name} import {attr_name} as {name}'\n\n\ndef _format_import_block(globals: Dict[str, Any], importer: Importer):\n import_strs: Set[str] = set()\n for name, obj in globals.items():\n import_strs.add(_format_import_statement(name, obj, importer))\n return '\\n'.join(import_strs)\n\n\ndef reduce_graph_module(body: Dict[Any, Any], import_block: str) -> torch.nn.Module:\n # BC: attribute name was changed from `code` to `_code` to facilitate\n # making `code` into a property and adding a docstring to it\n fn_src = body.get('_code') or body['code']\n forward = _forward_from_src(import_block + fn_src, {})\n return _deserialize_graph_module(forward, body, None)\n\n\ndef reduce_package_graph_module(importer: PackageImporter,\n body: Dict[Any, Any],\n generated_module_name: str) -> torch.nn.Module:\n forward = importer.import_module(generated_module_name).forward\n return _deserialize_graph_module(forward, body, importer)\n\n\ndef _deserialize_graph_module(forward, body: Dict[Any, Any], importer: Optional[PackageImporter]) -> torch.nn.Module:\n \"\"\"\n Deserialize a GraphModule given the dictionary of the original module,\n using the code to reconstruct the graph. We delete the actual graph before\n saving the dictionary so that changes to the in-memory graph format do not\n get serialized.\n \"\"\"\n # We create a dummy class here because symbolic_trace pulls the forward()\n # function off of the class, rather than the instance\n class CodeOnlyModule(torch.nn.Module):\n def __init__(self, body):\n super().__init__()\n self.__dict__ = body\n\n # Try to retrieve the forward source in a backward-compatible way\n CodeOnlyModule.forward = forward\n\n from .symbolic_trace import Tracer\n\n # we shouldn't trace into any of the submodules, they were not\n # because they were not traced in the original GraphModule\n class KeepModules(Tracer):\n def is_leaf_module(self, _: torch.nn.Module, __: str) -> bool:\n return True\n\n com = CodeOnlyModule(body)\n return GraphModule(com, KeepModules().trace(com))\n\n# copy an attribute value with qualified name 'target' from 'from_module' to 'to_module'\n# This installs empty Modules where none exist yet if they are subpaths of target\ndef _copy_attr(from_module: torch.nn.Module, to_module: torch.nn.Module, target: str):\n prefix, field = target.split('.')\n for item in prefix:\n f = getattr(from_module, item)\n t = getattr(to_module, item, None)\n if f is t:\n # we have already installed one of its parents\n # (e.g. target = root.linear.weight, but we have already installed root.linear)\n # once we install a parent, we no longer need to copy the children\n # since all the needed properties will already be present\n return\n\n if t is None:\n t = torch.nn.Module()\n setattr(to_module, item, t)\n from_module, to_module = f, t\n\n orig = getattr(from_module, field)\n # If it is a tensor and not a parameter attribute of a module, it should be a named buffer.\n # So, we register it as a named buffer in the target module.\n if isinstance(orig, torch.Tensor) and not isinstance(orig, torch.nn.Parameter):\n to_module.register_buffer(field, orig)\n else:\n setattr(to_module, field, orig)\n\n# Assign attribute 'from_obj' to the qualified name 'target' on 'to_module\n# This installs empty Modules where none exist yet if they are subpaths of target\ndef _assign_attr(from_obj: Any, to_module: torch.nn.Module, target: str):\n prefix, field = target.split('.')\n for item in prefix:\n t = getattr(to_module, item, None)\n\n if t is None:\n t = torch.nn.Module()\n setattr(to_module, item, t)\n to_module = t\n\n # If it is a tensor and not a parameter attribute of a module, it should be a named buffer.\n # So, we register it as a named buffer in the target module.\n if isinstance(from_obj, torch.Tensor) and not isinstance(from_obj, torch.nn.Parameter):\n to_module.register_buffer(field, from_obj)\n else:\n setattr(to_module, field, from_obj)\n\nclass GraphModule(torch.nn.Module):\n \"\"\"\n GraphModule is an nn.Module generated from an fx.Graph. Graphmodule has a\n ``graph`` attribute, as well as ``code`` and ``forward`` attributes generated\n from that ``graph``.\n\n .. warning::\n\n When ``graph`` is reassigned, ``code`` and ``forward`` will be automatically\n regenerated. However, if you edit the contents of the ``graph`` without reassigning\n the ``graph`` attribute itself, you must call ``recompile()`` to update the generated\n code.\n\n \"\"\"\n def __new__(cls: 'Type[GraphModule]', args, *kwargs):\n # each instance of a graph module needs its own forward method\n # so create a new singleton class for each instance.\n # it is a subclass of the user-defined class, the only difference\n # is an extra layer to install the forward method\n\n class GraphModuleImpl(cls): # type: ignore[misc, valid-type]\n pass\n return super().__new__(GraphModuleImpl)\n\n def __init__(self,\n root: Union[torch.nn.Module, Dict[str, Any]],\n graph: Graph,\n class_name: str = 'GraphModule'):\n \"\"\"\n Construct a GraphModule.\n\n Args:\n\n root (Union[torch.nn.Module, Dict[str, Any]):\n ``root`` can either be an nn.Module instance or a Dict mapping strings to any attribute type.\n In the case that ``root`` is a Module, any references to Module-based objects (via qualified\n name) in the Graph's Nodes' ``target`` field will be copied over from the respective place\n within ``root``'s Module hierarchy into the GraphModule's module hierarchy.\n In the case that ``root`` is a dict, the qualified name found in a Node's ``target`` will be\n looked up directly in the dict's keys. The object mapped to by the Dict will be copied\n over into the appropriate place within the GraphModule's module hierarchy.\n\n graph (Graph): ``graph`` contains the nodes this GraphModule should use for code generation\n\n class_name (str): ``name`` denotes the name of this GraphModule for debugging purposes. If it's unset, all\n error messages will report as originating from ``GraphModule``. It may be helpful to set this\n to ``root``'s original name or a name that makes sense within the context of your transform.\n\n \"\"\"\n super().__init__()\n self.__class__.__name__ = class_name\n if isinstance(root, torch.nn.Module):\n if hasattr(root, 'training'):\n self.training = root.training\n for node in graph.nodes:\n if node.op in ['get_attr', 'call_module']:\n assert isinstance(node.target, str)\n _copy_attr(root, self, node.target)\n elif isinstance(root, dict):\n targets_to_copy = []\n for node in graph.nodes:\n if node.op in ['get_attr', 'call_module']:\n assert isinstance(node.target, str)\n if node.target not in root:\n raise RuntimeError('Node ' + str(node) + ' referenced target ' + node.target +\n ' but that target was not provided in ``root``!')\n targets_to_copy.append(node.target)\n # Sort targets in ascending order of the # of atoms.\n # This will ensure that less deeply nested attributes are assigned\n # before more deeply nested attributes. For example, foo.bar\n # will be assigned before foo.bar.baz. Otherwise, we might assign\n # the user-provided ``foo.bar`` and wipe out the previously-assigned\n # ``foo.bar.baz``\n targets_to_copy.sort(key=lambda t: t.count('.'))\n for target_to_copy in targets_to_copy:\n _assign_attr(root[target_to_copy], self, target_to_copy)\n else:\n raise RuntimeError('Unsupported type ' + str(root) + ' passed for root!')\n\n self.graph = graph\n\n # TorchScript breaks trying to compile the graph setter because of the\n # continued string literal. Issue here: https://github.com/pytorch/pytorch/issues/44842\n #\n # Shouldn't be an issue since these methods shouldn't be used in TorchScript anyway\n __jit_unused_properties__ = ['graph']\n\n @property\n def graph(self) -> Graph:\n \"\"\"\n Return the ``Graph`` underlying this ``GraphModule``\n \"\"\"\n return self._graph\n\n @graph.setter\n def graph(self, g : Graph) -> None:\n \"\"\"\n Set the underlying ``Graph`` for this ``GraphModule``. This will internally\n recompile the ``GraphModule`` so that the generated ``forward()`` function\n corresponds to ``g``\n \"\"\"\n assert isinstance(g, Graph), f'Expected a Graph instance, but got {type(g)}'\n self._graph = g\n g.owning_module = self\n self.recompile()\n\n def to_folder(self, folder: Union[str, os.PathLike], module_name : str = \"FxModule\"):\n \"\"\"Dumps out module to ``folder`` with ``module_name`` so that it can be\n imported with ``from <folder> import <module_name>``\n\n Args:\n\n folder (Union[str, os.PathLike]): The folder to write the code out to\n\n module_name (str): Top-level name to use for the ``Module`` while\n writing out the code\n \"\"\"\n folder = Path(folder)\n Path(folder).mkdir(exist_ok=True)\n torch.save(self.state_dict(), folder / 'state_dict.pt')\n tab = \" \" 4\n model_str = f\"\"\"\nimport torch\nfrom torch.nn import \nclass {module_name}(torch.nn.Module):\n def __init__(self):\n super().__init__()\n\"\"\"\n\n def _gen_model_repr(module_name: str, module: torch.nn.Module) -> Optional[str]:\n safe_reprs = [nn.Linear, nn.Conv1d, nn.Conv2d, nn.Conv3d, nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d]\n if type(module) in safe_reprs:\n return f\"{module.__repr__()}\"\n else:\n return None\n\n blobified_modules = []\n for module_name, module in self.named_children():\n module_str = _gen_model_repr(module_name, module)\n if module_str is None:\n module_file = folder / f'{module_name}.pt'\n torch.save(module, module_file)\n blobified_modules.append(module_name)\n module_repr = module.__repr__().replace('\\r', ' ').replace('\\n', ' ')\n module_str = f\"torch.load(r'{module_file}') # {module_repr}\"\n model_str += f\"{tab2}self.{module_name} = {module_str}\\n\"\n\n for buffer_name, buffer in self._buffers.items():\n model_str += f\"{tab2}self.register_buffer('{buffer_name}', torch.empty({list(buffer.shape)}))\\n\"\n\n for param_name, param in self._parameters.items():\n model_str += f\"{tab2}self.{param_name} = torch.nn.Parameter(torch.empty({list(buffer.shape)}))\\n\"\n\n model_str += f\"{tab2}self.load_state_dict(torch.load(r'{folder}/state_dict.pt'))\\n\"\n model_str += f\"{_addindent(self.code, 4)}\\n\"\n\n module_file = folder / 'module.py'\n module_file.write_text(model_str)\n\n init_file = folder / '__init__.py'\n init_file.write_text('from .module import ')\n\n if len(blobified_modules) > 0:\n warnings.warn(\"Was not able to save the following children modules as reprs -\"\n f\"saved as pickled files instead: {blobified_modules}\")\n\n def add_submodule(self, target: str, m: torch.nn.Module) -> bool:\n \"\"\"\n Adds the given submodule to ``self``.\n\n This installs empty Modules where none exist yet if they are\n subpaths of ``target``.\n\n Args:\n target: The fully-qualified string name of the new submodule\n (See example in ``nn.Module.get_submodule`` for how to\n specify a fully-qualified string.)\n m: The submodule itself; the actual object we want to\n install in the current Module\n\n Return:\n bool: Whether or not the submodule could be inserted. For\n this method to return True, each object in the chain\n denoted by ``target`` must either a) not exist yet,\n or b) reference an ``nn.Module`` (not a parameter or\n other attribute)\n\n \"\"\"\n prefix, field = target.split('.')\n mod: torch.nn.Module = self\n\n for item in prefix:\n\n submod = getattr(mod, item, None)\n\n if submod is None:\n submod = torch.nn.Module()\n setattr(mod, item, submod)\n\n if not isinstance(submod, torch.nn.Module):\n return False\n\n mod = submod\n\n mod.add_module(field, m)\n return True\n\n def delete_submodule(self, target: str) -> bool:\n \"\"\"\n Deletes the given submodule from ``self``.\n\n The module will not be deleted if ``target`` is not a valid\n target.\n\n Args:\n target: The fully-qualified string name of the new submodule\n (See example in ``nn.Module.get_submodule`` for how to\n specify a fully-qualified string.)\n\n Returns:\n bool: Whether or not the target string referenced a\n submodule we want to delete. A return value of ``False``\n means that the ``target`` was not a valid reference to\n a submodule.\n \"\"\"\n atoms = target.split(\".\")\n path, target_submod = atoms[:-1], atoms[-1]\n mod: torch.nn.Module = self\n\n # Get the parent module\n for item in path:\n\n if not hasattr(mod, item):\n return False\n\n mod = getattr(mod, item)\n\n if not isinstance(mod, torch.nn.Module):\n return False\n\n if not hasattr(mod, target_submod):\n return False\n\n if not isinstance(getattr(mod, target_submod), torch.nn.Module):\n return False\n\n delattr(mod, target_submod)\n return True\n\n def delete_all_unused_submodules(self) -> None:\n \"\"\"\n Deletes all unused submodules from ``self``.\n\n A Module is considered \"used\" if any one of the following is\n true:\n 1. It has children that are used\n 2. Its forward is called directly via a ``call_module`` node\n 3. It has a non-Module attribute that is used from a\n ``get_attr`` node\n\n This method can be called to clean up an ``nn.Module`` without\n manually calling ``delete_submodule`` on each unused submodule.\n \"\"\"\n used: List[str] = []\n\n for node in self.graph.nodes:\n\n if node.op == \"call_module\" or node.op == \"get_attr\":\n\n # A list of strings representing the different parts\n # of the path. For exmaple, `foo.bar.baz` gives us\n # [\"foo\", \"bar\", \"baz\"]\n fullpath = node.target.split(\".\")\n\n # If we're looking at multiple parts of a path, join\n # join them with a dot. Otherwise, return that single\n # element without doing anything to it.\n def join_fn(x: str, y: str) -> str:\n return '.'.join([x, y] if y else [x])\n\n # Progressively collect all the names of intermediate\n # modules. For example, if we have the target\n # `foo.bar.baz`, we'll add `foo`, `foo.bar`, and\n # `foo.bar.baz` to the list.\n for path in itertools.accumulate(fullpath, join_fn):\n used.append(path)\n\n to_delete = [name for name, _ in self.named_modules()\n if name not in used]\n\n for name in to_delete:\n self.delete_submodule(name)\n\n @property\n def code(self) -> str:\n \"\"\"\n Return the Python code generated from the ``Graph`` underlying this\n ``GraphModule``.\n \"\"\"\n if not hasattr(self, '_code'):\n raise RuntimeError('Code has not been generated! Please report a bug to PyTorch')\n return self._code\n\n def recompile(self) -> PythonCode:\n \"\"\"\n Recompile this GraphModule from its ``graph`` attribute. This should be\n called after editing the contained ``graph``, otherwise the generated\n code of this ``GraphModule`` will be out of date.\n \"\"\"\n if self._graph._pytree_info is not None:\n self._in_spec = self._graph._pytree_info.in_spec\n self._out_spec = self._graph._pytree_info.out_spec\n python_code = self._graph.python_code(root_module='self')\n self._code = python_code.src\n\n cls = type(self)\n cls.forward = _forward_from_src(self._code, python_code.globals)\n\n cls_call = cls.__call__\n\n # Previously, if an error occurred when valid\n # symbolically-traced code was run with an invalid input, the\n # user would see the source of the error as coming from\n # `File \"<eval_with_key_N\">`, where N is some number. We use\n # this function to generate a more informative error message. We\n # return the traceback itself, a message explaining that the\n # error occurred in a traced Module's generated forward\n # function, and five lines of context surrounding the faulty\n # line\n def generate_error_message(frame_summary: traceback.FrameSummary) -> str:\n # auxiliary variables (for readability)\n err_lineno = frame_summary.lineno\n err_line_len = len(frame_summary.line)\n all_src_lines = _eval_cache[frame_summary.filename]\n\n # constituent substrings of the error message\n tb_repr = traceback.format_exc()\n custom_msg = (\"Call using an FX-traced Module, \"\n f\"line {err_lineno} of the traced Module's \"\n \"generated forward function:\")\n before_err = \"\".join(all_src_lines[err_lineno - 2 : err_lineno])\n marker = \"~\" err_line_len + \"~~~ <--- HERE\"\n err_and_after_err = \"\\n\".join(all_src_lines[err_lineno : err_lineno + 2])\n\n # joined message\n return \"\\n\".join([tb_repr, custom_msg, before_err, marker, err_and_after_err])\n\n def wrapped_call(self, args, kwargs):\n try:\n return cls_call(self, args, *kwargs)\n except Exception as e:\n assert e.__traceback__\n topmost_framesummary: traceback.FrameSummary = \\\n traceback.StackSummary.extract(traceback.walk_tb(e.__traceback__))[-1] # type: ignore[arg-type]\n if \"eval_with_key\" in topmost_framesummary.filename:\n print(generate_error_message(topmost_framesummary),\n file=sys.stderr)\n raise e.with_traceback(None)\n\n cls.__call__ = wrapped_call\n\n return python_code\n\n def __reduce_package__(self, exporter: PackageExporter):\n generated_module_name = f'fx-generated._{exporter.get_unique_id()}'\n python_code = self.recompile()\n import_block = _format_import_block(python_code.globals, exporter.importer)\n module_code = import_block + self.code\n exporter.save_source_string(generated_module_name, module_code)\n\n dict_without_graph = self.__dict__.copy()\n del dict_without_graph['_graph']\n return (reduce_package_graph_module, (dict_without_graph, generated_module_name))\n\n def __reduce__(self):\n \"\"\"\n Serialization of GraphModule. We serialize only the generated code, not\n the underlying ``Graph``. This is because ``Graph`` does not have on-disk\n backward-compatibility guarantees, whereas Python source code does.\n On the deserialization side, we symbolically trace through the generated\n code to regenerate the underlying ``Graph``\n \"\"\"\n dict_without_graph = self.__dict__.copy()\n python_code = self.recompile()\n import_block = _format_import_block(python_code.globals, sys_importer)\n del dict_without_graph['_graph']\n return (reduce_graph_module, (dict_without_graph, import_block))\n\n # because __reduce__ is defined for serialization,\n # we need to define deepcopy otherwise it will call __reduce__\n # and cause symbolic tracing to occur every time we try to copy the object\n def __deepcopy__(self, memo):\n fake_mod = torch.nn.Module()\n fake_mod.__dict__ = copy.deepcopy(self.__dict__)\n return GraphModule(fake_mod, self.graph)\n\n def __copy__(self):\n return GraphModule(self, self.graph)\n\n def __str__(self) -> str:\n orig_str = super().__str__()\n return '\\n'.join([orig_str, self._code])\n\n# workarounds for issues in __torch_function__\n\n# WAR for __torch_function__ not handling tensor lists,\n# fix is in https://github.com/pytorch/pytorch/pull/34725\n# orig_cat = torch.cat\n# def patched_cat(args, *kwargs):\n# tensors = args[0]\n# for t in tensors:\n# if isinstance(t, Proxy):\n# return t.__torch_function__(patched_cat, (), args, kwargs)\n# return orig_cat(args, **kwargs)\n# patched_cat.__module__ = 'torch'\n# patched_cat.__name__ = 'cat'\n# torch.cat = patched_cat\n" ]	[ [ "torch.nn.Module", "torch.nn.modules.module._addindent", "torch.save" ] ]

ms440/bnlearn

[ "229b2bf05b6b6f2aa7dc96e6d55bf972cdbbfe52" ]

[ "bnlearn/helpers/network.py" ]

[ "\"\"\" This function has functionalities for network creation, clustering and plotting.\n\n\tG = network.to_graph(adjmat)\n\tlabx = network.cluster(G)\n\tfig = network.plot(G, labx)\n\n INPUT:\n adjmat: pd.DataFrame(): Edges are any values >0 between intersecting nodes.\n rows = features\n colums = samples\n OPTIONAL\n\n verbose: Integer [0..5] if verbose >= DEBUG: print('debug message')\n 0: (default)\n 1: ERROR\n 2: WARN\n 3: INFO\n 4: DEBUG\n \n\n OUTPUT\n\toutput\n\n DESCRIPTION\n This function has functionalities for network creation, clustering and plotting\n \n REQUIRES\n pip install python-louvain\n pip install --upgrade networkx\n \n\n\"\"\"\n\n#--------------------------------------------------------------------------\n# Name : network.py\n# Author : E.Taskesen\n# Contact : [email protected]\n# Date : July. 2019\n#--------------------------------------------------------------------------\n\n#%% Libraries\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport numpy as np\nimport community\nimport networkx as nx\nfrom sklearn.preprocessing import minmax_scale\nfrom sklearn.preprocessing import MinMaxScaler \nfrom ismember import ismember\nimport bnlearn.helpers.confmatrix as confmatrix\n\n#%% Make graph from adjacency matrix\ndef to_graph(adjmat, verbose=3):\n assert float(nx.__version__)>2, 'This function requires networkx to be v2 or higher. Try to: pip install --upgrade networkx'\n config = dict()\n config['verbose'] = verbose\n\n adjmat = is_DataFrame(adjmat)\n if config['verbose']>=3: print('[NETWORK.to_graph] Making graph')\n G=nx.from_pandas_adjacency(adjmat)\n\n return(G)\n\n#%% Convert Adjmat to graph (G) (also works with lower versions of networkx)\ndef adjmat2graph(adjmat):\n G = nx.DiGraph() # Directed graph\n # Convert adjmat to source target\n df_edges=adjmat.stack().reset_index()\n df_edges.columns=['source', 'target', 'weight']\n df_edges['weight']=df_edges['weight'].astype(float)\n \n # Add directed edge with weigth\n for i in range(df_edges.shape[0]):\n if df_edges['weight'].iloc[i]!=0:\n # Setup color\n if df_edges['weight'].iloc[i]==1:\n color='k'\n elif df_edges['weight'].iloc[i]>1:\n color='r'\n elif df_edges['weight'].iloc[i]<0:\n color='b'\n else:\n color='p'\n \n # Create edge in graph\n G.add_edge(df_edges['source'].iloc[i], df_edges['target'].iloc[i], weight=np.abs(df_edges['weight'].iloc[i]), color=color) \n # Return\n return(G)\n \n#%% Compute similarity matrix\ndef compute_centrality(G, centrality='betweenness', verbose=3):\n if verbose>=3: print('[NETWORK.compute_centrality] Computing centrality %s' %(centrality))\n \n if centrality=='betweenness':\n bb=nx.centrality.betweenness_centrality(G)\n elif centrality=='closeness':\n bb=nx.centrality.closeness_centrality(G)\n elif centrality=='eigenvector':\n bb=nx.centrality.eigenvector_centrality(G)\n elif centrality=='degree':\n bb=nx.centrality.degree_centrality(G)\n elif centrality=='edge':\n bb=nx.centrality.edge_betweenness(G)\n elif centrality=='harmonic':\n bb=nx.centrality.harmonic_centrality(G)\n elif centrality=='katz':\n bb=nx.centrality.katz_centrality(G)\n elif centrality=='local':\n bb=nx.centrality.local_reaching_centrality(G)\n elif centrality=='out_degree':\n bb=nx.centrality.out_degree_centrality(G)\n elif centrality=='percolation':\n bb=nx.centrality.percolation_centrality(G)\n elif centrality=='second_order':\n bb=nx.centrality.second_order_centrality(G)\n elif centrality=='subgraph':\n bb=nx.centrality.subgraph_centrality(G)\n elif centrality=='subgraph_exp':\n bb=nx.centrality.subgraph_centrality_exp(G)\n elif centrality=='information':\n bb=nx.centrality.information_centrality(G)\n else:\n print('[NETWORK] [ERROR] Centrality <%s> does not exist!' %(centrality))\n \n # Set the attributes\n score=np.array([*bb.values()])\n nx.set_node_attributes(G, bb, centrality)\n \n return(G, score)\n\n#%% compute clusters\ndef cluster(G, verbose=3):\n if verbose>=3: print('[NETWORK.cluster] Clustering using best partition')\n # Partition\n partition=community.best_partition(G)\n # Set property to node\n nx.set_node_attributes(G, partition, 'clusterlabel')\n # Extract labels\n labx=[partition.get(node) for node in G.nodes()]\n labx=np.array(labx)\n \n return(G, labx)\n\n#%% Compute cluster comparison\ndef cluster_comparison_centralities(G, width=5, height=4, showfig=False, methodtype='default', verbose=3):\n config=dict()\n config['showfig']=showfig\n config['width']=width\n config['height']=height\n config['verbose']=verbose\n\n if verbose>=3: print('[NETWORK] Compute a dozen of centralities and clusterlabels')\n \n # compute labx for each of the centralities\n centralities=['betweenness', 'closeness','eigenvector','degree','edge','harmonic','katz','local','out_degree','percolation','second_order','subgraph','subgraph_exp','information']\n \n # Compute best positions for the network\n pos=nx.spring_layout(G)\n\n # Cluster data nd store label in G\n [G, score] = cluster(G)\n \n # Compute centrality score for each of the centralities and store in G\n for centrality in centralities:\n [G,score]=compute_centrality(G, centrality=centrality)\n \n # Store\n df=pd.DataFrame([*G.nodes.values()])\n df.set_index(np.array([*G.nodes.keys()]), inplace=True)\n \n # Make plots\n for centrality in centralities:\n if config['showfig']:\n plot(G, node_color=df['clusterlabel'], node_size=df[centrality], pos=pos, cmap='Set1', title=centrality, width=config['width'], height=config['height'], methodtype='default')\n \n return(G, df)\n\n#%% Make plot\ndef plot(G, node_color=None, node_label=None, node_size=100, node_size_scale=[25,200], alpha=0.8, font_size=18, cmap='Set1', width=40, height=30, pos=None, filename=None, title=None, methodtype='default', verbose=3):\n # https://networkx.github.io/documentation/networkx-1.7/reference/generated/networkx.drawing.nx_pylab.draw_networkx.html\n config=dict()\n config['filename']=filename\n config['width']=width\n config['height']=height\n config['verbose']=verbose\n config['node_size_scale']=node_size_scale\n \n if verbose>=3: print('[NETWORK] Creating network plot')\n \n if 'pandas' in str(type(node_size)):\n node_size=node_size.values\n \n #scaling node sizes\n if config['node_size_scale']!=None and 'numpy' in str(type(node_size)):\n if verbose>=3: print('[NETWORK] Scaling node sizes')\n node_size=minmax_scale(node_size, feature_range=(node_size_scale[0], node_size_scale[1]))\n\n # Node positions\n# if isinstance(pos, type(None)):\n# pos=nx.spring_layout(G)\n\n# if isinstance(node_label, type(None)):\n# node_label=[*G.nodes])\n\n fig=plt.figure(figsize=(config['width'], config['height']))\n \n # Make the graph\n if methodtype=='circular':\n nx.draw_circular(G, labels=node_label, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size, with_labels=True)\n elif methodtype=='kawai':\n nx.draw_kamada_kawai(G, labels=node_label, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size, with_labels=True)\n else:\n nx.draw_networkx(G, labels=node_label, pos=pos, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size, with_labels=True)\n# nx.draw_networkx(G, pos=pos, node_size=node_size, alhpa=alpha, node_color=node_color, cmap=cmap, font_size=font_size)\n \n plt.title(title)\n plt.grid(True)\n plt.show()\n \n # Savefig\n if not isinstance(config['filename'], type(None)):\n if verbose>=3: print('[NETWORK.plot] Saving figure')\n plt.savefig(config['filename'])\n \n return(fig)\n\n#%% Normalize in good d3 range\ndef normalize_size(getsizes, minscale=0.1, maxscale=4):\n getsizes = MinMaxScaler(feature_range=(minscale,maxscale)).fit_transform(getsizes).flatten()\n return(getsizes)\n\n#%% Convert dataframe to Graph\ndef df2G(df_nodes, df_edges, verbose=3):\n # Put edge information in G\n# G = nx.from_pandas_edgelist(df_edges, 'source', 'target', ['weight', 'edge_weight','edge_width','source_label','target_label'])\n \n colnames=list(df_edges.columns.values[~np.isin(df_edges.columns.values,['source','target'])])\n G = nx.from_pandas_edgelist(df_edges, 'source', 'target', colnames)\n\n # Put node info in G\n getnodes=[*G.nodes]\n for col in df_nodes.columns:\n for i in range(0, df_nodes.shape[0]):\n if np.any(np.isin(getnodes, df_nodes.index.values[i])):\n G.nodes[df_nodes.index.values[i]][col] = str(df_nodes[col].iloc[i])\n \n return(G)\n \n#%% Convert Graph to dataframe\ndef G2df(G, node_color=None, node_label=None, node_size=100, edge_distance_minmax=[1,100], verbose=3):\n # Nodes\n df_node_names=pd.DataFrame([*G.nodes], columns=['node_name'])\n df_node_props=pd.DataFrame([*G.nodes.values()])\n df_nodes=pd.concat([df_node_names, df_node_props], axis=1)\n\n if not np.any(df_nodes.columns=='node_color'):\n df_nodes['node_color']='#000080'\n if not np.any(df_nodes.columns=='node_color_edge'):\n df_nodes['node_color_edge']='#000000'\n if not np.any(df_nodes.columns=='node_size_edge'):\n df_nodes['node_size_edge']=1\n if not isinstance(node_label, type(None)):\n df_nodes['node_label']=node_label\n \n if np.any(df_nodes.columns=='node_size'):\n df_nodes['node_size']=normalize_size(df_nodes['node_size'].values.reshape(-1,1), 1, 10)\n else:\n df_nodes['node_size']=10\n\n # Edges\n df_edge_links=pd.DataFrame([*G.edges], columns=['source_label','target_label'])\n df_edge_props=pd.DataFrame([*G.edges.values()])\n df_edges=pd.concat([df_edge_links, df_edge_props], axis=1)\n \n # Source and target values\n df_nodes['index_value']=None\n df_edges['source']=None\n df_edges['target']=None\n# uinodes=np.unique(np.append(df_edges['source_label'], df_edges['target_label']))\n uinodes=np.unique(df_nodes['node_name'])\n for i in range(0,len(uinodes)):\n I=(uinodes[i]==df_edges['source_label'])\n df_edges['source'].loc[I]=i\n I=(uinodes[i]==df_edges['target_label'])\n df_edges['target'].loc[I]=i\n \n I=df_nodes['node_name']==uinodes[i]\n df_nodes['index_value'].loc[I]=i\n \n df_nodes.set_index(df_nodes['index_value'], inplace=True)\n del df_nodes['index_value']\n \n # Include width and weights\n if not np.any(df_edges.columns=='edge_weight') and np.any(df_edges.columns=='weight'):\n df_edges['edge_weight']=normalize_size(df_edges['weight'].values.reshape(-1,1), edge_distance_minmax[0], edge_distance_minmax[1])\n else:\n df_edges['edge_weight']=2\n if not np.any(df_edges.columns=='edge_width'):\n df_edges['edge_width']=2\n if not np.any(df_edges.columns=='weight'):\n df_edges['weight']=2\n\n # Remove self-loops\n I=df_edges['source']!=df_edges['target']\n df_edges=df_edges.loc[I,:].reset_index(drop=True)\n\n return(df_nodes, df_edges)\n\n#%% Make plot\ndef bokeh(G, node_color=None, node_label=None, node_size=100, node_size_scale=[25,200], alpha=0.8, font_size=18, cmap='Set1', width=40, height=30, pos=None, filename=None, title=None, methodtype='default', verbose=3):\n import networkx as nx\n from bokeh.io import show, output_file\n from bokeh.models import Plot, Range1d, MultiLine, Circle, HoverTool, BoxZoomTool, ResetTool\n from bokeh.models.graphs import from_networkx\n from bokeh.palettes import Spectral4\n \n SAME_CLUB_COLOR, DIFFERENT_CLUB_COLOR = \"black\", \"red\"\n edge_attrs = {}\n \n for start_node, end_node, _ in G.edges(data=True):\n edge_color = SAME_CLUB_COLOR if G.nodes[start_node][\"club\"] == G.nodes[end_node][\"club\"] else DIFFERENT_CLUB_COLOR\n edge_attrs[(start_node, end_node)] = edge_color\n \n nx.set_edge_attributes(G, edge_attrs, \"edge_color\")\n \n # Show with Bokeh\n plot = Plot(plot_width=400, plot_height=400,\n x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1))\n plot.title.text = \"Graph Interaction Demonstration\"\n \n node_hover_tool = HoverTool(tooltips=[(\"index\", \"@index\"), (\"club\", \"@club\")])\n plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool())\n \n graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0))\n \n graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0])\n graph_renderer.edge_renderer.glyph = MultiLine(line_color=\"edge_color\", line_alpha=0.8, line_width=1)\n plot.renderers.append(graph_renderer)\n \n output_file(\"interactive_graphs.html\")\n show(plot)\n\n#%% Comparison of two networks\ndef compare_networks(adjmat_true, adjmat_pred, pos=None, showfig=True, width=15, height=8, verbose=3):\n # Make sure columns and indices to match\n [IArow,IBrow]=ismember(adjmat_true.index.values, adjmat_pred.index.values)\n [IAcol,IBcol]=ismember(adjmat_true.columns.values, adjmat_pred.columns.values)\n adjmat_true = adjmat_true.loc[IArow,IAcol]\n adjmat_pred = adjmat_pred.iloc[IBrow,IBcol]\n \n # Make sure it is boolean adjmat\n adjmat_true = adjmat_true>0\n adjmat_pred = adjmat_pred>0\n\n # Check whether order is correct\n assert np.all(adjmat_true.columns.values==adjmat_pred.columns.values), 'Column order of both input values could not be matched'\n assert np.all(adjmat_true.index.values==adjmat_pred.index.values), 'Row order of both input values could not be matched'\n \n # Get edges\n y_true = adjmat_true.stack().reset_index()[0].values\n y_pred = adjmat_pred.stack().reset_index()[0].values\n \n # Confusion matrix\n scores=confmatrix.twoclass(y_true, y_pred, threshold=0.5, classnames=['Disconnected','Connected'], title='', cmap=plt.cm.Blues, showfig=1, verbose=0)\n #bayes.plot(out_bayes['adjmat'], pos=G['pos'])\n \n # Setup graph\n adjmat_diff = adjmat_true.astype(int)\n adjmat_diff[(adjmat_true.astype(int) - adjmat_pred.astype(int))<0]=2\n adjmat_diff[(adjmat_true.astype(int) - adjmat_pred.astype(int))>0]=-1\n \n if showfig:\n # Setup graph\n # G_true = adjmat2graph(adjmat_true)\n G_diff = adjmat2graph(adjmat_diff)\n # Graph layout\n pos = graphlayout(G_diff, pos=pos, scale=1, layout='fruchterman_reingold')\n # Bootup figure\n plt.figure(figsize=(width,height))\n # nodes\n nx.draw_networkx_nodes(G_diff, pos, node_size=700)\n # edges\n colors = [G_diff[u][v]['color'] for u,v in G_diff.edges()]\n #weights = [G_diff[u][v]['weight'] for u,v in G_diff.edges()]\n nx.draw_networkx_edges(G_diff, pos, arrowstyle='->', edge_color=colors, width=1)\n # Labels\n nx.draw_networkx_labels(G_diff, pos, font_size=20, font_family='sans-serif')\n # Get labels of weights\n #labels = nx.get_edge_attributes(G,'weight')\n # Plot weights\n nx.draw_networkx_edge_labels(G_diff, pos, edge_labels=nx.get_edge_attributes(G_diff,'weight'))\n # Making figure nice\n #plt.legend(['Nodes','TN','FP','test'])\n ax = plt.gca()\n ax.set_axis_off()\n plt.show()\n \n # Return\n return(scores, adjmat_diff)\n\n#%% Make graph layout\ndef graphlayout(model, pos, scale=1, layout='fruchterman_reingold', verbose=3):\n if isinstance(pos, type(None)):\n if layout=='fruchterman_reingold':\n pos = nx.fruchterman_reingold_layout(model, scale=scale, iterations=50)\n else:\n pos = nx.spring_layout(model, scale=scale, iterations=50)\n else:\n if verbose>=3: print('[NETWORK.graphlayout] Existing coordinates from <pos> are used.')\n\n return(pos)\n\n#%% Convert to pandas dataframe\ndef is_DataFrame(data, verbose=0):\n if isinstance(data, list):\n data=pd.DataFrame(data)\n elif isinstance(data, np.ndarray):\n data=pd.DataFrame(data)\n elif isinstance(data, pd.DataFrame):\n pass\n else:\n print('Typing should be pd.DataFrame()!')\n data=None\n \n return(data)\n" ]

[ [ "numpy.isin", "matplotlib.pyplot.gca", "pandas.concat", "numpy.abs", "matplotlib.pyplot.title", "numpy.unique", "pandas.DataFrame", "matplotlib.pyplot.savefig", "numpy.all", "numpy.any", "matplotlib.pyplot.grid", "sklearn.preprocessing.MinMaxScaler", "numpy.array", "sklearn.preprocessing.minmax_scale", "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ] ]

Vpatrik/mech_ros

[ "3119908b25b2c86756c1d88e9da2d60cb426e1cc" ]

[ "src/Compare_Aruco_board_marker_detection.py" ]

[ "#!/usr/bin/env python\n\n# Patrik Vavra 2019\n\n\"\"\"\nCompares estimated pose of ArUco marker and ChArUco board, computes statistical data\nand write them to csv file.\n\"\"\"\n\n\nimport numpy as np\n# import cv2\nimport yaml\n# import time\nimport rospy\nimport cv2\nimport math\nimport csv\n\n\nfrom geometry_msgs.msg import PoseWithCovarianceStamped\nfrom mech_ros_msgs.msg import MarkerList\nfrom mech_ros_msgs.msg import Marker\n\nfilename = \"/home/patrik/catkin_ws/src/mech_ros/localization/Data_natoceni.csv\"\n\n\n# Static transformation from board to marker\nx_tr = 0\ny_tr = 0\nz_tr = 0\n\n## Generate dictionary\ndictionary = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_5X5_50)\ndictionary_b = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_4X4_50)\n# dictionary_b = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)\nboard = cv2.aruco.CharucoBoard_create(4,3,0.0633,0.0475,dictionary_b)# Doma\n# board = cv2.aruco.CharucoBoard_create(8,5,.034566,.01725,dictionary_b)\n# board = cv2.aruco.CharucoBoard_create(3,2,0.0895,0.0714,dictionary_b) # mechlab\n\n# Define topics\nmarker_detector_topic = \"/markers\"\nboard_detector_topic = \"/board\"\nframe_id = \"/camera\"\n\n# Define calibration filename\ncalibration_file = \"/home/patrik/catkin_ws/src/mech_ros/Config_ARuco/camera.yaml\"\n\nmarkerLength = 0.088\n\n\n## Define Aruco Detector Params\narucoParams = cv2.aruco.DetectorParameters_create()\n\narucoParams.adaptiveThreshConstant = 7\narucoParams.adaptiveThreshWinSizeMax = 35 # default 23\narucoParams.adaptiveThreshWinSizeMin = 3 # default 3\narucoParams.adaptiveThreshWinSizeStep = 8 # default 10\n\narucoParams.cornerRefinementMethod = 1\narucoParams.cornerRefinementMaxIterations = 30\narucoParams.cornerRefinementMinAccuracy = 0.01\narucoParams.cornerRefinementWinSize = 5\n\narucoParams.errorCorrectionRate = 0.6\narucoParams.minCornerDistanceRate = 0.05 # min distance between marker corners,\n# min. distance[pix] = Perimeter*minCornerDistanceRate\narucoParams.minMarkerDistanceRate = 0.05 # min distance between corners of different markers,\n# min. distance[pix] = Perimeter(smaller one)*minMarkerDistanceRate\narucoParams.minMarkerPerimeterRate = 0.1 # min_mark_perim[pix]= max. dimension of image [pix]*minMark-per-Rate\narucoParams.maxMarkerPerimeterRate = 4.0\narucoParams.minOtsuStdDev = 5.0\narucoParams.perspectiveRemoveIgnoredMarginPerCell = 0.13\narucoParams.perspectiveRemovePixelPerCell = 8\narucoParams.polygonalApproxAccuracyRate = 0.01\narucoParams.markerBorderBits = 1\narucoParams.maxErroneousBitsInBorderRate = 0.04\narucoParams.minDistanceToBorder = 3\n\n\n## Define Aruco board Detector Params\narucoParams_b = cv2.aruco.DetectorParameters_create()\narucoParams_b.adaptiveThreshConstant = 7\narucoParams_b.adaptiveThreshWinSizeMax = 45 # default 23\narucoParams_b.adaptiveThreshWinSizeMin = 3 # default 3\narucoParams_b.adaptiveThreshWinSizeStep = 7 # default 10\narucoParams_b.cornerRefinementMethod = 0\n# arucoParams_b.errorCorrectionRate = 0.6\n# arucoParams_b.minOtsuStdDev = 5.0\n# arucoParams_b.perspectiveRemoveIgnoredMarginPerCell = 0.13\n# arucoParams_b.perspectiveRemovePixelPerCell = 8\n# arucoParams_b.polygonalApproxAccuracyRate = 0.01\narucoParams_b.markerBorderBits = 1\n# arucoParams_b.maxErroneousBitsInBorderRate = 0.04\n# arucoParams_b.minDistanceToBorder = 3\n\n\n\n## Initialization\nmarkerIds = np.array([])\nmarkerCorners = np.array([])\nrejectedImgPoints = np.array([])\naxis = np.float32([[markerLength/2,markerLength/2,0], [-markerLength/2,markerLength/2,0], [-markerLength/2,-markerLength/2,0], [markerLength/2,-markerLength/2,0],\n [markerLength/2,markerLength/2,markerLength],[-markerLength/2,markerLength/2,markerLength],[-markerLength/2,-markerLength/2,markerLength],[markerLength/2,-markerLength/2,markerLength] ])\n\n## Initialization for statistics\nmarker_pose = np.zeros((50,3))\nboard_pose = np.zeros((50,3))\npose_difference = np.zeros((50,3))\nsurface_matrix = np.zeros((50,2))\n\n\n# Matrix for conversion from ROS frame to OpenCV in camera\nR_ROS_O_camera = np.array([[ 0.0, 0.0, 1.0],\n [ -1.0, 0.0, 0.0],\n [ 0.0, -1.0, 0.0]])\n\n # Matrix for conversion from OpenCV frame to ROS in marker\nR_O_ROS_marker = np.array([[ 0.0, 1.0, 0.0],\n [ 0.0, 0.0, 1.0],\n [ 1.0, 0.0, 0.0]])\n\n\n## Load coefficients\ndef load_coefficient(calibration_file):\n with open(calibration_file) as stream:\n try:\n data_loaded = yaml.load(stream)\n c_matrix = np.array(data_loaded[\"camera_matrix\"][\"data\"]).reshape((3,3))\n dist_coeff = np.array(data_loaded[\"distortion_coefficients\"][\"data\"])\n return c_matrix, dist_coeff\n except yaml.YAMLError as exc:\n print(exc)\n # with np.load('/home/patrik/catkin_ws/src/mech_ros/map/camCal2.npz') as X:\n # c_matrix, dist_coeff, _, _ = [X[i] for i in ('mtx', 'dist', 'rvecs', 'tvecs')]\n # return c_matrix, dist_coeff\n\n\n\n_FLOAT_EPS_4 = np.finfo(float).eps * 4.0\n\ndef rotationMatrixToEulerAngles(M, cy_thresh=None):\n # cy_thresh : None or scalar, optional\n # threshold below which to give up on straightforward arctan for\n # estimating x rotation. If None (default), estimate from\n # precision of input. Source : http://www.graphicsgems.org/\n\n if cy_thresh is None:\n try:\n cy_thresh = np.finfo(M.dtype).eps * 4\n except ValueError:\n cy_thresh = _FLOAT_EPS_4\n r11, r12, r13, r21, r22, r23, r31, r32, r33 = M.flat\n # cy: sqrt((cos(y)*cos(z))**2 + (cos(x)*cos(y))**2)\n cy = math.sqrt(r33*r33 + r23*r23)\n if cy > cy_thresh: # cos(y) not close to zero, standard form\n z = math.atan2(-r12, r11) # atan2(cos(y)*sin(z), cos(y)*cos(z))\n y = math.atan2(r13, cy) # atan2(sin(y), cy)\n x = math.atan2(-r23, r33) # atan2(cos(y)*sin(x), cos(x)*cos(y))\n else: # cos(y) (close to) zero, so x -> 0.0 (see above)\n # so r21 -> sin(z), r22 -> cos(z) and\n z = math.atan2(r21, r22)\n y = math.atan2(r13, cy) # atan2(sin(y), cy)\n x = 0.0\n return [x, y, z]\n\n\ndef rotationToQuaternion(M):\n trace = M[0,0] + M[1,1] + M[2,2]\n q = [0,0,0,0]\n if trace>0:\n s = math.sqrt(trace+1.0) \n q[3] = s*0.5\n s = 0.5/s\n q[0] = (M[2,1]-M[1,2])*s\n q[1] = (M[0,2]-M[2,0])*s\n q[2] = (M[1,0]-M[0,1])*s\n\n else:\n if M[0,0] < M[1,1]:\n if M[1,1] < M[2,2]:\n i = 2\n else:\n i = 1\n else:\n if M[0,0] < M[2,2]:\n i = 2\n else:\n i = 0\n j = (i+1)%3\n k = (i+1)%3\n s = math.sqrt(M[i,i] - M[j,j] - M[k,k] +1.0)\n q[i] = s*0.5\n s = 0.5/s\n q[3] = (M[k,j] - M[j,k])*s\n q[j] = (M[j,i] - M[i,j])*s\n q[k] = (M[k,i] - M[i,k])*s\n \n return q\n\ndef draw(img, corners, imgpts):\n imgpts = np.int32(imgpts).reshape(-1,2)\n # draw ground floor in green\n# img = cv2.drawContours(img, [imgpts[:4]],-1,(0,255,0),-3)\n # draw pillars in blue color\n for i,j in zip(range(4),range(4,8)):\n img = cv2.line(img, tuple(imgpts[i]), tuple(imgpts[j]),(255),3)\n # draw top layer in red color\n img = cv2.drawContours(img, [imgpts[4:]],-1,(0,0,255),3)\n return img\n\n\n\n# i = 0\n# time_last = time.time()\n\n############### Capture stream ###############\n\n######## UDP ####################\n#pipe = \"udpsrc port=5777 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! appsink sync=false\"\n\n########## TCP ################\ndef aruco_detect(camera_matrix, dist_coeff):\n cap = cv2.VideoCapture('tcpclientsrc host=mechros1.local port=8080 ! gdpdepay ! rtph264depay ! avdec_h264 ! videoconvert ! appsink sync=false', cv2.CAP_GSTREAMER)\n # cap = cv2.VideoCapture(0)\n # pipe = 'tcp://10.42.0.85:5001'\n # cap = cv2.VideoCapture(pipe)\n\n\n # cap.set(cv2.CAP_PROP_AUTOFOCUS,0)\n cap.set(cv2.CAP_PROP_FOCUS,0)\n cap.set(cv2.CAP_PROP_FRAME_WIDTH,1280)\n cap.set(cv2.CAP_PROP_FRAME_HEIGHT,720)\n # cap.set(cv2.CAP_PROP_BUFFERSIZE,3)\n # cap.set(cv2.CAP_PROP_SETTINGS,0)\n # cap.set(cv2.CAP_PROP_FOURCC =\n\n k=0\n flag_started = False\n\n while(cap.isOpened()) and not(rospy.is_shutdown()):\n ret, frame = cap.read()\n # frame = cv2.flip(frame,0)\n time = rospy.Time.now()\n marker_yaw = None\n ret_b = 0\n\n if ret==True:\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n markerCorners,markerIds,_ = cv2.aruco.detectMarkers(gray,dictionary,parameters = arucoParams, cameraMatrix = camera_matrix,\n distCoeff = dist_coeff )\n\n markerCorners_b,markerIds_b,_ = cv2.aruco.detectMarkers(gray,dictionary_b,parameters = arucoParams_b, cameraMatrix = camera_matrix,\n distCoeff = dist_coeff )\n\n\n if len(markerCorners) > 0:\n rvec, tvec, _objPoints = cv2.aruco.estimatePoseSingleMarkers(markerCorners, markerLength, camera_matrix, dist_coeff) # For a single marker\n cv2.aruco.drawDetectedMarkers(frame,markerCorners, markerIds)\n aruco_MarkerList = MarkerList()\n aruco_MarkerList.header.stamp = time\n aruco_MarkerList.header.frame_id = frame_id\n\n\n for i in range(markerIds.size):\n frame = cv2.aruco.drawAxis(frame, camera_matrix, dist_coeff, rvec[i], tvec[i], 0.1)\n imgpts, jac = cv2.projectPoints(axis, rvec[i], tvec[i], camera_matrix, dist_coeff)\n frame = draw(frame, markerCorners[i], imgpts)\n\n # Calculate surface area in pixels\n surface = cv2.contourArea(markerCorners[i], False)\n \n # Fill MarkerList with each marker\n aruco_Marker = Marker()\n aruco_Marker.id = str(markerIds[i,0])\n aruco_Marker.surface = surface\n\n # Prevedeni rodrigues vectoru na rotacni matici\n Rmat = np.zeros(shape=(3,3))\n cv2.Rodrigues(rvec[i,0],Rmat)\n\n # Convert from Opencv frame to ROS frame in camera\n R = np.dot(R_ROS_O_camera, Rmat)\n\n # Convert inverted matrix from Opencv frame to ROS frame in marker\n R = np.dot(R, R_O_ROS_marker)\n\n # Convert from Rotation matrix to Euler angles\n Euler = rotationMatrixToEulerAngles(R.T) # rotace z markeru do kamery\n\n # Fill Marker orientation vector\n aruco_Marker.pose.orientation.r = Euler[0]\n aruco_Marker.pose.orientation.p = Euler[1]\n aruco_Marker.pose.orientation.y = Euler[2]\n marker_yaw = Euler[2]\n\n # Coordinate vector of camera position from marker in camera coordinate frame\n aruco_Marker.pose.position.x = -tvec[i,0,2]\n aruco_Marker.pose.position.y = tvec[i,0,0]\n aruco_Marker.pose.position.z = tvec[i,0,1]\n # For comparsion with board\n marker_x = -tvec[i,0,2]\n marker_y = tvec[i,0,0]\n ## For compatibility with gazebo\n aruco_Marker.header.stamp = time\n\n # All coordinates are in marker frame\n aruco_MarkerList.markers.append(aruco_Marker)\n\n marker_publisher.publish(aruco_MarkerList)\n\n\n if len(markerCorners_b) > 0:\n ret, ch_corners, ch_ids = cv2.aruco.interpolateCornersCharuco(markerCorners_b, markerIds_b, gray, board,camera_matrix, dist_coeff)\n cv2.aruco.drawDetectedMarkers(frame,markerCorners_b, markerIds_b)\n if ret > 3:\n ret_b, rvec, tvec = cv2.aruco.estimatePoseCharucoBoard(ch_corners, ch_ids, board, camera_matrix, dist_coeff) # For a single marker\n \n if ret_b:\n # cv2.aruco.drawDetectedMarkers(frame,markerCorners_b, markerIds_b)\n aruco_MarkerList_b = MarkerList()\n aruco_MarkerList_b.header.stamp = time\n aruco_MarkerList_b.header.frame_id = frame_id\n\n # cv2.aruco.drawAxis(frame, camera_matrix, dist_coeff, rvec[i], tvec[i], 0.1)\n # imgpts, jac = cv2.projectPoints(axis, rvec[i], tvec[i], camera_matrix, dist_coeff)\n # frame = draw(frame, markerCorners[i], imgpts)\n\n # Fill MarkerList with each marker\n aruco_Marker_b = Marker()\n # aruco_Marker.id = str(markerIds[0][0])\n # aruco_Marker.surface = surface\n\n # Prevedeni rodrigues vectoru na rotacni matici\n Rmat = np.zeros(shape=(3,3))\n cv2.Rodrigues(rvec,Rmat)\n\n\n\n # Convert from Opencv frame to ROS frame in camera\n R = np.dot(R_ROS_O_camera, Rmat)\n\n # Convert inverted matrix from Opencv frame to ROS frame in marker\n R = np.dot(R, R_O_ROS_marker)\n\n # Convert from Rotation matrix to Euler angles\n Euler_b = rotationMatrixToEulerAngles(R.T) # rotace z markeru do kamery\n\n \n # Fill Marker orientation vector\n aruco_Marker_b.pose.orientation.y = Euler_b[2]\n aruco_Marker_b.pose.orientation.r = Euler_b[0]\n aruco_Marker_b.pose.orientation.p = Euler_b[1]\n\n surface = cv2.contourArea(ch_corners, False)\n aruco_Marker_b.surface = surface\n\n # Coordinate vector of camera position from marker in camera coordinate frame\n aruco_Marker_b.pose.position.x = -tvec[2]\n aruco_Marker_b.pose.position.y = tvec[0]\n aruco_Marker_b.pose.position.z = tvec[1]\n\n ## For compatibility with gazebo\n aruco_Marker_b.header.stamp = time\n\n # All coordinates are in marker frame\n aruco_MarkerList_b.markers.append(aruco_Marker_b)\n\n board_publisher.publish(aruco_MarkerList_b)\n\n key = cv2.waitKey(1) & 0xFF\n if key == ord('s'):\n flag_started = True\n rospy.loginfo(\"Measurement started!\")\n\n if k < 50 and flag_started:\n if len(markerCorners_b) > 0 and ret_b > 0:\n yaw_m = Euler[2] % (2*math.pi)\n yaw_b = Euler_b[2] % (2*math.pi)\n\n marker_pose[k,:] = aruco_Marker.pose.position.x,aruco_Marker.pose.position.y, yaw_m\n board_pose[k,:] = aruco_Marker_b.pose.position.x,aruco_Marker_b.pose.position.y, yaw_b\n surface_matrix[k,:] = aruco_Marker.surface, aruco_Marker_b.surface\n k +=1\n\n elif k >= 50 and flag_started:\n k = 0\n flag_started = False\n\n avg_pose_m = np.mean(marker_pose, axis= 0)\n avg_pose_b = np.mean(board_pose, axis= 0)\n avg_surface = np.mean(surface_matrix,axis=0)\n pose_difference = marker_pose - avg_pose_b\n measur_cov = np.cov(marker_pose,y = None, rowvar=False)\n # diff_cov = np.cov(pose_difference,y = None, rowvar=False)\n err_cov = np.sum(pose_difference*pose_difference, axis=0)/50\n\n \n\n # Write to file\n # x_m, y_m, Yaw_m, x_b, y_b, Yaw_b, var_meas_x, var_meas_y, var_meas_Yaw, var_err_x, var_err_y, var_err_Yaw\n row = [avg_surface[0], avg_surface[1], avg_pose_m[0],avg_pose_m[1], avg_pose_m[2],avg_pose_b[0],avg_pose_b[1], avg_pose_b[2],\n measur_cov[0,0],measur_cov[1,1], measur_cov[2,2], err_cov[0], err_cov[1], err_cov[2]]\n\n with open(filename, 'a') as csvFile:\n writer = csv.writer(csvFile)\n writer.writerow(row)\n csvFile.close()\n\n rospy.loginfo(\"Measurement ended!\") \n\n # frame = cv2.flip(frame,0)\t\n cv2.imshow('frame',frame)\n if key == ord('q'):\n break\n\n # rospy.spin()\n\n # rospy.spin()\n\n csvFile.close()\n cap.release()\n #out.release()\n cv2.destroyAllWindows()\n\n\nif __name__ == '__main__':\n rospy.init_node('aruco_detect', anonymous=True)\n marker_publisher = rospy.Publisher(marker_detector_topic, MarkerList,queue_size=10)\n board_publisher = rospy.Publisher(board_detector_topic, MarkerList,queue_size=10)\n camera_matrix, dist_coeff = load_coefficient(calibration_file)\n aruco_detect(camera_matrix,dist_coeff)\n # rospy.spin()" ]

[ [ "numpy.dot", "numpy.int32", "numpy.finfo", "numpy.cov", "numpy.mean", "numpy.float32", "numpy.array", "numpy.zeros", "numpy.sum" ] ]

farizrahman4u/AdelaiDet

[ "156e60bb0a5dde4aa6e29ebd3623834c5d32b3c1" ]

[ "adet/evaluation/text_evaluation.py" ]

[ "import contextlib\nimport copy\nimport io\nimport itertools\nimport json\nimport logging\nimport numpy as np\nimport os\nimport re\nimport torch\nfrom collections import OrderedDict\n# from fvcore.common.file_io import PathManager\n# from detectron2.utils.file_io import PathManager\nfrom adet.utils.file_io import PathManager\nfrom pycocotools.coco import COCO\n\nfrom detectron2.utils import comm\nfrom detectron2.data import MetadataCatalog\nfrom detectron2.evaluation.evaluator import DatasetEvaluator\n\nimport glob\nimport shutil\nfrom shapely.geometry import Polygon, LinearRing\nfrom adet.evaluation import text_eval_script\nimport zipfile\n\n\nclass TextEvaluator(DatasetEvaluator):\n \"\"\"\n Evaluate text proposals and recognition.\n \"\"\"\n\n def __init__(self, dataset_name, cfg, distributed, output_dir=None):\n self._tasks = (\"polygon\", \"recognition\")\n self._distributed = distributed\n self._output_dir = output_dir\n\n self._cpu_device = torch.device(\"cpu\")\n self._logger = logging.getLogger(__name__)\n\n self._metadata = MetadataCatalog.get(dataset_name)\n if not hasattr(self._metadata, \"json_file\"):\n raise AttributeError(\n f\"json_file was not found in MetaDataCatalog for '{dataset_name}'.\"\n )\n\n json_file = PathManager.get_local_path(self._metadata.json_file)\n with contextlib.redirect_stdout(io.StringIO()):\n self._coco_api = COCO(json_file)\n\n # use dataset_name to decide eval_gt_path\n if \"totaltext\" in dataset_name:\n self._text_eval_gt_path = \"datasets/evaluation/gt_totaltext.zip\"\n self._word_spotting = True\n elif \"ctw1500\" in dataset_name:\n self._text_eval_gt_path = \"datasets/evaluation/gt_ctw1500.zip\"\n self._word_spotting = False\n self._text_eval_confidence = cfg.MODEL.FCOS.INFERENCE_TH_TEST\n\n def reset(self):\n self._predictions = []\n\n def process(self, inputs, outputs):\n for input, output in zip(inputs, outputs):\n prediction = {\"image_id\": input[\"image_id\"]}\n\n instances = output[\"instances\"].to(self._cpu_device)\n prediction[\"instances\"] = instances_to_coco_json(instances, input[\"image_id\"])\n self._predictions.append(prediction)\n\n def to_eval_format(self, file_path, temp_dir=\"temp_det_results\", cf_th=0.5):\n def fis_ascii(s):\n a = (ord(c) < 128 for c in s)\n return all(a)\n\n def de_ascii(s):\n a = [c for c in s if ord(c) < 128]\n outa = ''\n for i in a:\n outa +=i\n return outa\n\n with open(file_path, 'r') as f:\n data = json.load(f)\n with open('temp_all_det_cors.txt', 'w') as f2:\n for ix in range(len(data)):\n if data[ix]['score'] > 0.1:\n outstr = '{}: '.format(data[ix]['image_id'])\n xmin = 1000000\n ymin = 1000000\n xmax = 0 \n ymax = 0\n for i in range(len(data[ix]['polys'])):\n outstr = outstr + str(int(data[ix]['polys'][i][0])) +','+str(int(data[ix]['polys'][i][1])) +','\n ass = de_ascii(data[ix]['rec'])\n if len(ass)>=0: # \n outstr = outstr + str(round(data[ix]['score'], 3)) +',####'+ass+'\\n'\t\n f2.writelines(outstr)\n f2.close()\n dirn = temp_dir\n lsc = [cf_th] \n fres = open('temp_all_det_cors.txt', 'r').readlines()\n for isc in lsc:\t\n if not os.path.isdir(dirn):\n os.mkdir(dirn)\n\n for line in fres:\n line = line.strip()\n s = line.split(': ')\n filename = '{:07d}.txt'.format(int(s[0]))\n outName = os.path.join(dirn, filename)\n with open(outName, 'a') as fout:\n ptr = s[1].strip().split(',####')\n score = ptr[0].split(',')[-1]\n if float(score) < isc:\n continue\n cors = ','.join(e for e in ptr[0].split(',')[:-1])\n fout.writelines(cors+',####'+ptr[1]+'\\n')\n os.remove(\"temp_all_det_cors.txt\")\n\n def sort_detection(self, temp_dir):\n origin_file = temp_dir\n output_file = \"final_\"+temp_dir\n\n if not os.path.isdir(output_file):\n os.mkdir(output_file)\n\n files = glob.glob(origin_file+'*.txt')\n files.sort()\n\n for i in files:\n out = i.replace(origin_file, output_file)\n fin = open(i, 'r').readlines()\n fout = open(out, 'w')\n for iline, line in enumerate(fin):\n ptr = line.strip().split(',####')\n rec = ptr[1]\n cors = ptr[0].split(',')\n assert(len(cors) %2 == 0), 'cors invalid.'\n pts = [(int(cors[j]), int(cors[j+1])) for j in range(0,len(cors),2)]\n try:\n pgt = Polygon(pts)\n except Exception as e:\n print(e)\n print('An invalid detection in {} line {} is removed ... '.format(i, iline))\n continue\n \n if not pgt.is_valid:\n print('An invalid detection in {} line {} is removed ... '.format(i, iline))\n continue\n \n pRing = LinearRing(pts)\n if pRing.is_ccw:\n pts.reverse()\n outstr = ''\n for ipt in pts[:-1]:\n outstr += (str(int(ipt[0]))+','+ str(int(ipt[1]))+',')\n outstr += (str(int(pts[-1][0]))+','+ str(int(pts[-1][1])))\n outstr = outstr+',####' + rec\n fout.writelines(outstr+'\\n')\n fout.close()\n os.chdir(output_file)\n\n def zipdir(path, ziph):\n # ziph is zipfile handle\n for root, dirs, files in os.walk(path):\n for file in files:\n ziph.write(os.path.join(root, file))\n\n zipf = zipfile.ZipFile('../det.zip', 'w', zipfile.ZIP_DEFLATED)\n zipdir('./', zipf)\n zipf.close()\n os.chdir(\"../\")\n # clean temp files\n shutil.rmtree(origin_file)\n shutil.rmtree(output_file)\n return \"det.zip\"\n \n def evaluate_with_official_code(self, result_path, gt_path):\n return text_eval_script.text_eval_main(det_file=result_path, gt_file=gt_path, is_word_spotting=self._word_spotting)\n\n def evaluate(self):\n if self._distributed:\n comm.synchronize()\n predictions = comm.gather(self._predictions, dst=0)\n predictions = list(itertools.chain(*predictions))\n\n if not comm.is_main_process():\n return {}\n else:\n predictions = self._predictions\n\n if len(predictions) == 0:\n self._logger.warning(\"[COCOEvaluator] Did not receive valid predictions.\")\n return {}\n\n coco_results = list(itertools.chain(*[x[\"instances\"] for x in predictions]))\n PathManager.mkdirs(self._output_dir)\n\n file_path = os.path.join(self._output_dir, \"text_results.json\")\n self._logger.info(\"Saving results to {}\".format(file_path))\n with PathManager.open(file_path, \"w\") as f:\n f.write(json.dumps(coco_results))\n f.flush()\n\n self._results = OrderedDict()\n \n # eval text\n temp_dir = \"temp_det_results/\"\n self.to_eval_format(file_path, temp_dir, self._text_eval_confidence)\n result_path = self.sort_detection(temp_dir)\n text_result = self.evaluate_with_official_code(result_path, self._text_eval_gt_path)\n os.remove(result_path)\n\n # parse\n template = \"(\\S+): (\\S+): (\\S+), (\\S+): (\\S+), (\\S+): (\\S+)\"\n for task in (\"e2e_method\", \"det_only_method\"):\n result = text_result[task]\n groups = re.match(template, result).groups()\n self._results[groups[0]] = {groups[i*2+1]: float(groups[(i+1)*2]) for i in range(3)}\n\n return copy.deepcopy(self._results)\n\n\ndef instances_to_coco_json(instances, img_id):\n num_instances = len(instances)\n if num_instances == 0:\n return []\n\n scores = instances.scores.tolist()\n beziers = instances.beziers.numpy()\n recs = instances.recs.numpy()\n\n results = []\n for bezier, rec, score in zip(beziers, recs, scores):\n # convert beziers to polygons\n poly = bezier_to_polygon(bezier)\n s = decode(rec)\n result = {\n \"image_id\": img_id,\n \"category_id\": 1,\n \"polys\": poly,\n \"rec\": s,\n \"score\": score,\n }\n results.append(result)\n return results\n\n\ndef bezier_to_polygon(bezier):\n u = np.linspace(0, 1, 20)\n bezier = bezier.reshape(2, 4, 2).transpose(0, 2, 1).reshape(4, 4)\n points = np.outer((1 - u) ** 3, bezier[:, 0]) \\\n + np.outer(3 * u * ((1 - u) ** 2), bezier[:, 1]) \\\n + np.outer(3 * (u ** 2) * (1 - u), bezier[:, 2]) \\\n + np.outer(u ** 3, bezier[:, 3])\n \n # convert points to polygon\n points = np.concatenate((points[:, :2], points[:, 2:]), axis=0)\n return points.tolist()\n\n\nCTLABELS = [' ','!','\"','#','$','%','&','\\'','(',')','*','+',',','-','.','/','0','1','2','3','4','5','6','7','8','9',':',';','<','=','>','?','@','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','[','\\\\',']','^','_','`','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','{','|','}','~']\n\n\ndef ctc_decode(rec):\n # ctc decoding\n last_char = False\n s = ''\n for c in rec:\n c = int(c)\n if c < 95:\n if last_char != c:\n s += CTLABELS[c]\n last_char = c\n elif c == 95:\n s += u'口'\n else:\n last_char = False\n return s\n\n\ndef decode(rec):\n s = ''\n for c in rec:\n c = int(c)\n if c < 95:\n s += CTLABELS[c]\n elif c == 95:\n s += u'口'\n\n return s\n \n" ]

[ [ "numpy.concatenate", "torch.device", "numpy.linspace", "numpy.outer" ] ]

BEAR-algorithm/BEAR

[ "3793ac9a736f99f880ccd3693a9ccd54f5c45f04" ]

[ "SOFTMAX-MISSION-Topk-minibatch.py" ]

[ "import numpy as np\nimport matplotlib.pyplot as plt\nimport random\nimport time\nimport warnings\nimport murmurhash\nimport pickle\nimport heapq\nfrom countminsketch_mmh3_parallel import CountMinSketch\nfrom topkheap import mytopkheap\nwarnings.filterwarnings(\"ignore\")\n\ndef loss_softmax(W, X, y_ind, reg):\n loss = 0\n num_train, dim = X.shape\n scores = X.dot(W) # [N, K]\n predicted_class = np.argmax(scores,axis=1)\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[list(range(num_train)), y_ind] # [N, ]\n scores_exp_sum = np.sum(scores_exp, axis=1) # [N, ]\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= num_train\n loss += 0.5 * reg * np.sum(W * W)\n return loss,predicted_class\n\n\ndef merge_classes(top_k,top_k_value):\n merged_heap = mytopkheap(top_k_value)\n for top_k_heap in top_k:\n merged_heap.push(top_k_heap.output_topk_heap())\n return list(zip(*top_k_heap.output_topk_heap()))[1]\n\ndef merge_classes_fast(top_k):\n merged_heap = []\n for top_k_heap in top_k:\n merged_heap.extend(top_k_heap.output_topk_heap())\n\n top_k_value_local = int(len(merged_heap) / len(top_k))\n heapq.heapify( merged_heap )\n return list(zip(*heapq.nlargest(top_k_value_local,merged_heap)))[1]\n\n\ndef loss_grad_softmax(W, X, y_ind, reg):\n \"\"\" Compute the loss and gradients using softmax with vectorized version\"\"\"\n loss = 0\n grad = np.zeros_like(W)\n num_train, dim = np.shape(X)\n\n scores = X.dot(W) # [N, K]\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[list(range(num_train)), y_ind] # [N, ]\n scores_exp_sum = np.sum(scores_exp, axis=1) # [N, ]\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= num_train\n loss += 0.5 * reg * np.sum(W * W)\n\n scores_exp_normalized = (scores_exp.T / scores_exp_sum).T\n # deal with the correct class\n scores_exp_normalized[list(range(num_train)), y_ind] -= 1 # [N, K]\n grad = X.T.dot(scores_exp_normalized)\n grad /= num_train\n grad += reg * W\n\n return loss, grad\n\n\nnp.random.seed(0)\nrandom.seed(0)\n\nfilepath = 'RCV1/rcv1_train.binary'\n\ndata_dimension = 47236\nnumber_of_classes = 2\nstep_size = 1\n\ncms = CountMinSketch(1000,5,2)\ntop_k = []\ntop_k_value = 400\ntop_k_value = 2 * top_k_value\nfor c in range(number_of_classes):\n top_k.append(mytopkheap(top_k_value))\n\nepoch = 1\nloss = 1\nmini_batch_size = 2000\n\nindicies_in_minibatch = []\nindicies_in_minibatch_flat = []\nvalues_in_minibatch = []\ndata_label = []\n\ntraining_loss_store = []\ncnt_store = []\ntime_store = []\n\nstart_time = time.time()\nwhile loss > 0.01 and epoch < 2:\n\n line = 'start'\n print('epoch = ', epoch)\n\n cnt = 0\n with open(filepath) as fp:\n while line and cnt< 20242: \n\n line = fp.readline()\n line = line[:-1]\n line_splited = line.split(' ')\n data_label.append(int((int(line_splited[0])+1)/2))\n\n indicies_in_data = []\n values_in_data = []\n for feature_index, feature_value in enumerate(line_splited[1:]):\n feature,value = feature_value.split(':')\n feature = int(feature)-1\n value = float(value)\n indicies_in_data.append(feature)\n indicies_in_minibatch_flat.append(feature)\n values_in_data.append(value)\n\n indicies_in_minibatch.append(indicies_in_data)\n values_in_minibatch.append(values_in_data)\n\n if cnt % mini_batch_size == mini_batch_size - 1:\n\n indicies_in_minibatch_flat = list(set(indicies_in_minibatch_flat))\n indicies_in_minibatch_flat_dict = dict(zip(indicies_in_minibatch_flat,range(len(indicies_in_minibatch_flat))))\n\n data_vector = np.zeros((len(indicies_in_minibatch_flat) ,mini_batch_size))\n for data_ind in range(mini_batch_size):\n for item_ind,item in enumerate(indicies_in_minibatch[data_ind]):\n data_vector[indicies_in_minibatch_flat_dict[item],data_ind] = values_in_minibatch[data_ind][item_ind]\n\n\n X = data_vector.T\n y_ind = np.asarray(data_label)\n\n\n top_k_merged_indicies = set(merge_classes_fast(top_k)) # merge the top_k among classes\n WW = cms.query(list( map(str,indicies_in_minibatch_flat)))\n for indd,item in enumerate(indicies_in_minibatch_flat): # zero out the feautues that are out of top-k\n if item not in top_k_merged_indicies:\n WW[indd,:] = 0\n\n loss, grad = loss_grad_softmax(WW, X, y_ind, reg=0)\n cms.add(list( map(str,indicies_in_minibatch_flat) ),- step_size * grad)\n WW = cms.query(list(map(str,indicies_in_minibatch_flat)))\n for c in range(number_of_classes): # update the top_k heaps for each class\n top_k[c].push(list(zip(np.abs(WW[:,c]),indicies_in_minibatch_flat)))\n\n\n\n indicies_in_minibatch = []\n values_in_minibatch = []\n data_label = []\n indicies_in_minibatch_flat = []\n\n cnt += 1\n\n if cnt % 10000 == 0:\n\n training_loss_store.append(loss)\n cnt_store.append(cnt)\n time_store.append(time.time()-start_time)\n print(cnt)\n print(loss)\n\n epoch += 1\n\nfp.close()\n\n## save the convergence trajectories\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-loss.p\", 'wb')\npickle.dump(training_loss_store, filehandler)\nfilehandler.close()\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-cnt.p\", 'wb')\npickle.dump(cnt_store, filehandler)\nfilehandler.close()\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-time.p\", 'wb')\npickle.dump(time_store, filehandler)\nfilehandler.close()\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-features.p\", 'wb')\npickle.dump(set(top_k_merged_indicies), filehandler)\nfilehandler.close()\nprint(len(set(top_k_merged_indicies)))\n\n# finding the test loss\nindicies_in_minibatch = []\nindicies_in_minibatch_flat = []\nvalues_in_minibatch = []\ntotal_test_loss = []\ndata_label = []\nline = 'start'\ncnt = 0\nfilepath = '/Users/amirali/Desktop/RCV1/rcv1_test.binary'\naccuracy_list = []\npredicted_class_TEST = np.asarray([])\nground_truth_TEST = np.asarray([])\nwith open(filepath) as fp:\n while line and cnt < 120000 : ##677399\n if cnt % 10000 == 0:\n print(cnt)\n\n line = fp.readline()\n line = line[:-1]\n line_splited = line.split(' ')\n data_label.append(int((int(line_splited[0])+1)/2))\n\n indicies_in_data = []\n values_in_data = []\n for feature_index, feature_value in enumerate(line_splited[1:]):\n feature,value = feature_value.split(':')\n feature = int(feature)-1\n value = float(value)\n indicies_in_data.append(feature)\n indicies_in_minibatch_flat.append(feature)\n values_in_data.append(value)\n\n\n indicies_in_minibatch.append(indicies_in_data)\n values_in_minibatch.append(values_in_data)\n\n if cnt % mini_batch_size == mini_batch_size - 1:\n\n indicies_in_minibatch_flat = list(set(indicies_in_minibatch_flat))\n indicies_in_minibatch_flat_dict = dict(zip(indicies_in_minibatch_flat,range(len(indicies_in_minibatch_flat))))\n\n data_vector = np.zeros((len(indicies_in_minibatch_flat) ,mini_batch_size))\n for data_ind in range(mini_batch_size):\n for item_ind,item in enumerate(indicies_in_minibatch[data_ind]):\n data_vector[indicies_in_minibatch_flat_dict[item],data_ind] = values_in_minibatch[data_ind][item_ind]\n\n\n X = data_vector.T\n y_ind = data_label\n\n WW = cms.query(list( map(str,indicies_in_minibatch_flat)))\n for indd,item in enumerate(indicies_in_minibatch_flat): # zero out the feautues that are out of top-k\n if item not in top_k_merged_indicies:\n WW[indd,:] = 0\n\n loss,predicted_class = loss_softmax(WW, X, y_ind, reg=0)\n total_test_loss.append(loss)\n\n predicted_class_TEST = np.append(predicted_class_TEST,predicted_class)\n ground_truth_TEST = np.append(ground_truth_TEST,data_label)\n\n indicies_in_minibatch = []\n values_in_minibatch = []\n data_label = []\n indicies_in_minibatch_flat = []\n\n cnt += 1\n\n\nprint('***')\nprint('average test loss is ')\nprint(np.mean(np.asarray(total_test_loss)))\nprint('accuracy')\nacc_val = (predicted_class_TEST == ground_truth_TEST).sum() / len(ground_truth_TEST)\nprint(acc_val)\n\n## store\nfile = open(\"results/MISSION-b2000-step1-w1000-d5-k400-log.txt\",\"w\")\nfile.write(\"Average test loss %f \\n\" %np.mean(np.asarray(total_test_loss)) )\nfile.write(\"Average test accuracy %f \\n\" % acc_val )\nfile.close()\n\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-test-ground-truth.p\", 'wb')\npickle.dump(ground_truth_TEST, filehandler)\nfilehandler.close()\n\nfilehandler = open(\"results/MISSION-b2000-step1-w1000-d5-k400-test-prediction.p\", 'wb')\npickle.dump(predicted_class_TEST, filehandler)\nfilehandler.close()\n" ]

[ [ "numpy.log", "numpy.abs", "numpy.random.seed", "numpy.asarray", "numpy.max", "numpy.append", "numpy.argmax", "numpy.zeros_like", "numpy.shape", "numpy.exp", "numpy.sum" ] ]

neeradp/incubator-mxnet

[ "b34addeb1ffa4786158636e10724083d8462ed07" ]

[ "python/mxnet/contrib/onnx/onnx2mx/_op_translations.py" ]

[ "# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n\n# coding: utf-8\n\"\"\" Module for translating ONNX operators into Mxnet operatoes\"\"\"\n# pylint: disable=unused-argument,protected-access\nimport numpy as np\nfrom . import _translation_utils as translation_utils\nfrom .... import symbol\n# Method definitions for the callable objects mapped in the import_helper module\n\ndef identity(attrs, inputs, proto_obj):\n \"\"\"Returns the identity function of the input.\"\"\"\n return 'identity', attrs, inputs\n\ndef random_uniform(attrs, inputs, proto_obj):\n \"\"\"Draw random samples from a uniform distribtuion.\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n \"Instructions to install - https://github.com/onnx/onnx\")\n new_attrs = translation_utils._remove_attributes(attrs, ['seed'])\n new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attrs.get('dtype', 1))]\n return 'random_uniform', new_attrs, inputs\n\ndef random_normal(attrs, inputs, proto_obj):\n \"\"\"Draw random samples from a Gaussian distribution.\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n \"Instructions to install - https://github.com/onnx/onnx\")\n new_attr = translation_utils._remove_attributes(attrs, ['seed'])\n new_attr = translation_utils._fix_attribute_names(new_attr, {'mean': 'loc'})\n new_attr['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attr.get('dtype', 1))]\n return 'random_normal', new_attr, inputs\n\ndef sample_multinomial(attrs, inputs, proto_obj):\n \"\"\"Draw random samples from a multinomial distribution.\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n + \"Instructions to install - https://github.com/onnx/onnx\")\n new_attrs = translation_utils._remove_attributes(attrs, ['seed'])\n new_attrs = translation_utils._fix_attribute_names(new_attrs, {'sample_size': 'shape'})\n new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(attrs.get('dtype', 6))]\n return 'sample_multinomial', new_attrs, inputs\n\n# Arithmetic Operations\ndef add(attrs, inputs, proto_obj):\n \"\"\"Adding two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_add', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_add', new_attr, inputs\n\ndef subtract(attrs, inputs, proto_obj):\n \"\"\"Subtracting two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_sub', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_sub', new_attr, inputs\n\ndef multiply(attrs, inputs, proto_obj):\n \"\"\"Multiply two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_mul', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_mul', new_attr, inputs\n\ndef divide(attrs, inputs, proto_obj):\n \"\"\"Divide two tensors\"\"\"\n new_attr = {}\n\n if 'broadcast' in attrs and attrs['broadcast'] == 1:\n broadcast_axis = attrs['axis']\n op_value = translation_utils._fix_broadcast('broadcast_div', inputs,\n broadcast_axis, proto_obj)\n return op_value, new_attr, inputs\n return 'broadcast_div', new_attr, inputs\n\ndef mean(attrs, inputs, proto_obj):\n \"\"\"Mean of all the input tensors.\"\"\"\n concat_input = [symbol.expand_dims(op_input, axis=0) for op_input in inputs]\n concat_sym = symbol.concat(*concat_input, dim=0)\n mean_sym = symbol.mean(concat_sym, axis=0)\n return mean_sym, attrs, inputs\n\ndef logical_and(attrs, inputs, proto_obj):\n \"\"\"Logical and of two input arrays.\"\"\"\n return 'broadcast_logical_and', attrs, inputs\n\ndef logical_or(attrs, inputs, proto_obj):\n \"\"\"Logical or of two input arrays.\"\"\"\n return 'broadcast_logical_or', attrs, inputs\n\ndef logical_xor(attrs, inputs, proto_obj):\n \"\"\"Logical xor of two input arrays.\"\"\"\n return 'broadcast_logical_xor', attrs, inputs\n\ndef logical_not(attrs, inputs, proto_obj):\n \"\"\"Logical not of two input arrays.\"\"\"\n return 'logical_not', attrs, inputs\n\ndef absolute(attrs, inputs, proto_obj):\n \"\"\"Returns element-wise absolute value of the input.\"\"\"\n return 'abs', attrs, inputs\n\ndef negative(attrs, inputs, proto_obj):\n \"\"\"Negation of every element in a tensor\"\"\"\n return 'negative', attrs, inputs\n\ndef add_n(attrs, inputs, proto_obj):\n \"\"\"Elementwise sum of arrays\"\"\"\n return 'add_n', attrs, inputs\n\n# Sorting and Searching\ndef argmax(attrs, inputs, proto_obj):\n \"\"\"Returns indices of the maximum values along an axis\"\"\"\n axis = attrs.get('axis', 0)\n keepdims = attrs.get('keepdims', 1)\n argmax_op = symbol.argmax(inputs[0], axis=axis, keepdims=keepdims)\n # onnx argmax operator always expects int64 as output type\n cast_attrs = {'dtype': 'int64'}\n return 'cast', cast_attrs, argmax_op\n\ndef argmin(attrs, inputs, proto_obj):\n \"\"\"Returns indices of the minimum values along an axis.\"\"\"\n axis = attrs.get('axis', 0)\n keepdims = attrs.get('keepdims', 1)\n argmin_op = symbol.argmin(inputs[0], axis=axis, keepdims=keepdims)\n # onnx argmax operator always expects int64 as output type\n cast_attrs = {'dtype': 'int64'}\n return 'cast', cast_attrs, argmin_op\n\ndef maximum(attrs, inputs, proto_obj):\n \"\"\"\n Elementwise maximum of arrays.\n MXNet maximum compares only two symbols at a time.\n ONNX can send more than two to compare.\n Breaking into multiple mxnet ops to compare two symbols at a time\n \"\"\"\n if len(inputs) > 1:\n mxnet_op = symbol.maximum(inputs[0], inputs[1])\n for op_input in inputs[2:]:\n mxnet_op = symbol.maximum(mxnet_op, op_input)\n else:\n mxnet_op = symbol.maximum(inputs[0], inputs[0])\n return mxnet_op, attrs, inputs\n\ndef minimum(attrs, inputs, proto_obj):\n \"\"\"Elementwise minimum of arrays.\"\"\"\n # MXNet minimum compares only two symbols at a time.\n # ONNX can send more than two to compare.\n # Breaking into multiple mxnet ops to compare two symbols at a time\n if len(inputs) > 1:\n mxnet_op = symbol.minimum(inputs[0], inputs[1])\n for op_input in inputs[2:]:\n mxnet_op = symbol.minimum(mxnet_op, op_input)\n else:\n mxnet_op = symbol.minimum(inputs[0], inputs[0])\n return mxnet_op, attrs, inputs\n\ndef lesser(attrs, inputs, proto_obj):\n \"\"\"Logical Lesser operator with broadcasting.\"\"\"\n return 'broadcast_lesser', attrs, inputs\n\ndef greater(attrs, inputs, proto_obj):\n \"\"\"Logical Greater operator with broadcasting.\"\"\"\n return 'broadcast_greater', attrs, inputs\n\ndef equal(attrs, inputs, proto_obj):\n \"\"\"Logical Equal operator with broadcasting.\"\"\"\n return 'broadcast_equal', attrs, inputs\n\n#Hyperbolic functions\ndef tanh(attrs, inputs, proto_obj):\n \"\"\"Returns the hyperbolic tangent of the input array.\"\"\"\n return 'tanh', attrs, inputs\n\n# Rounding\ndef ceil(attrs, inputs, proto_obj):\n \"\"\" Calculate ceil value for input \"\"\"\n return 'ceil', attrs, inputs\n\ndef floor(attrs, inputs, proto_obj):\n \"\"\" Calculate floor value for input \"\"\"\n return 'floor', attrs, inputs\n\n# Joining and spliting\ndef concat(attrs, inputs, proto_obj):\n \"\"\" Joins input arrays along a given axis. \"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axis': 'dim'})\n return 'concat', new_attrs, inputs\n\n# Basic neural network functions\ndef softsign(attrs, inputs, proto_obj):\n \"\"\"Computes softsign of x element-wise.\"\"\"\n return 'softsign', attrs, inputs\n\ndef sigmoid(attrs, inputs, proto_obj):\n \"\"\"Computes elementwise sigmoid of the input array\"\"\"\n return 'sigmoid', attrs, inputs\n\ndef hardsigmoid(attrs, inputs, proto_obj):\n \"\"\"Computes elementwise hard sigmoid of the input array\"\"\"\n return 'hard_sigmoid', attrs, inputs\n\ndef relu(attrs, inputs, proto_obj):\n \"\"\"Computes rectified linear function.\"\"\"\n return 'relu', attrs, inputs\n\ndef pad(attrs, inputs, proto_obj):\n \"\"\" Add padding to input tensor\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'pads' : 'pad_width',\n 'value' : 'constant_value'\n })\n new_attrs['pad_width'] = translation_utils._pad_sequence_fix(new_attrs.get('pad_width'))\n return 'pad', new_attrs, inputs\n\ndef matrix_multiplication(attrs, inputs, proto_obj):\n \"\"\"Performs general matrix multiplication\"\"\"\n return 'linalg_gemm2', attrs, inputs\n\ndef batch_norm(attrs, inputs, proto_obj):\n \"\"\"Batch normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon': 'eps',\n 'is_test': 'fix_gamma'})\n new_attrs = translation_utils._remove_attributes(new_attrs,\n ['spatial', 'consumed_inputs'])\n # Disable cuDNN BN only if epsilon from model is < than minimum cuDNN eps (1e-5)\n cudnn_min_eps = 1e-5\n cudnn_off = 0 if attrs.get('epsilon', cudnn_min_eps) >= cudnn_min_eps else 1\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'cudnn_off': cudnn_off})\n\n # in test mode \"fix_gamma\" should be unset.\n new_attrs['fix_gamma'] = not attrs.get('is_test', 1)\n return 'BatchNorm', new_attrs, inputs\n\ndef instance_norm(attrs, inputs, proto_obj):\n \"\"\"Instance Normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon' : 'eps'})\n new_attrs['eps'] = attrs.get('epsilon', 1e-5)\n return 'InstanceNorm', new_attrs, inputs\n\ndef leaky_relu(attrs, inputs, proto_obj):\n \"\"\"Leaky Relu function\"\"\"\n if 'alpha' in attrs:\n new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})\n else:\n new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 0.01})\n return 'LeakyReLU', new_attrs, inputs\n\ndef _elu(attrs, inputs, proto_obj):\n \"\"\"Elu function\"\"\"\n if 'alpha' in attrs:\n new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})\n else:\n new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 1.0})\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'act_type': 'elu'})\n return 'LeakyReLU', new_attrs, inputs\n\ndef _prelu(attrs, inputs, proto_obj):\n \"\"\"PRelu function\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'act_type': 'prelu'})\n return 'LeakyReLU', new_attrs, inputs\n\ndef _selu(attrs, inputs, proto_obj):\n \"\"\"Selu function\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'act_type': 'selu'})\n return 'LeakyReLU', new_attrs, inputs\n\ndef softmax(attrs, inputs, proto_obj):\n \"\"\"Softmax function.\"\"\"\n if 'axis' not in attrs:\n attrs = translation_utils._add_extra_attributes(attrs, {'axis': 1})\n return 'softmax', attrs, inputs\n\ndef log_softmax(attrs, inputs, proto_obj):\n \"\"\"Computes the log softmax of the input. This is equivalent to\n computing softmax followed by log.\"\"\"\n return 'log_softmax', attrs, inputs\n\ndef softplus(attrs, inputs, proto_obj):\n \"\"\"Applies the sofplus activation function element-wise to the input.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'act_type' : 'softrelu'})\n return 'Activation', new_attrs, inputs\n\ndef conv(attrs, inputs, proto_obj):\n \"\"\"Compute N-D convolution on (N+2)-D input.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'kernel_shape' : 'kernel',\n 'strides' : 'stride',\n 'pads': 'pad',\n 'dilations': 'dilate',\n 'group': 'num_group'})\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'num_group' : 1})\n new_attrs = translation_utils._fix_bias('Convolution', new_attrs, len(inputs))\n\n new_attrs = translation_utils._fix_channels('Convolution', new_attrs, inputs, proto_obj)\n kernel = new_attrs['kernel']\n stride = new_attrs['stride'] if 'stride' in new_attrs else []\n padding = new_attrs['pad'] if 'pad' in new_attrs else []\n dilations = new_attrs['dilate'] if 'dilate' in new_attrs else []\n num_filter = new_attrs['num_filter']\n num_group = new_attrs['num_group']\n no_bias = new_attrs['no_bias'] if 'no_bias' in new_attrs else 0\n bias = None if no_bias is True else inputs[2]\n\n # Unlike ONNX, MXNet's convolution operator does not support asymmetric padding, so we first\n # use 'Pad' operator, which supports asymmetric padding. Then use the convolution operator.\n pad_width = (0, 0, 0, 0) + translation_utils._pad_sequence_fix(padding, kernel_dim=len(kernel))\n pad_op = symbol.pad(inputs[0], mode='constant', pad_width=pad_width)\n\n conv_op = symbol.Convolution(pad_op, inputs[1], bias,\n kernel=kernel, stride=stride, dilate=dilations,\n num_filter=num_filter, num_group=num_group, no_bias=no_bias)\n\n return conv_op, new_attrs, inputs\n\ndef deconv(attrs, inputs, proto_obj):\n \"\"\"Computes transposed convolution of the input tensor.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'kernel_shape' : 'kernel',\n 'strides' : 'stride',\n 'pads': 'pad',\n 'dilations': 'dilate',\n 'group': 'num_group',\n 'output_padding': 'adj'})\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'num_group' : 1})\n new_attrs = translation_utils._fix_bias('Deconvolution', new_attrs, len(inputs))\n\n new_attrs = translation_utils._fix_channels('Deconvolution', new_attrs, inputs, proto_obj)\n kernel = new_attrs['kernel']\n stride = new_attrs['stride'] if 'stride' in new_attrs else []\n padding = new_attrs['pad'] if 'pad' in new_attrs else []\n dilations = new_attrs['dilate'] if 'dilate' in new_attrs else []\n num_filter = new_attrs['num_filter']\n num_group = new_attrs['num_group']\n no_bias = new_attrs['no_bias'] if 'no_bias' in new_attrs else False\n bias = None if no_bias is True else inputs[2]\n adj = new_attrs['adj'][:len(kernel)]\n\n # Unlike ONNX, MXNet's deconvolution operator does not support asymmetric padding, so we first\n # use 'Pad' operator, which supports asymmetric padding. Then use the deconvolution operator.\n pad_width = (0, 0, 0, 0) + translation_utils._pad_sequence_fix(padding, kernel_dim=len(kernel))\n pad_op = symbol.pad(inputs[0], mode='constant', pad_width=pad_width)\n\n deconv_op = symbol.Deconvolution(pad_op, inputs[1], bias,\n kernel=kernel, stride=stride, dilate=dilations,\n num_filter=num_filter, num_group=num_group, no_bias=no_bias,\n adj=adj)\n\n return deconv_op, new_attrs, inputs\n\ndef fully_connected(attrs, inputs, proto_obj):\n \"\"\"Applies a linear transformation: Y=XWT+b.\"\"\"\n new_attrs = translation_utils._remove_attributes(attrs, ['axis'])\n\n new_attrs = translation_utils._fix_bias('FullyConnected', new_attrs, len(inputs))\n\n new_attrs = translation_utils._fix_channels('FullyConnected', new_attrs, inputs, proto_obj)\n\n return 'FullyConnected', new_attrs, inputs\n\n\ndef global_maxpooling(attrs, inputs, proto_obj):\n \"\"\"Performs max pooling on the input.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,\n 'kernel': (1, 1),\n 'pool_type': 'max'})\n return 'Pooling', new_attrs, inputs\n\n\ndef global_avgpooling(attrs, inputs, proto_obj):\n \"\"\"Performs avg pooling on the input.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,\n 'kernel': (1, 1),\n 'pool_type': 'avg'})\n return 'Pooling', new_attrs, inputs\n\ndef global_lppooling(attrs, inputs, proto_obj):\n \"\"\"Performs global lp pooling on the input.\"\"\"\n p_value = attrs.get('p', 2)\n new_attrs = translation_utils._add_extra_attributes(attrs, {'global_pool': True,\n 'kernel': (1, 1),\n 'pool_type': 'lp',\n 'p_value': p_value})\n new_attrs = translation_utils._remove_attributes(new_attrs, ['p'])\n return 'Pooling', new_attrs, inputs\n\ndef linalg_gemm(attrs, inputs, proto_obj):\n \"\"\"Performs general matrix multiplication and accumulation\"\"\"\n trans_a = 0\n trans_b = 0\n alpha = 1\n beta = 1\n if 'transA' in attrs:\n trans_a = attrs['transA']\n if 'transB' in attrs:\n trans_b = attrs['transB']\n if 'alpha' in attrs:\n alpha = attrs['alpha']\n if 'beta' in attrs:\n beta = attrs['beta']\n flatten_a = symbol.flatten(inputs[0])\n matmul_op = symbol.linalg_gemm2(A=flatten_a, B=inputs[1],\n transpose_a=trans_a, transpose_b=trans_b,\n alpha=alpha)\n gemm_op = symbol.broadcast_add(matmul_op, beta*inputs[2])\n new_attrs = translation_utils._fix_attribute_names(attrs, {'transA': 'transpose_a',\n 'transB': 'transpose_b'})\n new_attrs = translation_utils._remove_attributes(new_attrs, ['broadcast'])\n return gemm_op, new_attrs, inputs\n\ndef local_response_norm(attrs, inputs, proto_obj):\n \"\"\"Local Response Normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'bias': 'knorm',\n 'size' : 'nsize'})\n return 'LRN', new_attrs, inputs\n\ndef dropout(attrs, inputs, proto_obj):\n \"\"\"Dropout Regularization.\"\"\"\n mode = 'training'\n if 'is_test' in attrs and attrs['is_test'] == 0:\n mode = 'always'\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'ratio': 'p'})\n new_attrs = translation_utils._remove_attributes(new_attrs, ['is_test'])\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'mode': mode})\n return 'Dropout', new_attrs, inputs\n\n# Changing shape and type.\ndef reshape(attrs, inputs, proto_obj):\n \"\"\"Reshape the given array by the shape attribute.\"\"\"\n if len(inputs) == 1:\n return 'reshape', attrs, inputs[0]\n reshape_shape = list(proto_obj._params[inputs[1].name].asnumpy())\n reshape_shape = [int(i) for i in reshape_shape]\n new_attrs = {'shape': reshape_shape}\n return 'reshape', new_attrs, inputs[:1]\n\ndef cast(attrs, inputs, proto_obj):\n \"\"\" Cast input to a given dtype\"\"\"\n try:\n from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE\n except ImportError:\n raise ImportError(\"Onnx and protobuf need to be installed. \"\n + \"Instructions to install - https://github.com/onnx/onnx\")\n new_attrs = translation_utils._fix_attribute_names(attrs, {'to' : 'dtype'})\n new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attrs['dtype'])]\n return 'cast', new_attrs, inputs\n\ndef split(attrs, inputs, proto_obj):\n \"\"\"Splits an array along a particular axis into multiple sub-arrays.\"\"\"\n split_list = attrs.get('split') if 'split' in attrs else []\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'split' : 'num_outputs'})\n if 'axis' not in attrs:\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'axis': 0})\n\n if not split_list:\n num_outputs = len(proto_obj.model_metadata.get('output_tensor_data'))\n else:\n if len(set(split_list)) == 1:\n num_outputs = len(split_list)\n else:\n raise NotImplementedError(\"Operator {} in MXNet does not support variable splits.\"\n \"Tracking the issue to support variable split here: \"\n \"https://github.com/apache/incubator-mxnet/issues/11594\"\n .format('split'))\n\n new_attrs['num_outputs'] = num_outputs\n return 'split', new_attrs, inputs\n\ndef _slice(attrs, inputs, proto_obj):\n \"\"\"Returns a slice of the input tensor along multiple axes.\"\"\"\n input_tensor_data = proto_obj.model_metadata.get('input_tensor_data')[0]\n input_shape = input_tensor_data[1]\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'axes' : 'axis',\n 'ends' : 'end',\n 'starts' : 'begin'})\n # onnx slice provides slicing on multiple axis. Adding multiple slice_axis operator\n # for multiple axes from mxnet\n begin = new_attrs.get('begin')\n end = list(new_attrs.get('end'))\n axes = new_attrs.get('axis', tuple(range(len(begin))))\n for i, axis in enumerate(axes):\n end[i] = None if end[i] >= input_shape[axis] else end[i]\n slice_op = symbol.slice_axis(inputs[0], axis=axes[0], begin=begin[0], end=end[0])\n if len(axes) > 1:\n for i, axis in enumerate(axes):\n slice_op = symbol.slice_axis(slice_op, axis=axis, begin=begin[i], end=end[i])\n return slice_op, new_attrs, inputs\n\ndef transpose(attrs, inputs, proto_obj):\n \"\"\"Transpose the input array.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'perm' : 'axes'})\n return 'transpose', new_attrs, inputs\n\ndef squeeze(attrs, inputs, proto_obj):\n \"\"\"Remove single-dimensional entries from the shape of a tensor.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'axes' : 'axis'})\n return 'squeeze', new_attrs, inputs\n\ndef unsqueeze(attrs, inputs, cls):\n \"\"\"Inserts a new axis of size 1 into the array shape\"\"\"\n # MXNet can only add one axis at a time.\n mxnet_op = inputs[0]\n for axis in attrs[\"axes\"]:\n mxnet_op = symbol.expand_dims(mxnet_op, axis=axis)\n\n return mxnet_op, attrs, inputs\n\ndef flatten(attrs, inputs, proto_obj):\n \"\"\"Flattens the input array into a 2-D array by collapsing the higher dimensions.\"\"\"\n #Mxnet does not have axis support. By default uses axis=1\n if 'axis' in attrs and attrs['axis'] != 1:\n raise RuntimeError(\"Flatten operator only supports axis=1\")\n new_attrs = translation_utils._remove_attributes(attrs, ['axis'])\n return 'Flatten', new_attrs, inputs\n\ndef clip(attrs, inputs, proto_obj):\n \"\"\"Clips (limits) the values in an array.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'min' : 'a_min',\n 'max' : 'a_max'})\n if 'a_max' not in new_attrs:\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'a_max' : np.inf})\n if 'a_min' not in new_attrs:\n new_attrs = translation_utils._add_extra_attributes(new_attrs, {'a_min' : -np.inf})\n return 'clip', new_attrs, inputs\n\ndef gather(attrs, inputs, proto_obj):\n \"\"\"Gather elements from an input array along the given axis.\"\"\"\n return 'take', attrs, inputs\n\n#Powers\ndef reciprocal(attrs, inputs, proto_obj):\n \"\"\"Returns the reciprocal of the argument, element-wise.\"\"\"\n return 'reciprocal', attrs, inputs\n\ndef squareroot(attrs, inputs, proto_obj):\n \"\"\"Returns element-wise square-root value of the input.\"\"\"\n return 'sqrt', attrs, inputs\n\ndef power(attrs, inputs, proto_obj):\n \"\"\"Returns element-wise result of base element raised to powers from exp element.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'exponent':'exp'})\n if 'broadcast' in attrs:\n new_attrs = translation_utils._remove_attributes(new_attrs, ['broadcast'])\n if attrs['broadcast'] == 1:\n return 'broadcast_power', new_attrs, inputs\n else:\n mxnet_op = symbol.pow(inputs[0], inputs[1])\n return mxnet_op, new_attrs, inputs\n mxnet_op = symbol.broadcast_power(inputs[0], inputs[1])\n return mxnet_op, new_attrs, inputs\n\ndef exponent(attrs, inputs, proto_obj):\n \"\"\"Elementwise exponent of input array.\"\"\"\n return 'exp', attrs, inputs\n\ndef _cos(attrs, inputs, proto_obj):\n \"\"\"Elementwise cosine of input array.\"\"\"\n return 'cos', attrs, inputs\n\ndef _sin(attrs, inputs, proto_obj):\n \"\"\"Elementwise sine of input array.\"\"\"\n return 'sin', attrs, inputs\n\ndef _tan(attrs, inputs, proto_obj):\n \"\"\"Elementwise tan of input array.\"\"\"\n return 'tan', attrs, inputs\n\ndef arccos(attrs, inputs, proto_obj):\n \"\"\"Elementwise inverse cos of input array.\"\"\"\n return 'arccos', attrs, inputs\n\ndef arcsin(attrs, inputs, proto_obj):\n \"\"\"Elementwise inverse sin of input array.\"\"\"\n return 'arcsin', attrs, inputs\n\ndef arctan(attrs, inputs, proto_obj):\n \"\"\"Elementwise inverse tan of input array.\"\"\"\n return 'arctan', attrs, inputs\n\ndef _log(attrs, inputs, proto_obj):\n \"\"\"Elementwise log of input array.\"\"\"\n return 'log', attrs, inputs\n\n# Reduce Functions\ndef reduce_max(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by maximum value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'max', new_attrs, inputs\n\ndef reduce_mean(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by mean value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'mean', new_attrs, inputs\n\ndef reduce_min(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by minimum value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'min', new_attrs, inputs\n\ndef reduce_sum(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by sum value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'sum', new_attrs, inputs\n\ndef reduce_prod(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by product value\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'prod', new_attrs, inputs\n\ndef reduce_log_sum(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by log sum value\"\"\"\n keep_dims = True if 'keepdims' not in attrs else attrs.get('keepdims')\n sum_op = symbol.sum(inputs[0], axis=attrs.get('axes'),\n keepdims=keep_dims)\n log_sym = symbol.log(sum_op)\n return log_sym, attrs, inputs\n\ndef reduce_log_sum_exp(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by log sum exp value\"\"\"\n keep_dims = True if 'keepdims' not in attrs else attrs.get('keepdims')\n exp_op = symbol.exp(inputs[0])\n sum_op = symbol.sum(exp_op, axis=attrs.get('axes'),\n keepdims=keep_dims)\n log_sym = symbol.log(sum_op)\n return log_sym, attrs, inputs\n\ndef reduce_sum_square(attrs, inputs, proto_obj):\n \"\"\"Reduce the array along a given axis by sum square value\"\"\"\n square_op = symbol.square(inputs[0])\n sum_op = symbol.sum(square_op, axis=attrs.get('axes'),\n keepdims=attrs.get('keepdims'))\n return sum_op, attrs, inputs\n\ndef reduce_l1(attrs, inputs, proto_obj):\n \"\"\"Reduce input tensor by l1 normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'ord' : 1})\n return 'norm', new_attrs, inputs\n\ndef shape(attrs, inputs, proto_obj):\n \"\"\"Returns shape of input array.\"\"\"\n return 'shape_array', attrs, inputs\n\ndef size(attrs, inputs, proto_obj):\n \"\"\"Returns array containing size of data.\"\"\"\n return \"size_array\", attrs, inputs\n\ndef reduce_l2(attrs, inputs, proto_obj):\n \"\"\"Reduce input tensor by l2 normalization.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})\n return 'norm', new_attrs, inputs\n\ndef avg_pooling(attrs, inputs, proto_obj):\n \"\"\" Average pooling\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'kernel_shape': 'kernel',\n 'strides': 'stride',\n 'pads': 'pad',\n })\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'pooling_convention': 'valid'\n })\n new_op = translation_utils._fix_pooling('avg', inputs, new_attrs)\n\n return new_op, new_attrs, inputs\n\ndef lp_pooling(attrs, inputs, proto_obj):\n \"\"\"LP Pooling\"\"\"\n p_value = attrs.get('p', 2)\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'kernel_shape': 'kernel',\n 'strides': 'stride',\n 'pads': 'pad'\n })\n new_attrs = translation_utils._remove_attributes(new_attrs, ['p'])\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'pooling_convention': 'valid',\n 'p_value': p_value\n })\n new_op = translation_utils._fix_pooling('lp', inputs, new_attrs)\n return new_op, new_attrs, inputs\n\ndef max_pooling(attrs, inputs, proto_obj):\n \"\"\" Average pooling\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'kernel_shape': 'kernel',\n 'strides': 'stride',\n 'pads': 'pad',\n })\n\n new_attrs = translation_utils._add_extra_attributes(new_attrs,\n {'pooling_convention': 'valid'\n })\n new_op = translation_utils._fix_pooling('max', inputs, new_attrs)\n\n return new_op, new_attrs, inputs\n\ndef max_roi_pooling(attrs, inputs, proto_obj):\n \"\"\"Max ROI Pooling.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs,\n {'pooled_shape': 'pooled_size',\n 'spatial_scale': 'spatial_scale'\n })\n return 'ROIPooling', new_attrs, inputs\n\ndef depthtospace(attrs, inputs, proto_obj):\n \"\"\"Rearranges data from depth into blocks of spatial data.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'blocksize':'block_size'})\n\n return \"depth_to_space\", new_attrs, inputs\n\ndef spacetodepth(attrs, inputs, proto_obj):\n \"\"\"Rearranges blocks of spatial data into depth.\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'blocksize':'block_size'})\n\n return \"space_to_depth\", new_attrs, inputs\n\ndef hardmax(attrs, inputs, proto_obj):\n \"\"\"Returns batched one-hot vectors.\"\"\"\n input_tensor_data = proto_obj.model_metadata.get('input_tensor_data')[0]\n input_shape = input_tensor_data[1]\n\n axis = int(attrs.get('axis', 1))\n axis = axis if axis >= 0 else len(input_shape) + axis\n\n if axis == len(input_shape) - 1:\n amax = symbol.argmax(inputs[0], axis=-1)\n one_hot = symbol.one_hot(amax, depth=input_shape[-1])\n return one_hot, attrs, inputs\n\n # since reshape doesn't take a tensor for shape,\n # computing with np.prod. This needs to be changed to\n # to use mx.sym.prod() when mx.sym.reshape() is fixed.\n # (https://github.com/apache/incubator-mxnet/issues/10789)\n new_shape = (int(np.prod(input_shape[:axis])),\n int(np.prod(input_shape[axis:])))\n reshape_op = symbol.reshape(inputs[0], new_shape)\n amax = symbol.argmax(reshape_op, axis=-1)\n one_hot = symbol.one_hot(amax, depth=new_shape[-1])\n hardmax_op = symbol.reshape(one_hot, input_shape)\n return hardmax_op, attrs, inputs\n\ndef lpnormalization(attrs, inputs, proto_obj):\n \"\"\"ONNX does not have eps attribute, so cannot map it to L2normalization in MXNet\n without that, it works as norm operator discussion in PR:\n https://github.com/onnx/onnx/pull/1330\"\"\"\n new_attrs = translation_utils._fix_attribute_names(attrs, {'p': 'ord'})\n axis = int(attrs.get(\"axis\", -1))\n new_attrs.update(axis=axis)\n return 'norm', new_attrs, inputs\n\n\ndef topk(attrs, inputs, proto_obj):\n \"\"\"Returns the top k elements in an input array along the given axis.\"\"\"\n new_attrs = translation_utils._add_extra_attributes(attrs,\n {'ret_typ': 'both',\n 'dtype': 'int64'})\n return 'topk', new_attrs, inputs\n" ]

[ [ "numpy.prod" ] ]

Aadi0902/AirSim

[ "50411c2e7b5ff85916485f8ed08e07dff12153db" ]

[ "PythonClient/multirotor/AK testing/PWM model/PWMtest.py" ]

[ "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun Jul 19 13:02:17 2020\n\n@author: amk170930\nG\"\"\"\n\n\nimport numpy as np\nimport airsim\nfrom airsim import Vector3r\nimport time\nimport xlrd\nimport control\nimport matrixmath\nimport gain_matrix_calculator as calK\nfrom scipy import signal\nfrom squaternion import Quaternion\nimport control.matlab\nfrom scipy.spatial.transform import Rotation as R\n\nclass PWMtest:\n def main(self):\n multirotorClient = airsim.MultirotorClient()\n multirotorClient.confirmConnection()\n multirotorClient.enableApiControl(True)\n \n pwm = 0.6\n state = multirotorClient.getMultirotorState()\n initialTime = state.timestamp/1000000000\n \n for ind in range(5):\n print(\"Iteration: %d\" %(ind)) \n multirotorClient.moveByMotorPWMsAsync(pwm, pwm, pwm, pwm, 2).join()\n \n state = multirotorClient.getMultirotorState()\n FinalTime = state.timestamp/1000000000\n print(\"Time: %f\" %(FinalTime - initialTime))\n \n print(\"Out\")\n time.sleep(20)\n print(\"Hover\")\n multirotorClient.hoverAsync().join()\n time.sleep(10)\n \nclass LQRtestPWM:\n def main(self): \n #Time step\n Ts = 0.1\n \n # Maximum angular velocity\n max_angular_vel = 6393.667 * 2 * np.pi / 60\n \n #Final state\n x_bar = np.array([[10.0],\n [10.0],\n [10.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0],\n [0.0]])\n #Gain matrix\n K, u_bar = calK.gainMatrix(Ts,max_angular_vel)\n\n # #Setup airsim multirotor multirotorClient\n multirotorClient = airsim.MultirotorClient()\n multirotorClient.confirmConnection()\n multirotorClient.enableApiControl(True)\n \n vehicleClient = airsim.VehicleClient()\n \n state = multirotorClient.getMultirotorState()\n print(state.kinematics_estimated.position)\n # Arm the drone\n print(\"arming the drone...\")\n multirotorClient.armDisarm(True)\n \n if state.landed_state == airsim.LandedState.Landed:\n print(\"taking off...\")\n multirotorClient.takeoffAsync().join()\n else:\n multirotorClient.hoverAsync().join()\n \n time.sleep(2)\n \n\n \n # Declare u matrix 4 x 1\n # u = [0,\n # 0,\n # 0,\n # 0]\n # pwm = np.array([0,\n # 0,\n # 0,\n # 0])\n \n print(\"Controls start\")\n #time.sleep(2)\n #multirotorClient.moveByMotorPWMsAsync(1, 1, 1, 1,3).join()\n #newX = [[],[],[],[],[],[],[],[],[],[],[],[]]\n # Start step loop\n for index in range(1000):\n # Re initilize u for every iteration\n # u = [0,\n # 0,\n # 0,\n # 0]\n\n # Get state of the multiorotor\n state = multirotorClient.getMultirotorState()\n state = state.kinematics_estimated\n \n initialState = state.position\n \n #Convert from quaternion to euler angle\n #euler = ls.quaternion_to_euler(state.orientation.x_val,state.orientation.y_val, state.orientation.z_val,state.orientation.w_val)\n \n q = R.from_quat([state.orientation.x_val,\n state.orientation.y_val,\n state.orientation.z_val,\n state.orientation.w_val])\n e = q.as_euler('zyx')\n # q = Quaternion(state.orientation.w_val,\n # state.orientation.x_val,\n # state.orientation.y_val,\n # state.orientation.z_val)\n # e = q.to_euler()\n # rotationMatrix = np.linalg.inv([[0, 1, 0],\n # [1, 0, 0],\n # [0, 0, -1]])\n # position = [[state.position.x_val], \n # [state.position.y_val], \n # [state.position.z_val]]\n # linear_velocity = [[state.linear_velocity.x_val], \n # [state.linear_velocity.x_val], \n # [state.linear_velocity.z_val]]\n #Store the current state of multirotor in x\n #e[2] = e[2] + np.pi if e[2]<=np.pi else e[2] - np.pi\n x = np.array([[state.position.x_val],\n [-state.position.y_val],\n [-state.position.z_val],\n [e[0]],\n [-e[1]],\n [-e[2]],\n [state.linear_velocity.x_val],\n [-state.linear_velocity.y_val],\n [-state.linear_velocity.z_val],\n [state.angular_velocity.x_val],\n [-state.angular_velocity.y_val],\n [-state.angular_velocity.z_val]])\n \n # Compute u\n u = np.dot(K, x_bar-x) + u_bar\n #print(np.dot(K, x_bar - x))\n #squared_angular_velocity = u_bar\n # pwmHover = 0.5937\n # # Compute required pwm signal\n # sq_ctrl_hover = (pwmHover * max_angular_vel)**2\n #sq_ctrl_delta = np.dot(K, x_bar - x)\n sq_ctrl = [max(u[0][0], 0.0),\n max(u[1][0], 0.0),\n max(u[2][0], 0.0),\n max(u[3][0], 0.0)] # max is just in case norm of sq_ctrl_delta is too large (can be negative)\n pwm1 = min((np.sqrt(sq_ctrl[0])/max_angular_vel),1.0)\n pwm2 = min((np.sqrt(sq_ctrl[1])/max_angular_vel),1.0)\n pwm3 = min((np.sqrt(sq_ctrl[2])/max_angular_vel),1.0)\n pwm4 = min((np.sqrt(sq_ctrl[3])/max_angular_vel),1.0)\n #pwm = np.sqrt(max(squared_angular_velocity + (pwmHover*max_angular_vel)**2, 0)) / max_angular_vel\n \n multirotorClient.moveByMotorPWMsAsync(pwm4, pwm1, pwm3, pwm2,Ts).join()\n #multirotorClient.moveToPositionAsync(x_bar[0], x_bar[1], x_bar[2], 0, 1200,\n #airsim.DrivetrainType.MaxDegreeOfFreedom, airsim.YawMode(False,0), -1, 1).join()\n\n #multirotorClient.moveByMotorPWMsAsync(pwmHover, pwmHover, pwmHover, pwmHover, Ts).join()\n \n # print(x_bar[0][0])\n # multirotorClient.moveToPositionAsync(x_bar[0][0], x_bar[1][0], -x_bar[2][0], 1.0).join() \n\n state = multirotorClient.getMultirotorState()\n state = state.kinematics_estimated\n\n \n # print(state)\n time.sleep(10)\n print(\"Free fall\")\n multirotorClient.moveByMotorPWMsAsync(0, 0, 0, 0, 10).join\n time.sleep(10)\n \n print(\"disarming...\")\n multirotorClient.armDisarm(False)\n \n multirotorClient.enableApiControl(False)\n print(\"done.\")\n \n def quaternion_to_euler(self,x, y, z, w):\n \n \n r = R.from_quat([x,y,z,w])\n r = r.as_euler('xyz')\n # import math\n # t0 = +2.0 * (w * x + y * z)\n # t1 = +1.0 - 2.0 * (x ** 2 + y ** y)\n # X = math.atan2(t0, t1)\n \n # t2 = +2.0 * (w * y - z * x)\n # t2 = +1.0 if t2 > +1.0 else t2\n # t2 = -1.0 if t2 < -1.0 else t2\n # Y = math.asin(t2)\n \n # t3 = +2.0 * (w * z + x * y)\n # t4 = +1.0 - 2.0 * (y * y + z * z)\n # Z = math.atan2(t3, t4)\n \n return r[0], r[1], r[2]\n\nls = LQRtestPWM()\nprint(ls.quaternion_to_euler(0.7071068, 0, 0, 0.7071068))\nls.main()\n" ]

[ [ "numpy.dot", "numpy.array", "numpy.sqrt", "scipy.spatial.transform.Rotation.from_quat" ] ]

anhdhbn/face

[ "e29b6396cd9d2bce4bff5889daef9735a8129db0" ]

[ "Learner.py" ]

[ "import bcolz\nimport math\nfrom torchvision import transforms as trans\nfrom torchvision.utils import make_grid\nfrom PIL import Image\nfrom utils import get_time, gen_plot, hflip_batch, separate_bn_paras\nfrom matplotlib import pyplot as plt\nfrom tensorboardX import SummaryWriter\nfrom tqdm import tqdm\nimport numpy as np\nfrom torch import optim\nimport torch\nfrom verifacation import evaluate, evaluate_custom\nfrom model import Backbone, Arcface, MobileFaceNet, Am_softmax, l2_norm\nfrom data.data_pipe import de_preprocess, get_train_loader, get_val_loader, get_val_data\nplt.switch_backend('agg')\n\n\nclass face_learner(object):\n def __init__(self, conf, inference=False):\n print(conf)\n self.conf = conf\n if conf.use_mobilfacenet:\n self.model = MobileFaceNet(conf.embedding_size).to(conf.device)\n print('MobileFaceNet model generated')\n else:\n self.model = Backbone(\n conf.net_depth, conf.drop_ratio, conf.net_mode).to(conf.device)\n print('{}_{} model generated'.format(\n conf.net_mode, conf.net_depth))\n\n if not inference:\n self.milestones = conf.milestones\n self.train_loader, self.class_num = get_train_loader(conf)\n self.val_loader = get_val_loader(conf)\n\n self.writer = SummaryWriter(conf.log_path)\n self.step = 0\n self.head = Arcface(embedding_size=conf.embedding_size,\n classnum=self.class_num).to(conf.device)\n\n print('two model heads generated')\n\n paras_only_bn, paras_wo_bn = separate_bn_paras(self.model)\n\n if conf.use_mobilfacenet:\n self.optimizer = optim.SGD([\n {'params': paras_wo_bn[:-1], 'weight_decay': 4e-5},\n {'params': [\n paras_wo_bn[-1]] + [self.head.kernel], 'weight_decay': 4e-4},\n {'params': paras_only_bn}\n ], lr=conf.lr, momentum=conf.momentum)\n else:\n self.optimizer = optim.SGD([\n {'params': paras_wo_bn +\n [self.head.kernel], 'weight_decay': 5e-4},\n {'params': paras_only_bn}\n ], lr=conf.lr, momentum=conf.momentum)\n print(self.optimizer)\n# self.scheduler = optim.lr_scheduler.ReduceLROnPlateau(self.optimizer, patience=40, verbose=True)\n\n print('[INFO] Optimizers generated')\n # self.board_loss_every = len(self.train_loader)//100\n self.board_loss_every = 5\n if (self.board_loss_every < 5):\n self.board_loss_every = 5\n print(f\"[INFO] Board loss every: {self.board_loss_every}\")\n self.evaluate_every = len(self.train_loader)//4\n print(f\"[INFO] Evaluate every: {self.evaluate_every}\")\n self.save_every = len(self.train_loader)//4\n print(f\"[INFO] Save every: {self.save_every}\")\n # self.agedb_30, self.cfp_fp, self.lfw, self.agedb_30_issame, self.cfp_fp_issame, self.lfw_issame = get_val_data(self.train_loader.dataset.root.parent)\n else:\n self.threshold = conf.threshold\n\n def save_state(self, accuracy, to_save_folder=False, extra=None, model_only=False):\n if to_save_folder:\n save_path = self.conf.save_path\n else:\n save_path = self.conf.model_path\n torch.save(\n self.model.state_dict(), save_path /\n ('model_{}_accuracy:{}_step:{}_{}.pth'.format(get_time(), accuracy, self.step, extra)))\n if not model_only:\n torch.save(\n self.head.state_dict(), save_path /\n ('head_{}_accuracy:{}_step:{}_{}.pth'.format(get_time(), accuracy, self.step, extra)))\n torch.save(\n self.optimizer.state_dict(), save_path /\n ('optimizer_{}_accuracy:{}_step:{}_{}.pth'.format(get_time(), accuracy, self.step, extra)))\n\n def load_state(self, fixed_str, from_save_folder=True, model_only=False):\n if from_save_folder:\n save_path = self.conf.save_path\n else:\n save_path = self.conf.model_path\n self.model.load_state_dict(torch.load(\n save_path/'model_{}'.format(fixed_str)))\n if not model_only:\n self.head.load_state_dict(torch.load(\n save_path/'head_{}'.format(fixed_str)))\n self.optimizer.load_state_dict(torch.load(\n save_path/'optimizer_{}'.format(fixed_str)))\n\n def board_val(self, db_name, accuracy, best_threshold, roc_curve_tensor):\n self.writer.add_scalar('{}_accuracy'.format(\n db_name), accuracy, self.step)\n self.writer.add_scalar('{}_best_threshold'.format(\n db_name), best_threshold, self.step)\n self.writer.add_image('{}_roc_curve'.format(\n db_name), roc_curve_tensor, self.step)\n# self.writer.add_scalar('{}_val:true accept ratio'.format(db_name), val, self.step)\n# self.writer.add_scalar('{}_val_std'.format(db_name), val_std, self.step)\n# self.writer.add_scalar('{}_far:False Acceptance Ratio'.format(db_name), far, self.step)\n\n\n def evaluate(self, carray, issame, nrof_folds=5, tta=False):\n self.model.eval()\n idx = 0\n embeddings = np.zeros([len(carray), self.conf.embedding_size])\n with torch.no_grad():\n while idx + self.conf.batch_size <= len(carray):\n batch = torch.tensor(carray[idx:idx + self.conf.batch_size])\n if tta:\n fliped = hflip_batch(batch)\n emb_batch = self.model(\n batch.to(self.conf.device)) + self.model(fliped.to(self.conf.device))\n embeddings[idx:idx + self.conf.batch_size] = l2_norm(emb_batch)\n else:\n embeddings[idx:idx +\n self.conf.batch_size] = self.model(batch.to(self.conf.device)).cpu()\n idx += self.conf.batch_size\n if idx < len(carray):\n batch = torch.tensor(carray[idx:])\n if tta:\n fliped = hflip_batch(batch)\n emb_batch = self.model(\n batch.to(self.conf.device)) + self.model(fliped.to(self.conf.device))\n embeddings[idx:] = l2_norm(emb_batch)\n else:\n embeddings[idx:] = self.model(batch.to(self.conf.device)).cpu()\n tpr, fpr, accuracy, best_thresholds = evaluate(\n embeddings, issame, nrof_folds)\n buf = gen_plot(fpr, tpr)\n roc_curve = Image.open(buf)\n roc_curve_tensor = trans.ToTensor()(roc_curve)\n return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor\n\n def find_lr(self,\n init_value=1e-8,\n final_value=10.,\n beta=0.98,\n bloding_scale=3.,\n num=None):\n if not num:\n num = len(self.train_loader)\n mult = (final_value / init_value)**(1 / num)\n lr = init_value\n for params in self.optimizer.param_groups:\n params['lr'] = lr\n self.model.train()\n avg_loss = 0.\n best_loss = 0.\n batch_num = 0\n losses = []\n log_lrs = []\n for i, (imgs, labels) in tqdm(enumerate(self.train_loader), total=num):\n\n imgs = imgs.to(self.conf.device)\n labels = labels.to(self.conf.device)\n batch_num += 1\n\n self.optimizer.zero_grad()\n\n embeddings = self.model(imgs)\n thetas = self.head(embeddings, labels)\n loss = self.conf.ce_loss(thetas, labels)\n\n # Compute the smoothed loss\n avg_loss = beta * avg_loss + (1 - beta) * loss.item()\n self.writer.add_scalar('avg_loss', avg_loss, batch_num)\n smoothed_loss = avg_loss / (1 - beta**batch_num)\n self.writer.add_scalar('smoothed_loss', smoothed_loss, batch_num)\n # Stop if the loss is exploding\n if batch_num > 1 and smoothed_loss > bloding_scale * best_loss:\n print('exited with best_loss at {}'.format(best_loss))\n plt.plot(log_lrs[10:-5], losses[10:-5])\n return log_lrs, losses\n # Record the best loss\n if smoothed_loss < best_loss or batch_num == 1:\n best_loss = smoothed_loss\n # Store the values\n losses.append(smoothed_loss)\n log_lrs.append(math.log10(lr))\n self.writer.add_scalar('log_lr', math.log10(lr), batch_num)\n # Do the SGD step\n # Update the lr for the next step\n\n loss.backward()\n self.optimizer.step()\n\n lr *= mult\n for params in self.optimizer.param_groups:\n params['lr'] = lr\n if batch_num > num:\n plt.plot(log_lrs[10:-5], losses[10:-5])\n return log_lrs, losses\n\n def evaluate_custom(self, nrof_folds=5, tta=False):\n self.model.eval()\n idx = 0\n embeddings1 = np.zeros(\n (len(self.val_loader.dataset), self.conf.embedding_size))\n # print(embeddings1.shape)\n embeddings2 = np.zeros(\n (len(self.val_loader.dataset), self.conf.embedding_size))\n # print(embeddings1.shape)\n actual_issame = np.zeros((len(self.val_loader.dataset)))\n\n with torch.no_grad():\n samples_tqdm = tqdm(iter(self.val_loader))\n for idx, (imgs1, imgs2, issame) in enumerate(samples_tqdm):\n\n embedding1 = self.model(imgs1.to(self.conf.device)).cpu().numpy()\n embedding2 = self.model(imgs2.to(self.conf.device)).cpu().numpy()\n # print(f\"[INFO] shape embedding1: {embedding1.shape[0]}\")\n embeddings1[idx * self.conf.batch_size : idx * self.conf.batch_size + embedding1.shape[0], :] = embedding1\n\n embeddings2[idx * self.conf.batch_size:idx * self.conf.batch_size + embedding2.shape[0], :] = embedding2\n actual_issame[idx * self.conf.batch_size : idx * self.conf.batch_size + issame.shape[0]] = issame\n # print(f\"[INFO] actual_issame : {actual_issame.shape}\")\n tpr, fpr, accuracy, best_thresholds = evaluate_custom(\n embeddings1, embeddings2, actual_issame, nrof_folds)\n buf = gen_plot(fpr, tpr)\n roc_curve = Image.open(buf)\n roc_curve_tensor = trans.ToTensor()(roc_curve)\n # print(f\"[INFO] Acc: {accuracy.mean()}\");\n # print(f\"[INFO] TF: {best_thresholds.mean()}\");\n return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor, tpr, fpr\n\n def train(self, epochs):\n self.model.train()\n running_loss = 0.\n accuracy = 0\n loss_board = 0\n for e in range(epochs):\n print('epoch {} started'.format(e))\n if e == self.milestones[0]:\n self.schedule_lr()\n if e == self.milestones[1]:\n self.schedule_lr()\n if e == self.milestones[2]:\n self.schedule_lr()\n\n samples_tqdm = tqdm(iter(self.train_loader), position=0, leave=True)\n for imgs, labels in samples_tqdm:\n imgs = imgs.to(self.conf.device)\n # print(f\"[INFO] Images: {imgs}\")\n labels = labels.to(self.conf.device)\n # print(f\"[INFO] Labels: {labels}\")\n self.optimizer.zero_grad()\n embeddings = self.model(imgs)\n # print(f\"[INFO] Embeddings: {embeddings}\")\n thetas = self.head(embeddings, labels)\n loss = self.conf.ce_loss(thetas, labels)\n # print(\"size of thetas: \", thetas.size())\n # print(f\"[INFO] Loss: {loss}\")\n loss.backward()\n running_loss += loss.item()\n self.optimizer.step()\n\n if self.step % self.board_loss_every == 0 and self.step != 0:\n loss_board = running_loss / self.board_loss_every\n self.writer.add_scalar('train_loss', loss_board, self.step)\n samples_tqdm.set_description('Epoch: {:.0f}, Step: {:.0f}, Loss: {:.4f}'.format(\n e, self.step, loss_board\n ))\n running_loss = 0.\n\n if self.step % self.evaluate_every == 0 and self.step != 0:\n accuracy, best_threshold, roc_curve_tensor, tpr, fpr = self.evaluate_custom()\n print('\\n Loss: {:.4f}, Accuracy: {:.4f}, Best_threshold: {:.4f}'.format(\n loss_board, accuracy, best_threshold\n ))\n self.board_val('cfp_fp', accuracy, best_threshold, roc_curve_tensor)\n\n self.model.train()\n\n if self.step % self.save_every == 0 and self.step != 0:\n self.save_state(accuracy)\n\n self.step += 1\n self.save_state(accuracy, to_save_folder=True, extra='final')\n\n def schedule_lr(self):\n for params in self.optimizer.param_groups:\n params['lr'] /= 10\n print(self.optimizer)\n\n def infer(self, faces, target_embs, tta=False):\n '''\n faces : list of PIL Image\n target_embs : [n, 512] computed embeddings of faces in facebank\n names : recorded names of faces in facebank\n tta : test time augmentation (hfilp, that's all)\n '''\n embs = []\n for img in faces:\n if tta:\n mirror = trans.functional.hflip(img)\n emb = self.model(self.conf.test_transform(\n img).to(self.conf.device).unsqueeze(0))\n emb_mirror = self.model(self.conf.test_transform(\n mirror).to(self.conf.device).unsqueeze(0))\n embs.append(l2_norm(emb + emb_mirror))\n else:\n embs.append(self.model(self.conf.test_transform(\n img).to(self.conf.device).unsqueeze(0)))\n source_embs = torch.cat(embs)\n\n diff = source_embs.unsqueeze(-1) - \\\n target_embs.transpose(1, 0).unsqueeze(0)\n dist = torch.sum(torch.pow(diff, 2), dim=1)\n minimum, min_idx = torch.min(dist, dim=1)\n min_idx[minimum > self.threshold] = -1 # if no match, set idx to -1\n return min_idx, minimum\n" ]

[ [ "torch.cat", "matplotlib.pyplot.switch_backend", "torch.min", "torch.tensor", "matplotlib.pyplot.plot", "torch.no_grad", "torch.optim.SGD", "torch.pow" ] ]

ijnek/ipm

[ "dee4f2ac99f5d24bd0d2a8c9ff7c748b74727a2f" ]

[ "ipm_library/ipm_library/utils.py" ]

[ "# Copyright (c) 2022 Hamburg Bit-Bots\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Optional, Tuple\n\nfrom geometry_msgs.msg import Transform\nimport numpy as np\nfrom rclpy.duration import Duration\nfrom sensor_msgs.msg import CameraInfo\nfrom shape_msgs.msg import Plane\nfrom tf2_geometry_msgs import PointStamped\nimport tf2_ros\n\n\ndef transform_to_normal_plane(plane: Plane) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Convert a plane msg to a normal vector and a base point.\n\n :param plane: The input plane\n :returns: A tuple with the normal vector and the base_point\n \"\"\"\n # ax + by + cz + d = 0 where a, b, c are the normal vector\n a, b, c, d = plane.coef\n normal = np.array([a, b, c])\n normal = normal / np.linalg.norm(normal)\n base_point = normal * d\n return normal, base_point\n\n\ndef transform_plane_to_frame(\n plane: Tuple[np.ndarray, np.ndarray],\n input_frame: str,\n output_frame: str,\n stamp,\n buffer: tf2_ros.Buffer,\n timeout: Optional[Duration] = None) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Transform a plane from one frame to another.\n\n :param plane: The planes normal and base point as numpy arrays\n :param input_frame: Current frame of the plane\n :param output_frame: The desired frame of the plane\n :param stamp: Timestamp which is used to query\n the tf buffer and get the tranform at this moment\n :param buffer: The refrence to the used tf buffer\n :param timeout: An optinal timeout after which an exception is raised\n :returns: A Tuple containing the planes normal and base point in the\n new frame at the provided timestamp\n \"\"\"\n # Set optinal timeout\n if timeout is None:\n timeout = Duration(seconds=0.2)\n\n # Create two points to transform the base point and the normal vector\n # The second point is generated by adding the normal to the base point\n field_normal = PointStamped()\n field_normal.header.frame_id = input_frame\n field_normal.header.stamp = stamp\n field_normal.point.x = plane[0][0] + plane[1][0]\n field_normal.point.y = plane[0][1] + plane[1][1]\n field_normal.point.z = plane[0][2] + plane[1][2]\n field_normal = buffer.transform(\n field_normal, output_frame, timeout=timeout)\n field_point = PointStamped()\n field_point.header.frame_id = input_frame\n field_point.header.stamp = stamp\n field_point.point.x = plane[1][0]\n field_point.point.y = plane[1][1]\n field_point.point.z = plane[1][2]\n field_point = buffer.transform(field_point, output_frame, timeout=timeout)\n\n field_normal = np.array([\n field_normal.point.x,\n field_normal.point.y,\n field_normal.point.z])\n field_point = np.array([\n field_point.point.x,\n field_point.point.y,\n field_point.point.z])\n\n # field normal is a vector! so it stats at field point and goes up in z direction\n field_normal = field_point - field_normal\n return field_normal, field_point\n\n\ndef get_field_intersection_for_pixels(\n camera_info: CameraInfo,\n points: np.ndarray,\n plane_normal: np.ndarray,\n plane_base_point: np.ndarray,\n scale: float = 1.0) -> np.ndarray:\n \"\"\"\n Project an NumPy array of points in image space on the given plane.\n\n :param points: A nx3 array with n being the number of points\n :param plane_normal: The normal vector of the projection plane\n :param plane_base_point: The base point of the projection plane\n :param scale: A scaling factor used if e.g. a mask with a lower resolution is transformed\n :returns: A NumPy array containing the projected points\n in 3d relative to the camera optical frame\n \"\"\"\n camera_projection_matrix = camera_info.k\n\n # Calculate binning and scale\n binning_x = max(camera_info.binning_x, 1) / scale\n binning_y = max(camera_info.binning_y, 1) / scale\n\n # Create rays\n points[:, 0] = (points[:, 0] - (camera_projection_matrix[2] /\n binning_x)) / (camera_projection_matrix[0] / binning_x)\n points[:, 1] = (points[:, 1] - (camera_projection_matrix[5] /\n binning_y)) / (camera_projection_matrix[4] / binning_y)\n points[:, 2] = 1\n\n # Calculate ray -> plane intersections\n intersections = line_plane_intersections(\n plane_normal, plane_base_point, points)\n\n return intersections\n\n\ndef line_plane_intersections(\n plane_normal: np.ndarray,\n plane_base_point: np.ndarray,\n ray_directions: np.ndarray) -> np.ndarray:\n \"\"\"\n Calculate the intersections of rays with a plane described by a normal and a point.\n\n :param plane_normal: The normal vector of the projection plane\n :param plane_base_point: The base point of the projection plane\n :param ray_directions: A nx3 array with n being the number of rays\n :returns: A nx3 array containing the 3d intersection points with n being the number of rays.\n \"\"\"\n n_dot_u = np.tensordot(plane_normal, ray_directions, axes=([0], [1]))\n relative_ray_distance = -plane_normal.dot(-plane_base_point) / n_dot_u\n\n # we are casting a ray, intersections need to be in front of the camera\n relative_ray_distance[relative_ray_distance <= 0] = np.nan\n\n ray_directions[:, 0] = np.multiply(\n relative_ray_distance, ray_directions[:, 0])\n ray_directions[:, 1] = np.multiply(\n relative_ray_distance, ray_directions[:, 1])\n ray_directions[:, 2] = np.multiply(\n relative_ray_distance, ray_directions[:, 2])\n\n return ray_directions\n\n\ndef transform_points(point_cloud: np.ndarray, transform: Transform) -> np.ndarray:\n \"\"\"\n Transform a bulk of points from an numpy array using a provided `Transform`.\n\n :param point_cloud: nx3 Array of points where n is the number of points\n :param transform: TF2 transform used for the transformation\n :returns: Array with the same shape as the input array, but with the transformation applied\n \"\"\"\n # Build affine transformation\n transform_translation = np.array([\n transform.translation.x,\n transform.translation.y,\n transform.translation.z\n ])\n transform_rotation_matrix = _get_mat_from_quat(\n np.array([\n transform.rotation.w,\n transform.rotation.x,\n transform.rotation.y,\n transform.rotation.z\n ]))\n\n # \"Batched\" matmul meaning a matmul for each point\n # First we offset all points by the translation part\n # followed by a rotation using the rotation matrix\n return np.einsum(\n 'ij, pj -> pi',\n transform_rotation_matrix,\n point_cloud) + transform_translation\n\n\ndef _get_mat_from_quat(quaternion: np.ndarray) -> np.ndarray:\n \"\"\"\n Convert a quaternion to a rotation matrix.\n\n This method is currently needed because transforms3d is not released as a `.dep` and\n would require user interaction to set up.\n For reference see: https://github.com/matthew-brett/transforms3d/blob/\n f185e866ecccb66c545559bc9f2e19cb5025e0ab/transforms3d/quaternions.py#L101\n\n :param quaternion: A numpy array containing the w, x, y, and z components of the quaternion\n :returns: The rotation matrix\n \"\"\"\n Nq = np.sum(np.square(quaternion))\n if Nq < np.finfo(np.float64).eps:\n return np.eye(3)\n\n XYZ = quaternion[1:] * 2.0 / Nq\n wXYZ = XYZ * quaternion[0]\n xXYZ = XYZ * quaternion[1]\n yYZ = XYZ[1:] * quaternion[2]\n zZ = XYZ[2] * quaternion[3]\n\n return np.array(\n [[1.0-(yYZ[0]+zZ), xXYZ[1]-wXYZ[2], xXYZ[2]+wXYZ[1]],\n [xXYZ[1]+wXYZ[2], 1.0-(xXYZ[0]+zZ), yYZ[1]-wXYZ[0]],\n [xXYZ[2]-wXYZ[1], yYZ[1]+wXYZ[0], 1.0-(xXYZ[0]+yYZ[0])]])\n" ]

[ [ "numpy.square", "numpy.multiply", "numpy.einsum", "numpy.eye", "numpy.linalg.norm", "numpy.finfo", "numpy.tensordot", "numpy.array" ] ]

akosik-anyvision/incubator-tvm

[ "e1b11712ac09c32614483d24a4c7e0245ee4cb4b" ]

[ "python/tvm/relay/frontend/tflite.py" ]

[ "# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n# pylint: disable=invalid-name, unused-argument, too-many-lines, import-outside-toplevel\n\"\"\"Tensorflow lite frontend.\"\"\"\nimport math\nimport itertools\nimport numpy as np\nimport tvm\nfrom tvm.ir import IRModule\n\nfrom tvm import relay\nfrom .. import analysis\nfrom .. import expr as _expr\nfrom .. import function as _function\nfrom .. import op as _op\nfrom .. import qnn as _qnn\nfrom ... import nd as _nd\nfrom .common import ExprTable\nfrom .common import infer_shape as _infer_shape\nfrom .tflite_flexbuffer import FlexBufferDecoder\n\n\n__all__ = ['from_tflite']\n\nclass TensorWrapper(object):\n \"\"\"Tensor wrapper for TFLite Tensor\"\"\"\n def __init__(self, tensor_idx, tensor, buffer, qnn_params=None):\n self.tensor_idx = tensor_idx\n self.tensor = tensor\n self.buffer = buffer\n self.qnn_params = qnn_params\n\nclass OperatorConverter(object):\n \"\"\"Operator Converted for converting TFLite ops to Relay ops\"\"\"\n def __init__(self, model, subgraph, exp_tab):\n\n try:\n from tflite.BuiltinOperator import BuiltinOperator\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ActivationFunctionType import ActivationFunctionType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n self.model = model\n self.subgraph = subgraph\n self.exp_tab = exp_tab\n self.builtin_op_code = build_str_map(BuiltinOperator())\n self.activation_fn_type = build_str_map(ActivationFunctionType())\n self.builtin_options = build_str_map(BuiltinOptions())\n\n # Add more operators\n self.convert_map = {\n 'ABS': self.convert_abs,\n 'ADD': self.convert_add,\n 'ADD_N': self.convert_add_n,\n 'AVERAGE_POOL_2D': self.convert_average_pool2d,\n 'BATCH_TO_SPACE_ND': self.convert_batch_to_space_nd,\n 'CAST': self.convert_cast,\n 'CEIL': self.convert_ceil,\n 'CONCATENATION': self.convert_concatenation,\n 'CONV_2D': self.convert_conv2d,\n 'COS': self.convert_cos,\n 'DEPTH_TO_SPACE': self.convert_depth_to_space,\n 'DEPTHWISE_CONV_2D': self.convert_depthwise_conv2d,\n 'DEQUANTIZE': self.convert_dequantize,\n 'DETECTION_POSTPROCESS': self.convert_detection_postprocess,\n 'DIV': self.convert_div,\n 'ELU': self.convert_elu,\n 'EQUAL': self.convert_equal,\n 'EXP': self.convert_exp,\n 'FILL': self.convert_fill,\n 'FLOOR_DIV': self.convert_floor_div,\n 'FLOOR_MOD': self.convert_floor_mod,\n 'FLOOR': self.convert_floor,\n 'FULLY_CONNECTED': self.convert_fully_connected,\n 'GATHER': self.convert_gather,\n 'GATHER_ND' : self.convert_gather_nd,\n 'GREATER_EQUAL': self.convert_greater_equal,\n 'GREATER': self.convert_greater,\n 'HARD_SWISH': self.convert_hard_swish,\n 'L2_NORMALIZATION': self.convert_l2_normalization,\n 'L2_POOL_2D': self.convert_l2_pool2d,\n 'LESS_EQUAL': self.convert_less_equal,\n 'LESS': self.convert_less,\n 'LOCAL_RESPONSE_NORMALIZATION': self.convert_lrn,\n 'LOG': self.convert_log,\n 'LOGICAL_AND': self.convert_logical_and,\n 'LOGICAL_NOT': self.convert_logical_not,\n 'LOGICAL_OR': self.convert_logical_or,\n 'LOGISTIC': self.convert_logistic,\n 'MAX_POOL_2D': self.convert_max_pool2d,\n 'MAXIMUM': self.convert_maximum,\n 'MEAN': self.convert_reduce_mean,\n 'MINIMUM': self.convert_minimum,\n 'MIRROR_PAD': self.convert_mirror_pad,\n 'MUL': self.convert_mul,\n 'NEG': self.convert_neg,\n 'NOT_EQUAL': self.convert_not_equal,\n 'PACK': self.convert_pack,\n 'PAD': self.convert_pad,\n 'POW': self.convert_pow,\n 'PRELU': self.convert_prelu,\n 'RANGE': self.convert_range,\n 'QUANTIZE': self.convert_quantize,\n 'REDUCE_ANY': self.convert_reduce_any,\n 'REDUCE_MAX': self.convert_reduce_max,\n 'REDUCE_MIN': self.convert_reduce_min,\n 'REDUCE_PROD': self.convert_reduce_prod,\n 'RELU':self.convert_relu,\n 'RESHAPE': self.convert_reshape,\n 'RESIZE_BILINEAR': self.convert_resize_bilinear,\n 'RESIZE_NEAREST_NEIGHBOR': self.convert_resize_nearest_neighbor,\n 'ROUND': self.convert_round,\n 'RSQRT': self.convert_rsqrt,\n 'SELECT': self.convert_select,\n 'SHAPE': self.convert_shape,\n 'SIN': self.convert_sin,\n 'SLICE': self.convert_slice,\n 'SOFTMAX': self.convert_softmax,\n 'SPACE_TO_BATCH_ND': self.convert_space_to_batch_nd,\n 'SPACE_TO_DEPTH': self.convert_space_to_depth,\n 'SPARSE_TO_DENSE': self.convert_sparse_to_dense,\n 'SPLIT': self.convert_split,\n 'SPLIT_V': self.convert_split_v,\n 'SQRT': self.convert_sqrt,\n 'SQUARE': self.convert_square,\n 'SQUARED_DIFFERENCE': self.convert_squared_difference,\n 'SQUEEZE': self.convert_squeeze,\n 'STRIDED_SLICE': self.convert_strided_slice,\n 'SUB': self.convert_sub,\n 'SUM': self.convert_reduce_sum,\n 'TAN': self.convert_tan,\n 'TANH':self.convert_tanh,\n 'TILE': self.convert_tile,\n 'TOPK_V2': self.convert_topk_v2,\n 'TRANSPOSE_CONV': self.convert_transpose_conv,\n 'TRANSPOSE': self.convert_transpose,\n 'UNPACK': self.convert_unpack,\n 'WHERE': self.convert_select,\n 'ZEROS_LIKE': self.convert_zeros_like,\n }\n\n def check_unsupported_ops(self):\n \"\"\"Check unsupported TFLite ops in our converter.\"\"\"\n unsupported_ops_set = set()\n\n for op_idx in range(self.subgraph.OperatorsLength()):\n op = self.subgraph.Operators(op_idx)\n op_code_str = self.get_op_code_str(op)\n if op_code_str not in self.convert_map:\n unsupported_ops_set.add(op_code_str)\n\n if unsupported_ops_set:\n msg = 'The following operators are not supported in frontend ' \\\n 'TFLite: {}'\n ops = str(list(unsupported_ops_set)).strip('[,]')\n raise tvm.error.OpNotImplemented(msg.format(ops))\n\n def convert_op_to_relay(self):\n \"\"\"Convert TFLite ops to relay ops\"\"\"\n for op_idx in range(self.subgraph.OperatorsLength()):\n op = self.subgraph.Operators(op_idx)\n op_code_str = self.get_op_code_str(op)\n output_tensors = self.get_output_tensors(op)\n try:\n from tflite.Operator import Operator\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n assert isinstance(op, Operator)\n ret = self.convert_map[op_code_str](op)\n\n if len(output_tensors) == 1:\n tensor_idx = output_tensors[0].tensor_idx\n self.exp_tab.set_expr(get_tensor_name(self.subgraph, tensor_idx), ret)\n else:\n for idx, output_tensor in enumerate(output_tensors):\n self.exp_tab.set_expr(get_tensor_name(self.subgraph, output_tensor.tensor_idx),\n ret[idx])\n\n def get_op_code_str(self, op):\n \"\"\"Get TFLite ops string representation\"\"\"\n try:\n from tflite.BuiltinOperator import BuiltinOperator\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n op_code_list_idx = op.OpcodeIndex()\n op_code_id = self.model.OperatorCodes(op_code_list_idx).BuiltinCode()\n try:\n op_code_str = self.builtin_op_code[op_code_id]\n except KeyError:\n raise NotImplementedError('TFLite operator with code ' + str(op_code_id) + \\\n ' is not supported by this version of the fbs schema.')\n if op_code_id == BuiltinOperator.CUSTOM:\n # Custom operator\n custom_op_code_str = self.model.OperatorCodes(op_code_list_idx).CustomCode()\n if custom_op_code_str == b'TFLite_Detection_PostProcess':\n return \"DETECTION_POSTPROCESS\"\n\n raise NotImplementedError(\"Custom operators are currently not supported\")\n return op_code_str\n\n def get_input_tensors(self, op):\n operator_inputs = op.InputsAsNumpy()\n return self.get_tensors(operator_inputs)\n\n def get_output_tensors(self, op):\n operator_outputs = op.OutputsAsNumpy()\n return self.get_tensors(operator_outputs)\n\n def get_tensors(self, tensors_idx_list):\n \"\"\"Get tensor wrapper list from given TFLite tensor index list\"\"\"\n return_list = list()\n for tensor_idx in tensors_idx_list:\n if tensor_idx < 0:\n return_list.append(TensorWrapper(tensor_idx, 0, 0))\n continue\n\n tensor = self.subgraph.Tensors(tensor_idx)\n buffer_idx = tensor.Buffer()\n buffer = self.model.Buffers(buffer_idx)\n\n # Check if the tensors are quantized. Parse if yes.\n qnn_params = None\n tflite_qnn_params = tensor.Quantization()\n if tflite_qnn_params is not None:\n scale = float(tflite_qnn_params.ScaleAsNumpy())\n zero_point = int(tflite_qnn_params.ZeroPointAsNumpy())\n # Check that the scale and zero points are valid.\n if scale != 0 or zero_point != 0:\n qnn_params = dict()\n qnn_params['scale'] = relay.const(scale, 'float32')\n qnn_params['zero_point'] = relay.const(zero_point, 'int32')\n return_list.append(TensorWrapper(tensor_idx, tensor, buffer, qnn_params))\n return return_list\n\n def get_tensor_value(self, tensor_wrapper):\n \"\"\"Get tensor buffer value from given tensor wrapper\"\"\"\n assert isinstance(tensor_wrapper, TensorWrapper)\n\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if tensor_wrapper.tensor.Type() == TensorType.UINT8:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.uint8).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.FLOAT32:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.float32).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.INT32:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.int32).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.INT64:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.int64).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n if tensor_wrapper.tensor.Type() == TensorType.BOOL:\n return np.frombuffer(tensor_wrapper.buffer.DataAsNumpy(), dtype=np.bool_).reshape(\n tensor_wrapper.tensor.ShapeAsNumpy())\n raise NotImplementedError(\"Tensor type {} is currently not supported\"\n .format(str(tensor_wrapper.tensor.Type())))\n\n def get_tensor_type_str(self, tensor_type):\n \"\"\"Get tensor type string representation when given TFLite tensor type\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if tensor_type == TensorType.INT8:\n return \"int8\"\n if tensor_type == TensorType.UINT8:\n return \"uint8\"\n if tensor_type == TensorType.FLOAT32:\n return \"float32\"\n if tensor_type == TensorType.INT32:\n return \"int32\"\n if tensor_type == TensorType.INT64:\n return \"int64\"\n if tensor_type == TensorType.BOOL:\n return \"bool\"\n raise NotImplementedError(\"Tensor type {} is currently not supported\"\n .format(str(tensor_type)))\n\n def has_same_qnn_params(self, lhs_tensor, rhs_tensor):\n lhs_scale = lhs_tensor.qnn_params['scale']\n rhs_scale = rhs_tensor.qnn_params['scale']\n lhs_zero_point = lhs_tensor.qnn_params['zero_point']\n rhs_zero_point = rhs_tensor.qnn_params['zero_point']\n lhs_scale_value = get_scalar_from_constant(lhs_scale)\n rhs_scale_value = get_scalar_from_constant(rhs_scale)\n lhs_zero_point_value = get_scalar_from_constant(lhs_zero_point)\n rhs_zero_point_value = get_scalar_from_constant(rhs_zero_point)\n return lhs_scale_value == rhs_scale_value and \\\n lhs_zero_point_value == rhs_zero_point_value\n\n def is_quantized(self, op):\n \"\"\"Check if an input tensor is quantized.\"\"\"\n input_tensors = self.get_input_tensors(op)\n first_tensor = input_tensors[0]\n return first_tensor.qnn_params is not None\n\n def quantize(self, expr, tensor_to_quantize):\n \"\"\" Helper function to quantize a tensor with Relay \"\"\"\n tensor_type = tensor_to_quantize.tensor.Type()\n tensor_type_str = self.get_tensor_type_str(tensor_type)\n quantized = _qnn.op.quantize(data=expr,\n output_scale=tensor_to_quantize.qnn_params['scale'],\n output_zero_point=tensor_to_quantize.qnn_params['zero_point'],\n out_dtype=tensor_type_str)\n return quantized\n\n def dequantize(self, expr, tensor):\n \"\"\" Helper function to dequantize a tensor with Relay \"\"\"\n dequantized = _qnn.op.dequantize(data=expr,\n input_scale=tensor.qnn_params['scale'],\n input_zero_point=tensor.qnn_params['zero_point'])\n return dequantized\n\n\n def convert_qnn_fused_activation_function(self, expr, fused_activation_fn,\n scale, zero_point, dtype):\n \"\"\"Convert TFLite fused activation function. The expr is an input quantized tensor with\n scale and zero point \"\"\"\n try:\n from tflite.ActivationFunctionType import ActivationFunctionType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n # Quantize a float value to an quantized integer value\n quantize = lambda x: float(int(round(x / scale)) + zero_point)\n\n # Get min/max of the output dtype. This will be used to ensure that clip a_min/a_max are not\n # beyond the dtype range.\n qmin = float(tvm.tir.op.min_value(dtype).value)\n qmax = float(tvm.tir.op.max_value(dtype).value)\n\n # The input expr is a quantized tensor with its scale and zero point. We calculate the\n # suitable clip off points based on these scale and zero point.\n if fused_activation_fn == ActivationFunctionType.NONE:\n return expr\n if fused_activation_fn == ActivationFunctionType.RELU6:\n return _op.clip(expr,\n a_min=max(qmin, quantize(0)),\n a_max=min(qmax, quantize(6.0)))\n if fused_activation_fn == ActivationFunctionType.RELU_N1_TO_1:\n return _op.clip(expr,\n a_min=max(qmin, quantize(-1.0)),\n a_max=min(qmax, quantize(1.0)))\n if fused_activation_fn == ActivationFunctionType.RELU:\n return _op.clip(expr,\n a_min=max(qmin, quantize(0.0)),\n a_max=qmax)\n\n fused_activation_fn_str = self.activation_fn_type[fused_activation_fn]\n raise tvm.error.OpNotImplemented(\n 'Quantized activation {} is not supported yet.'.format(fused_activation_fn_str))\n\n def convert_conv2d(self, op):\n \"\"\"Convert TFLite conv2d\"\"\"\n return self.convert_conv(op, \"conv2d\")\n\n def convert_depthwise_conv2d(self, op):\n \"\"\"Convert TFLite depthwise conv2d\"\"\"\n return self.convert_conv(op, \"depthwise\")\n\n def convert_average_pool2d(self, op):\n \"\"\"Convert TFLite average pool2d\"\"\"\n return self.convert_pool2d(op, \"average\")\n\n def convert_max_pool2d(self, op):\n \"\"\"Convert TFLite max pool2d\"\"\"\n return self.convert_pool2d(op, \"max\")\n\n def convert_l2_pool2d(self, op):\n \"\"\"Convert TFLite l2 pool2d\"\"\"\n return self.convert_pool2d(op, \"l2\")\n\n def convert_reshape(self, op):\n \"\"\"Convert TFLite reshape\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ReshapeOptions import ReshapeOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert input_tensors, \"input tensors should not be empty\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n assert op.BuiltinOptionsType() == BuiltinOptions.ReshapeOptions\n op_options = op.BuiltinOptions()\n reshape_options = ReshapeOptions()\n reshape_options.Init(op_options.Bytes, op_options.Pos)\n target_shape = reshape_options.NewShapeAsNumpy()\n\n in_expr = self.get_expr(input_tensor_idx)\n\n # If the tensors are quantized, ensure that input/output qnn params are same.\n if input_tensor.qnn_params:\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"There should be only 1 output tensor\"\n output_tensor = output_tensors[0]\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n \"TFLite reshape requires input and output scale and zero points to be equal\"\n out = _op.reshape(in_expr, newshape=tuple(target_shape))\n return out\n\n def _convert_resize(self, method, op):\n \"\"\"Generic method to Convert TFLite RESIZE operators\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ResizeBilinearOptions import ResizeBilinearOptions\n # ResizeNearestNeighborOptions was added in tflite v1.13\n tflite_ver = 1120\n if 'ResizeNearestNeighborOptions' in dir(BuiltinOptions):\n from tflite.ResizeNearestNeighborOptions import ResizeNearestNeighborOptions\n tflite_ver = 1130\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # images, 4-D Tensor with shape NHWC.\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # size - 1-D int32 Tensor of 2 elements: new_height, new_width\n target_size = tuple(self.get_tensor_value(input_tensors[1]))\n\n # Options - align_corners (bool)\n resize_options = None\n align_corners = False\n if method == \"bilinear\":\n assert op.BuiltinOptionsType() == BuiltinOptions.ResizeBilinearOptions\n resize_options = ResizeBilinearOptions()\n elif tflite_ver >= 1130:\n assert op.BuiltinOptionsType() == BuiltinOptions.ResizeNearestNeighborOptions\n resize_options = ResizeNearestNeighborOptions()\n\n if resize_options is not None:\n op_options = op.BuiltinOptions()\n resize_options.Init(op_options.Bytes, op_options.Pos)\n align_corners = resize_options.AlignCorners()\n\n # Use layout NHWC\n coord_trans = \"align_corners\" if align_corners else \"asymmetric\"\n out = _op.image.resize(in_expr, target_size, \"NHWC\", method,\n coordinate_transformation_mode=coord_trans)\n return out\n\n def convert_resize_bilinear(self, op):\n \"\"\"Convert TFLite RESIZE_BILINEAR\"\"\"\n return self._convert_resize(\"bilinear\", op)\n\n def convert_resize_nearest_neighbor(self, op):\n \"\"\"Convert TFLite RESIZE_NEAREST_NEIGHBOR\"\"\"\n return self._convert_resize(\"nearest_neighbor\", op)\n\n def convert_l2_normalization(self, op):\n \"\"\"Convert TFLite L2_NORMALIZATION \"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.L2NormOptions import L2NormOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n assert op.BuiltinOptionsType() == BuiltinOptions.L2NormOptions\n op_options = op.BuiltinOptions()\n l2_norm_options = L2NormOptions()\n l2_norm_options.Init(op_options.Bytes, op_options.Pos)\n fused_activation_fn = l2_norm_options.FusedActivationFunction()\n\n # TFLite supports normalization only over the last dim\n input_tensor_rank = len(input_tensor.tensor.ShapeAsNumpy())\n\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFLite quantized L2_NORMALIZATION operator is not supported yet.')\n\n # TFL uses only the default epsilon value\n out = _op.nn.l2_normalize(in_expr, eps=1e-12, axis=[input_tensor_rank - 1])\n\n # if we have fused activation fn\n if output_tensor.qnn_params:\n raise tvm.error.OpNotImplemented(\n 'TFLite quantized L2_NORMALIZATION operator is not supported yet.')\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_lrn(self, op):\n \"\"\"Convert TFLite LOCAL_RESPONSE_NORMALIZATION \"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.LocalResponseNormalizationOptions import LocalResponseNormalizationOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LRN operator is not supported yet.')\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n\n assert op.BuiltinOptionsType() == BuiltinOptions.LocalResponseNormalizationOptions\n op_options = op.BuiltinOptions()\n lrn_options = LocalResponseNormalizationOptions()\n lrn_options.Init(op_options.Bytes, op_options.Pos)\n radius = lrn_options.Radius()\n bias = lrn_options.Bias()\n alpha = lrn_options.Alpha()\n beta = lrn_options.Beta()\n size = (radius * 2) + 1\n alpha = alpha * size\n axis = 3 # NHWC format\n out = _op.nn.lrn(in_expr, size=size, axis=axis, bias=bias, alpha=alpha, beta=beta)\n\n return out\n\n def convert_logistic(self, op):\n \"\"\"Convert TFLite LOGISTIC\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n if input_tensor.qnn_params:\n in_expr = self.dequantize(in_expr, input_tensor)\n out = _op.sigmoid(in_expr)\n if output_tensor.qnn_params:\n out = self.quantize(out, output_tensor)\n\n return out\n\n def convert_softmax(self, op):\n \"\"\"Convert TFLite softmax\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n params = {'axis': 1} # 1 is channel\n in_expr = self.get_expr(input_tensor_idx)\n\n # TODO - Naive softmax int8 implementation leads to bad accuracy. Currently, we can\n # dequantize to FP32 and perform softmax on FP32. We can investigate an integer only softmax\n # implementation in future.\n if input_tensor.qnn_params:\n in_expr = self.dequantize(in_expr, input_tensor)\n\n out = _op.nn.softmax(in_expr, **params)\n\n # Go back to integer dataype if the original operator was quantized.\n if output_tensor.qnn_params:\n out = self.quantize(out, output_tensor)\n\n return out\n\n def convert_tanh(self, op):\n \"\"\"Convert TFLite TANH\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.tanh(in_expr)\n\n return out\n\n def convert_range(self, op):\n \"\"\"Convert TFLite Range\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n start, limit, delta = input_tensors[0], input_tensors[1], input_tensors[2]\n\n expressions = [self.get_tensor_expr(t) for t in [start, limit, delta]]\n\n # out type inference\n if delta.tensor.Type() == TensorType.FLOAT32:\n out_type = self.get_tensor_type_str(delta.tensor.Type())\n else:\n out_type = self.get_tensor_type_str(start.tensor.Type())\n\n out = _op.arange(expressions[0], expressions[1], expressions[2], out_type)\n\n return out\n\n def convert_shape(self, op):\n \"\"\"Convert TFLite Shape\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n out = _op.shape_of(self.get_tensor_expr(input_tensors[0]))\n\n return out\n\n def convert_relu(self, op):\n \"\"\"Convert TFLite ReLU\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.nn.relu(in_expr)\n\n return out\n\n def convert_hard_swish(self, op):\n \"\"\"Convert TFLite Hard swish\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n def _relu6(data):\n return _op.tensor.clip(data, 0.0, 6.0)\n\n def _hard_swish(data):\n return data * _relu6(data + relay.const(3.0)) / relay.const(6.0)\n\n # Dequantize if the input is quantized.\n if input_tensor.qnn_params:\n in_expr = self.dequantize(in_expr, input_tensor)\n\n # Perform hardswish\n out = _hard_swish(in_expr)\n\n # Go back to integer dataype if the original operator was quantized.\n if output_tensor.qnn_params:\n out = self.quantize(out, output_tensor)\n\n return out\n\n def convert_concatenation(self, op):\n \"\"\"Convert TFLite concatenation\"\"\"\n try:\n from tflite.ConcatenationOptions import ConcatenationOptions\n from tflite.BuiltinOptions import BuiltinOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 1, \"input tensors should greater than 1\"\n in_exprs = [self.get_expr(input_tensor.tensor_idx) for input_tensor in input_tensors]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n assert op.BuiltinOptionsType() == BuiltinOptions.ConcatenationOptions\n op_options = op.BuiltinOptions()\n concatenation_options = ConcatenationOptions()\n concatenation_options.Init(op_options.Bytes, op_options.Pos)\n concatenation_axis = concatenation_options.Axis()\n fused_activation_fn = concatenation_options.FusedActivationFunction()\n\n if not input_tensors[0].qnn_params:\n out = _op.concatenate(in_exprs, axis=concatenation_axis)\n else:\n input_scales = [input_tensor.qnn_params['scale'] for input_tensor in input_tensors]\n input_zero_points = \\\n [input_tensor.qnn_params['zero_point'] for input_tensor in input_tensors]\n out = _qnn.op.concatenate(in_exprs,\n input_scales=input_scales,\n input_zero_points=input_zero_points,\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n axis=concatenation_axis)\n\n # Handle fused activations\n if output_tensor.qnn_params:\n scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n output_tensor_type_str = self.get_tensor_type_str(output_tensor.tensor.Type())\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=scale_val,\n zero_point=zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def _convert_unary_elemwise(self, relay_op, op):\n \"\"\"Generic method to convert TFLite unary elemwise functions\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = relay_op(in_expr)\n\n return out\n\n def convert_abs(self, op):\n \"\"\"Convert TFLite ABS\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized ABS operator is not supported yet.')\n return self._convert_unary_elemwise(_op.abs, op)\n\n def convert_ceil(self, op):\n \"\"\"Convert TFLite CEIL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized CEIL operator is not supported yet.')\n return self._convert_unary_elemwise(_op.ceil, op)\n\n def convert_floor(self, op):\n \"\"\"Convert TFLite FLOOR\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized FLOOR operator is not supported yet.')\n return self._convert_unary_elemwise(_op.floor, op)\n\n def convert_round(self, op):\n \"\"\"Convert TFLite ROUND\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized ROUND operator is not supported yet.')\n return self._convert_unary_elemwise(_op.round, op)\n\n def convert_exp(self, op):\n \"\"\"Convert TFLite EXP\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized EXP operator is not supported yet.')\n return self._convert_unary_elemwise(_op.exp, op)\n\n def convert_log(self, op):\n \"\"\"Convert TFLite LOG\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LOG operator is not supported yet.')\n return self._convert_unary_elemwise(_op.log, op)\n\n def convert_sin(self, op):\n \"\"\"Convert TFLite SIN\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized SIN operator is not supported yet.')\n return self._convert_unary_elemwise(_op.sin, op)\n\n def convert_tan(self, op):\n \"\"\"Convert TFLite TAN\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized TAN operator is not supported yet.')\n return self._convert_unary_elemwise(_op.tan, op)\n\n def convert_cos(self, op):\n \"\"\"Convert TFLite COS\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized COS operator is not supported yet.')\n return self._convert_unary_elemwise(_op.cos, op)\n\n def convert_sqrt(self, op):\n \"\"\"Convert TFLite SQRT\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized SQRT operator is not supported yet.')\n return self._convert_unary_elemwise(_op.sqrt, op)\n\n def convert_rsqrt(self, op):\n \"\"\"Convert TFLite RSQRT\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized RSQRT operator is not supported yet.')\n return self._convert_unary_elemwise(_op.rsqrt, op)\n\n def convert_neg(self, op):\n \"\"\"Convert TFLite NEG\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized NEG operator is not supported yet.')\n return self._convert_unary_elemwise(_op.negative, op)\n\n def convert_elu(self, op):\n \"\"\"Convert TFLite ELU\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized ELU operator is not supported yet.')\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n exp_type = self.get_tensor_type_str(input_tensor.tensor.Type())\n out = relay.const(-1.0, exp_type) * \\\n _op.nn.relu(relay.const(1., exp_type) - _op.exp(in_expr)) + \\\n _op.nn.relu(in_expr)\n\n return out\n\n def convert_square(self, op):\n \"\"\"Convert TFLite SQUARE\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized SQUARE operator is not supported yet.')\n\n exp_type = self.get_tensor_type_str(output_tensor.tensor.Type())\n out = _op.power(in_expr, relay.const(2, exp_type))\n\n return out\n\n def _convert_elemwise(self, relay_op, op):\n \"\"\"Generic method to Convert TFLite elemwise\"\"\"\n try:\n from tflite.AddOptions import AddOptions\n from tflite.SubOptions import SubOptions\n from tflite.MulOptions import MulOptions\n from tflite.DivOptions import DivOptions\n from tflite.BuiltinOptions import BuiltinOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n lhs_tensor = input_tensors[0]\n rhs_tensor = input_tensors[1]\n lhs_expr = self.get_tensor_expr(lhs_tensor)\n rhs_expr = self.get_tensor_expr(rhs_tensor)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n # If quantized, extracts qnn params and call QNN add operator.\n if lhs_tensor.qnn_params:\n assert rhs_tensor.qnn_params, \"Both tensors should be quantized.\"\n assert output_tensor.qnn_params, \"Output tensor should be quantized.\"\n out = relay_op(lhs=lhs_expr,\n rhs=rhs_expr,\n lhs_scale=lhs_tensor.qnn_params['scale'],\n lhs_zero_point=lhs_tensor.qnn_params['zero_point'],\n rhs_scale=rhs_tensor.qnn_params['scale'],\n rhs_zero_point=rhs_tensor.qnn_params['zero_point'],\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'])\n else:\n out = relay_op(lhs_expr, rhs_expr)\n\n # Options (fused_activation_function)\n options = None\n if op.BuiltinOptionsType() == BuiltinOptions.AddOptions:\n options = AddOptions()\n elif op.BuiltinOptionsType() == BuiltinOptions.SubOptions:\n options = SubOptions()\n elif op.BuiltinOptionsType() == BuiltinOptions.MulOptions:\n options = MulOptions()\n elif op.BuiltinOptionsType() == BuiltinOptions.DivOptions:\n options = DivOptions()\n\n if options is not None:\n op_options = op.BuiltinOptions()\n options.Init(op_options.Bytes, op_options.Pos)\n fused_activation_fn = options.FusedActivationFunction()\n\n # Handle fused activations\n if output_tensor.qnn_params:\n scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n output_tensor_type_str = self.get_tensor_type_str(output_tensor.tensor.Type())\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=scale_val,\n zero_point=zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n return out\n\n def convert_add(self, op):\n \"\"\"Convert TFLite ADD\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n return self._convert_elemwise(_qnn.op.add, op)\n return self._convert_elemwise(_op.add, op)\n\n def convert_add_n(self, op):\n \"\"\"Convert TFLite ADD_N\"\"\"\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n\n input_tensors = self.get_input_tensors(op)\n assert not input_tensors[0].qnn_params, \"TFLite does not support quantized ADD_N.\"\n lhs_expr = self.get_tensor_expr(input_tensors[0])\n for rhs_tensor in input_tensors[1:]:\n assert not rhs_tensor.qnn_params, \"TFLite does not support quantized ADD_N\"\n rhs_expr = self.get_tensor_expr(rhs_tensor)\n lhs_expr = _op.add(lhs_expr, rhs_expr)\n return lhs_expr\n\n def convert_sub(self, op):\n \"\"\"Convert TFLite SUB\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n return self._convert_elemwise(_qnn.op.subtract, op)\n return self._convert_elemwise(_op.subtract, op)\n\n def convert_mul(self, op):\n \"\"\"Convert TFLite MUL\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n return self._convert_elemwise(_qnn.op.mul, op)\n return self._convert_elemwise(_op.multiply, op)\n\n def convert_div(self, op):\n \"\"\"Convert TFLite DIV\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized DIV operator is not supported yet.')\n return self._convert_elemwise(_op.divide, op)\n\n def convert_pow(self, op):\n \"\"\"Convert TFLite POW\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized POW operator is not supported yet.')\n return self._convert_elemwise(_op.power, op)\n\n def convert_maximum(self, op):\n \"\"\"Convert TFLite MAXIMUM\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized MAXIMUM operator is not supported yet.')\n return self._convert_elemwise(_op.maximum, op)\n\n def convert_minimum(self, op):\n \"\"\"Convert TFLite MINIMUM\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized MINIMUM operator is not supported yet.')\n return self._convert_elemwise(_op.minimum, op)\n\n def convert_greater(self, op):\n \"\"\"Convert TFLite GREATER\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized GREATER operator is not supported yet.')\n return self._convert_elemwise(_op.greater, op)\n\n def convert_squared_difference(self, op):\n \"\"\"Convert TFLite SQUARED DIFFERENCE\"\"\"\n # Check if the input tensor is quantized, call QNN op\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized squared difference operator is not supported yet.')\n difference = self._convert_elemwise(_op.subtract, op)\n # _convert_elemwise has guaranteed only have one output tensor\n exp_type = self.get_tensor_type_str(self.get_output_tensors(op)[0].tensor.Type())\n out = _op.power(difference, relay.const(2, exp_type))\n return out\n\n def convert_greater_equal(self, op):\n \"\"\"Convert TFLite GREATER_EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized GREATER_EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.greater_equal, op)\n\n def convert_less(self, op):\n \"\"\"Convert TFLite LESS\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LESS operator is not supported yet.')\n return self._convert_elemwise(_op.less, op)\n\n def convert_less_equal(self, op):\n \"\"\"Convert TFLite LESS_EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized LESS_EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.less_equal, op)\n\n def convert_equal(self, op):\n \"\"\"Convert TFLite EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.equal, op)\n\n def convert_not_equal(self, op):\n \"\"\"Convert TFLite NOT_EQUAL\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized NOT_EQUAL operator is not supported yet.')\n return self._convert_elemwise(_op.not_equal, op)\n\n def _convert_logical_binary(self, relay_op, op):\n \"\"\"Generic method to convert logical binary ops\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n lhs_tensor = input_tensors[0]\n lhs_expr = self.get_expr(lhs_tensor.tensor_idx)\n rhs_tensor = input_tensors[1]\n rhs_expr = self.get_expr(rhs_tensor.tensor_idx)\n out = relay_op(lhs_expr, rhs_expr)\n\n return out\n\n def convert_logical_and(self, op):\n \"\"\"Convert tflite LOGICAL_AND\"\"\"\n return self._convert_logical_binary(_op.logical_and, op)\n\n def convert_logical_or(self, op):\n \"\"\"Convert tflite LOGICAL_OR\"\"\"\n return self._convert_logical_binary(_op.logical_or, op)\n\n def convert_logical_not(self, op):\n \"\"\"Convert tflite LOGICAL_NOT\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n data = self.get_expr(input_tensors[0].tensor_idx)\n out = _op.logical_not(data)\n\n return out\n\n def convert_gather(self, op):\n \"\"\"Method to Convert TFLite GATHER operator\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.GatherOptions import GatherOptions\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n data = self.get_expr(input_tensors[0].tensor_idx)\n\n indices = input_tensors[1]\n indices_type = indices.tensor.Type()\n assert indices_type in (TensorType.INT32, TensorType.INT64)\n indices_type_str = self.get_tensor_type_str(indices_type)\n indices = self.exp_tab.new_const(self.get_tensor_value(indices),\n dtype=indices_type_str)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.GatherOptions\n op_options = op.BuiltinOptions()\n gather_options = GatherOptions()\n gather_options.Init(op_options.Bytes, op_options.Pos)\n axis = gather_options.Axis()\n\n # Check the indices are with in bounds.\n data_shape = list(input_tensors[0].tensor.ShapeAsNumpy())\n data_dim = len(data_shape)\n\n axis_n = axis\n if axis_n < 0:\n axis_n += axis_n + data_dim\n assert axis_n >= 0, \"Axis out of bounds\"\n assert axis_n < data_dim, \"Axis out of bounds\"\n\n indices_val = self.get_tensor_value(input_tensors[1])\n indices_shape = list(indices_val.shape)\n indices_len = len(indices_shape)\n\n out_shape = []\n for i in range(data_dim):\n if axis_n == i:\n for j in range(indices_len):\n out_shape.append(indices_shape[j])\n else:\n out_shape.append(data_shape[i])\n\n loopover = [range(s) for s in out_shape]\n for idx in list(itertools.product(*loopover)):\n indices_position = [idx[j] for j in range(axis_n, axis_n+indices_len)]\n\n real_indices = [idx[j] for j in range(axis_n)]\n real_indices.append(indices_val[tuple(indices_position)])\n real_indices.extend([idx[j] for j in range(axis_n + indices_len, len(idx))])\n for r, d in zip(real_indices, data_shape):\n if r >= d:\n raise ValueError(\"TFLite out of bound indices are not supported.\")\n\n # Use mode 'fast' since indices are already checked within bounds.\n out = _op.take(data, indices, axis=axis, mode=\"fast\")\n return out\n\n def convert_gather_nd(self, op):\n \"\"\"Method to Convert TFLite GATHER_ND operator\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n for t in input_tensors:\n assert not t.qnn_params, \"Quantized input is not expected.\"\n\n data = self.get_tensor_expr(input_tensors[0])\n indices = self.get_tensor_expr(input_tensors[1])\n\n indices_type = input_tensors[1].tensor.Type()\n assert indices_type in (TensorType.INT32, TensorType.INT64)\n\n indices_dims = len(_infer_shape(indices))\n indices_t = _op.transpose(indices, axes=[-1] + list(range(indices_dims-1)))\n\n out = _op.gather_nd(data, indices_t)\n return out\n\n def convert_strided_slice(self, op):\n \"\"\"Method to Convert TFLite STRIDED_SLICE operator.\n NOTE: Eventhough tensorflow supports begin_mask, end_mask, ellipsis_mask, new_axis_mask\n and shrink_axis_mask, tflite doesn't support these and expect these values to be zero.\n But in future, they may open up the mask implementation, so kept the implementation\n same as tensorflow.\n\n This op extracts a slice of size (end - begin) / stride from the given input tensor.\n Starting at the location specified by begin the slice continues by adding stride to the\n index until all dimensions are not less than end. Note that a stride can be negative,\n which causes a reverse slice.\n\n For slice input[val0, val1, ..., valn], begin/end/strides will be vectors of length n.\n\n In each mask field(begin_mask, end_mask, ellipsis_mask, new_axis_mask, shrink_axis_mask)\n the ith bit will correspond to the ith val.\n\n If the ith bit of begin_mask is set, begin[i] is ignored and the fullest possible range\n in that dimension is used instead.\n\n If the ith bit of ellipsis_mask is set, as many unspecified dimensions as needed will be\n inserted between other dimensions. Only one non-zero bit is allowed in ellipsis_mask.\n\n If the ith bit of new_axis_mask is set, then begin, end, and stride are ignored and a\n new length 1 dimension is added at this point in the output tensor.\n\n If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks\n the dimensionality by 1, taking on the value at index begin[i]. end[i] and strides[i]\n are ignored in this case.\n begin and end are zero-indexed. strides entries must be non-zero.\n\n TVM Relay implementation of doesn't support mask, so the mask values are processed in\n this function and begin/end/strides are updated accordingly. If any mask is present, and\n since tvm doesn't support mask computation directly, the output need a final reshape.\n \"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.StridedSliceOptions import StridedSliceOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 4, \"input tensors length should be 4\"\n\n data_expr = self.get_expr(input_tensors[0].tensor_idx)\n\n begin = list(self.get_tensor_value(input_tensors[1]))\n end = list(self.get_tensor_value(input_tensors[2]))\n stride = list(self.get_tensor_value(input_tensors[3]))\n\n assert op.BuiltinOptionsType() == BuiltinOptions.StridedSliceOptions\n op_options = op.BuiltinOptions()\n options = StridedSliceOptions()\n options.Init(op_options.Bytes, op_options.Pos)\n begin_mask = options.BeginMask()\n end_mask = options.EndMask()\n ellipsis_mask = options.EllipsisMask()\n new_axis_mask = options.NewAxisMask()\n shrink_axis_mask = options.ShrinkAxisMask()\n\n data_shape = list(input_tensors[0].tensor.ShapeAsNumpy())\n data_dim = len(data_shape)\n stride_dim = len(stride)\n def _transform_mask(stride_dim, ellipsis_mask):\n \"\"\"Handle mask inputs to create new begin, end, stride and output shape\"\"\"\n m_begin = [0] * data_dim\n m_end = [0] * data_dim\n m_stride = [0] * data_dim\n fshape_indices = []\n #Count new axis after ellipsis_mask, consider while applying ellipsis_mask.\n ellipsis_seen = False\n new_axes_after_ellipsis = 0\n for i in range(stride_dim):\n mask = 1 << i\n if ellipsis_seen and (mask & new_axis_mask) != 0:\n new_axes_after_ellipsis += 1\n if (mask & ellipsis_mask) != 0:\n ellipsis_seen = True\n if not ellipsis_seen:\n #Used later for extending the stride attributes in the below loop.\n ellipsis_mask |= (1 << stride_dim)\n stride_dim += 1\n final_index = 0\n for index in range(stride_dim):\n mask = 1 << index\n if mask & ellipsis_mask:\n #Identify the end index for applying ellipsis_mask\n to_index = min(((data_dim - (stride_dim-index)) + 1 \\\n + new_axes_after_ellipsis), data_dim)\n for i in range(final_index, to_index):\n m_begin[final_index] = 0\n m_end[final_index] = data_shape[final_index]\n m_stride[final_index] = 1\n fshape_indices.append(final_index)\n final_index += 1\n elif mask &new_axis_mask:\n fshape_indices.append(-1)\n elif not mask & new_axis_mask:\n if final_index == len(m_begin):\n break\n if mask & begin_mask:\n m_begin[final_index] = data_shape[final_index] \\\n if stride[index] < 0 else 0\n elif begin[index]:\n m_begin[final_index] = begin[index]\n if mask & end_mask:\n m_end[final_index] = 0 if stride[index] < 0 \\\n else data_shape[final_index]\n elif end[index]:\n m_end[final_index] = end[index]\n m_stride[final_index] = stride[index]\n if mask & shrink_axis_mask:\n #Tensorflow make axis with shrink_axis_mask as dimension 1\n m_begin[final_index] = data_shape[final_index] + begin[index] \\\n if begin[index] < 0 else begin[index]\n m_end[final_index] = begin[index] + 1\n m_stride[final_index] = 1\n fshape_indices.append(-2)\n else:\n fshape_indices.append(final_index)\n\n final_index += 1\n return m_begin, m_end, m_stride, fshape_indices\n\n fshape_indices = None\n if begin_mask or end_mask or ellipsis_mask or new_axis_mask or shrink_axis_mask:\n begin, end, stride, fshape_indices = _transform_mask(stride_dim, ellipsis_mask)\n\n out = _op.strided_slice(data_expr, begin=begin, end=end, strides=stride)\n out_shape = _infer_shape(out)\n if not fshape_indices:\n fshape_indices = range(len(out_shape))\n\n #Create final output shape.\n final_output = []\n for gather_index in fshape_indices:\n if gather_index == -1:\n final_output.append(1)\n elif gather_index == -2:\n pass\n else:\n final_output.append(out_shape[gather_index])\n\n if not final_output:\n return out\n return _op.reshape(out, newshape=tuple(final_output))\n\n def convert_zeros_like(self, op):\n \"\"\"Convert TFLite ZEROS LIKE\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.zeros_like(in_expr)\n\n return out\n\n def convert_fill(self, op):\n \"\"\"Convert TFLite FILL\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n if self.has_expr(input_tensors[0].tensor_idx):\n raise tvm.error.OpNotImplemented(\"For dims parameter of Fill operator,\"\n \" only constant values are supported.\")\n\n in_dims = list(self.get_tensor_value(input_tensors[0]))\n in_value_expr = self.get_expr(input_tensors[1].tensor_idx)\n out = _op.full(in_value_expr, in_dims)\n\n return out\n\n def _convert_reduce(self, relay_op, op):\n \"\"\"Generic method to Convert TFLite REDUCE operators\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.ReducerOptions import ReducerOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # input_tensor\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # axis\n axis = tuple(self.get_tensor_value(input_tensors[1]))\n\n # Options - keep_dims (bool)\n assert op.BuiltinOptionsType() == BuiltinOptions.ReducerOptions\n reduce_options = ReducerOptions()\n op_options = op.BuiltinOptions()\n reduce_options.Init(op_options.Bytes, op_options.Pos)\n keep_dims = reduce_options.KeepDims()\n\n if input_tensor.qnn_params:\n in_expr = _op.cast(in_expr, \"int32\")\n\n out = relay_op(in_expr, axis, keep_dims)\n\n # Finally if the reduce is quantized. Add a requantize at the end.\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type_str = self.get_tensor_type_str(output_tensor.tensor.Type())\n if output_tensor.qnn_params:\n out = _qnn.op.requantize(out,\n input_scale=input_tensor.qnn_params['scale'],\n input_zero_point=input_tensor.qnn_params['zero_point'],\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n out_dtype=output_tensor_type_str)\n\n return out\n\n def convert_reduce_min(self, op):\n return self._convert_reduce(_op.reduce.min, op)\n\n def convert_reduce_max(self, op):\n return self._convert_reduce(_op.reduce.max, op)\n\n def convert_reduce_mean(self, op):\n return self._convert_reduce(_op.reduce.mean, op)\n\n def convert_reduce_prod(self, op):\n return self._convert_reduce(_op.reduce.prod, op)\n\n def convert_reduce_sum(self, op):\n return self._convert_reduce(_op.reduce.sum, op)\n\n def convert_reduce_any(self, op):\n return self._convert_reduce(_op.reduce.any, op)\n\n def convert_fully_connected(self, op):\n \"\"\"Convert TFLite fully connected\"\"\"\n try:\n from tflite.FullyConnectedOptions import FullyConnectedOptions\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 2, \"input tensors length should be >= 2\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n weight_tensor = input_tensors[1]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n input_tensor_shape = input_tensor.tensor.ShapeAsNumpy()\n weight_tensor_shape = weight_tensor.tensor.ShapeAsNumpy()\n\n # Weight should have only 2 dimensions(TFLite convention)\n assert len(weight_tensor_shape) == 2, \"Weight should be only 2-dim\"\n\n # Input shape: [i_batch_size, ..., n_inputs]\n # Filter shape: [n_inputs, n_units]\n #\n # As we will transform Fully_Connected Input to Dense Op inputs as below\n # Dense expected Input shape: [batch_size, n_units]\n # Dense expected Weight shape: [out_dim, n_units]\n # Dense output shape: [batch_size, out_dim]\n # So it is evident that input shape: [batch_size = input_size / n_units, n_units]\n input_size = 1\n for _, shape in enumerate(input_tensor_shape):\n input_size *= shape\n\n # First get the batch size\n batch_size = int(input_size / weight_tensor_shape[1])\n target_shape = tuple((batch_size, weight_tensor_shape[1]))\n in_expr = self.get_expr(input_tensor_idx)\n in_expr = _op.reshape(in_expr, target_shape)\n\n #TODO: Change the output shape calculation based on keep_dim option\n assert op.BuiltinOptionsType() == BuiltinOptions.FullyConnectedOptions\n op_options = op.BuiltinOptions()\n fully_connected_options = FullyConnectedOptions()\n fully_connected_options.Init(op_options.Bytes, op_options.Pos)\n fused_activation_fn = fully_connected_options.FusedActivationFunction()\n\n # weight tensor type should be UINT8 (quantization) or FLOAT32\n weight_tensor_type = weight_tensor.tensor.Type()\n assert weight_tensor_type in (TensorType.UINT8, TensorType.FLOAT32)\n weight_tensor_type_str = self.get_tensor_type_str(weight_tensor_type)\n\n if self.has_expr(weight_tensor.tensor_idx):\n weight_expr = self.get_expr(weight_tensor.tensor_idx)\n else:\n weight_value = self.get_tensor_value(weight_tensor)\n weight_expr = self.exp_tab.new_const(weight_value, dtype=weight_tensor_type_str)\n weight_shape = _infer_shape(weight_expr)\n\n if input_tensor.qnn_params:\n out = _qnn.op.dense(in_expr, weight_expr,\n input_zero_point=input_tensor.qnn_params['zero_point'],\n kernel_zero_point=weight_tensor.qnn_params['zero_point'],\n input_scale=input_tensor.qnn_params['scale'],\n kernel_scale=weight_tensor.qnn_params['scale'],\n units=weight_shape[0],\n out_dtype='int32')\n else:\n out = _op.nn.dense(in_expr, weight_expr)\n\n # if we have bias\n if len(input_tensors) == 3:\n bias_tensor = input_tensors[2]\n bias_tensor_type = bias_tensor.tensor.Type()\n # bias tensor type should be INT32 (quantization) or FLOAT32\n assert bias_tensor_type in (TensorType.INT32, TensorType.FLOAT32)\n bias_tensor_type_str = self.get_tensor_type_str(bias_tensor_type)\n bias_expr = self.exp_tab.new_const(self.get_tensor_value(bias_tensor),\n dtype=bias_tensor_type_str)\n out = _op.nn.bias_add(out, bias_expr)\n\n # Finally if the dense is quantized. Add a requantize at the end.\n if output_tensor.qnn_params:\n data_scale = input_tensor.qnn_params['scale']\n weight_scale = weight_tensor.qnn_params['scale']\n data_scale_val = get_scalar_from_constant(data_scale)\n weight_scale_val = get_scalar_from_constant(weight_scale)\n new_input_scale_val = data_scale_val * weight_scale_val\n new_input_scale = relay.const(new_input_scale_val, 'float32')\n new_input_zero_point = relay.const(0, 'int32')\n\n # Requantize\n out = _qnn.op.requantize(out,\n input_scale=new_input_scale,\n input_zero_point=new_input_zero_point,\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n out_dtype=output_tensor_type_str)\n\n # Call activation function\n output_scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n output_zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=output_scale_val,\n zero_point=output_zero_point_val,\n dtype=output_tensor_type_str)\n\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_squeeze(self, op):\n \"\"\"Convert TFLite squeeze\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.SqueezeOptions import SqueezeOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n output_tensors = self.get_output_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n assert op.BuiltinOptionsType() == BuiltinOptions.SqueezeOptions\n op_options = op.BuiltinOptions()\n squeeze_options = SqueezeOptions()\n squeeze_options.Init(op_options.Bytes, op_options.Pos)\n squeeze_axis = squeeze_options.SqueezeDimsAsNumpy()\n\n in_expr = self.get_expr(input_tensor_idx)\n out = _op.squeeze(in_expr, axis=tuple(squeeze_axis))\n\n return out\n\n def convert_fused_activation_function(self, in_expr, fused_activation_fn):\n \"\"\"Convert TFLite fused activation function\"\"\"\n try:\n from tflite.ActivationFunctionType import ActivationFunctionType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n if fused_activation_fn == ActivationFunctionType.NONE:\n return in_expr\n if fused_activation_fn == ActivationFunctionType.RELU6:\n return _op.clip(in_expr, a_min=0, a_max=6)\n if fused_activation_fn == ActivationFunctionType.RELU:\n return _op.nn.relu(in_expr)\n if fused_activation_fn == ActivationFunctionType.RELU_N1_TO_1:\n return _op.clip(in_expr, a_min=-1, a_max=1)\n if fused_activation_fn == ActivationFunctionType.TANH:\n return _op.tanh(in_expr)\n fused_activation_fn_str = self.activation_fn_type[fused_activation_fn]\n raise tvm.error.OpNotImplemented(\n 'Fused activation {} is not supported yet.'.format(fused_activation_fn_str))\n\n def convert_conv(self, op, conv_type):\n \"\"\"convolution implementation.\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.TensorType import TensorType\n from tflite.Conv2DOptions import Conv2DOptions\n from tflite.DepthwiseConv2DOptions import DepthwiseConv2DOptions\n from tflite.Padding import Padding\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 2, \"input tensors length should be >= 2\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n weight_tensor = input_tensors[1]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n is_depthwise_conv = False\n if conv_type == 'conv2d':\n assert op.BuiltinOptionsType() == BuiltinOptions.Conv2DOptions\n op_options = op.BuiltinOptions()\n conv_options = Conv2DOptions()\n conv_options.Init(op_options.Bytes, op_options.Pos)\n elif conv_type == 'depthwise':\n is_depthwise_conv = True\n assert op.BuiltinOptionsType() == BuiltinOptions.DepthwiseConv2DOptions\n op_options = op.BuiltinOptions()\n conv_options = DepthwiseConv2DOptions()\n conv_options.Init(op_options.Bytes, op_options.Pos)\n depth_multiplier = conv_options.DepthMultiplier()\n else:\n raise tvm.error.OpNotImplemented(\n 'Operator {} is not supported for frontend TFLite.'.format(conv_type))\n\n stride_h = conv_options.StrideH()\n stride_w = conv_options.StrideW()\n dilation_h = conv_options.DilationHFactor()\n dilation_w = conv_options.DilationWFactor()\n padding = conv_options.Padding()\n fused_activation_fn = conv_options.FusedActivationFunction()\n\n _, input_h, input_w, input_c = input_tensor.tensor.ShapeAsNumpy()\n\n if is_depthwise_conv:\n # TFLite depthwise convolution kernel layout is:\n # 1 KH KW C(input_c * depth_multiplier)\n _, kernel_h, kernel_w, in_channels = weight_tensor.tensor.ShapeAsNumpy()\n assert in_channels == input_c * depth_multiplier\n else:\n output_channels, kernel_h, kernel_w, _ = weight_tensor.tensor.ShapeAsNumpy()\n\n dilated_kernel_h = dilation_h * (kernel_h - 1) + 1\n dilated_kernel_w = dilation_w * (kernel_w - 1) + 1\n\n params = {'kernel_size': [kernel_h, kernel_w],\n 'strides': [stride_h, stride_w],\n 'dilation': [dilation_h, dilation_w],\n 'padding': [0, 0],\n 'data_layout': 'NHWC'}\n\n if is_depthwise_conv:\n params['channels'] = int(in_channels)\n params['groups'] = int(input_c)\n # If number of input channels is 1, treat as normal\n # convolution.\n params['kernel_layout'] = 'HWIO' if input_c == 1 else 'HWOI'\n else:\n params['channels'] = int(output_channels)\n params['kernel_layout'] = 'HWIO'\n\n # weight tensor type should be UINT8 (quantization) or FLOAT32\n weight_tensor_type = weight_tensor.tensor.Type()\n assert weight_tensor_type in (TensorType.UINT8, TensorType.FLOAT32)\n weight_tensor_type_str = self.get_tensor_type_str(weight_tensor_type)\n\n in_expr = self.get_expr(input_tensor_idx)\n weight_value = self.get_tensor_value(weight_tensor)\n\n # TFLite kernel layout:\n # convolution:\n # OC KH KW IC, we require KH KW IC OC (HWIO)\n # depthwise convolution:\n # 1 KH KW C(input_c * depth_multiplier), we require\n # KH KW IC M (depth_multiplier) (HWOI)\n if is_depthwise_conv:\n weight_value = weight_value.reshape(kernel_h, kernel_w, input_c, depth_multiplier)\n else:\n weight_value = weight_value.transpose((1, 2, 3, 0))\n\n weight_expr = self.exp_tab.new_const(weight_value, dtype=weight_tensor_type_str)\n\n if padding == Padding.VALID:\n pass\n elif padding == Padding.SAME:\n pad_top, pad_bottom = get_pad_value(input_h, dilated_kernel_h, stride_h)\n pad_left, pad_right = get_pad_value(input_w, dilated_kernel_w, stride_w)\n do_pad = not (pad_top == 0 and pad_bottom == 0 and pad_left == 0 and pad_right == 0)\n if do_pad:\n params['padding'] = [pad_top, pad_left, pad_bottom, pad_right]\n\n else:\n raise tvm.error.OpAttributeUnImplemented(\n 'Padding format {} is not supported for operator Conv.'.format(padding))\n\n if input_tensor.qnn_params:\n qnn_conv2d_params = dict(params)\n qnn_conv2d_params['input_zero_point'] = input_tensor.qnn_params['zero_point']\n qnn_conv2d_params['kernel_zero_point'] = weight_tensor.qnn_params['zero_point']\n qnn_conv2d_params['out_dtype'] = 'int32'\n qnn_conv2d_params['input_scale'] = input_tensor.qnn_params['scale']\n qnn_conv2d_params['kernel_scale'] = weight_tensor.qnn_params['scale']\n out = _qnn.op.conv2d(in_expr, weight_expr, **qnn_conv2d_params)\n else:\n out = _op.nn.conv2d(in_expr, weight_expr, **params)\n\n # if we have bias\n if len(input_tensors) == 3:\n bias_tensor = input_tensors[2]\n bias_tensor_type = bias_tensor.tensor.Type()\n # bias tensor type should be INT32 (quantization) or FLOAT32\n assert bias_tensor_type in (TensorType.INT32, TensorType.FLOAT32)\n bias_tensor_type_str = self.get_tensor_type_str(bias_tensor_type)\n bias_expr = self.exp_tab.new_const(self.get_tensor_value(bias_tensor),\n dtype=bias_tensor_type_str)\n channel_axis = 3\n out = _op.nn.bias_add(out, bias_expr, axis=channel_axis)\n\n # Handle fused activation.\n if output_tensor.qnn_params:\n # Calculate the intermediate scale and zero point of the int32 output.\n data_scale = input_tensor.qnn_params['scale']\n weight_scale = weight_tensor.qnn_params['scale']\n data_scale_val = get_scalar_from_constant(data_scale)\n weight_scale_val = get_scalar_from_constant(weight_scale)\n new_input_scale_val = data_scale_val * weight_scale_val\n new_input_scale = relay.const(new_input_scale_val, 'float32')\n new_input_zero_point = relay.const(0, 'int32')\n\n # Finally requantize\n out = _qnn.op.requantize(out,\n input_scale=new_input_scale,\n input_zero_point=new_input_zero_point,\n output_scale=output_tensor.qnn_params['scale'],\n output_zero_point=output_tensor.qnn_params['zero_point'],\n out_dtype=output_tensor_type_str)\n\n # Call activation function\n output_scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n output_zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=output_scale_val,\n zero_point=output_zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_split(self, op):\n \"\"\"split implementation.\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.SplitOptions import SplitOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n\n assert len(input_tensors) == 2, \"input tensors length should be == 2\"\n\n axis_tensor = input_tensors[0]\n split_axis = self.get_tensor_value(axis_tensor)\n input_tensor = input_tensors[1]\n input_tensor_idx = input_tensor.tensor_idx\n\n assert op.BuiltinOptionsType() == BuiltinOptions.SplitOptions\n op_options = op.BuiltinOptions()\n split_options = SplitOptions()\n split_options.Init(op_options.Bytes, op_options.Pos)\n num_splits = split_options.NumSplits()\n\n in_expr = self.get_expr(input_tensor_idx)\n out = _op.split(in_expr, num_splits, axis=int(split_axis))\n # Relay does not like a TupleWrapper of 1 element, further this\n # only shows up with tf1.13 if we use a split with num_splits==1.\n # In tf 1.14 this doesn't appear as it is automatically a reshape\n # operation.\n if isinstance(out, _expr.TupleWrapper):\n if out.size == 1:\n out = out[0]\n\n return out\n\n def convert_split_v(self, op):\n \"\"\"SPLIT_V implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n\n if self.has_expr(input_tensors[1].tensor_idx):\n raise tvm.error.OpNotImplemented(\"For size_splits parameter of SPLIT_V operator, \"\n \"only constant values are supported.\")\n size_splits = list(self.get_tensor_value(input_tensors[1]))\n size_splits = tuple(np.cumsum(size_splits)[:-1])\n\n axis_tensor = input_tensors[2]\n split_axis = self.get_tensor_value(axis_tensor)\n\n out = _op.split(in_expr, size_splits, axis=int(split_axis))\n # Relay does not like a TupleWrapper of 1 element, further this\n # only shows up with tf1.13 if we use a split with num_splits==1.\n # In tf 1.14 this doesn't appear as it is automatically a reshape\n # operation.\n if isinstance(out, _expr.TupleWrapper) and out.size == 1:\n out = out[0]\n\n return out\n\n def convert_slice(self, op):\n \"\"\"Convert TFLite SLICE\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be == 3\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n begin = list(self.get_tensor_value(input_tensors[1]))\n size = list(self.get_tensor_value(input_tensors[2]))\n # strided_slice(Relay) needs the slice's end indices, not the size\n end = size\n input_tensor_shape = input_tensor.tensor.ShapeAsNumpy()\n input_tensor_rank = len(input_tensor_shape)\n for i in range(input_tensor_rank):\n if size[i] == -1:\n end[i] = input_tensor_shape[i]\n else:\n end[i] += begin[i]\n\n out = _op.strided_slice(in_expr, begin, end)\n\n return out\n\n def convert_select(self, op):\n \"\"\"Convert TFLite SELECT\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be == 3\"\n cond = self.get_tensor_expr(input_tensors[0])\n x = self.get_tensor_expr(input_tensors[1])\n y = self.get_tensor_expr(input_tensors[2])\n\n out = _op.where(cond, x, y)\n\n return out\n\n def convert_transpose(self, op):\n \"\"\"transpose implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n in_expr = self.get_expr(input_tensor_idx)\n\n # axis\n in_axis = tuple(self.get_tensor_value(input_tensors[1]))\n\n if not in_axis:\n out = _op.transpose(in_expr)\n else:\n out = _op.transpose(in_expr, in_axis)\n\n return out\n\n def convert_cast(self, op):\n \"\"\"Convert TFLite CAST\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.CastOptions import CastOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.CastOptions\n op_options = op.BuiltinOptions()\n cast_options = CastOptions()\n cast_options.Init(op_options.Bytes, op_options.Pos)\n cast_dtype = cast_options.OutDataType()\n\n out = _op.cast(in_expr, self.get_tensor_type_str(cast_dtype))\n\n return out\n\n def convert_tile(self, op):\n \"\"\"tile implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n in_expr = self.get_expr(input_tensor_idx)\n\n # reps (tuple of int) – The number of times repeating the tensor data.\n reps = tuple(self.get_tensor_value(input_tensors[1]))\n\n out = _op.tile(in_expr, reps)\n\n return out\n\n def convert_topk_v2(self, op):\n \"\"\" Convert TFLite TOPK_v2 \"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n k = self.get_tensor_value(input_tensors[1])\n out = _op.topk(in_expr, int(k))\n\n return out\n\n def convert_pool2d(self, op, pool_type):\n \"\"\"pool2d implementation.\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.Pool2DOptions import Pool2DOptions\n from tflite.Padding import Padding\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.Pool2DOptions\n op_options = op.BuiltinOptions()\n pool2d_options = Pool2DOptions()\n pool2d_options.Init(op_options.Bytes, op_options.Pos)\n stride_h = pool2d_options.StrideH()\n stride_w = pool2d_options.StrideW()\n padding = pool2d_options.Padding()\n filter_h = pool2d_options.FilterHeight()\n filter_w = pool2d_options.FilterWidth()\n fused_activation_fn = pool2d_options.FusedActivationFunction()\n\n params = {'pool_size': (filter_h, filter_w),\n 'strides': (stride_h, stride_w),\n 'padding': [0, 0],\n 'layout': 'NHWC'}\n\n in_expr = self.get_expr(input_tensor_idx)\n\n _, input_h, input_w, _ = input_tensor.tensor.ShapeAsNumpy()\n if padding == Padding.VALID:\n pass\n elif padding == Padding.SAME:\n pad_top, pad_bottom = get_pad_value(input_h, filter_h, stride_h)\n pad_left, pad_right = get_pad_value(input_w, filter_w, stride_w)\n params['padding'] = [pad_top, pad_left, pad_bottom, pad_right]\n else:\n raise tvm.error.OpAttributeUnImplemented(\n 'Padding format {} for operator Pool2D is not supported.'.format(padding))\n\n if pool_type == \"average\":\n if input_tensor.qnn_params:\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n 'TFLite avg_pool2dreshape requires input and output scale' \\\n 'and zero points to be equal'\n out = _op.cast(in_expr, dtype=\"int32\")\n out = _op.nn.avg_pool2d(out, **params)\n out = _op.cast(out, dtype=output_tensor_type_str)\n else:\n out = _op.nn.avg_pool2d(in_expr, **params)\n elif pool_type == \"max\":\n if input_tensor.qnn_params:\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n \"qnn.op.max_pool2d requires input and output qnn params to be same\"\n out = _op.nn.max_pool2d(in_expr, **params)\n elif pool_type == \"l2\":\n # L2_POOL_2D is equivalent to square_root(avg_pool(square(in_data)))\n # TFLite does not have support for quantised L2_POOL_2D op.\n assert not input_tensor.qnn_params, \\\n \"As TFLite does not have support for quantized L2_POOL_2D, \\\n Quantized input is not expected.\"\n exp_type = self.get_tensor_type_str(output_tensor.tensor.Type())\n square_exp = _op.power(in_expr, relay.const(2, exp_type))\n avg_pool_exp = _op.nn.avg_pool2d(square_exp, **params)\n out = _op.sqrt(avg_pool_exp)\n else:\n raise tvm.error.OpNotImplemented(\n 'Operator {} is not supported for frontend TFLite.'.format(pool_type + ' pool'))\n\n # Handle fused activations\n if output_tensor.qnn_params:\n scale_val = get_scalar_from_constant(output_tensor.qnn_params['scale'])\n zero_point_val = get_scalar_from_constant(output_tensor.qnn_params['zero_point'])\n out = self.convert_qnn_fused_activation_function(\\\n expr=out,\n fused_activation_fn=fused_activation_fn,\n scale=scale_val,\n zero_point=zero_point_val,\n dtype=output_tensor_type_str)\n else:\n out = self.convert_fused_activation_function(out, fused_activation_fn)\n\n return out\n\n def convert_pad(self, op):\n \"\"\"Convert TFLite PAD\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # TFLite PAD only support CONSTANT mode and does not support constant_values parameter.\n # tensor\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # paddings\n pad_list = self.get_tensor_value(input_tensors[1])\n # convert list of lists to tuple of tuples\n paddings = tuple(tuple(l) for l in pad_list)\n\n # Set the pad value\n pad_value = 0\n if input_tensor.qnn_params:\n # Check that input and output tensor have same qnn params.\n output_tensors = self.get_output_tensors(op)\n output_tensor = output_tensors[0]\n assert self.has_same_qnn_params(input_tensor, output_tensor), \\\n \"TFLite reshape requires input and output scale and zero points to be equal\"\n\n # The pad value for quantized pad is the input zero point.\n pad_value = float(input_tensor.qnn_params['zero_point'].data.asnumpy())\n\n out = _op.nn.pad(in_expr, pad_width=paddings, pad_value=pad_value)\n return out\n\n def convert_floor_div(self, op):\n \"\"\"Convert TFLite FLOOR_DIV\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized FLOOR DIV operator is not supported yet.')\n return self._convert_elemwise(_op.floor_divide, op)\n\n def convert_floor_mod(self, op):\n \"\"\"Convert TFLite FLOOR_MOD\"\"\"\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized FLOOR MOD operator is not supported yet.')\n return self._convert_elemwise(_op.floor_mod, op)\n\n def convert_mirror_pad(self, op):\n \"\"\"Convert TFLite MIRROR_PAD\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.MirrorPadOptions import MirrorPadOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n # the quantized form MirrorPad is not yet implemented in TFLite.\n if self.is_quantized(op):\n raise tvm.error.OpNotImplemented(\n 'TFlite quantized MIRROR_PAD operator is not supported yet.')\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n # tensor\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # paddings\n pad_list = self.get_tensor_value(input_tensors[1])\n # convert list of lists to tuple of tuples\n paddings = tuple(tuple(l) for l in pad_list)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.MirrorPadOptions\n op_options = op.BuiltinOptions()\n mirror_pad_options = MirrorPadOptions()\n mirror_pad_options.Init(op_options.Bytes, op_options.Pos)\n mode_byte = mirror_pad_options.Mode()\n\n mode = \"REFLECT\" if mode_byte == 0 else \"SYMMETRIC\"\n out = _op.nn.mirror_pad(in_expr, paddings, mode)\n\n return out\n\n def convert_pack(self, op):\n \"\"\"Convert TFLite pack\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.PackOptions import PackOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) >= 1, \"input tensors should greater than 1\"\n in_exprs = [self.get_expr(input_tensor.tensor_idx) for input_tensor in input_tensors]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n\n assert op.BuiltinOptionsType() == BuiltinOptions.PackOptions\n op_options = op.BuiltinOptions()\n pack_options = PackOptions()\n pack_options.Init(op_options.Bytes, op_options.Pos)\n pack_axis = pack_options.Axis()\n\n in_exprs_reshaped = [_op.expand_dims(i, axis=pack_axis, num_newaxis=1) for i in in_exprs]\n out = _op.concatenate(in_exprs_reshaped, pack_axis)\n return out\n\n def convert_unpack(self, op):\n \"\"\"Convert TFLite unpack\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.UnpackOptions import UnpackOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n assert op.BuiltinOptionsType() == BuiltinOptions.UnpackOptions\n op_options = op.BuiltinOptions()\n unpack_options = UnpackOptions()\n unpack_options.Init(op_options.Bytes, op_options.Pos)\n num_unpacks = unpack_options.Num()\n unpack_axis = unpack_options.Axis()\n\n # Relay doesn't support 'unpack' operator so we use 'split' & 'squeeze' instead.\n # We have to do 'squeeze' along the split axis but Relay expects\n # squeeze_axis to be either None or List.\n squeeze_axis = None if unpack_axis == 0 else [unpack_axis]\n\n # Relay doesn't like TupleWrapper of 1 element so we isolate the case of unpacking\n # a tensor by an axis with len(axis) == 1. For reference see convert_split().\n # Such unpacking will result in the same tensor so we omit 'split' and only squeeze\n # along the axis of dim == 1.\n if num_unpacks == 1:\n squeezed = _op.squeeze(in_expr, axis=squeeze_axis)\n if isinstance(squeezed, _expr.TupleWrapper):\n squeezed = squeezed[0]\n else:\n splitted = _op.split(in_expr,\n indices_or_sections=num_unpacks,\n axis=unpack_axis)\n squeezed = _expr.TupleWrapper(\n _expr.Tuple([_op.squeeze(split_item, axis=squeeze_axis) \\\n for split_item in splitted]), len(splitted))\n\n return squeezed\n\n def convert_batch_to_space_nd(self, op):\n \"\"\"batch_to_space_nd implementation.\"\"\"\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n\n input_shape = list(input_tensor.tensor.ShapeAsNumpy())\n batch = input_shape[0]\n\n block_shape = list(self.get_tensor_value(input_tensors[1]))\n M = len(block_shape)\n\n crops = list(self.get_tensor_value(input_tensors[2]))\n\n # From https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/batch-to-space-n-d:\n # Reshape input to reshaped of shape\n shape1 = block_shape + [batch // np.prod(block_shape)] + input_shape[1:]\n reshaped = _op.reshape(in_expr, newshape=shape1)\n\n # Permute dimensions of reshaped to produce permuted of shape\n axes = [M] + [axis for i in range(M) for axis in [M + i + 1, i]] + \\\n list(range(2 * M + 1, len(shape1)))\n permuted = _op.transpose(reshaped, axes=axes)\n\n # Reshape permuted to produce reshaped_permuted of shape\n shape2 = [0] + [-3] * M + [-2]\n reshaped_permuted = _op.reshape(permuted, newshape=shape2)\n\n # Crop the start and end of dimensions [1, ..., M] of reshaped_permuted according to crops\n # to produce the output of shape:\n reshaped_permuted_shape = _infer_shape(reshaped_permuted)\n cropped = reshaped_permuted\n for axis in range(1, M + 1):\n crop = crops[axis - 1]\n if (crop != [0, 0]).all():\n indices = _op.arange(\n _expr.const(crop[0]),\n _expr.const(reshaped_permuted_shape[axis] - crop[1]),\n dtype='int32'\n )\n cropped = _op.take(cropped, indices=indices, axis=axis)\n\n return cropped\n\n def convert_space_to_batch_nd(self, op):\n \"\"\"space_to_batch_nd implementation.\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n input_tensor = input_tensors[0]\n input_tensor_idx = input_tensor.tensor_idx\n in_expr = self.get_expr(input_tensor_idx)\n\n input_shape = list(input_tensor.tensor.ShapeAsNumpy())\n batch = input_shape[0]\n N = len(input_shape)\n\n block_shape = list(self.get_tensor_value(input_tensors[1]))\n M = len(block_shape)\n\n paddings = list(self.get_tensor_value(input_tensors[2]))\n\n # From https://www.tensorflow.org/api_docs/python/tf/space_to_batch_nd:\n # Zero-pad the start and end of dimensions [1, ..., M] of the input according to paddings\n # to produce padded of shape padded_shape.\n remaining_shape_length = N - M - 1\n padded_list = [(0, 0)] + paddings + [(0, 0)] * remaining_shape_length\n\n padded_shape = []\n for element in padded_list:\n if isinstance(element, np.ndarray):\n element = element.tolist()\n\n padded_shape.append(element)\n\n padded_shape = tuple(padded_shape)\n padded = _op.nn.pad(in_expr, pad_width=tuple(padded_shape))\n\n # Reshape padded to reshaped_padded of shape:\n shape1 = [batch] + [item for i in range(M) for item in [-4, -1, block_shape[i]]] + [-2]\n reshaped_padded = _op.reshape(padded, newshape=shape1)\n\n # Permute dimensions of reshaped_padded to produce permuted_reshaped_padded of shape:\n axes = [2 * i + 2 for i in range(M)] + [0] + [2 * i + 1 for i in range(M)] + \\\n list(range(1 + 2 * M, 1 + 2 * M + remaining_shape_length))\n permuted_reshaped_padded = _op.transpose(reshaped_padded, axes=axes)\n permuted_reshaped_padded_shape = _infer_shape(permuted_reshaped_padded)\n\n # Reshape permuted_reshaped_padded to flatten block_shape into the batch dimension,\n # producing an output tensor of shape:\n shape2 = [batch * np.prod(block_shape)] + list(permuted_reshaped_padded_shape)[M + 1:]\n reshaped_permuted_reshaped_padded = _op.reshape(permuted_reshaped_padded, newshape=shape2)\n\n return reshaped_permuted_reshaped_padded\n\n def convert_depth_to_space(self, op):\n \"\"\"Convert TFLite DEPTH_TO_SPACE\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.DepthToSpaceOptions import DepthToSpaceOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.DepthToSpaceOptions\n op_options = op.BuiltinOptions()\n depth_to_space_options = DepthToSpaceOptions()\n depth_to_space_options.Init(op_options.Bytes, op_options.Pos)\n block_size = depth_to_space_options.BlockSize()\n out = _op.nn.depth_to_space(in_expr, block_size, layout='NHWC')\n\n return out\n\n def convert_space_to_depth(self, op):\n \"\"\"Convert TFLite SPACE_TO_DEPTH\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.SpaceToDepthOptions import SpaceToDepthOptions\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.SpaceToDepthOptions\n op_options = op.BuiltinOptions()\n space_to_depth_options = SpaceToDepthOptions()\n space_to_depth_options.Init(op_options.Bytes, op_options.Pos)\n block_size = space_to_depth_options.BlockSize()\n out = _op.nn.space_to_depth(in_expr, block_size, layout='NHWC')\n\n return out\n\n def convert_sparse_to_dense(self, op):\n \"\"\"Convert TFLite SPARSE_TO_DENSE\"\"\"\n try:\n from tflite.TensorType import TensorType\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 4, \"input tensors length should be 4\"\n\n indices, values = input_tensors[0], input_tensors[2]\n default_value = input_tensors[3]\n output_shape = input_tensors[1]\n\n for t in input_tensors:\n assert not t.qnn_params, \"Quantized input is not expected.\"\n\n for t in [indices, output_shape]:\n t_type = t.tensor.Type()\n assert t_type in (TensorType.INT32, TensorType.INT64)\n\n out = _op.sparse_to_dense(\n self.get_tensor_expr(indices),\n list(self.get_tensor_value(output_shape)),\n self.get_tensor_expr(values),\n self.get_tensor_expr(default_value)\n )\n\n return out\n\n def convert_prelu(self, op):\n \"\"\"Convert TFLite PReLU\"\"\"\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 2, \"input tensors length should be 2\"\n\n input_tensor = input_tensors[0]\n alpha_tensor = input_tensors[1]\n alpha_tensor_type = alpha_tensor.tensor.Type()\n alpha_tensor_type_str = self.get_tensor_type_str(alpha_tensor_type)\n alpha_expr = self.exp_tab.new_const(self.get_tensor_value(alpha_tensor).flatten(),\n dtype=alpha_tensor_type_str)\n in_expr = self.get_expr(input_tensor.tensor_idx)\n out = _op.nn.prelu(in_expr, alpha_expr, axis=3)\n\n return out\n\n def convert_transpose_conv(self, op):\n \"\"\"Convert TFLite TRANSPOSE_CONV\"\"\"\n try:\n from tflite.BuiltinOptions import BuiltinOptions\n from tflite.TensorType import TensorType\n from tflite.TransposeConvOptions import TransposeConvOptions\n from tflite.Padding import Padding\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 3, \"input tensors length should be 3\"\n\n # Input (data) Tensor. NHWC layout\n input_tensor = input_tensors[2]\n _, _, _, input_c = input_tensor.tensor.ShapeAsNumpy()\n # Weights tensor. TFLite uses OHWI layout\n weights_tensor = input_tensors[1]\n out_channels, kernel_h, kernel_w, in_channels = weights_tensor.tensor.ShapeAsNumpy()\n assert input_c == in_channels, \\\n \"Input channel in the filter should match to channel in the input\"\n # output_shape Tensor. NHWC layout\n output_shape_tensor = input_tensors[0]\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n output_tensor_type = output_tensor.tensor.Type()\n output_tensor_type_str = self.get_tensor_type_str(output_tensor_type)\n\n assert op.BuiltinOptionsType() == BuiltinOptions.TransposeConvOptions\n op_options = op.BuiltinOptions()\n deconv_options = TransposeConvOptions()\n deconv_options.Init(op_options.Bytes, op_options.Pos)\n\n padding = deconv_options.Padding()\n stride_h = deconv_options.StrideH()\n stride_w = deconv_options.StrideW()\n assert padding in (Padding.VALID, Padding.SAME), \\\n 'Padding format {} is not supported for operator TRANSPOSE_CONV'.format(padding)\n\n # Data\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # Weights\n weights_tensor_type = weights_tensor.tensor.Type()\n # weights tensor type should be UINT8 (quantization) or FLOAT32\n assert weights_tensor_type in (TensorType.UINT8, TensorType.FLOAT32)\n weight_tensor_type_str = self.get_tensor_type_str(weights_tensor_type)\n weight_value_ohwi = self.get_tensor_value(weights_tensor)\n # Relay kernel_layout should be OIHW\n # Relay weights layout should be different from kernel_layout - it should be IOHW\n weight_value_iohw = np.transpose(weight_value_ohwi, (3, 0, 1, 2))\n weight_expr_iohw = self.exp_tab.new_const(weight_value_iohw, dtype=weight_tensor_type_str)\n\n # Output shape value\n output_shape_value = self.get_tensor_value(output_shape_tensor)\n # Relay expects filter output channel to match to output tensor channel.\n assert out_channels == output_shape_value[3], \\\n \"Output channel in the filter should match to channel in the output_shape\"\n\n # TF frontend supports 'SAME' padding for kernel 1x1 only. Lets do the same here\n if padding == Padding.SAME:\n assert (kernel_h, kernel_w) == (1, 1), \\\n \"SAME padding is supported for kernel (1,1) only\"\n\n out = _op.nn.conv2d_transpose(in_expr, weight_expr_iohw,\n strides=(stride_h, stride_w),\n channels=int(out_channels),\n kernel_size=(int(kernel_h), int(kernel_w)),\n data_layout=\"NHWC\",\n kernel_layout=\"OIHW\",\n out_dtype=output_tensor_type_str)\n\n return out\n\n def convert_quantize(self, op):\n \"\"\"Convert TFLite Quantize\"\"\"\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n output_tensors = self.get_output_tensors(op)\n assert len(output_tensors) == 1, \"output tensors length should be 1\"\n output_tensor = output_tensors[0]\n\n # The output must be quantized\n assert output_tensor.qnn_params\n # Quantize the input\n out = self.quantize(in_expr, output_tensor)\n\n return out\n\n def convert_dequantize(self, op):\n \"\"\"Convert TFLite Dequantize\"\"\"\n\n input_tensors = self.get_input_tensors(op)\n assert len(input_tensors) == 1, \"input tensors length should be 1\"\n input_tensor = input_tensors[0]\n in_expr = self.get_expr(input_tensor.tensor_idx)\n\n # The input must be quantized\n assert input_tensor.qnn_params\n # Dequantize the input.\n out = self.dequantize(in_expr, input_tensor)\n\n return out\n\n def convert_detection_postprocess(self, op):\n \"\"\"Convert TFLite_Detection_PostProcess\"\"\"\n flexbuffer = op.CustomOptionsAsNumpy().tobytes()\n custom_options = FlexBufferDecoder(flexbuffer).decode()\n\n if \"use_regular_nms\" in custom_options:\n if custom_options[\"use_regular_nms\"]:\n raise tvm.error.OpAttributeUnImplemented(\n \"use_regular_nms=True is not yet supported for operator {}.\"\n .format(\"TFLite_Detection_PostProcess\")\n )\n\n inputs = self.get_input_tensors(op)\n assert len(inputs) == 3, \"inputs length should be 3\"\n cls_pred = self.get_expr(inputs[1].tensor_idx)\n loc_prob = self.get_expr(inputs[0].tensor_idx)\n batch_size = inputs[1].tensor.Shape(0)\n anchor_values = self.get_tensor_value(inputs[2])\n anchor_boxes = len(anchor_values)\n anchor_type = self.get_tensor_type_str(inputs[2].tensor.Type())\n anchor_expr = self.exp_tab.new_const(anchor_values, dtype=anchor_type)\n\n if inputs[0].qnn_params:\n loc_prob = _qnn.op.dequantize(data=loc_prob,\n input_scale=inputs[0].qnn_params['scale'],\n input_zero_point=inputs[0].qnn_params['zero_point'])\n if inputs[1].qnn_params:\n cls_pred = _qnn.op.dequantize(data=cls_pred,\n input_scale=inputs[1].qnn_params['scale'],\n input_zero_point=inputs[1].qnn_params['zero_point'])\n if inputs[2].qnn_params:\n anchor_expr = _qnn.op.dequantize(data=anchor_expr,\n input_scale=inputs[2].qnn_params['scale'],\n input_zero_point=inputs[2].qnn_params['zero_point'])\n\n # reshape the cls_pred and loc_prob tensors so\n # they can be consumed by multibox_transform_loc\n cls_pred = _op.transpose(cls_pred, [0, 2, 1])\n # loc_prob coords are in yxhw format\n # need to convert to xywh\n loc_coords = _op.split(loc_prob, 4, axis=2)\n loc_prob = _op.concatenate(\n [loc_coords[1], loc_coords[0], loc_coords[3], loc_coords[2]], axis=2\n )\n loc_prob = _op.reshape(loc_prob, [batch_size, anchor_boxes*4])\n\n # anchor coords are in yxhw format\n # need to convert to ltrb\n anchor_coords = _op.split(anchor_expr, 4, axis=1)\n anchor_y = anchor_coords[0]\n anchor_x = anchor_coords[1]\n anchor_h = anchor_coords[2]\n anchor_w = anchor_coords[3]\n plus_half = _expr.const(0.5, dtype='float32')\n minus_half = _expr.const(-0.5, dtype='float32')\n anchor_l = _op.add(anchor_x, _op.multiply(anchor_w, minus_half))\n anchor_r = _op.add(anchor_x, _op.multiply(anchor_w, plus_half))\n anchor_t = _op.add(anchor_y, _op.multiply(anchor_h, minus_half))\n anchor_b = _op.add(anchor_y, _op.multiply(anchor_h, plus_half))\n anchor_expr = _op.concatenate([anchor_l, anchor_t, anchor_r, anchor_b], axis=1)\n anchor_expr = _op.expand_dims(anchor_expr, 0)\n\n # attributes for multibox_transform_loc\n multibox_transform_loc_attrs = {}\n multibox_transform_loc_attrs[\"clip\"] = False\n multibox_transform_loc_attrs[\"threshold\"] = custom_options[\"nms_score_threshold\"]\n multibox_transform_loc_attrs[\"variances\"] = (\n 1 / custom_options[\"x_scale\"],\n 1 / custom_options[\"y_scale\"],\n 1 / custom_options[\"w_scale\"],\n 1 / custom_options[\"h_scale\"],\n )\n\n # attributes for non_max_suppression\n non_max_suppression_attrs = {}\n non_max_suppression_attrs[\"return_indices\"] = False\n non_max_suppression_attrs[\"iou_threshold\"] = custom_options[\"nms_iou_threshold\"]\n non_max_suppression_attrs[\"force_suppress\"] = False\n non_max_suppression_attrs[\"top_k\"] = anchor_boxes\n non_max_suppression_attrs[\"max_output_size\"] = custom_options[\"max_detections\"]\n non_max_suppression_attrs[\"invalid_to_bottom\"] = False\n\n ret = _op.vision.multibox_transform_loc(cls_pred, loc_prob,\n anchor_expr, **multibox_transform_loc_attrs)\n ret = _op.vision.non_max_suppression(ret[0], ret[1], **non_max_suppression_attrs)\n ret = _op.vision.get_valid_counts(ret, 0)\n valid_count = ret[0]\n # keep only the top 'max_detections' rows\n ret = _op.strided_slice(ret[1],\n [0, 0, 0],\n [batch_size, custom_options[\"max_detections\"], anchor_boxes])\n # the output needs some reshaping to match tflite\n ret = _op.split(ret, 6, axis=2)\n cls_ids = _op.reshape(ret[0], [batch_size, -1])\n scores = _op.reshape(ret[1], [batch_size, -1])\n boxes = _op.concatenate([ret[3], ret[2], ret[5], ret[4]], axis=2)\n ret = _expr.TupleWrapper(_expr.Tuple([boxes, cls_ids, scores, valid_count]), size=4)\n return ret\n\n def get_expr(self, input_tensor_idx):\n return self.exp_tab.get_expr(get_tensor_name(self.subgraph, input_tensor_idx))\n\n def has_expr(self, input_tensor_idx):\n return self.exp_tab.has_expr(get_tensor_name(self.subgraph, input_tensor_idx))\n\n def get_tensor_expr(self, tensor):\n \"\"\" Returns constant expr for constant else a tensor expr\"\"\"\n if self.has_expr(tensor.tensor_idx):\n # In most cases, we can assume that TOCO fuses elemwise operators\n # with constants - it means both will be tensors.\n expr = self.get_expr(tensor.tensor_idx)\n else:\n # However, in some corner cases, the elemwise operator is not fused,\n # we can receive as constant.\n type_str = self.get_tensor_type_str(tensor.tensor.Type())\n expr = self.exp_tab.new_const(self.get_tensor_value(tensor), dtype=type_str)\n\n return expr\n\n\ndef get_scalar_from_constant(expr):\n \"\"\" Returns scalar value from Relay constant scalar. \"\"\"\n assert isinstance(expr, _expr.Constant) and not expr.data.shape, \\\n \"Expr is not a constant scalar.\"\n value = expr.data.asnumpy()\n assert value.dtype == np.dtype(np.int32) or value.dtype == np.dtype(np.float32), \\\n \"value must be float32/int32\"\n return np.asscalar(value)\n\n\ndef build_str_map(obj):\n \"\"\"Build string map of TFLite enum int value\n\n Parameters\n ----------\n obj:\n TFLite class which contains enum int value, such as BuiltInOptions\n\n Returns\n -------\n String representation map of TFLite class enum int value\n \"\"\"\n ret = {}\n for field_name in dir(obj):\n if not field_name.startswith('_'):\n field_value = getattr(obj, field_name)\n if isinstance(field_value, int):\n ret[field_value] = field_name\n return ret\n\n# SAME padding: https://www.tensorflow.org/api_guides/python/nn\ndef get_pad_value(data, kernel, stride):\n \"\"\"Get the pad tuple of value for SAME padding\n\n Parameters\n ----------\n data:\n 1D input data\n\n kernel:\n 1D input kernel\n\n stride:\n 1D input stride\n\n Returns\n -------\n pad tuple of value\n \"\"\"\n\n out = int(math.ceil(float(data) / float(stride)))\n pad = max(0, (out - 1) * stride + kernel - data)\n pad_before = pad // 2\n pad_after = pad - pad_before\n return pad_before, pad_after\n\n\ndef get_tensor_name(subgraph, tensor_idx):\n \"\"\"Get the tensor name.\n\n Parameters\n ----------\n subgraph:\n tflite.Subgraph.Subgraph\n\n tensor:\n tensor index in subgraph\n\n Returns\n -------\n tensor name in UTF-8 encoding\n \"\"\"\n return subgraph.Tensors(tensor_idx).Name().decode(\"utf-8\")\n\n\ndef from_tflite(model, shape_dict, dtype_dict):\n \"\"\"Convert from tflite model into compatible relay Function.\n\n Parameters\n ----------\n model:\n tflite.Model or tflite.Model.Model (depending on tflite version)\n\n shape_dict : dict of str to int list/tuple\n Input shapes of the model.\n\n dtype_dict : dict of str to str\n Input types of the model.\n\n Returns\n -------\n mod : tvm.IRModule\n The relay module for compilation.\n\n params : dict of str to tvm.nd.NDArray\n The parameter dict to be used by relay\n \"\"\"\n try:\n import tflite.SubGraph\n import tflite.BuiltinOperator\n except ImportError:\n raise ImportError(\"The tflite package must be installed\")\n\n # TFLite.Model.Model has changed to TFLite.Model from 1.14 to 2.1\n try:\n import tflite\n assert isinstance(model, tflite.Model)\n except TypeError:\n import tflite.Model\n assert isinstance(model, tflite.Model.Model)\n\n # keep the same as tflite\n assert model.SubgraphsLength() == 1, \"only support one subgraph (main subgraph)\"\n subgraph = model.Subgraphs(0)\n\n # model inputs / outputs\n model_inputs = subgraph.InputsAsNumpy()\n model_outputs = subgraph.OutputsAsNumpy()\n\n exp_tab = ExprTable()\n for model_input in model_inputs:\n model_input_name = get_tensor_name(subgraph, model_input)\n shape = shape_dict[model_input_name] if model_input_name in shape_dict else None\n dtype = dtype_dict[model_input_name] if model_input_name in dtype_dict else \"float32\"\n exp_tab.set_expr(model_input_name, _expr.var(model_input_name, shape=shape, dtype=dtype))\n\n # op code in model\n op_converter = OperatorConverter(model, subgraph, exp_tab)\n op_converter.check_unsupported_ops()\n op_converter.convert_op_to_relay()\n\n # params and outputs\n params = {k:_nd.array(np.array(v)) for k, v in exp_tab.params.items()}\n outputs = [exp_tab.get_expr(get_tensor_name(subgraph, i)) for i in model_outputs]\n outputs = outputs[0] if len(outputs) == 1 else _expr.Tuple(outputs)\n func = _function.Function(analysis.free_vars(outputs), outputs)\n mod = IRModule.from_expr(func)\n return mod, params\n" ]

[ [ "numpy.asscalar", "numpy.cumsum", "numpy.dtype", "numpy.prod", "numpy.transpose", "numpy.array" ] ]

illdopejake/data_driven_pathology

[ "489e2d7dc8b6b7e459a56b70a95317b1619e31b7" ]

[ "CrossDecomp.py" ]

[ "import pandas\nimport numpy as np\nimport scipy.stats as stats\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\n\ndef evaluate_components(clf, x, y, n_iterations=500, check = 100,\n evaluate = True, plot = True, thr = 0.95,\n metric=None, random_state=123):\n \n if type(x) != type(pandas.DataFrame()):\n x = pandas.DataFrame(x)\n \n # fit model\n clf.fit(x,y)\n n_comps = clf.n_components\n \n # prepare output\n results = pandas.DataFrame(index = range(n_comps * (n_iterations+1)),\n columns = ['score', 'component', 'model'])\n results.loc[:,'component'] = list(range(n_comps))*(n_iterations+1)\n results.loc[range(n_comps),'model'] = ['True']*n_comps\n results.loc[range(n_comps,n_comps*(n_iterations+1)), 'model'\n ] = ['Null']*(n_comps*n_iterations)\n if not metric:\n \ttrue_scores = [stats.pearsonr(clf.x_scores_[:,x], clf.y_scores_[:,x]\n )[0]**2 for x in range(n_comps)]\n else:\n true_scores = [metric(clf.x_scores_[:,x], clf.y_scores_[:,x]\n ) for x in range(n_comps)]\n results.loc[results[results.model=='True'].index,'score'] = true_scores\n \n k = clf.n_components\n # permute and refit model\n rs = np.random.RandomState(random_state)\n x.index = range(len(x.index))\n for i in range(n_iterations):\n new_ind = rs.permutation(x.index)\n new_x = x.iloc[new_ind]\n newmod = clf.fit(new_x,y)\n if not metric:\n new_scores = [stats.pearsonr(newmod.x_scores_[:,x], \n newmod.y_scores_[:,x]\n )[0]**2 for x in range(n_comps)]\n else:\n new_scores = [metric(newmod.x_scores_[:,x], newmod.y_scores_[:,x]\n ) for x in range(n_comps)]\n results.loc[range(k, k+n_comps), 'score'] = new_scores\n if check:\n if i % check == 0:\n print('finished iteration',i)\n \n k += n_comps\n \n if evaluate:\n if plot:\n cr = display_results(results, thr)\n else:\n cr = display_results(results, thr, False)\n \n return results, cr\n\ndef display_results(results, thr = 0.95, plot=True):\n \n if plot:\n # plot components\n sns.set_context('paper')\n plt.close()\n sns.catplot(x='component', y = 'score', hue='model', data=results,kind='point')\n plt.show()\n \n # get p-values\n comp_results = pandas.DataFrame(index=results.component.unique(),\n columns = ['r','p','sig'])\n for i in results.component.unique():\n nullz = results[(results.component==i) & (results.model=='Null')\n ]['score'].sort_values().values\n real = results[(results.component==i) & (results.model=='True')]['score'].values[0]\n comp_results.loc[i,'r'] = real\n p = (len(nullz[nullz>real])+1) / len(nullz)\n if p < (1 - thr):\n comp_results.loc[i,['p','sig']] = [p, 1]\n print('component %s: p = %s ***'%(i,p))\n else:\n comp_results.loc[i,['p','sig']] = [p, 0]\n print('component %s: p = %s'%(i,p))\n \n \n return comp_results\n\n\ndef bootstrap_features(clf, fit_model, X, y, n_iterations=500, check = 100, on ='x'):\n \n if type(X) != type(pandas.DataFrame()):\n X = pandas.DataFrame(X)\n if type(y) != type(pandas.DataFrame()):\n y = pandas.DataFrame(y)\n\n # fit model\n orig = fit_model\n\n # prepare output\n n_feats_x = X.shape[-1]\n n_feats_y = y.shape[-1]\n all_results_x = {}\n all_results_y = {}\n\n for i in range(orig.n_components):\n results = pandas.DataFrame(index = range(n_iterations), columns = range(n_feats_x))\n all_results_x.update({i: results})\n results = pandas.DataFrame(index = range(n_iterations), columns = range(n_feats_y))\n all_results_y.update({i: results})\n bs_ratio_x = pandas.DataFrame(index = range(orig.n_components), \n columns = range(n_feats_x))\n bs_ratio_y = pandas.DataFrame(index = range(orig.n_components), \n columns = range(n_feats_y))\n\n # bootstrap\n for i in range(n_iterations):\n n_ind = np.random.choice(X.index, len(X.index))\n n_samp = pandas.DataFrame(X.loc[n_ind],copy=True)\n ny = pandas.DataFrame(y.loc[n_ind],copy=True)\n newmod = clf.fit(n_samp,ny)\n for c in range(orig.n_components):\n xcorrs = [stats.pearsonr(orig.x_loadings_[:,c],\n newmod.x_loadings_[:,x])[0]**2 for x in range(orig.n_components)]\n closest = np.argmax(xcorrs)\n # account for possible inversion\n if stats.pearsonr(orig.x_loadings_[:,c],\n newmod.x_loadings_[:,closest])[0] < 0:\n new_loadingsX = newmod.x_loadings_[:,closest] * -1\n new_loadingsy = newmod.y_loadings_[:,closest] * -1\n else:\n new_loadingsX = newmod.x_loadings_[:,closest]\n new_loadingsy = newmod.y_loadings_[:,closest]\n\n all_results_x[c].loc[i] = new_loadingsX\n all_results_y[c].loc[i] = new_loadingsy\n if check:\n if i % check == 0:\n print('finished iteration',i)\n\n # calculate bootstrap ratio\n bs_ratio_x = bootstrap_ratio(all_results_x, bs_ratio_x)\n bs_ratio_y = bootstrap_ratio(all_results_y, bs_ratio_y)\n \n return bs_ratio_x, bs_ratio_y, all_results_x, all_results_y\n\ndef bootstrap_ratio(all_results, bs_ratio):\n\n all_stats = {'mean': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns),\n 'se': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns),\n 'bsr': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns),\n 'p': pandas.DataFrame(index = bs_ratio.index, columns = bs_ratio.columns)}\n \n for i,res in all_results.items():\n mn = res.mean()\n sem = res.sem()\n all_stats['bsr'].loc[i] = mn / sem\n all_stats['mean'].loc[i] = mn\n all_stats['se'].loc[i] = sem\n ps = []\n for x in range(res.shape[-1]):\n jnk = res.values[:,x]\n if mn[x] > 0:\n p = (len(jnk[jnk<0])+1) / len(jnk)\n else:\n p = (len(jnk[jnk>0])+1) / len(jnk)\n ps.append(p)\n all_stats['p'].loc[i] = ps\n \n \n return all_stats\n\n \n" ]

[ [ "scipy.stats.pearsonr", "pandas.DataFrame", "numpy.argmax", "matplotlib.pyplot.close", "numpy.random.RandomState", "matplotlib.pyplot.show" ] ]

trumanw/ESP_DNN

[ "26b08787dc2836fac3c50559447ebaa56c2c8277" ]

[ "esp_dnn/graph_conv.py" ]

[ "# Copyright 2019 Astex Therapeutics Ltd.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom __future__ import absolute_import\n\nfrom keras import activations, initializers, regularizers, constraints\nfrom keras import backend as K\nfrom keras.constraints import min_max_norm\nfrom keras.engine.topology import Layer, InputSpec\nimport tensorflow as tf\n\n\nclass PrintLayerInput(Layer):\n def call(self, inputs):\n inputs = tf.Print(inputs, data=[inputs],\n message=\"layer inputs: \", summarize=100)\n return inputs\n\n\nclass GraphConv(Layer):\n\n def __init__(self,\n width,\n activation=None,\n use_bias=True,\n kernel_initializer=\"glorot_uniform\",\n bias_initializer=\"zeros\",\n kernel_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n kernel_constraint=None,\n bias_constraint=None,\n # \"single\": only one weight applied to all neighbor sums\n # \"all\": a different weight for each property\n conv_wts=\"single\",\n **kwargs):\n\n if \"input_shape\" not in kwargs and \"input_dim\" in kwargs:\n kwargs[\"input_shape\"] = (kwargs.pop(\"input_dim\"),)\n\n allowed_conv_wts = (\"all\", \"single\")\n if conv_wts not in allowed_conv_wts:\n raise ValueError(\"conv_wt should be one of %r\" % allowed_conv_wts)\n\n super(GraphConv, self).__init__(**kwargs)\n\n self.width = width\n self.conv_wts = conv_wts\n\n self.activation = activations.get(activation)\n self.use_bias = use_bias\n self.kernel_initializer = initializers.get(kernel_initializer)\n self.bias_initializer = initializers.get(bias_initializer)\n self.kernel_regularizer = regularizers.get(kernel_regularizer)\n self.bias_regularizer = regularizers.get(bias_regularizer)\n self.activity_regularizer = regularizers.get(activity_regularizer)\n self.kernel_constraint = constraints.get(kernel_constraint)\n self.bias_constraint = constraints.get(bias_constraint)\n self.input_spec = [InputSpec(ndim=3), InputSpec(ndim=3)]\n\n def build(self, input_shapes):\n X_shape = input_shapes[0]\n # number of atom props * output width\n kernel_shape = (X_shape[-1], self.width)\n\n # atom (self) weights\n self.kernel_dense = self.add_weight(shape=kernel_shape,\n initializer=self.kernel_initializer,\n name=\"dense_kernel\",\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint)\n if self.use_bias is not None:\n self.bias = self.add_weight(shape=(self.width,),\n initializer=self.bias_initializer,\n name=\"bias\",\n regularizer=self.bias_regularizer,\n constraint=self.bias_constraint)\n else:\n self.bias = None\n\n constraint = min_max_norm(\n min_value=0.0, max_value=1.0, rate=1.0, axis=0)\n if self.conv_wts == \"single\":\n self.kernel_neigh = self.add_weight(shape=[1],\n initializer=self.kernel_initializer,\n name=\"kernel_neigh\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n self.kernel_self = self.add_weight(shape=[1],\n initializer=self.kernel_initializer,\n name=\"kernel_self\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n elif self.conv_wts == \"all\":\n self.kernel_neigh = self.add_weight(shape=(self.width,),\n initializer=self.kernel_initializer,\n name=\"kernel_neigh\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n self.kernel_self = self.add_weight(shape=(self.width,),\n initializer=self.kernel_initializer,\n name=\"kernel_neigh\",\n regularizer=self.kernel_regularizer,\n constraint=constraint)\n\n self.built = True\n\n def call(self, inputs):\n x = inputs[0] # n_atom * n_props\n d = inputs[1] # [n_atoms, n_atoms]\n\n self_output = K.dot(x, self.kernel_dense)\n # sum values from the neighbors\n neigh_output = K.batch_dot(d, self_output, axes=[2, 1])\n\n if self.conv_wts == \"single\":\n neigh_output = neigh_output * self.kernel_neigh[0]\n self_output = self_output * self.kernel_self[0]\n elif self.conv_wts == \"all\":\n neigh_output = neigh_output * self.kernel_neigh\n self_output = self_output * self.kernel_self\n\n output = self_output + neigh_output\n if self.use_bias is not None:\n output += K.reshape(self.bias, (1, self.width))\n output = self.activation(output)\n return output\n\n def compute_output_shape(self, input_shape):\n return (input_shape[0][0], input_shape[0][1], self.width)\n\n def get_config(self):\n config = {\n \"width\": self.width,\n \"conv_wts\": self.conv_wts,\n \"activation\": activations.serialize(self.activation),\n \"use_bias\": self.use_bias,\n \"kernel_initializer\": initializers.serialize(self.kernel_initializer),\n \"bias_initializer\": initializers.serialize(self.bias_initializer),\n \"kernel_regularizer\": regularizers.serialize(self.kernel_regularizer),\n \"bias_regularizer\": regularizers.serialize(self.bias_regularizer),\n \"activity_regularizer\": regularizers.serialize(self.activity_regularizer),\n \"kernel_constraint\": constraints.serialize(self.kernel_constraint),\n \"bias_constraint\": constraints.serialize(self.bias_constraint)\n }\n base_config = super(GraphConv, self).get_config()\n return dict(list(base_config.items()) + list(config.items()))\n" ]

[ [ "tensorflow.Print" ] ]

remz1337/DataFrame

[ "e5aa82854a56201d75ed87cdc1f5b4059409ef8d" ]

[ "test/pandas_performance.py" ]

[ "import numpy as np\nimport pandas as pd\n\n# ------------------------------------------------------------------------------\n\ntimestamps = pd.date_range(\"1970-01-01\", \"2019-08-15\", freq='S')\ndf = pd.DataFrame({\"timestamp\": timestamps,\n \"normal\": np.random.normal(size=len(timestamps)),\n \"log_normal\": np.random.lognormal(size=len(timestamps)),\n \"exponential\": np.random.exponential(size=len(timestamps)),\n })\ndf.set_index(\"timestamp\")\n\nprint(\"All memory allocations are done. Calculating means ...\")\n\ndf[\"normal\"].mean()\ndf[\"log_normal\"].mean()\ndf[\"exponential\"].mean()\n\n# ------------------------------------------------------------------------------\n\n# Local Variables:\n# mode:Python\n# tab-width:4\n# c-basic-offset:4\n# End:\n" ]

[ [ "pandas.date_range" ] ]

Shall-Chee/Vision-based-Vehicle-Detection-and-Tracking

[ "dff14e34779f142daa3254934f1e001e0777733f" ]

[ "iou.py" ]

[ "'''\nCombining detector and tracker\ntracker can track multiple object in the video\n'''\nimport numpy as np\nimport json\nfrom utils import *\nfrom constant import *\n\nfrom constant import t_min\n\nfrom ast import literal_eval\n\ndef overlap(box1, box2):\n '''\n check the overlap of two boxes\n @param\n box: shape(4,) ndarray, [x, y, w, h]\n\n @return\n ratio: intersection / union\n '''\n x1, y1, w1, h1 = box1\n x2, y2, w2, h2 = box2\n\n # compute each box's area\n s1 = w1 * h1\n s2 = w2 * h2\n\n # compute intersection\n left = min(x1, x2)\n right = max(x1 + w1, x2 + w2)\n w = w1 + w2 - (right - left)\n\n up = min(y1, y2)\n down = max(y1 + h1, y2 + h2)\n h = h1 + h2 - (down - up)\n\n if w <= 0 or h <= 0:\n return 0\n else:\n intersect = w * h\n union = s1 + s2 - intersect\n ratio = intersect / union\n return ratio\n\n\ndef update_track_object(detections, iou_ratio):\n '''\n IOU tracker\n https://ieeexplore.ieee.org/document/8078516\n\n @param:\n detections: list of detections per frame\n iou_ratio: iou threshold\n\n @return:\n track_finished: list of track\n '''\n tracks_active = []\n tracks_finished = []\n for frame_idx, dets_per_frame in enumerate(detections, start = 1):\n for trk_a in tracks_active:\n if len(dets_per_frame) > 0:\n iou = [overlap(trk_a['boxes'][-1], det) for det in dets_per_frame]\n iou = np.array(iou)\n det_best_idx = np.argmax(iou)\n det_best = dets_per_frame[det_best_idx]\n if overlap(trk_a['boxes'][-1], det_best) >= iou_ratio:\n # add d_best to t_i\n trk_a['boxes'].append(det_best)\n # remove d_best from dets_per_frame\n dets_per_frame.pop(det_best_idx)\n else:\n # finish track when min # of matches is hit\n if len(trk_a['boxes']) >= t_min:\n tracks_finished.append(trk_a)\n tracks_active.remove(trk_a)\n \n # start new track with new detection and insert into tracks_active\n new_tracks = [{'boxes': [det], 'start frame': frame_idx} for det in dets_per_frame]\n tracks_active += new_tracks\n \n # finish all remaining active tracks\n tracks_finished += [trk_a for trk_a in tracks_active if len(trk_a['boxes']) >= t_min]\n\n return tracks_finished\n\nif __name__ == \"__main__\":\n # read detections\n detections = []\n with open('export/file.txt') as f:\n for line in f:\n line = line.rstrip()\n line = literal_eval(line)\n detections.append(line)\n \n track_object = update_track_object(detections, 0.15)\n\n with open('export/object.txt', 'w') as f:\n for t in track_object:\n json.dump(t, f)\n f.write('\\n')\n \n" ]

[ [ "numpy.array", "numpy.argmax" ] ]

vodev/vocloud-RDF

[ "a98468cfe7e805e12ba14218b2508936143ba6d3" ]

[ "data_set_handler.py" ]

[ "import io\nimport os\n\nimport pandas as pd\nimport pyfits\nfrom astropy.io.votable import parse\nfrom astropy.io.votable.tree import VOTableFile, Resource, Table, Field\nfrom sklearn.cross_validation import StratifiedKFold, KFold\nfrom sklearn.cross_validation import train_test_split\n\n\ndef load_header(uri):\n votable = parse(uri)\n table = votable.get_table_by_index(0)\n values = table.array[0][1].tolist()\n return [str(value) for value in values] + [\"class\"]\n\n\ndef load_set(uri, format='csv', header=None, delimiter=','):\n print(str(header))\n return pd.read_csv(uri, header=None, names=header, sep=None, dtype=None,\n na_values='?', skipinitialspace=True)\n\n\ndef _to_votable(data, file_name):\n votable = VOTableFile()\n resource = Resource()\n votable.resources.append(resource)\n table = Table(votable)\n resource.tables.append(table)\n columns = data.columns\n if data.columns[-1] == 'class':\n columns = columns[:-1]\n fields = [\n Field(votable, name=\"intensities\", datatype=\"double\", arraysize='*')]\n table.fields.extend(fields)\n table.create_arrays(1)\n table.array[0] = columns.tolist()\n votable.to_xml(file_name)\n\n\ndef _write_csv(data, uri, header=None, separator=',', dtypes=None):\n with io.open(uri, 'w', encoding='utf-8') as out:\n if header is not None:\n _to_votable(header,\n \"meta.xml\")\n\n for row in data:\n rec_num = 0\n for record in row:\n val = record\n if (dtypes is not None and 'int' in str(dtypes[rec_num])):\n val = int(val)\n elif (dtypes is not None and 'float' in str(dtypes[rec_num])):\n val = float(val)\n out.write(str(val))\n if (rec_num != len(row) - 1):\n out.write(separator)\n rec_num += 1\n out.write('\\n')\n\n\ndef _parse_fits(uri):\n fits = pyfits.open(uri, memmap=False)\n dat = fits[1].data\n fits.close()\n return dat.tolist()\n\n\ndef split_train_set(uri, label=-1, ratio=0.67, sep=',', header=None):\n header_num = None if not header else 0\n array = pd.read_csv(uri, delimiter=sep, skipinitialspace=True,\n na_values=['?'])\n train, test = train_test_split(array.values, train_size=ratio)\n base_name, ext = os.path.splitext(os.path.basename(uri))\n directory = os.path.dirname(uri)\n train_name = directory + base_name + '_train' + ext\n test_name = directory + base_name + '_score' + ext\n _write_csv(train, train_name, separator=sep, header=None)\n _write_csv(test, test_name, separator=sep, header=None)\n return (train_name, test_name)\n\n\ndef create_xvalidation_files(data_uri, data_conf, header, configuration,\n target=None, base_folder='./result/xvalidation'):\n df = pd.read_csv(data_uri, sep=None, header=None, names=header,\n skipinitialspace=True, na_values=['?'])\n kfold = None\n labels = df[target].values\n folds = configuration['folds']\n if (target is not None):\n kfold = StratifiedKFold(labels, folds)\n else:\n kfold = KFold(n=len(labels), n_folds=folds)\n\n if not os.path.exists(base_folder):\n os.makedirs(os.path.abspath(base_folder))\n i = 1\n uris = []\n for train, test in kfold:\n train_uri = base_folder + '/train_' + str(i)\n test_uri = base_folder + '/test_' + str(i)\n _write_csv(df.values[train], train_uri, header=header, dtypes=df.dtypes)\n _write_csv(df.values[test], test_uri, header=header, dtypes=df.dtypes)\n uris.append((train_uri, test_uri))\n i += 1\n return uris\n" ]

[ [ "sklearn.cross_validation.train_test_split", "pandas.read_csv", "sklearn.cross_validation.StratifiedKFold" ] ]

matthewlchambers/flowsa

[ "97fdab9250d205bfd8d9341e3b62cc464bc854c7" ]

[ "flowsa/data_source_scripts/StatCan_LFS.py" ]

[ "# Stat_Canada.py (flowsa)\n# !/usr/bin/env python3\n# coding=utf-8\n\n\"\"\"\nLabour force characteristics by industry, annual (x 1,000)\nHow to cite: Statistics Canada. Table 14-10-0023-01 Labour\nforce characteristics by industry, annual (x 1,000)\nDOI: https://doi.org/10.25318/1410002301-eng\n\"\"\"\n\nimport io\nimport zipfile\nimport pycountry\nimport pandas as pd\nfrom flowsa.common import WITHDRAWN_KEYWORD\n\n\ndef sc_lfs_call(*, resp, **_):\n \"\"\"\n Convert response for calling url to pandas dataframe, begin parsing df\n into FBA format\n :param resp: df, response from url call\n :return: pandas dataframe of original source data\n \"\"\"\n # Convert response to dataframe\n # read all files in the stat canada zip\n with zipfile.ZipFile(io.BytesIO(resp.content), \"r\") as f:\n # read in file names\n for name in f.namelist():\n # if filename does not contain \"MetaData\", then create dataframe\n if \"MetaData\" not in name:\n data = f.open(name)\n df = pd.read_csv(data, header=0)\n return df\n\n\ndef sc_lfs_parse(*, df_list, **_):\n \"\"\"\n Combine, parse, and format the provided dataframes\n :param df_list: list of dataframes to concat and format\n :return: df, parsed and partially formatted to flowbyactivity\n specifications\n \"\"\"\n # concat dataframes\n df = pd.concat(df_list, sort=False)\n # drop columns\n df = df.drop(columns=['COORDINATE', 'DECIMALS', 'DGUID', 'SYMBOL',\n 'TERMINATED', 'UOM_ID', 'SCALAR_ID', 'VECTOR'])\n # rename columns\n df = df.rename(columns={'GEO': 'Location',\n 'North American Industry Classification System '\n '(NAICS)': 'Description',\n 'REF_DATE': 'Year',\n 'STATUS': 'Spread',\n 'VALUE': \"FlowAmount\",\n 'Labour force characteristics': 'FlowName'})\n # limit data to pull\n df = df[df['Location'] == 'Canada']\n df = df[df['Sex'] == 'Both sexes']\n df = df[df['Age group'] == '15 years and over']\n df = df[df['FlowName'] == 'Employment'].reset_index(drop=True)\n df.loc[:, 'FlowAmount'] = df['FlowAmount'] * 10000\n df.loc[:, 'Unit'] = 'p'\n df = df.drop(columns=['Sex', 'Age group', 'UOM', 'SCALAR_FACTOR'])\n # extract NAICS as activity column. rename activity based on flowname\n df['Activity'] = df['Description'].str.extract('.*\\[(.*)\\].*')\n df.loc[df['Description'] == 'Total, all industries', 'Activity'] = '31-33'\n df.loc[df['Description'] ==\n 'Other manufacturing industries', 'Activity'] = 'Other'\n df['FlowName'] = df['FlowName'].str.strip()\n df.loc[df['FlowName'] == 'Water intake',\n 'ActivityConsumedBy'] = df['Activity']\n df.loc[df['FlowName'].isin(['Water discharge', \"Water recirculation\"]),\n 'ActivityProducedBy'] = df['Activity']\n # drop columns used to create unit and activity columns\n df = df.drop(columns=['Activity'])\n # Modify the assigned RSD letter values to numeric value\n df.loc[df['Spread'] == 'A', 'Spread'] = 2.5 # given range: 0.01 - 4.99%\n df.loc[df['Spread'] == 'B', 'Spread'] = 7.5 # given range: 5 - 9.99%\n df.loc[df['Spread'] == 'C', 'Spread'] = 12.5 # given range: 10 - 14.99%\n df.loc[df['Spread'] == 'D', 'Spread'] = 20 # given range: 15 - 24.99%\n df.loc[df['Spread'] == 'E', 'Spread'] = 37.5 # given range:25 - 49.99%\n df.loc[df['Spread'] == 'F', 'Spread'] = 75 # given range: > 49.99%\n df.loc[df['Spread'] == 'x', 'Spread'] = WITHDRAWN_KEYWORD\n # hard code data\n df['Class'] = 'Employment'\n df['SourceName'] = 'StatCan_LFS'\n # temp hardcode canada iso code\n df['Location'] = call_country_code('Canada')\n df['LocationSystem'] = \"ISO\"\n df[\"MeasureofSpread\"] = 'RSD'\n df[\"DataReliability\"] = 3\n df[\"DataCollection\"] = 4\n return df\n\n\ndef call_country_code(country):\n \"\"\"\n Determine country code, use pycountry to call on 3 digit iso country code\n :param country: str, country name\n :return: str, country code\n \"\"\"\n country_info = pycountry.countries.get(name=country)\n country_numeric_iso = country_info.numeric\n return country_numeric_iso\n" ]

[ [ "pandas.concat", "pandas.read_csv" ] ]

mlindauer/SMAC3

[ "9e871f61d72c789c0c0a25f1ddbcbb39621cfe74" ]

[ "test/test_smbo/test_acquisition.py" ]

[ "import unittest\n\nimport numpy as np\n\nfrom smac.smbo.acquisition import EI\n\n\nclass MockModel(object):\n def __init__(self, num_targets=1):\n self.num_targets = num_targets\n\n def predict_marginalized_over_instances(self, X):\n return np.array([np.mean(X, axis=1).reshape((1, -1))] *\n self.num_targets).reshape((-1, 1)), \\\n np.array([np.mean(X, axis=1).reshape((1, -1))] *\n self.num_targets).reshape((-1, 1))\n\n\nclass TestEI(unittest.TestCase):\n def setUp(self):\n self.model = MockModel()\n self.ei = EI(self.model)\n\n def test_1xD(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[1.0, 1.0, 1.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (1, 1))\n self.assertAlmostEqual(acq[0][0], 0.3989422804014327)\n\n def test_NxD(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[0.0, 0.0, 0.0],\n [0.1, 0.1, 0.1],\n [1.0, 1.0, 1.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (3, 1))\n self.assertAlmostEqual(acq[0][0], 0.0)\n self.assertAlmostEqual(acq[1][0], 0.90020601136712231)\n self.assertAlmostEqual(acq[2][0], 0.3989422804014327)\n\n def test_1x1(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[1.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (1, 1))\n self.assertAlmostEqual(acq[0][0], 0.3989422804014327)\n\n def test_Nx1(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[0.0001],\n [1.0],\n [2.0]])\n acq = self.ei(X)\n self.assertEqual(acq.shape, (3, 1))\n self.assertAlmostEqual(acq[0][0], 0.9999)\n self.assertAlmostEqual(acq[1][0], 0.3989422804014327)\n self.assertAlmostEqual(acq[2][0], 0.19964122837424575)\n\n def test_zero_variance(self):\n self.ei.update(model=self.model, eta=1.0)\n X = np.array([[0.0]])\n acq = np.array(X)\n self.assertAlmostEqual(acq[0][0], 0.0)\n" ]

[ [ "numpy.array", "numpy.mean" ] ]

AdamMiltonBarker/AI-Classification

[ "67a0a9d4ec1636014d51e404b23c5b2ecc8ea149" ]

[ "Projects/2/Classes/Model.py" ]

[ "############################################################################################\n#\n# Project: Peter Moss COVID-19 AI Research Project\n# Repository: AI-Classification\n# Repo Project: COVID-19 Tensorflow DenseNet Classifier\n#\n# Author: Adam Milton-Barker (AdamMiltonBarker.com)\n# Contributors:\n# Title: Model Class\n# Description: Model functions for the COVID-19 Tensorflow DenseNet Classifier.\n# License: MIT License\n# Last Modified: 2020-06-28\n#\n############################################################################################\n\nimport cv2\nimport json\nimport requests\nimport time\n\nimport tensorflow as tf\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom sklearn.metrics import confusion_matrix\n\nfrom Classes.Helpers import Helpers\n\n\nclass Model():\n \"\"\" Model Class\n\n Model functions for the COVID-19 Tensorflow DenseNet Classifier.\n \"\"\"\n\n def __init__(self):\n \"\"\" Initializes the class. \"\"\"\n\n self.Helpers = Helpers(\"Model\", False)\n\n self.Helpers.logger.info(\n \"Model class initialization complete.\")\n\n def do_model(self, data):\n\n self.Data = data\n\n inp = tf.keras.Input(shape=(self.Helpers.confs[\"data\"][\"dim\"], self.Helpers.confs[\"data\"][\"dim\"],\n self.Helpers.confs[\"data\"][\"channels\"]))\n\n net = tf.keras.layers.Conv2D(3, (3, 3), padding='same')(inp)\n\n dnet = tf.keras.applications.DenseNet121(\n weights='imagenet', include_top=False)\n net = dnet(net)\n\n net = tf.keras.layers.GlobalAveragePooling2D()(net)\n net = tf.keras.layers.BatchNormalization()(net)\n net = tf.keras.layers.Dropout(\n self.Helpers.confs[\"model\"][\"dropout\"])(net)\n net = tf.keras.layers.Dense(256, activation='relu')(net)\n net = tf.keras.layers.BatchNormalization()(net)\n net = tf.keras.layers.Dropout(\n self.Helpers.confs[\"model\"][\"dropout\"])(net)\n\n preds = tf.keras.layers.Dense(\n 2, activation='softmax', name='root')(net)\n\n self.tfmodel = tf.keras.Model(inp, preds)\n self.tfmodel.summary()\n\n self.Helpers.logger.info(\"Network initialization complete.\")\n\n def do_train(self):\n \"\"\" Trains the network. \"\"\"\n\n self.Helpers.logger.info(\"Using Adam Optimizer.\")\n\n optimizer = tf.keras.optimizers.Adam(lr=self.Helpers.confs[\"model\"][\"lr\"],\n beta_1=self.Helpers.confs[\"model\"][\"beta_1\"],\n beta_2=self.Helpers.confs[\"model\"][\"beta_2\"],\n epsilon=self.Helpers.confs[\"model\"][\"epsilon\"],\n decay=self.Helpers.confs[\"model\"][\"decay\"])\n\n self.tfmodel.compile(loss='categorical_crossentropy',\n optimizer=optimizer, metrics=[tf.keras.metrics.BinaryAccuracy(name='acc'),\n tf.keras.metrics.Precision(\n name='precision'),\n tf.keras.metrics.Recall(\n name='recall'),\n tf.keras.metrics.AUC(name='auc')])\n\n monitor = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_acc',\n factor=self.Helpers.confs[\"model\"][\"factor\"],\n patience=self.Helpers.confs[\"model\"][\"patience\"],\n verbose=1,\n min_lr=self.Helpers.confs[\"model\"][\"min_lr\"])\n\n checkpoint = tf.keras.callbacks.ModelCheckpoint(\n self.Helpers.confs[\"model\"][\"weights\"], verbose=1, save_best_only=True)\n\n self.history = self.tfmodel.fit(self.Data.X_train, self.Data.y_train,\n batch_size=self.Helpers.confs[\"data\"][\"batch\"],\n epochs=self.Helpers.confs[\"model\"][\"epochs\"],\n callbacks=[monitor, checkpoint],\n validation_data=(self.Data.X_test, self.Data.y_test))\n\n print(self.history)\n print(\"\")\n\n self.save_model_as_json()\n self.export_saved_model()\n\n def save_model_as_json(self):\n \"\"\" Saves the model to JSON. \"\"\"\n\n with open(self.Helpers.confs[\"model\"][\"json\"], \"w\") as file:\n file.write(self.tfmodel.to_json())\n\n self.Helpers.logger.info(\n \"Model JSON saved \" + self.Helpers.confs[\"model\"][\"json\"])\n\n def export_saved_model(self):\n \"\"\" Saves the model as TF SavedModel. \"\"\"\n \n tf.keras.models.save_model(\n self.tfmodel, self.Helpers.confs[\"model\"][\"tf\"], save_format=\"tf\")\n\n self.Helpers.logger.info(\n \"TF Model saved to \" + self.Helpers.confs[\"model\"][\"tf\"])\n\n def do_evaluate(self):\n \"\"\" Evaluates the model \"\"\"\n\n self.do_predictions()\n\n metrics = self.tfmodel.evaluate(\n self.Data.X_test, self.Data.y_test, verbose=0)\n for name, value in zip(self.tfmodel.metrics_names, metrics):\n self.Helpers.logger.info(\"Metrics: \" + name + \" \" + str(value))\n print()\n\n self.visualize_metrics()\n self.confusion_matrix()\n self.figures_of_merit()\n\n def do_predictions(self):\n \"\"\" Makes predictions on the train & test sets. \"\"\"\n\n self.train_preds = self.tfmodel.predict(self.Data.X_train)\n self.test_preds = self.tfmodel.predict(self.Data.X_test)\n\n self.Helpers.logger.info(\n \"Training predictions: \" + str(self.train_preds))\n self.Helpers.logger.info(\n \"Testing predictions: \" + str(self.test_preds))\n print(\"\")\n\n def visualize_metrics(self):\n \"\"\" Visualize the metrics. \"\"\"\n\n plt.plot(self.history.history['acc'])\n plt.plot(self.history.history['val_acc'])\n plt.title('Model Accuracy')\n plt.ylabel('Accuracy')\n plt.xlabel('Epoch')\n plt.ylim((0, 1))\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Accuracy.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['loss'])\n plt.plot(self.history.history['val_loss'])\n plt.title('Model Loss')\n plt.ylabel('loss')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Loss.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['auc'])\n plt.plot(self.history.history['val_auc'])\n plt.title('Model AUC')\n plt.ylabel('AUC')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/AUC.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['precision'])\n plt.plot(self.history.history['val_precision'])\n plt.title('Model Precision')\n plt.ylabel('Precision')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Precision.png')\n plt.show()\n plt.clf()\n\n plt.plot(self.history.history['recall'])\n plt.plot(self.history.history['val_recall'])\n plt.title('Model Recall')\n plt.ylabel('Recall')\n plt.xlabel('Epoch')\n plt.legend(['Train', 'Validate'], loc='upper left')\n plt.savefig('Model/Plots/Recall.png')\n plt.show()\n plt.clf()\n\n def confusion_matrix(self):\n \"\"\" Prints/displays the confusion matrix. \"\"\"\n\n self.matrix = confusion_matrix(self.Data.y_test.argmax(axis=1),\n self.test_preds.argmax(axis=1))\n\n self.Helpers.logger.info(\"Confusion Matrix: \" + str(self.matrix))\n print(\"\")\n\n plt.imshow(self.matrix, cmap=plt.cm.Blues)\n plt.xlabel(\"Predicted labels\")\n plt.ylabel(\"True labels\")\n plt.xticks([], [])\n plt.yticks([], [])\n plt.title('Confusion matrix ')\n plt.colorbar()\n plt.savefig('Model/Plots/Confusion-Matrix.png')\n plt.show()\n plt.clf()\n\n def figures_of_merit(self):\n \"\"\" Calculates/prints the figures of merit. \"\"\"\n\n test_len = len(self.Data.X_test)\n\n TP = self.matrix[1][1]\n TN = self.matrix[0][0]\n FP = self.matrix[0][1]\n FN = self.matrix[1][0]\n\n TPP = (TP * 100)/test_len\n FPP = (FP * 100)/test_len\n FNP = (FN * 100)/test_len\n TNP = (TN * 100)/test_len\n\n specificity = TN/(TN+FP)\n\n misc = FP + FN\n miscp = (misc * 100)/test_len\n\n self.Helpers.logger.info(\n \"True Positives: \" + str(TP) + \"(\" + str(TPP) + \"%)\")\n self.Helpers.logger.info(\n \"False Positives: \" + str(FP) + \"(\" + str(FPP) + \"%)\")\n self.Helpers.logger.info(\n \"True Negatives: \" + str(TN) + \"(\" + str(TNP) + \"%)\")\n self.Helpers.logger.info(\n \"False Negatives: \" + str(FN) + \"(\" + str(FNP) + \"%)\")\n\n self.Helpers.logger.info(\"Specificity: \" + str(specificity))\n self.Helpers.logger.info(\n \"Misclassification: \" + str(misc) + \"(\" + str(miscp) + \"%)\")\n\n def load_model_and_weights(self):\n \"\"\" Loads the model and weights. \"\"\"\n\n with open(self.Helpers.confs[\"model\"][\"json\"]) as file:\n m_json = file.read()\n\n self.tfmodel = tf.keras.models.model_from_json(m_json)\n self.tfmodel.load_weights(self.Helpers.confs[\"model\"][\"weights\"])\n\n self.Helpers.logger.info(\"Model loaded \")\n\n self.tfmodel.summary()\n print(\"\")\n\n def test_classifier(self):\n \"\"\" Tests the trained model. \"\"\"\n\n files = 0\n tp = 0\n fp = 0\n tn = 0\n fn = 0\n\n combined = self.Helpers.confs[\"data\"][\"test_0\"] + \\\n self.Helpers.confs[\"data\"][\"test_1\"]\n\n for testFile in combined:\n\n files += 1\n\n img = tf.keras.preprocessing.image.load_img(testFile, grayscale=False,\n target_size=(self.Helpers.confs[\"data\"][\"dim\"],\n self.Helpers.confs[\"data\"][\"dim\"]))\n self.Helpers.logger.info(\"Loaded test image \" + testFile)\n\n prediction = self.get_prediction(img)\n self.Helpers.logger.info(\"Predicted Label: \" + str(prediction[0]))\n\n msg = \"\"\n if prediction[0] == 1 and testFile.find(\"/1/\") != -1:\n tp += 1\n msg = \"COVID-19 correctly detected (True Positive) with confidence: \" + str(prediction[1])\n elif prediction[0] == 1 and testFile.find(\"/0/\") != -1:\n fp += 1\n msg = \"COVID-19 incorrectly detected (False Positive) with confidence: \" + str(prediction[1])\n elif prediction[0] == 0 and testFile.find(\"/0/\") != -1:\n tn += 1\n msg = \"COVID-19 correctly not detected (True Negative) with confidence: \" + str(prediction[1])\n elif prediction[0] == 0 and testFile.find(\"/1/\") != -1:\n fn += 1\n msg = \"COVID-19 incorrectly not detected (False Negative) with confidence: \" + str(prediction[1])\n\n self.Helpers.logger.info(msg)\n\n self.Helpers.logger.info(\"Images Classified: \" + str(files))\n self.Helpers.logger.info(\"True Positives: \" + str(tp))\n self.Helpers.logger.info(\"False Positives: \" + str(fp))\n self.Helpers.logger.info(\"True Negatives: \" + str(tn))\n self.Helpers.logger.info(\"False Negatives: \" + str(fn))\n\n def test_http_classifier(self):\n \"\"\" Tests the trained model. \"\"\"\n\n files = 0\n tp = 0\n fp = 0\n tn = 0\n fn = 0\n\n combined = self.Helpers.confs[\"data\"][\"test_0\"] + \\\n self.Helpers.confs[\"data\"][\"test_1\"]\n\n for testFile in combined:\n\n files += 1\n\n response = self.send_request(testFile)\n\n msg = \"\"\n if response[\"Diagnosis\"] == \"Positive\" and testFile.find(\"/1/\") != -1:\n tp += 1\n msg = \"COVID-19 correctly detected (True Positive) with confidence: \" + str(response[\"Confidence\"])\n elif response[\"Diagnosis\"] == \"Positive\" and testFile.find(\"/0/\") != -1:\n fp += 1\n msg = \"COVID-19 incorrectly detected (False Positive) with confidence: \" + str(response[\"Confidence\"])\n elif response[\"Diagnosis\"] == \"Negative\" and testFile.find(\"/0/\") != -1:\n tn += 1\n msg = \"COVID-19 correctly not detected (True Negative) with confidence: \" + str(response[\"Confidence\"])\n elif response[\"Diagnosis\"] == \"Negative\" and testFile.find(\"/1/\") != -1:\n fn += 1\n msg = \"COVID-19 incorrectly not detected (False Negative) with confidence: \" + str(response[\"Confidence\"])\n\n self.Helpers.logger.info(msg)\n print()\n time.sleep(7)\n\n self.Helpers.logger.info(\"Images Classifier: \" + str(files))\n self.Helpers.logger.info(\"True Positives: \" + str(tp))\n self.Helpers.logger.info(\"False Positives: \" + str(fp))\n self.Helpers.logger.info(\"True Negatives: \" + str(tn))\n self.Helpers.logger.info(\"False Negatives: \" + str(fn))\n\n def send_request(self, img_path):\n \"\"\" Sends image to the inference API endpoint. \"\"\"\n\n addr = \"http://\" + self.Helpers.confs[\"server\"][\"ip\"] + \\\n ':'+str(self.Helpers.confs[\"server\"][\"port\"]) + '/Inference'\n headers = {'content-type': 'image/jpeg'}\n\n self.Helpers.logger.info(\"Sending request for: \" + img_path)\n\n _, img_encoded = cv2.imencode('.png', cv2.imread(img_path))\n response = requests.post(\n addr, data=img_encoded.tostring(), headers=headers)\n response = json.loads(response.text)\n\n return response\n\n def http_classify(self, req):\n \"\"\" Classifies an image sent via HTTP. \"\"\"\n\n if len(req.files) != 0:\n img = np.fromstring(req.files['file'].read(), np.uint8)\n else:\n img = np.fromstring(req.data, np.uint8)\n\n img = cv2.imdecode(img, cv2.IMREAD_UNCHANGED)\n img = cv2.resize(img, (self.Helpers.confs[\"data\"][\"dim\"],\n self.Helpers.confs[\"data\"][\"dim\"]))\n\n return self.get_prediction(img)\n\n def get_prediction(self, img):\n \"\"\" Gets a prediction for an image. \"\"\"\n\n x = tf.keras.preprocessing.image.img_to_array(img)\n x = cv2.cvtColor(x, cv2.COLOR_BGRA2BGR)\n x = np.expand_dims(x, axis=0)\n x /= 255\n\n predictions = self.tfmodel.predict(x)\n prediction = predictions[0]\n predictioni = np.argmax(prediction)\n prediction = self.Helpers.confs[\"model\"][\"labels\"][predictioni]\n confidence = predictions[0][prediction]\n\n return prediction, confidence\n" ]

[ [ "matplotlib.pyplot.legend", "matplotlib.pyplot.imshow", "numpy.expand_dims", "tensorflow.keras.metrics.BinaryAccuracy", "tensorflow.keras.preprocessing.image.load_img", "tensorflow.keras.models.save_model", "matplotlib.pyplot.plot", "tensorflow.keras.applications.DenseNet121", "tensorflow.keras.layers.Dropout", "tensorflow.keras.Input", "tensorflow.keras.layers.Conv2D", "tensorflow.keras.metrics.AUC", "numpy.argmax", "tensorflow.keras.preprocessing.image.img_to_array", "tensorflow.keras.callbacks.ModelCheckpoint", "matplotlib.pyplot.title", "matplotlib.pyplot.ylim", "tensorflow.keras.layers.Dense", "tensorflow.keras.callbacks.ReduceLROnPlateau", "tensorflow.keras.Model", "matplotlib.pyplot.savefig", "tensorflow.keras.metrics.Precision", "tensorflow.keras.metrics.Recall", "matplotlib.pyplot.show", "matplotlib.pyplot.xticks", "matplotlib.pyplot.ylabel", "tensorflow.keras.layers.GlobalAveragePooling2D", "matplotlib.pyplot.colorbar", "tensorflow.keras.optimizers.Adam", "matplotlib.pyplot.clf", "tensorflow.keras.layers.BatchNormalization", "numpy.fromstring", "tensorflow.keras.models.model_from_json", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.yticks" ] ]

hnmspirit/malaria_centernet

[ "e855e99016e60c6ec7a66f05591ead5993a41a18" ]

[ "lib/models/networks/mobi3.py" ]

[ "from torch.utils import model_zoo\r\nfrom ..backbones import mobilenetv3\r\n\r\n\r\nclass Mobi3Enc(mobilenetv3.MobileNetV3):\r\n def __init__(self, cfgs, mode='large', width_mult=1., outputs=[16], url=None):\r\n self.url = url\r\n super().__init__(cfgs, mode, width_mult=width_mult)\r\n self.outputs = outputs\r\n del self.conv\r\n del self.avgpool\r\n del self.classifier\r\n\r\n def initialize(self):\r\n self.load_state_dict(model_zoo.load_url(self.url), strict=False)\r\n\r\n def forward(self, x):\r\n outputs = []\r\n for idx, feat in enumerate(self.features):\r\n x = feat(x)\r\n if idx in self.outputs:\r\n outputs.append(x)\r\n return outputs\r\n\r\n\r\ndef mobi3_enc():\r\n cfgs = [\r\n # k, t, c, SE, HS, s\r\n [3, 1, 16, 0, 0, 1],\r\n [3, 4, 24, 0, 0, 2],\r\n [3, 3, 24, 0, 0, 1],\r\n [5, 3, 40, 1, 0, 2],\r\n [5, 3, 40, 1, 0, 1],\r\n [5, 3, 40, 1, 0, 1],\r\n [3, 6, 80, 0, 1, 2],\r\n [3, 2.5, 80, 0, 1, 1],\r\n [3, 2.3, 80, 0, 1, 1],\r\n [3, 2.3, 80, 0, 1, 1],\r\n [3, 6, 112, 1, 1, 1],\r\n [3, 6, 112, 1, 1, 1],\r\n [5, 6, 160, 1, 1, 2],\r\n [5, 6, 160, 1, 1, 1],\r\n [5, 6, 160, 1, 1, 1]\r\n ]\r\n mode = 'large'\r\n width_mult = 1.\r\n outputs = [3, 6, 12, 15]\r\n url = 'https://github.com/d-li14/mobilenetv3.pytorch/raw/master/pretrained/mobilenetv3-large-1cd25616.pth'\r\n encoder = Mobi3Enc(cfgs, mode, width_mult, outputs, url)\r\n encoder.initialize()\r\n return encoder\r\n\r\nmobi3_inchannels = [24, 40, 112, 160]" ]

[ [ "torch.utils.model_zoo.load_url" ] ]

kaixindelele/DRL

[ "74bb73caafd30547be0de7cdf0f6b945e51ecf6f", "74bb73caafd30547be0de7cdf0f6b945e51ecf6f", "74bb73caafd30547be0de7cdf0f6b945e51ecf6f" ]

[ "spinup/algos/sac1_rnn/test.py", "spinup/algos/maxsqn/maxsqn_football.py", "spinup/algos/sac1/sac1_BipedalWalkerHardcore-v2_old.py" ]

[ "\nimport tensorflow as tf\nimport gym\nimport joblib\nimport os\nimport os.path as osp\nfrom spinup.utils.logx import restore_tf_graph\n\n\ndef load_policy(fpath, itr='last', deterministic=False):\n\n # handle which epoch to load from\n if itr=='last':\n saves = [int(x[11:]) for x in os.listdir(fpath) if 'simple_save' in x and len(x)>11]\n itr = '%d'%max(saves) if len(saves) > 0 else ''\n else:\n itr = '%d'%itr\n\n # load the things!\n sess = tf.Session()\n model = restore_tf_graph(sess, osp.join(fpath, 'simple_save'+itr))\n\n # get the correct op for executing actions\n if deterministic and 'mu' in model.keys():\n # 'deterministic' is only a valid option for SAC policies\n print('Using deterministic action op.')\n action_op = model['mu']\n else:\n print('Using default action op.')\n action_op = model['pi']\n\n # make function for producing an action given a single state\n get_action = lambda x : sess.run(action_op, feed_dict={model['x']: x[None,:]})[0]\n\n # try to load environment from save\n # (sometimes this will fail because the environment could not be pickled)\n try:\n state = joblib.load(osp.join(fpath, 'vars'+itr+'.pkl'))\n env = state['env']\n except:\n env = None\n\n return env, get_action\n\n\nif __name__ == '__main__':\n\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument('--env', type=str, default='BipedalWalkerHardcore-v2')\n parser.add_argument('--render', type=bool, default=True)\n args = parser.parse_args()\n\n file_model = '/home/liu/project/DRL/data/317biped_sac1_stump6_actnoise0.3_alphaauto_2/biped_sac1_stump6_actnoise0.3_alphaauto_2_s0'\n print(file_model)\n\n _env, get_action = load_policy(file_model, deterministic=True)\n\n test_env = gym.make(args.env)\n ave_ep_ret = 0\n for j in range(10000):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not d: # (d or (ep_len == 2000)):\n o, r, d, _ = test_env.step(get_action(o))\n ep_ret += r\n ep_len += 1\n if args.render:\n test_env.render()\n ave_ep_ret = (j*ave_ep_ret + ep_ret)/(j+1)\n print('ep_len', ep_len, 'ep_ret:', ep_ret, 'ave_ep_ret:',ave_ep_ret,'({}/10000)'.format(j+1) )\n \n\n\n", "import numpy as np\nimport tensorflow as tf\nfrom numbers import Number\nimport gym\nimport time, os\nfrom spinup.algos.maxsqn import core\nfrom spinup.algos.maxsqn.core import get_vars\nfrom spinup.utils.logx import EpochLogger\nfrom gym.spaces import Box, Discrete\n\nclass ReplayBuffer:\n \"\"\"\n A simple FIFO experience replay buffer for SAC agents.\n \"\"\"\n\n def __init__(self, obs_dim, act_dim, size):\n self.obs1_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.obs2_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.acts_buf = np.zeros([size, act_dim], dtype=np.float32)\n self.rews_buf = np.zeros(size, dtype=np.float32)\n self.done_buf = np.zeros(size, dtype=np.float32)\n self.ptr, self.size, self.max_size = 0, 0, size\n\n def store(self, obs, act, rew, next_obs, done):\n self.obs1_buf[self.ptr] = obs\n self.obs2_buf[self.ptr] = next_obs\n self.acts_buf[self.ptr] = act\n self.rews_buf[self.ptr] = rew\n self.done_buf[self.ptr] = done\n self.ptr = (self.ptr+1) % self.max_size\n self.size = min(self.size+1, self.max_size)\n\n def sample_batch(self, batch_size=32):\n idxs = np.random.randint(0, self.size, size=batch_size)\n return dict(obs1=self.obs1_buf[idxs],\n obs2=self.obs2_buf[idxs],\n acts=self.acts_buf[idxs],\n rews=self.rews_buf[idxs],\n done=self.done_buf[idxs])\n\n\"\"\"\n\nSoft Actor-Critic\n\n(With slight variations that bring it closer to TD3)\n\n\"\"\"\n\n\"\"\" make sure: max_ep_len < steps_per_epoch \"\"\"\n\ndef maxsqn(args, env_fn, actor_critic=core.mlp_actor_critic, ac_kwargs=dict(), seed=0,\n steps_per_epoch=5000, epochs=100, replay_size=int(5e6), gamma=0.99,\n polyak=0.995, lr=1e-3, alpha=0.2, batch_size=256, start_steps=20000,\n max_ep_len=1000, logger_kwargs=dict(), save_freq=1):\n \"\"\"\n\n Args:\n env_fn : A function which creates a copy of the environment.\n The environment must satisfy the OpenAI Gym API.\n\n actor_critic: A function which takes in placeholder symbols\n for state, ``x_ph``, and action, ``a_ph``, and returns the main\n outputs from the agent's Tensorflow computation graph:\n\n =========== ================ ======================================\n Symbol Shape Description\n =========== ================ ======================================\n ``mu`` (batch, act_dim) | Computes mean actions from policy\n | given states.\n ``pi`` (batch, act_dim) | Samples actions from policy given\n | states.\n ``logp_pi`` (batch,) | Gives log probability, according to\n | the policy, of the action sampled by\n | ``pi``. Critical: must be differentiable\n | with respect to policy parameters all\n | the way through action sampling.\n ``q1`` (batch,) | Gives one estimate of Q* for\n | states in ``x_ph`` and actions in\n | ``a_ph``.\n ``q2`` (batch,) | Gives another estimate of Q* for\n | states in ``x_ph`` and actions in\n | ``a_ph``.\n ``q1_pi`` (batch,) | Gives the composition of ``q1`` and\n | ``pi`` for states in ``x_ph``:\n | q1(x, pi(x)).\n ``q2_pi`` (batch,) | Gives the composition of ``q2`` and\n | ``pi`` for states in ``x_ph``:\n | q2(x, pi(x)).\n =========== ================ ======================================\n\n ac_kwargs (dict): Any kwargs appropriate for the actor_critic\n function you provided to SAC.\n\n seed (int): Seed for random number generators.\n\n steps_per_epoch (int): Number of steps of interaction (state-action pairs)\n for the agent and the environment in each epoch.\n\n epochs (int): Number of epochs to run and train agent.\n\n replay_size (int): Maximum length of replay buffer.\n\n gamma (float): Discount factor. (Always between 0 and 1.)\n\n polyak (float): Interpolation factor in polyak averaging for target\n networks. Target networks are updated towards main networks\n according to:\n\n .. math:: \\\\theta_{\\\\text{targ}} \\\\leftarrow\n \\\\rho \\\\theta_{\\\\text{targ}} + (1-\\\\rho) \\\\theta\n\n where :math:`\\\\rho` is polyak. (Always between 0 and 1, usually\n close to 1.)\n\n lr (float): Learning rate (used for policy/value/alpha learning).\n\n alpha (float/'auto'): Entropy regularization coefficient. (Equivalent to\n inverse of reward scale in the original SAC paper.) / 'auto': alpha is automated.\n\n batch_size (int): Minibatch size for SGD.\n\n start_steps (int): Number of steps for uniform-random action selection,\n before running real policy. Helps exploration.\n\n max_ep_len (int): Maximum length of trajectory / episode / rollout.\n\n logger_kwargs (dict): Keyword args for EpochLogger.\n\n save_freq (int): How often (in terms of gap between epochs) to save\n the current policy and value function.\n\n \"\"\"\n if not args.is_test:\n logger = EpochLogger(**logger_kwargs)\n logger.save_config(locals())\n\n tf.set_random_seed(seed)\n np.random.seed(seed)\n\n\n env, test_env = env_fn(3), env_fn(1)\n # obs_dim = env.observation_space.shape[0]\n # obs_space = env.observation_space\n\n scenario_obsdim = {'academy_empty_goal':32, 'academy_empty_goal_random':32, 'academy_3_vs_1_with_keeper':44, 'academy_3_vs_1_with_keeper_random':44, 'academy_single_goal_versus_lazy':108}\n obs_dim = scenario_obsdim[args.env]\n obs_space = Box(low=-1.0, high=1.0, shape=(obs_dim,), dtype=np.float32)\n\n act_dim = env.action_space.n\n act_space = env.action_space\n\n\n # Share information about action space with policy architecture\n ac_kwargs['action_space'] = env.action_space\n\n # Inputs to computation graph\n x_ph, a_ph, x2_ph, r_ph, d_ph = core.placeholders_from_space(obs_space, act_space, obs_space, None, None)\n\n\n ######\n if alpha == 'auto':\n # target_entropy = (-np.prod(env.action_space.n))\n # target_entropy = (np.prod(env.action_space.n))/4/10\n target_entropy = 0.5\n\n log_alpha = tf.get_variable('log_alpha', dtype=tf.float32, initializer=0.0)\n alpha = tf.exp(log_alpha)\n ######\n\n\n # Main outputs from computation graph\n with tf.variable_scope('main'):\n mu, pi, logp_pi, logp_pi2, q1, q2, q1_pi, q2_pi, q1_mu, q2_mu = actor_critic(x_ph,x2_ph, a_ph, alpha, **ac_kwargs)\n\n # Target value network\n with tf.variable_scope('target'):\n _, _, logp_pi_, _, _, _,q1_pi_, q2_pi_,q1_mu_, q2_mu_= actor_critic(x2_ph, x2_ph,a_ph, alpha, **ac_kwargs)\n\n # Experience buffer\n if isinstance(act_space, Box):\n a_dim = act_dim\n elif isinstance(act_space, Discrete):\n a_dim = 1\n replay_buffer = ReplayBuffer(obs_dim=obs_dim, act_dim=a_dim, size=replay_size)\n\n # Count variables\n var_counts = tuple(core.count_vars(scope) for scope in\n ['main/pi', 'main/q1', 'main/q2', 'main'])\n print(('\\nNumber of parameters: \\t pi: %d, \\t' + \\\n 'q1: %d, \\t q2: %d, \\t total: %d\\n')%var_counts)\n\n\n######\n if isinstance(alpha,tf.Tensor):\n alpha_loss = tf.reduce_mean(-log_alpha * tf.stop_gradient(logp_pi_ + target_entropy))\n\n alpha_optimizer = tf.train.AdamOptimizer(learning_rate=lr, name='alpha_optimizer')\n train_alpha_op = alpha_optimizer.minimize(loss=alpha_loss, var_list=[log_alpha])\n######\n\n # Min Double-Q:\n min_q_pi = tf.minimum(q1_pi_, q2_pi_)\n # min_q_pi = tf.minimum(q1_mu_, q2_mu_)\n\n # min_q_pi = tf.clip_by_value(min_q_pi, 0.0, 200.0)\n\n\n # Targets for Q and V regression\n v_backup = tf.stop_gradient(min_q_pi - alpha * logp_pi2) ############################## alpha=0\n q_backup = r_ph + gamma*(1-d_ph)*v_backup\n\n\n # Soft actor-critic losses\n q1_loss = 0.5 * tf.reduce_mean((q_backup - q1)**2)\n q2_loss = 0.5 * tf.reduce_mean((q_backup - q2)**2)\n value_loss = q1_loss + q2_loss\n\n # # Policy train op\n # # (has to be separate from value train op, because q1_pi appears in pi_loss)\n # pi_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n # train_pi_op = pi_optimizer.minimize(pi_loss, var_list=get_vars('main/pi'))\n\n # Value train op\n # (control dep of train_pi_op because sess.run otherwise evaluates in nondeterministic order)\n value_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n value_params = get_vars('main/q')\n #with tf.control_dependencies([train_pi_op]):\n train_value_op = value_optimizer.minimize(value_loss, var_list=value_params)\n\n # Polyak averaging for target variables\n # (control flow because sess.run otherwise evaluates in nondeterministic order)\n with tf.control_dependencies([train_value_op]):\n target_update = tf.group([tf.assign(v_targ, polyak*v_targ + (1-polyak)*v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n # All ops to call during one training step\n if isinstance(alpha, Number):\n step_ops = [q1_loss, q2_loss, q1, q2, logp_pi_, tf.identity(alpha),\n train_value_op, target_update]\n else:\n step_ops = [q1_loss, q2_loss, q1, q2, logp_pi_, alpha,\n train_value_op, target_update, train_alpha_op]\n\n # Initializing targets to match main variables\n target_init = tf.group([tf.assign(v_targ, v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n sess.run(target_init)\n\n\n\n ############################## save and restore ############################\n\n saver = tf.train.Saver()\n\n checkpoint_path = logger_kwargs['output_dir'] + '/checkpoints'\n if not os.path.exists(checkpoint_path):\n os.makedirs(checkpoint_path)\n\n if args.is_test or args.is_restore_train:\n ckpt = tf.train.get_checkpoint_state(checkpoint_path)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(sess, ckpt.model_checkpoint_path)\n print(\"Model restored.\")\n\n\n def get_action(o, deterministic=False):\n act_op = mu if deterministic else pi\n return sess.run(act_op, feed_dict={x_ph: np.expand_dims(o, axis=0)})[0]\n\n\n\n ############################## test ############################\n\n if args.is_test:\n test_env = football_env.create_environment(env_name=args.env, representation='simple115', with_checkpoints=False, render=True)\n ave_ep_ret = 0\n for j in range(10000):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not (d or (ep_len == 500)): # (d or (ep_len == 2000)):\n o, r, d, _ = test_env.step(get_action(o, True))\n # print(r, d)\n time.sleep(0.05)\n ep_ret += r\n ep_len += 1\n if args.test_render:\n test_env.render()\n ave_ep_ret = (j*ave_ep_ret + ep_ret)/(j+1)\n print('ep_len', ep_len, 'ep_ret:', ep_ret, 'ave_ep_ret:',ave_ep_ret,'({}/10000)'.format(j+1) )\n return\n\n\n ############################## train ############################\n\n def test_agent(n=20): # n: number of tests\n global sess, mu, pi, q1, q2, q1_pi, q2_pi\n for j in range(n):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not(d or (ep_len == max_ep_len)): # max_ep_len\n # Take deterministic actions at test time\n o, r, d, _ = test_env.step(get_action(o, args.test_determin))\n ep_ret += r\n ep_len += 1\n logger.store(TestEpRet=ep_ret, TestEpLen=ep_len)\n\n start_time = time.time()\n\n\n # o = env.reset() #####################\n # o, r, d, ep_ret, ep_len = env.step(1)[0], 0, False, 0, 0 #####################\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n\n\n total_steps = steps_per_epoch * epochs\n\n ep_index = 0\n test_ep_ret_best = test_ep_ret = -10000.0\n is_wrap = False\n # Main loop: collect experience in env and update/log each epoch\n for t in range(total_steps):\n\n \"\"\"\n Until start_steps have elapsed, randomly sample actions\n from a uniform distribution for better exploration. Afterwards, \n use the learned policy. \n \"\"\"\n # if t > start_steps and 100*t/total_steps > np.random.random(): # greedy, avoid falling into sub-optimum\n if t > start_steps:\n a = get_action(o)\n else:\n a = env.action_space.sample()\n\n # if np.random.random() > t/(3e6):\n # a = env.action_space.sample()\n # else:\n # a = get_action(o)\n\n\n\n # Step the env\n o2, r, d, _ = env.step(a)\n #print(a,o2)\n # o2, r, _, d = env.step(a) #####################\n # d = d['ale.lives'] < 5 #####################\n\n ep_ret += r\n ep_len += 1\n\n # Ignore the \"done\" signal if it comes from hitting the time\n # horizon (that is, when it's an artificial terminal signal\n # that isn't based on the agent's state)\n d = False if ep_len==max_ep_len else d\n\n # d_store = True if r == 1.0 else False\n\n # Store experience to replay buffer\n replay_buffer.store(o, a, r, o2, d)\n # print(a,r,d)\n\n # Super critical, easy to overlook step: make sure to update\n # most recent observation!\n o = o2\n\n # End of episode. Training (ep_len times).\n if d or (ep_len == max_ep_len): # make sure: max_ep_len < steps_per_epoch\n ep_index += 1\n print('episode: {}, ep_len: {}, reward: {}'.format(ep_index, ep_len, ep_ret))\n \"\"\"\n Perform all SAC updates at the end of the trajectory.\n This is a slight difference from the SAC specified in the\n original paper.\n \"\"\"\n for j in range(ep_len):\n batch = replay_buffer.sample_batch(batch_size)\n feed_dict = {x_ph: batch['obs1'],\n x2_ph: batch['obs2'],\n a_ph: batch['acts'],\n r_ph: batch['rews'],\n d_ph: batch['done'],\n }\n # step_ops = [q1_loss, q2_loss, q1, q2, logp_pi, alpha, train_pi_op, train_value_op, target_update]\n outs = sess.run(step_ops, feed_dict)\n logger.store(LossQ1=outs[0], LossQ2=outs[1],\n Q1Vals=outs[2], Q2Vals=outs[3],\n LogPi=outs[4], Alpha=outs[5])\n logger.store(EpRet=ep_ret, EpLen=ep_len)\n\n\n\n\n # End of epoch wrap-up\n if is_wrap:\n epoch = t // steps_per_epoch\n\n # if epoch < 30:\n # test_agent(1)\n # # test_ep_ret = logger.get_stats('TestEpRet')[0]\n # # print('TestEpRet', test_ep_ret, 'Best:', test_ep_ret_best)\n # else:\n # test_agent(1)\n # test_ep_ret = logger.get_stats('TestEpRet')[0]\n # # if test_ep_ret > test_ep_ret_best:\n # # test_agent(30)\n # # test_ep_ret = logger.get_stats('TestEpRet')[0]\n # print('TestEpRet', test_ep_ret, 'Best:', test_ep_ret_best)\n\n # logger.store(): store the data; logger.log_tabular(): log the data; logger.dump_tabular(): write the data\n # Log info about epoch\n logger.log_tabular('Epoch', epoch)\n logger.log_tabular('EpRet', with_min_and_max=True)\n # logger.log_tabular('TestEpRet', with_min_and_max=True)\n logger.log_tabular('EpLen', average_only=True)\n # logger.log_tabular('TestEpLen', average_only=True)\n logger.log_tabular('TotalEnvInteracts', t)\n logger.log_tabular('Alpha',average_only=True)\n logger.log_tabular('Q1Vals', with_min_and_max=True)\n logger.log_tabular('Q2Vals', with_min_and_max=True)\n # logger.log_tabular('VVals', with_min_and_max=True)\n logger.log_tabular('LogPi', with_min_and_max=True)\n # logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('LossQ1', average_only=True)\n logger.log_tabular('LossQ2', average_only=True)\n # logger.log_tabular('LossV', average_only=True)\n logger.log_tabular('Time', time.time()-start_time)\n logger.dump_tabular()\n\n\n # Save model\n if ((epoch % args.save_freq == 0) or (epoch == epochs - 1)): # or test_ep_ret > test_ep_ret_best:\n save_path = saver.save(sess, checkpoint_path+'/model.ckpt', t)\n print(\"Model saved in path: %s\" % save_path)\n test_ep_ret_best = test_ep_ret\n\n is_wrap = False\n\n\n # o = env.reset() #####################\n # o, r, d, ep_ret, ep_len = env.step(1)[0], 0, False, 0, 0 #####################\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n if t > 0 and t % steps_per_epoch == 0:\n is_wrap = True\n\n\nif __name__ == '__main__':\n import argparse\n parser = argparse.ArgumentParser()\n # {'academy_empty_goal':32, 'academy_3_vs_1_with_keeper':44, 'academy_single_goal_versus_lazy':108}\n parser.add_argument('--env', type=str, default='academy_3_vs_1_with_keeper_random')\n parser.add_argument('--epochs', type=int, default=200000)\n parser.add_argument('--steps_per_epoch', type=int, default=int(5e3))\n parser.add_argument('--save_freq', type=int, default=40)\n parser.add_argument('--is_restore_train', type=bool, default=False)\n\n parser.add_argument('--is_test', type=bool, default=False)\n parser.add_argument('--test_determin', type=bool, default=True)\n parser.add_argument('--test_render', type=bool, default=False)\n\n # replay_size, steps_per_epoch, batch_size, start_steps, save_freq\n\n parser.add_argument('--replay_size', type=int, default=int(5e6))\n parser.add_argument('--net', type=list, default=[600,400,200])\n parser.add_argument('--batch_size', type=int, default=300)\n parser.add_argument('--start_steps', type=int, default=int(3e4))\n\n parser.add_argument('--gamma', type=float, default=0.997)\n parser.add_argument('--seed', '-s', type=int, default=0) # maxsqn_football100_a 790, maxsqn_football100_b 110\n\n parser.add_argument('--max_ep_len', type=int, default=170) # make sure: max_ep_len < steps_per_epoch\n parser.add_argument('--alpha', default='auto', help=\"alpha can be either 'auto' or float(e.g:0.2).\")\n parser.add_argument('--lr', type=float, default=5e-5)\n parser.add_argument('--exp_name', type=str, default='debug')#'3v1_scale200_repeat2_c_True')#'1_academy_empty_goal_random_seed0')#'1_academy_empty_goal_0-0')#'1_{}_seed{}-0-half-random_repeat2'.format(parser.parse_args().env,parser.parse_args().seed))\n args = parser.parse_args()\n\n from spinup.utils.run_utils import setup_logger_kwargs\n logger_kwargs = setup_logger_kwargs(args.exp_name, args.seed)\n\n import gfootball.env as football_env\n\n\n # reward wrapper\n class FootballWrapper(object):\n\n def __init__(self, env):\n self._env = env\n\n def __getattr__(self, name):\n return getattr(self._env, name)\n\n # def reset(self):\n # obs = self._env.reset()\n # if obs[0] > 0.5:\n # obs, _, _, _ = self._env.step(12)\n # return obs\n\n def step(self, action):\n r = 0.0\n for _ in range(2):\n obs, reward, done, info = self._env.step(action)\n # if reward != 0.0:\n # done = True\n # else:\n # done = False\n if reward < 0.0:\n reward = 0.0\n # reward -= 0.00175\n # reward += (0.5*obs[0] + (0.5-np.abs(obs[1])))*0.001\n if obs[0] < 0.0:\n done = True\n # reward = reward + self.incentive1(obs)\n r += reward\n\n if done:\n return obs, r * 200, done, info\n\n return obs, r*200, done, info\n\n def incentive1(self, obs):\n who_controls_ball = obs[7:9]\n pos_ball = obs[0:2]\n distance_to_goal =np.array([np.exp(-np.linalg.norm(pos_ball-[1.01,0])), -np.exp(-np.linalg.norm(pos_ball-[-1.01,0]))])\n r = np.dot(who_controls_ball,distance_to_goal)*0.003\n return r\n\n def incentive2(self, obs):\n who_controls_ball = obs[7:9]\n pos_ball = obs[0]\n distance_to_goal =np.array([(pos_ball+1)/2.0, (pos_ball-1)/2.0])\n r = np.dot(who_controls_ball,distance_to_goal)*0.003\n return r\n\n\n # academy_empty_goal academy_empty_goal_close\n env0 = football_env.create_environment(env_name=args.env, representation='simple115', with_checkpoints=False, render=False)\n env_1 = FootballWrapper(env0)\n env_3 = env_1\n maxsqn(args, lambda n : env_3 if n==3 else env_1, actor_critic=core.mlp_actor_critic,\n ac_kwargs=dict(hidden_sizes=args.net), replay_size=args.replay_size, steps_per_epoch=args.steps_per_epoch,\n batch_size=args.batch_size, start_steps=args.start_steps, save_freq=args.save_freq,\n gamma=args.gamma, seed=args.seed, epochs=args.epochs, alpha=args.alpha, lr=args.lr, max_ep_len = args.max_ep_len,\n logger_kwargs=logger_kwargs)", "import numpy as np\nimport tensorflow as tf\nfrom numbers import Number\nimport gym\nimport time\nfrom spinup.algos.sac1 import core\nfrom spinup.algos.sac1.core import get_vars\nfrom spinup.utils.logx import EpochLogger\nfrom gym.spaces import Box, Discrete\nfrom spinup.utils.frame_stack import FrameStack\n\n\n\nconfig = tf.ConfigProto()\nconfig.gpu_options.allow_growth = True\nsession = tf.Session(config=config)\n\n\nclass ReplayBuffer:\n \"\"\"\n A simple FIFO experience replay buffer for SAC agents.\n \"\"\"\n\n def __init__(self, obs_dim, act_dim, size):\n self.obs1_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.obs2_buf = np.zeros([size, obs_dim], dtype=np.float32)\n self.acts_buf = np.zeros([size, act_dim], dtype=np.float32)\n self.rews_buf = np.zeros(size, dtype=np.float32)\n self.done_buf = np.zeros(size, dtype=np.float32)\n self.ptr, self.size, self.max_size = 0, 0, size\n\n def store(self, obs, act, rew, next_obs, done):\n self.obs1_buf[self.ptr] = obs\n self.obs2_buf[self.ptr] = next_obs\n self.acts_buf[self.ptr] = act\n self.rews_buf[self.ptr] = rew\n self.done_buf[self.ptr] = done\n self.ptr = (self.ptr+1) % self.max_size\n self.size = min(self.size+1, self.max_size)\n\n def sample_batch(self, batch_size=32):\n idxs = np.random.randint(0, self.size, size=batch_size)\n return dict(obs1=self.obs1_buf[idxs],\n obs2=self.obs2_buf[idxs],\n acts=self.acts_buf[idxs],\n rews=self.rews_buf[idxs],\n done=self.done_buf[idxs])\n\n\"\"\"\n\nSoft Actor-Critic\n\n(With slight variations that bring it closer to TD3)\n\n\"\"\"\ndef sac1(env_fn, actor_critic=core.mlp_actor_critic, ac_kwargs=dict(), seed=0,\n steps_per_epoch=5000, epochs=100, replay_size=int(1e6), gamma=0.99, reward_scale=1.0,\n polyak=0.995, lr=5e-4, alpha=0.2, batch_size=100, start_steps=10000,\n max_ep_len_train=1000, max_ep_len_test=1000, logger_kwargs=dict(), save_freq=1):\n \"\"\"\n\n Args:\n env_fn : A function which creates a copy of the environment.\n The environment must satisfy the OpenAI Gym API.\n\n actor_critic: A function which takes in placeholder symbols \n for state, ``x_ph``, and action, ``a_ph``, and returns the main \n outputs from the agent's Tensorflow computation graph:\n\n =========== ================ ======================================\n Symbol Shape Description\n =========== ================ ======================================\n ``mu`` (batch, act_dim) | Computes mean actions from policy\n | given states.\n ``pi`` (batch, act_dim) | Samples actions from policy given \n | states.\n ``logp_pi`` (batch,) | Gives log probability, according to\n | the policy, of the action sampled by\n | ``pi``. Critical: must be differentiable\n | with respect to policy parameters all\n | the way through action sampling.\n ``q1`` (batch,) | Gives one estimate of Q* for \n | states in ``x_ph`` and actions in\n | ``a_ph``.\n ``q2`` (batch,) | Gives another estimate of Q* for \n | states in ``x_ph`` and actions in\n | ``a_ph``.\n ``q1_pi`` (batch,) | Gives the composition of ``q1`` and \n | ``pi`` for states in ``x_ph``: \n | q1(x, pi(x)).\n ``q2_pi`` (batch,) | Gives the composition of ``q2`` and \n | ``pi`` for states in ``x_ph``: \n | q2(x, pi(x)).\n =========== ================ ======================================\n\n ac_kwargs (dict): Any kwargs appropriate for the actor_critic \n function you provided to SAC.\n\n seed (int): Seed for random number generators.\n\n steps_per_epoch (int): Number of steps of interaction (state-action pairs) \n for the agent and the environment in each epoch.\n\n epochs (int): Number of epochs to run and train agent.\n\n replay_size (int): Maximum length of replay buffer.\n\n gamma (float): Discount factor. (Always between 0 and 1.)\n\n polyak (float): Interpolation factor in polyak averaging for target \n networks. Target networks are updated towards main networks \n according to:\n\n .. math:: \\\\theta_{\\\\text{targ}} \\\\leftarrow \n \\\\rho \\\\theta_{\\\\text{targ}} + (1-\\\\rho) \\\\theta\n\n where :math:`\\\\rho` is polyak. (Always between 0 and 1, usually \n close to 1.)\n\n lr (float): Learning rate (used for policy/value/alpha learning).\n\n alpha (float/'auto'): Entropy regularization coefficient. (Equivalent to\n inverse of reward scale in the original SAC paper.) / 'auto': alpha is automated.\n\n batch_size (int): Minibatch size for SGD.\n\n start_steps (int): Number of steps for uniform-random action selection,\n before running real policy. Helps exploration.\n\n max_ep_len (int): Maximum length of trajectory / episode / rollout.\n\n logger_kwargs (dict): Keyword args for EpochLogger.\n\n save_freq (int): How often (in terms of gap between epochs) to save\n the current policy and value function.\n\n \"\"\"\n\n logger = EpochLogger(**logger_kwargs)\n logger.save_config(locals())\n\n tf.set_random_seed(seed)\n np.random.seed(seed)\n\n env, test_env = env_fn(3), env_fn(1)\n obs_dim = env.observation_space.shape[0]\n act_dim = env.action_space.shape[0]\n\n # Action limit for clamping: critically, assumes all dimensions share the same bound!\n act_limit = env.action_space.high[0]\n\n # Share information about action space with policy architecture\n ac_kwargs['action_space'] = env.action_space\n\n # Inputs to computation graph\n x_ph, a_ph, x2_ph, r_ph, d_ph = core.placeholders(obs_dim, act_dim, obs_dim, None, None)\n\n # Main outputs from computation graph\n with tf.variable_scope('main'):\n mu, pi, logp_pi, logp_pi2, q1, q2, q1_pi, q2_pi = actor_critic(x_ph, x2_ph, a_ph, **ac_kwargs)\n\n # Target value network\n with tf.variable_scope('target'):\n _, _, logp_pi_, _, _, _, q1_pi_, q2_pi_ = actor_critic(x2_ph, x2_ph, a_ph, **ac_kwargs)\n\n # Experience buffer\n replay_buffer = ReplayBuffer(obs_dim=obs_dim, act_dim=act_dim, size=replay_size)\n\n # Count variables\n var_counts = tuple(core.count_vars(scope) for scope in \n ['main/pi', 'main/q1', 'main/q2', 'main'])\n print(('\\nNumber of parameters: \\t pi: %d, \\t' + \\\n 'q1: %d, \\t q2: %d, \\t total: %d\\n')%var_counts)\n\n######\n if alpha == 'auto':\n target_entropy = (-np.prod(env.action_space.shape))\n\n log_alpha = tf.get_variable( 'log_alpha', dtype=tf.float32, initializer=0.0)\n alpha = tf.exp(log_alpha)\n\n alpha_loss = tf.reduce_mean(-log_alpha * tf.stop_gradient(logp_pi + target_entropy))\n\n alpha_optimizer = tf.train.AdamOptimizer(learning_rate=lr*0.1, name='alpha_optimizer')\n train_alpha_op = alpha_optimizer.minimize(loss=alpha_loss, var_list=[log_alpha])\n######\n\n # Min Double-Q:\n min_q_pi = tf.minimum(q1_pi_, q2_pi_)\n\n # Targets for Q and V regression\n v_backup = tf.stop_gradient(min_q_pi - alpha * logp_pi2)\n q_backup = r_ph + gamma*(1-d_ph)*v_backup\n\n\n # Soft actor-critic losses\n pi_loss = tf.reduce_mean(alpha * logp_pi - q1_pi)\n q1_loss = 0.5 * tf.reduce_mean((q_backup - q1)**2)\n q2_loss = 0.5 * tf.reduce_mean((q_backup - q2)**2)\n value_loss = q1_loss + q2_loss\n\n # Policy train op \n # (has to be separate from value train op, because q1_pi appears in pi_loss)\n pi_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n train_pi_op = pi_optimizer.minimize(pi_loss, var_list=get_vars('main/pi'))\n\n # Value train op\n # (control dep of train_pi_op because sess.run otherwise evaluates in nondeterministic order)\n value_optimizer = tf.train.AdamOptimizer(learning_rate=lr)\n value_params = get_vars('main/q')\n with tf.control_dependencies([train_pi_op]):\n train_value_op = value_optimizer.minimize(value_loss, var_list=value_params)\n\n # Polyak averaging for target variables\n # (control flow because sess.run otherwise evaluates in nondeterministic order)\n with tf.control_dependencies([train_value_op]):\n target_update = tf.group([tf.assign(v_targ, polyak*v_targ + (1-polyak)*v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n # All ops to call during one training step\n if isinstance(alpha, Number):\n step_ops = [pi_loss, q1_loss, q2_loss, q1, q2, logp_pi, tf.identity(alpha),\n train_pi_op, train_value_op, target_update]\n else:\n step_ops = [pi_loss, q1_loss, q2_loss, q1, q2, logp_pi, alpha,\n train_pi_op, train_value_op, target_update, train_alpha_op]\n\n\n # Initializing targets to match main variables\n target_init = tf.group([tf.assign(v_targ, v_main)\n for v_main, v_targ in zip(get_vars('main'), get_vars('target'))])\n\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n sess.run(target_init)\n\n # Setup model saving\n logger.setup_tf_saver(sess, inputs={'x': x_ph, 'a': a_ph}, \n outputs={'mu': mu, 'pi': pi, 'q1': q1, 'q2': q2})\n\n def get_action(o, deterministic=False):\n act_op = mu if deterministic else pi\n return sess.run(act_op, feed_dict={x_ph: o.reshape(1,-1)})[0]\n\n def test_agent(n=25):\n global sess, mu, pi, q1, q2, q1_pi, q2_pi\n for j in range(n):\n o, r, d, ep_ret, ep_len = test_env.reset(), 0, False, 0, 0\n while not(d or (ep_len == max_ep_len_test)):\n # Take deterministic actions at test time \n o, r, d, _ = test_env.step(get_action(o, True))\n ep_ret += r\n ep_len += 1\n # test_env.render()\n logger.store(TestEpRet=ep_ret, TestEpLen=ep_len)\n\n start_time = time.time()\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n total_steps = steps_per_epoch * epochs\n\n # Main loop: collect experience in env and update/log each epoch\n for t in range(total_steps):\n\n \"\"\"\n Until start_steps have elapsed, randomly sample actions\n from a uniform distribution for better exploration. Afterwards, \n use the learned policy. \n \"\"\"\n if t > start_steps:\n a = get_action(o)\n else:\n a = env.action_space.sample()\n\n # Step the env\n o2, r, d, _ = env.step(a)\n ep_ret += r\n ep_len += 1\n\n # Ignore the \"done\" signal if it comes from hitting the time\n # horizon (that is, when it's an artificial terminal signal\n # that isn't based on the agent's state)\n # d = False if ep_len==max_ep_len_train else d\n\n # Store experience to replay buffer\n replay_buffer.store(o, a, r, o2, d)\n\n # Super critical, easy to overlook step: make sure to update \n # most recent observation!\n o = o2\n\n # End of episode. Training (ep_len times).\n if d or (ep_len == max_ep_len_train):\n \"\"\"\n Perform all SAC updates at the end of the trajectory.\n This is a slight difference from the SAC specified in the\n original paper.\n \"\"\"\n for j in range(ep_len):\n batch = replay_buffer.sample_batch(batch_size)\n feed_dict = {x_ph: batch['obs1'],\n x2_ph: batch['obs2'],\n a_ph: batch['acts'],\n r_ph: batch['rews'],\n d_ph: batch['done'],\n }\n # step_ops = [pi_loss, q1_loss, q2_loss, q1, q2, logp_pi, alpha, train_pi_op, train_value_op, target_update]\n outs = sess.run(step_ops, feed_dict)\n logger.store(LossPi=outs[0], LossQ1=outs[1], LossQ2=outs[2],\n Q1Vals=outs[3], Q2Vals=outs[4],\n LogPi=outs[5], Alpha=outs[6])\n\n logger.store(EpRet=ep_ret/reward_scale, EpLen=ep_len)\n o, r, d, ep_ret, ep_len = env.reset(), 0, False, 0, 0\n\n\n # End of epoch wrap-up\n if t > 0 and t % steps_per_epoch == 0:\n epoch = t // steps_per_epoch\n\n # Save model\n if (epoch % save_freq == 0) or (epoch == epochs-1):\n logger.save_state({'env': env}, None)\n\n # Test the performance of the deterministic version of the agent.\n test_agent()\n\n # logger.store(): store the data; logger.log_tabular(): log the data; logger.dump_tabular(): write the data\n # Log info about epoch\n logger.log_tabular('Epoch', epoch)\n logger.log_tabular('EpRet', with_min_and_max=True)\n logger.log_tabular('TestEpRet', with_min_and_max=False)\n logger.log_tabular('EpLen', average_only=True)\n logger.log_tabular('TestEpLen', average_only=True)\n logger.log_tabular('TotalEnvInteracts', t)\n logger.log_tabular('Alpha',average_only=True)\n logger.log_tabular('Q1Vals', with_min_and_max=False)\n ### logger.log_tabular('Q2Vals', with_min_and_max=True)\n # logger.log_tabular('VVals', with_min_and_max=True)\n ### logger.log_tabular('LogPi', with_min_and_max=True)\n logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('LossQ1', average_only=True)\n logger.log_tabular('LossQ2', average_only=True)\n # logger.log_tabular('LossV', average_only=True)\n logger.log_tabular('Time', time.time()-start_time)\n logger.dump_tabular()\n\nif __name__ == '__main__':\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument('--env', type=str, default='BipedalWalkerHardcore-v2') # 'Pendulum-v0'\n parser.add_argument('--max_ep_len_test', type=int, default=2000) # 'BipedalWalkerHardcore-v2' max_ep_len is 2000\n parser.add_argument('--max_ep_len_train', type=int, default=400) # max_ep_len_train < 2000//3 # 'BipedalWalkerHardcore-v2' max_ep_len is 2000\n parser.add_argument('--hid', type=int, default=300)\n parser.add_argument('--l', type=int, default=1)\n parser.add_argument('--gamma', type=float, default=0.99)\n parser.add_argument('--lr', type=float, default=1e-4)\n parser.add_argument('--seed', '-s', type=int, default=0)\n parser.add_argument('--epochs', type=int, default=10000)\n parser.add_argument('--alpha', default=0.1, help=\"alpha can be either 'auto' or float(e.g:0.2).\")\n parser.add_argument('--reward_scale', type=float, default=5.0)\n parser.add_argument('--act_noise', type=float, default=0.3)\n parser.add_argument('--obs_noise', type=float, default=0.0)\n parser.add_argument('--exp_name', type=str, default='sac1_BipedalWalkerHardcore-v2')\n parser.add_argument('--stack_frames', type=int, default=4)\n args = parser.parse_args()\n\n from spinup.utils.run_utils import setup_logger_kwargs\n logger_kwargs = setup_logger_kwargs(args.exp_name, args.seed)\n\n\n\n class Wrapper(object):\n\n def __init__(self, env, action_repeat=3):\n self._env = env\n self.action_repeat = action_repeat\n\n def __getattr__(self, name):\n return getattr(self._env, name)\n\n def reset(self):\n obs = self._env.reset() + args.obs_noise * (-2 * np.random.random(24) + 1)\n return obs\n\n def step(self, action):\n action += args.act_noise * (-2 * np.random.random(4) + 1)\n r = 0.0\n for _ in range(self.action_repeat):\n obs_, reward_, done_, info_ = self._env.step(action)\n r = r + reward_\n # r -= 0.001\n if done_ and self.action_repeat!=1:\n return obs_+ args.obs_noise * (-2 * np.random.random(24) + 1), 0.0, done_, info_\n if self.action_repeat==1:\n return obs_, r, done_, info_\n return obs_+ args.obs_noise * (-2 * np.random.random(24) + 1), args.reward_scale*r, done_, info_\n\n\n # env = FrameStack(env, args.stack_frames)\n\n env3 = Wrapper(gym.make(args.env), 3)\n env1 = Wrapper(gym.make(args.env), 1)\n\n sac1(lambda n : env3 if n==3 else env1, actor_critic=core.mlp_actor_critic,\n ac_kwargs=dict(hidden_sizes=[400,300]),\n gamma=args.gamma, seed=args.seed, epochs=args.epochs, alpha=args.alpha,\n logger_kwargs=logger_kwargs, lr = args.lr, reward_scale=args.reward_scale,\n max_ep_len_train = args.max_ep_len_train, max_ep_len_test=args.max_ep_len_test)\n\n" ]

[ [ "tensorflow.Session" ], [ "numpy.dot", "tensorflow.get_variable", "numpy.expand_dims", "tensorflow.control_dependencies", "tensorflow.minimum", "tensorflow.train.AdamOptimizer", "numpy.random.randint", "tensorflow.stop_gradient", "tensorflow.Session", "tensorflow.train.Saver", "numpy.zeros", "tensorflow.identity", "tensorflow.exp", "tensorflow.global_variables_initializer", "tensorflow.set_random_seed", "numpy.array", "tensorflow.train.get_checkpoint_state", "numpy.random.seed", "tensorflow.reduce_mean", "tensorflow.assign", "numpy.linalg.norm", "tensorflow.variable_scope" ], [ "tensorflow.get_variable", "tensorflow.control_dependencies", "tensorflow.minimum", "tensorflow.train.AdamOptimizer", "numpy.random.randint", "tensorflow.stop_gradient", "tensorflow.ConfigProto", "tensorflow.Session", "numpy.zeros", "tensorflow.identity", "tensorflow.exp", "tensorflow.global_variables_initializer", "tensorflow.set_random_seed", "numpy.random.random", "numpy.random.seed", "tensorflow.reduce_mean", "tensorflow.assign", "numpy.prod", "tensorflow.variable_scope" ] ]

TuomasJalonen/visual-product-tracking-system

[ "bc6c5499c4f146d4e2f77c79394018328615c19b" ]

[ "Preprocess_data.py" ]

[ "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Wed Aug 12 22:02:20 2020\n\n@author: Tuomas Jalonen\n\nThis file is used for preprocessing the data.\n\n\"\"\"\nimport os\nimport pandas as pd\nimport cv2\nimport numpy as np\n\ndef process_img(path, size):\n \"\"\"\n\n Parameters\n ----------\n path : Complete path to the image\n size : target image size, e.g. (224, 224)\n\n Returns\n -------\n img : Preprocessed image\n\n \"\"\"\n\n img = cv2.imread(path, 1)\n img = cv2.normalize(img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX,\n dtype=cv2.CV_32F)\n img = cv2.resize(img, size)\n\n return img\n\n# Define targeted image size\nIMG_SIZE = (224, 224)\n\n# Define how many image pairs are saved for validation and testing. Rest is\n# used for training.\nTEST_SIZE = 500\nVAL_SIZE = 200\n\n# Define path to CSV-file containing which images are pairs\nPATH_TO_CSV = '/path/'\n\n# Define path to folder containing wet images\nPATH_TO_WET = '/path/'\n\n# Define path to folder containing dry images\nPATH_TO_DRY = '/path/'\n\n# Read csv-file to pandas dataframe\ndf = pd.read_csv(PATH_TO_CSV, sep=';')\n\n# Print some info\nprint(df.head())\nprint(df.info())\n\n# Split the dataframe into test, validation and train data\ntest = df.sample(n=TEST_SIZE, random_state=42)\ndata_without_test = df.drop(test.index)\nval = data_without_test.sample(n=VAL_SIZE, random_state=42)\ntrain = data_without_test.drop(val.index)\n\n# Create empty lists for images and labels\ntrain_wet_imgs = []\ntrain_dry_imgs = []\n\ntest_wet_imgs = []\ntest_dry_imgs = []\n\nval_wet_imgs = []\nval_dry_imgs = []\n\ntrain_labels = []\ntest_labels = []\nval_labels = []\n\n# Loop dataframe rows\nfor index, row in df.iterrows():\n\n # Print progress\n if index % 10 == 0:\n print(index, '/', len(df))\n\n # Create correct path for the wet image, corresponding dry image\n wet_path = os.path.join(PATH_TO_WET, row['Filename_wet'])\n dry_path_pair = os.path.join(PATH_TO_DRY, row['Filename_dry'])\n\n # Read and process images\n wet_img = process_img(wet_path, IMG_SIZE)\n dry_img_pair = process_img(dry_path_pair, IMG_SIZE)\n\n # Next there are three if statements determining whether the image\n # belongs to train, validation or test set\n if row['Filename_wet'] in train['Filename_wet'].values:\n # Append four wet images to the list (one for pair and three for\n # not-pair images)\n train_wet_imgs.append(wet_img)\n train_wet_imgs.append(wet_img)\n train_wet_imgs.append(wet_img)\n train_wet_imgs.append(wet_img)\n\n # Append the pair dry image to list\n train_dry_imgs.append(dry_img_pair)\n\n # Get three random image paths from the correct dataset\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n dry_path_random2 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n\n # Make sure it's not pair\n while dry_path_pair == dry_path_random1:\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random2:\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random3:\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n train.sample().iloc[0]['Filename_dry'])\n\n # Process the image and append to list\n dry_img_random1 = process_img(dry_path_random1, IMG_SIZE)\n dry_img_random2 = process_img(dry_path_random2, IMG_SIZE)\n dry_img_random3 = process_img(dry_path_random3, IMG_SIZE)\n train_dry_imgs.append(dry_img_random1)\n train_dry_imgs.append(dry_img_random2)\n train_dry_imgs.append(dry_img_random3)\n\n # Append correct labels to lists\n train_labels.append([0, 1])\n train_labels.append([1, 0])\n train_labels.append([1, 0])\n train_labels.append([1, 0])\n\n continue\n\n if row['Filename_wet'] in val['Filename_wet'].values:\n # Append four wet images to the list (one for pair and three for\n # not-pair images)\n val_wet_imgs.append(wet_img)\n val_wet_imgs.append(wet_img)\n val_wet_imgs.append(wet_img)\n val_wet_imgs.append(wet_img)\n\n # Append the pair dry image to list\n val_dry_imgs.append(dry_img_pair)\n\n # Get random image path from the correct dataset\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n dry_path_random2 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n\n # Make sure it's not pair\n while dry_path_pair == dry_path_random1:\n dry_path_random1 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random2:\n dry_path_random2 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n while dry_path_pair == dry_path_random3:\n dry_path_random3 = os.path.join(\n PATH_TO_DRY,\n val.sample().iloc[0]['Filename_dry'])\n\n # Process the image and append to list\n dry_img_random1 = process_img(dry_path_random1, IMG_SIZE)\n dry_img_random2 = process_img(dry_path_random2, IMG_SIZE)\n dry_img_random3 = process_img(dry_path_random3, IMG_SIZE)\n val_dry_imgs.append(dry_img_random1)\n val_dry_imgs.append(dry_img_random2)\n val_dry_imgs.append(dry_img_random3)\n\n # Append correct labels to lists\n val_labels.append([0, 1])\n val_labels.append([1, 0])\n val_labels.append([1, 0])\n val_labels.append([1, 0])\n\n continue\n\n if row['Filename_wet'] in test['Filename_wet'].values:\n # Append wet image to the list\n test_wet_imgs.append(wet_img)\n\n # Append the pair dry image to list\n test_dry_imgs.append(dry_img_pair)\n\n # Append correct labels to lists\n test_labels.append([0, 1])\n\n continue\n\n# let's double the sample size by cross-sampling:\ntrain_input_A = train_wet_imgs + train_dry_imgs\ntrain_input_B = train_dry_imgs + train_wet_imgs\nval_input_A = val_wet_imgs + val_dry_imgs\nval_input_B = val_dry_imgs + val_wet_imgs\ntest_input_A = test_wet_imgs\ntest_input_B = test_dry_imgs\n\ntrain_labels += train_labels\n# test_labels stay the same\nval_labels += val_labels\n\n# Save the inputs to Numpy arrays\nnp.save('train_input_A.npy',\n np.array(train_input_A))\nnp.save('train_input_B.npy',\n np.array(train_input_B))\nnp.save('test_input_A.npy',\n np.array(test_input_A))\nnp.save('test_input_B.npy',\n np.array(test_input_B))\nnp.save('val_input_A.npy',\n np.array(val_input_A))\nnp.save('val_input_B.npy',\n np.array(val_input_B))\nnp.save('train_labels.npy',\n np.array(train_labels))\nnp.save('test_labels.npy',\n np.array(test_labels))\nnp.save('val_labels.npy',\n np.array(val_labels))\n" ]

[ [ "numpy.array", "pandas.read_csv" ] ]

rob-luke/mnelab

[ "4f2aa82fbc7d95ead253c463a7f8afee35e94163" ]

[ "mnelab/viz.py" ]

[ "# Authors: Clemens Brunner <[email protected]>\n#\n# License: BSD (3-clause)\n\nimport math\nimport matplotlib.pyplot as plt\nfrom mne.time_frequency import tfr_multitaper\nfrom mne.viz.utils import center_cmap\n\n\ndef _get_rows_cols(n):\n if n <= 3:\n rows, cols = 1, n\n else:\n rows = round(math.sqrt(n))\n cols = math.ceil(math.sqrt(n))\n return rows, cols\n\n\ndef plot_erds(data, freqs, n_cycles, baseline, times=(None, None)):\n tfr = tfr_multitaper(data, freqs, n_cycles, average=False, return_itc=False)\n tfr.apply_baseline(baseline, mode=\"percent\")\n tfr.crop(*times)\n\n figs = []\n n_rows, n_cols = _get_rows_cols(data.info[\"nchan\"])\n widths = n_cols * [10] + [1] # each map has width 10, each colorbar width 1\n\n for event in data.event_id: # separate figures for each event ID\n fig, axes = plt.subplots(n_rows, n_cols + 1, gridspec_kw={\"width_ratios\": widths})\n tfr_avg = tfr[event].average()\n vmin, vmax = -1, 2 # default for ERDS maps\n cmap = center_cmap(plt.cm.RdBu, vmin, vmax)\n for ch, ax in enumerate(axes[..., :-1].flat): # skip last column\n tfr_avg.plot([ch], vmin=vmin, vmax=vmax, cmap=(cmap, False), axes=ax,\n colorbar=False, show=False)\n ax.set_title(data.ch_names[ch], fontsize=10)\n ax.axvline(0, linewidth=1, color=\"black\", linestyle=\":\")\n ax.set(xlabel=\"t (s)\", ylabel=\"f (Hz)\")\n ax.label_outer()\n for ax in axes[..., -1].flat: # colorbars in last column\n fig.colorbar(axes.flat[0].images[-1], cax=ax)\n\n fig.suptitle(f\"ERDS ({event})\")\n figs.append(fig)\n return figs\n" ]

[ [ "matplotlib.pyplot.subplots" ] ]

richardwu/holoclean

[ "90668091f1c3baa5a8d19a5874194e8fcec13f6d" ]

[ "detect/detect.py" ]

[ "import pandas as pd\nimport time\nfrom dataset import AuxTables\n\n\nclass DetectEngine:\n def __init__(self, env, dataset):\n self.env = env\n self.ds = dataset\n\n def detect_errors(self, detectors):\n errors = []\n tic_total = time.clock()\n for detector in detectors:\n detector.setup(self.ds, self.env)\n for detector in detectors:\n tic = time.clock()\n error_df = detector.detect_noisy_cells()\n toc = time.clock()\n if self.env['verbose']:\n print(\"DONE with Error Detector: %s in %.2f secs\"%(detector.name, toc-tic))\n errors.append(error_df)\n errors_df = pd.concat(errors, ignore_index=True).drop_duplicates().reset_index(drop=True)\n errors_df['_cid_'] = errors_df.apply(lambda x: self.ds.get_cell_id(x['_tid_'], x['attribute']), axis=1)\n try:\n self.store_detected_errors(errors_df)\n status = \"DONE with error detection.\"\n except Exception as e:\n status = \"ERROR in detection: \"+str(e)\n toc_total = time.clock()\n detect_time = toc_total - tic_total\n return status, detect_time\n\n def store_detected_errors(self, errors_df):\n if errors_df.empty:\n raise Exception(\"ERROR: Detected errors dataframe is empty.\")\n else:\n self.ds.generate_aux_table(AuxTables.dk_cells, errors_df, store=True)\n self.ds.aux_table[AuxTables.dk_cells].create_db_index(self.ds.engine, ['_cid_'])\n\n" ]

[ [ "pandas.concat" ] ]

stevennic/pandas

[ "27aae225e82d602e1092a10adf018a3e05682bc5" ]

[ "pandas/tests/io/parser/test_common.py" ]

[ "\"\"\"\nTests that work on both the Python and C engines but do not have a\nspecific classification into the other test modules.\n\"\"\"\nimport codecs\nimport csv\nfrom datetime import datetime\nfrom inspect import signature\nfrom io import StringIO\nimport os\nimport platform\nfrom urllib.error import URLError\n\nimport numpy as np\nimport pytest\n\nfrom pandas._libs.tslib import Timestamp\nfrom pandas.errors import DtypeWarning, EmptyDataError, ParserError\nimport pandas.util._test_decorators as td\n\nfrom pandas import DataFrame, Index, MultiIndex, Series, compat, concat, option_context\nimport pandas._testing as tm\n\nfrom pandas.io.parsers import CParserWrapper, TextFileReader, TextParser\n\n\ndef test_override_set_noconvert_columns():\n # see gh-17351\n #\n # Usecols needs to be sorted in _set_noconvert_columns based\n # on the test_usecols_with_parse_dates test from test_usecols.py\n class MyTextFileReader(TextFileReader):\n def __init__(self):\n self._currow = 0\n self.squeeze = False\n\n class MyCParserWrapper(CParserWrapper):\n def _set_noconvert_columns(self):\n if self.usecols_dtype == \"integer\":\n # self.usecols is a set, which is documented as unordered\n # but in practice, a CPython set of integers is sorted.\n # In other implementations this assumption does not hold.\n # The following code simulates a different order, which\n # before GH 17351 would cause the wrong columns to be\n # converted via the parse_dates parameter\n self.usecols = list(self.usecols)\n self.usecols.reverse()\n return CParserWrapper._set_noconvert_columns(self)\n\n data = \"\"\"a,b,c,d,e\n0,1,20140101,0900,4\n0,1,20140102,1000,4\"\"\"\n\n parse_dates = [[1, 2]]\n cols = {\n \"a\": [0, 0],\n \"c_d\": [Timestamp(\"2014-01-01 09:00:00\"), Timestamp(\"2014-01-02 10:00:00\")],\n }\n expected = DataFrame(cols, columns=[\"c_d\", \"a\"])\n\n parser = MyTextFileReader()\n parser.options = {\n \"usecols\": [0, 2, 3],\n \"parse_dates\": parse_dates,\n \"delimiter\": \",\",\n }\n parser._engine = MyCParserWrapper(StringIO(data), **parser.options)\n\n result = parser.read()\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_decimal_marker(all_parsers):\n data = \"\"\"A|B|C\n1|2,334|5\n10|13|10.\n\"\"\"\n # Parsers support only length-1 decimals\n msg = \"Only length-1 decimal markers supported\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), decimal=\"\")\n\n\ndef test_bad_stream_exception(all_parsers, csv_dir_path):\n # see gh-13652\n #\n # This test validates that both the Python engine and C engine will\n # raise UnicodeDecodeError instead of C engine raising ParserError\n # and swallowing the exception that caused read to fail.\n path = os.path.join(csv_dir_path, \"sauron.SHIFT_JIS.csv\")\n codec = codecs.lookup(\"utf-8\")\n utf8 = codecs.lookup(\"utf-8\")\n parser = all_parsers\n msg = \"'utf-8' codec can't decode byte\"\n\n # Stream must be binary UTF8.\n with open(path, \"rb\") as handle, codecs.StreamRecoder(\n handle, utf8.encode, utf8.decode, codec.streamreader, codec.streamwriter\n ) as stream:\n\n with pytest.raises(UnicodeDecodeError, match=msg):\n parser.read_csv(stream)\n\n\ndef test_read_csv_local(all_parsers, csv1):\n prefix = \"file:///\" if compat.is_platform_windows() else \"file://\"\n parser = all_parsers\n\n fname = prefix + str(os.path.abspath(csv1))\n result = parser.read_csv(fname, index_col=0, parse_dates=True)\n\n expected = DataFrame(\n [\n [0.980269, 3.685731, -0.364216805298, -1.159738],\n [1.047916, -0.041232, -0.16181208307, 0.212549],\n [0.498581, 0.731168, -0.537677223318, 1.346270],\n [1.120202, 1.567621, 0.00364077397681, 0.675253],\n [-0.487094, 0.571455, -1.6116394093, 0.103469],\n [0.836649, 0.246462, 0.588542635376, 1.062782],\n [-0.157161, 1.340307, 1.1957779562, -1.097007],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index(\n [\n datetime(2000, 1, 3),\n datetime(2000, 1, 4),\n datetime(2000, 1, 5),\n datetime(2000, 1, 6),\n datetime(2000, 1, 7),\n datetime(2000, 1, 10),\n datetime(2000, 1, 11),\n ],\n name=\"index\",\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_1000_sep(all_parsers):\n parser = all_parsers\n data = \"\"\"A|B|C\n1|2,334|5\n10|13|10.\n\"\"\"\n expected = DataFrame({\"A\": [1, 10], \"B\": [2334, 13], \"C\": [5, 10.0]})\n\n result = parser.read_csv(StringIO(data), sep=\"|\", thousands=\",\")\n tm.assert_frame_equal(result, expected)\n\n\ndef test_squeeze(all_parsers):\n data = \"\"\"\\\na,1\nb,2\nc,3\n\"\"\"\n parser = all_parsers\n index = Index([\"a\", \"b\", \"c\"], name=0)\n expected = Series([1, 2, 3], name=1, index=index)\n\n result = parser.read_csv(StringIO(data), index_col=0, header=None, squeeze=True)\n tm.assert_series_equal(result, expected)\n\n # see gh-8217\n #\n # Series should not be a view.\n assert not result._is_view\n\n\ndef test_malformed(all_parsers):\n # see gh-6607\n parser = all_parsers\n data = \"\"\"ignore\nA,B,C\n1,2,3 # comment\n1,2,3,4,5\n2,3,4\n\"\"\"\n msg = \"Expected 3 fields in line 4, saw 5\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), header=1, comment=\"#\")\n\n\[email protected](\"nrows\", [5, 3, None])\ndef test_malformed_chunks(all_parsers, nrows):\n data = \"\"\"ignore\nA,B,C\nskip\n1,2,3\n3,5,10 # comment\n1,2,3,4,5\n2,3,4\n\"\"\"\n parser = all_parsers\n msg = \"Expected 3 fields in line 6, saw 5\"\n reader = parser.read_csv(\n StringIO(data), header=1, comment=\"#\", iterator=True, chunksize=1, skiprows=[2]\n )\n\n with pytest.raises(ParserError, match=msg):\n reader.read(nrows)\n\n\ndef test_unnamed_columns(all_parsers):\n data = \"\"\"A,B,C,,\n1,2,3,4,5\n6,7,8,9,10\n11,12,13,14,15\n\"\"\"\n parser = all_parsers\n expected = DataFrame(\n [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]],\n dtype=np.int64,\n columns=[\"A\", \"B\", \"C\", \"Unnamed: 3\", \"Unnamed: 4\"],\n )\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_csv_mixed_type(all_parsers):\n data = \"\"\"A,B,C\na,1,2\nb,3,4\nc,4,5\n\"\"\"\n parser = all_parsers\n expected = DataFrame({\"A\": [\"a\", \"b\", \"c\"], \"B\": [1, 3, 4], \"C\": [2, 4, 5]})\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_low_memory_no_rows_with_index(all_parsers):\n # see gh-21141\n parser = all_parsers\n\n if not parser.low_memory:\n pytest.skip(\"This is a low-memory specific test\")\n\n data = \"\"\"A,B,C\n1,1,1,2\n2,2,3,4\n3,3,4,5\n\"\"\"\n result = parser.read_csv(StringIO(data), low_memory=True, index_col=0, nrows=0)\n expected = DataFrame(columns=[\"A\", \"B\", \"C\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_dataframe(all_parsers, csv1):\n parser = all_parsers\n result = parser.read_csv(csv1, index_col=0, parse_dates=True)\n\n expected = DataFrame(\n [\n [0.980269, 3.685731, -0.364216805298, -1.159738],\n [1.047916, -0.041232, -0.16181208307, 0.212549],\n [0.498581, 0.731168, -0.537677223318, 1.346270],\n [1.120202, 1.567621, 0.00364077397681, 0.675253],\n [-0.487094, 0.571455, -1.6116394093, 0.103469],\n [0.836649, 0.246462, 0.588542635376, 1.062782],\n [-0.157161, 1.340307, 1.1957779562, -1.097007],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index(\n [\n datetime(2000, 1, 3),\n datetime(2000, 1, 4),\n datetime(2000, 1, 5),\n datetime(2000, 1, 6),\n datetime(2000, 1, 7),\n datetime(2000, 1, 10),\n datetime(2000, 1, 11),\n ],\n name=\"index\",\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_no_index_name(all_parsers, csv_dir_path):\n parser = all_parsers\n csv2 = os.path.join(csv_dir_path, \"test2.csv\")\n result = parser.read_csv(csv2, index_col=0, parse_dates=True)\n\n expected = DataFrame(\n [\n [0.980269, 3.685731, -0.364216805298, -1.159738, \"foo\"],\n [1.047916, -0.041232, -0.16181208307, 0.212549, \"bar\"],\n [0.498581, 0.731168, -0.537677223318, 1.346270, \"baz\"],\n [1.120202, 1.567621, 0.00364077397681, 0.675253, \"qux\"],\n [-0.487094, 0.571455, -1.6116394093, 0.103469, \"foo2\"],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\", \"E\"],\n index=Index(\n [\n datetime(2000, 1, 3),\n datetime(2000, 1, 4),\n datetime(2000, 1, 5),\n datetime(2000, 1, 6),\n datetime(2000, 1, 7),\n ]\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_wrong_num_columns(all_parsers):\n # Too few columns.\n data = \"\"\"A,B,C,D,E,F\n1,2,3,4,5,6\n6,7,8,9,10,11,12\n11,12,13,14,15,16\n\"\"\"\n parser = all_parsers\n msg = \"Expected 6 fields in line 3, saw 7\"\n\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data))\n\n\ndef test_read_duplicate_index_explicit(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo,12,13,14,15\nbar,12,13,14,15\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=0)\n\n expected = DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index([\"foo\", \"bar\", \"baz\", \"qux\", \"foo\", \"bar\"], name=\"index\"),\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_duplicate_index_implicit(all_parsers):\n data = \"\"\"A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo,12,13,14,15\nbar,12,13,14,15\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data))\n\n expected = DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=Index([\"foo\", \"bar\", \"baz\", \"qux\", \"foo\", \"bar\"]),\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,kwargs,expected\",\n [\n (\n \"A,B\\nTrue,1\\nFalse,2\\nTrue,3\",\n dict(),\n DataFrame([[True, 1], [False, 2], [True, 3]], columns=[\"A\", \"B\"]),\n ),\n (\n \"A,B\\nYES,1\\nno,2\\nyes,3\\nNo,3\\nYes,3\",\n dict(true_values=[\"yes\", \"Yes\", \"YES\"], false_values=[\"no\", \"NO\", \"No\"]),\n DataFrame(\n [[True, 1], [False, 2], [True, 3], [False, 3], [True, 3]],\n columns=[\"A\", \"B\"],\n ),\n ),\n (\n \"A,B\\nTRUE,1\\nFALSE,2\\nTRUE,3\",\n dict(),\n DataFrame([[True, 1], [False, 2], [True, 3]], columns=[\"A\", \"B\"]),\n ),\n (\n \"A,B\\nfoo,bar\\nbar,foo\",\n dict(true_values=[\"foo\"], false_values=[\"bar\"]),\n DataFrame([[True, False], [False, True]], columns=[\"A\", \"B\"]),\n ),\n ],\n)\ndef test_parse_bool(all_parsers, data, kwargs, expected):\n parser = all_parsers\n result = parser.read_csv(StringIO(data), **kwargs)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_int_conversion(all_parsers):\n data = \"\"\"A,B\n1.0,1\n2.0,2\n3.0,3\n\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data))\n\n expected = DataFrame([[1.0, 1], [2.0, 2], [3.0, 3]], columns=[\"A\", \"B\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"nrows\", [3, 3.0])\ndef test_read_nrows(all_parsers, nrows):\n # see gh-10476\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n expected = DataFrame(\n [[\"foo\", 2, 3, 4, 5], [\"bar\", 7, 8, 9, 10], [\"baz\", 12, 13, 14, 15]],\n columns=[\"index\", \"A\", \"B\", \"C\", \"D\"],\n )\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data), nrows=nrows)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"nrows\", [1.2, \"foo\", -1])\ndef test_read_nrows_bad(all_parsers, nrows):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n msg = r\"'nrows' must be an integer >=0\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), nrows=nrows)\n\n\[email protected](\"index_col\", [0, \"index\"])\ndef test_read_chunksize_with_index(all_parsers, index_col):\n parser = all_parsers\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n\n reader = parser.read_csv(StringIO(data), index_col=0, chunksize=2)\n expected = DataFrame(\n [\n [\"foo\", 2, 3, 4, 5],\n [\"bar\", 7, 8, 9, 10],\n [\"baz\", 12, 13, 14, 15],\n [\"qux\", 12, 13, 14, 15],\n [\"foo2\", 12, 13, 14, 15],\n [\"bar2\", 12, 13, 14, 15],\n ],\n columns=[\"index\", \"A\", \"B\", \"C\", \"D\"],\n )\n expected = expected.set_index(\"index\")\n\n chunks = list(reader)\n tm.assert_frame_equal(chunks[0], expected[:2])\n tm.assert_frame_equal(chunks[1], expected[2:4])\n tm.assert_frame_equal(chunks[2], expected[4:])\n\n\[email protected](\"chunksize\", [1.3, \"foo\", 0])\ndef test_read_chunksize_bad(all_parsers, chunksize):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n msg = r\"'chunksize' must be an integer >=1\"\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), chunksize=chunksize)\n\n\[email protected](\"chunksize\", [2, 8])\ndef test_read_chunksize_and_nrows(all_parsers, chunksize):\n # see gh-15755\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0, nrows=5)\n\n reader = parser.read_csv(StringIO(data), chunksize=chunksize, **kwargs)\n expected = parser.read_csv(StringIO(data), **kwargs)\n tm.assert_frame_equal(concat(reader), expected)\n\n\ndef test_read_chunksize_and_nrows_changing_size(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0, nrows=5)\n\n reader = parser.read_csv(StringIO(data), chunksize=8, **kwargs)\n expected = parser.read_csv(StringIO(data), **kwargs)\n\n tm.assert_frame_equal(reader.get_chunk(size=2), expected.iloc[:2])\n tm.assert_frame_equal(reader.get_chunk(size=4), expected.iloc[2:5])\n\n with pytest.raises(StopIteration, match=\"\"):\n reader.get_chunk(size=3)\n\n\ndef test_get_chunk_passed_chunksize(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C\n1,2,3\n4,5,6\n7,8,9\n1,2,3\"\"\"\n\n reader = parser.read_csv(StringIO(data), chunksize=2)\n result = reader.get_chunk()\n\n expected = DataFrame([[1, 2, 3], [4, 5, 6]], columns=[\"A\", \"B\", \"C\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"kwargs\", [dict(), dict(index_col=0)])\ndef test_read_chunksize_compat(all_parsers, kwargs):\n # see gh-12185\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n reader = parser.read_csv(StringIO(data), chunksize=2, **kwargs)\n\n result = parser.read_csv(StringIO(data), **kwargs)\n tm.assert_frame_equal(concat(reader), result)\n\n\ndef test_read_chunksize_jagged_names(all_parsers):\n # see gh-23509\n parser = all_parsers\n data = \"\\n\".join([\"0\"] * 7 + [\",\".join([\"0\"] * 10)])\n\n expected = DataFrame([[0] + [np.nan] * 9] * 7 + [[0] * 10])\n reader = parser.read_csv(StringIO(data), names=range(10), chunksize=4)\n\n result = concat(reader)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_data_list(all_parsers):\n parser = all_parsers\n kwargs = dict(index_col=0)\n data = \"A,B,C\\nfoo,1,2,3\\nbar,4,5,6\"\n\n data_list = [[\"A\", \"B\", \"C\"], [\"foo\", \"1\", \"2\", \"3\"], [\"bar\", \"4\", \"5\", \"6\"]]\n expected = parser.read_csv(StringIO(data), **kwargs)\n\n parser = TextParser(data_list, chunksize=2, **kwargs)\n result = parser.read()\n\n tm.assert_frame_equal(result, expected)\n\n\ndef test_iterator(all_parsers):\n # see gh-6607\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0)\n\n expected = parser.read_csv(StringIO(data), **kwargs)\n reader = parser.read_csv(StringIO(data), iterator=True, **kwargs)\n\n first_chunk = reader.read(3)\n tm.assert_frame_equal(first_chunk, expected[:3])\n\n last_chunk = reader.read(5)\n tm.assert_frame_equal(last_chunk, expected[3:])\n\n\ndef test_iterator2(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C\nfoo,1,2,3\nbar,4,5,6\nbaz,7,8,9\n\"\"\"\n\n reader = parser.read_csv(StringIO(data), iterator=True)\n result = list(reader)\n\n expected = DataFrame(\n [[1, 2, 3], [4, 5, 6], [7, 8, 9]],\n index=[\"foo\", \"bar\", \"baz\"],\n columns=[\"A\", \"B\", \"C\"],\n )\n tm.assert_frame_equal(result[0], expected)\n\n\ndef test_reader_list(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0)\n\n lines = list(csv.reader(StringIO(data)))\n reader = TextParser(lines, chunksize=2, **kwargs)\n\n expected = parser.read_csv(StringIO(data), **kwargs)\n chunks = list(reader)\n\n tm.assert_frame_equal(chunks[0], expected[:2])\n tm.assert_frame_equal(chunks[1], expected[2:4])\n tm.assert_frame_equal(chunks[2], expected[4:])\n\n\ndef test_reader_list_skiprows(all_parsers):\n data = \"\"\"index,A,B,C,D\nfoo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\"\n parser = all_parsers\n kwargs = dict(index_col=0)\n\n lines = list(csv.reader(StringIO(data)))\n reader = TextParser(lines, chunksize=2, skiprows=[1], **kwargs)\n\n expected = parser.read_csv(StringIO(data), **kwargs)\n chunks = list(reader)\n\n tm.assert_frame_equal(chunks[0], expected[1:3])\n\n\ndef test_iterator_stop_on_chunksize(all_parsers):\n # gh-3967: stopping iteration when chunksize is specified\n parser = all_parsers\n data = \"\"\"A,B,C\nfoo,1,2,3\nbar,4,5,6\nbaz,7,8,9\n\"\"\"\n\n reader = parser.read_csv(StringIO(data), chunksize=1)\n result = list(reader)\n\n assert len(result) == 3\n expected = DataFrame(\n [[1, 2, 3], [4, 5, 6], [7, 8, 9]],\n index=[\"foo\", \"bar\", \"baz\"],\n columns=[\"A\", \"B\", \"C\"],\n )\n tm.assert_frame_equal(concat(result), expected)\n\n\[email protected](\n \"kwargs\", [dict(iterator=True, chunksize=1), dict(iterator=True), dict(chunksize=1)]\n)\ndef test_iterator_skipfooter_errors(all_parsers, kwargs):\n msg = \"'skipfooter' not supported for 'iteration'\"\n parser = all_parsers\n data = \"a\\n1\\n2\"\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), skipfooter=1, **kwargs)\n\n\ndef test_nrows_skipfooter_errors(all_parsers):\n msg = \"'skipfooter' not supported with 'nrows'\"\n data = \"a\\n1\\n2\\n3\\n4\\n5\\n6\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), skipfooter=1, nrows=5)\n\n\[email protected](\n \"data,kwargs,expected\",\n [\n (\n \"\"\"foo,2,3,4,5\nbar,7,8,9,10\nbaz,12,13,14,15\nqux,12,13,14,15\nfoo2,12,13,14,15\nbar2,12,13,14,15\n\"\"\",\n dict(index_col=0, names=[\"index\", \"A\", \"B\", \"C\", \"D\"]),\n DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n index=Index([\"foo\", \"bar\", \"baz\", \"qux\", \"foo2\", \"bar2\"], name=\"index\"),\n columns=[\"A\", \"B\", \"C\", \"D\"],\n ),\n ),\n (\n \"\"\"foo,one,2,3,4,5\nfoo,two,7,8,9,10\nfoo,three,12,13,14,15\nbar,one,12,13,14,15\nbar,two,12,13,14,15\n\"\"\",\n dict(index_col=[0, 1], names=[\"index1\", \"index2\", \"A\", \"B\", \"C\", \"D\"]),\n DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n index=MultiIndex.from_tuples(\n [\n (\"foo\", \"one\"),\n (\"foo\", \"two\"),\n (\"foo\", \"three\"),\n (\"bar\", \"one\"),\n (\"bar\", \"two\"),\n ],\n names=[\"index1\", \"index2\"],\n ),\n columns=[\"A\", \"B\", \"C\", \"D\"],\n ),\n ),\n ],\n)\ndef test_pass_names_with_index(all_parsers, data, kwargs, expected):\n parser = all_parsers\n result = parser.read_csv(StringIO(data), **kwargs)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"index_col\", [[0, 1], [1, 0]])\ndef test_multi_index_no_level_names(all_parsers, index_col):\n data = \"\"\"index1,index2,A,B,C,D\nfoo,one,2,3,4,5\nfoo,two,7,8,9,10\nfoo,three,12,13,14,15\nbar,one,12,13,14,15\nbar,two,12,13,14,15\n\"\"\"\n headless_data = \"\\n\".join(data.split(\"\\n\")[1:])\n\n names = [\"A\", \"B\", \"C\", \"D\"]\n parser = all_parsers\n\n result = parser.read_csv(\n StringIO(headless_data), index_col=index_col, header=None, names=names\n )\n expected = parser.read_csv(StringIO(data), index_col=index_col)\n\n # No index names in headless data.\n expected.index.names = [None] * 2\n tm.assert_frame_equal(result, expected)\n\n\ndef test_multi_index_no_level_names_implicit(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C,D\nfoo,one,2,3,4,5\nfoo,two,7,8,9,10\nfoo,three,12,13,14,15\nbar,one,12,13,14,15\nbar,two,12,13,14,15\n\"\"\"\n\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n [\n [2, 3, 4, 5],\n [7, 8, 9, 10],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n [12, 13, 14, 15],\n ],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=MultiIndex.from_tuples(\n [\n (\"foo\", \"one\"),\n (\"foo\", \"two\"),\n (\"foo\", \"three\"),\n (\"bar\", \"one\"),\n (\"bar\", \"two\"),\n ]\n ),\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,expected,header\",\n [\n (\"a,b\", DataFrame(columns=[\"a\", \"b\"]), [0]),\n (\n \"a,b\\nc,d\",\n DataFrame(columns=MultiIndex.from_tuples([(\"a\", \"c\"), (\"b\", \"d\")])),\n [0, 1],\n ),\n ],\n)\[email protected](\"round_trip\", [True, False])\ndef test_multi_index_blank_df(all_parsers, data, expected, header, round_trip):\n # see gh-14545\n parser = all_parsers\n data = expected.to_csv(index=False) if round_trip else data\n\n result = parser.read_csv(StringIO(data), header=header)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_no_unnamed_index(all_parsers):\n parser = all_parsers\n data = \"\"\" id c0 c1 c2\n0 1 0 a b\n1 2 0 c d\n2 2 2 e f\n\"\"\"\n result = parser.read_csv(StringIO(data), sep=\" \")\n expected = DataFrame(\n [[0, 1, 0, \"a\", \"b\"], [1, 2, 0, \"c\", \"d\"], [2, 2, 2, \"e\", \"f\"]],\n columns=[\"Unnamed: 0\", \"id\", \"c0\", \"c1\", \"c2\"],\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_read_csv_parse_simple_list(all_parsers):\n parser = all_parsers\n data = \"\"\"foo\nbar baz\nqux foo\nfoo\nbar\"\"\"\n\n result = parser.read_csv(StringIO(data), header=None)\n expected = DataFrame([\"foo\", \"bar baz\", \"qux foo\", \"foo\", \"bar\"])\n tm.assert_frame_equal(result, expected)\n\n\[email protected]\ndef test_url(all_parsers, csv_dir_path):\n # TODO: FTP testing\n parser = all_parsers\n kwargs = dict(sep=\"\\t\")\n\n url = (\n \"https://raw.github.com/pandas-dev/pandas/master/\"\n \"pandas/tests/io/parser/data/salaries.csv\"\n )\n url_result = parser.read_csv(url, **kwargs)\n\n local_path = os.path.join(csv_dir_path, \"salaries.csv\")\n local_result = parser.read_csv(local_path, **kwargs)\n tm.assert_frame_equal(url_result, local_result)\n\n\[email protected]\ndef test_local_file(all_parsers, csv_dir_path):\n parser = all_parsers\n kwargs = dict(sep=\"\\t\")\n\n local_path = os.path.join(csv_dir_path, \"salaries.csv\")\n local_result = parser.read_csv(local_path, **kwargs)\n url = \"file://localhost/\" + local_path\n\n try:\n url_result = parser.read_csv(url, **kwargs)\n tm.assert_frame_equal(url_result, local_result)\n except URLError:\n # Fails on some systems.\n pytest.skip(\"Failing on: \" + \" \".join(platform.uname()))\n\n\ndef test_path_path_lib(all_parsers):\n parser = all_parsers\n df = tm.makeDataFrame()\n result = tm.round_trip_pathlib(df.to_csv, lambda p: parser.read_csv(p, index_col=0))\n tm.assert_frame_equal(df, result)\n\n\ndef test_path_local_path(all_parsers):\n parser = all_parsers\n df = tm.makeDataFrame()\n result = tm.round_trip_localpath(\n df.to_csv, lambda p: parser.read_csv(p, index_col=0)\n )\n tm.assert_frame_equal(df, result)\n\n\ndef test_nonexistent_path(all_parsers):\n # gh-2428: pls no segfault\n # gh-14086: raise more helpful FileNotFoundError\n # GH#29233 \"File foo\" instead of \"File b'foo'\"\n parser = all_parsers\n path = f\"{tm.rands(10)}.csv\"\n\n msg = r\"\\[Errno 2\\]\"\n with pytest.raises(FileNotFoundError, match=msg) as e:\n parser.read_csv(path)\n assert path == e.value.filename\n\n\[email protected]_if_windows # os.chmod does not work in windows\ndef test_no_permission(all_parsers):\n # GH 23784\n parser = all_parsers\n\n msg = r\"\\[Errno 13\\]\"\n with tm.ensure_clean() as path:\n os.chmod(path, 0) # make file unreadable\n\n # verify that this process cannot open the file (not running as sudo)\n try:\n with open(path):\n pass\n pytest.skip(\"Running as sudo.\")\n except PermissionError:\n pass\n\n with pytest.raises(PermissionError, match=msg) as e:\n parser.read_csv(path)\n assert path == e.value.filename\n\n\ndef test_missing_trailing_delimiters(all_parsers):\n parser = all_parsers\n data = \"\"\"A,B,C,D\n1,2,3,4\n1,3,3,\n1,4,5\"\"\"\n\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n [[1, 2, 3, 4], [1, 3, 3, np.nan], [1, 4, 5, np.nan]],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_skip_initial_space(all_parsers):\n data = (\n '\"09-Apr-2012\", \"01:10:18.300\", 2456026.548822908, 12849, '\n \"1.00361, 1.12551, 330.65659, 0355626618.16711, 73.48821, \"\n \"314.11625, 1917.09447, 179.71425, 80.000, 240.000, -350, \"\n \"70.06056, 344.98370, 1, 1, -0.689265, -0.692787, \"\n \"0.212036, 14.7674, 41.605, -9999.0, -9999.0, \"\n \"-9999.0, -9999.0, -9999.0, -9999.0, 000, 012, 128\"\n )\n parser = all_parsers\n\n result = parser.read_csv(\n StringIO(data),\n names=list(range(33)),\n header=None,\n na_values=[\"-9999.0\"],\n skipinitialspace=True,\n )\n expected = DataFrame(\n [\n [\n \"09-Apr-2012\",\n \"01:10:18.300\",\n 2456026.548822908,\n 12849,\n 1.00361,\n 1.12551,\n 330.65659,\n 355626618.16711,\n 73.48821,\n 314.11625,\n 1917.09447,\n 179.71425,\n 80.0,\n 240.0,\n -350,\n 70.06056,\n 344.9837,\n 1,\n 1,\n -0.689265,\n -0.692787,\n 0.212036,\n 14.7674,\n 41.605,\n np.nan,\n np.nan,\n np.nan,\n np.nan,\n np.nan,\n np.nan,\n 0,\n 12,\n 128,\n ]\n ]\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_trailing_delimiters(all_parsers):\n # see gh-2442\n data = \"\"\"A,B,C\n1,2,3,\n4,5,6,\n7,8,9,\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=False)\n\n expected = DataFrame({\"A\": [1, 4, 7], \"B\": [2, 5, 8], \"C\": [3, 6, 9]})\n tm.assert_frame_equal(result, expected)\n\n\ndef test_escapechar(all_parsers):\n # https://stackoverflow.com/questions/13824840/feature-request-for-\n # pandas-read-csv\n data = '''SEARCH_TERM,ACTUAL_URL\n\"bra tv bord\",\"http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord\"\n\"tv p\\xc3\\xa5 hjul\",\"http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord\"\n\"SLAGBORD, \\\\\"Bergslagen\\\\\", IKEA:s 1700-tals series\",\"http://www.ikea.com/se/sv/catalog/categories/departments/living_room/10475/?se%7cps%7cnonbranded%7cvardagsrum%7cgoogle%7ctv_bord\"''' # noqa\n\n parser = all_parsers\n result = parser.read_csv(\n StringIO(data), escapechar=\"\\\\\", quotechar='\"', encoding=\"utf-8\"\n )\n\n assert result[\"SEARCH_TERM\"][2] == 'SLAGBORD, \"Bergslagen\", IKEA:s 1700-tals series'\n\n tm.assert_index_equal(result.columns, Index([\"SEARCH_TERM\", \"ACTUAL_URL\"]))\n\n\ndef test_int64_min_issues(all_parsers):\n # see gh-2599\n parser = all_parsers\n data = \"A,B\\n0,0\\n0,\"\n result = parser.read_csv(StringIO(data))\n\n expected = DataFrame({\"A\": [0, 0], \"B\": [0, np.nan]})\n tm.assert_frame_equal(result, expected)\n\n\ndef test_parse_integers_above_fp_precision(all_parsers):\n data = \"\"\"Numbers\n17007000002000191\n17007000002000191\n17007000002000191\n17007000002000191\n17007000002000192\n17007000002000192\n17007000002000192\n17007000002000192\n17007000002000192\n17007000002000194\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n {\n \"Numbers\": [\n 17007000002000191,\n 17007000002000191,\n 17007000002000191,\n 17007000002000191,\n 17007000002000192,\n 17007000002000192,\n 17007000002000192,\n 17007000002000192,\n 17007000002000192,\n 17007000002000194,\n ]\n }\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_chunks_have_consistent_numerical_type(all_parsers):\n parser = all_parsers\n integers = [str(i) for i in range(499999)]\n data = \"a\\n\" + \"\\n\".join(integers + [\"1.0\", \"2.0\"] + integers)\n\n # Coercions should work without warnings.\n with tm.assert_produces_warning(None):\n result = parser.read_csv(StringIO(data))\n\n assert type(result.a[0]) is np.float64\n assert result.a.dtype == float\n\n\ndef test_warn_if_chunks_have_mismatched_type(all_parsers):\n warning_type = None\n parser = all_parsers\n integers = [str(i) for i in range(499999)]\n data = \"a\\n\" + \"\\n\".join(integers + [\"a\", \"b\"] + integers)\n\n # see gh-3866: if chunks are different types and can't\n # be coerced using numerical types, then issue warning.\n if parser.engine == \"c\" and parser.low_memory:\n warning_type = DtypeWarning\n\n with tm.assert_produces_warning(warning_type):\n df = parser.read_csv(StringIO(data))\n assert df.a.dtype == object\n\n\[email protected](\"sep\", [\" \", r\"\\s+\"])\ndef test_integer_overflow_bug(all_parsers, sep):\n # see gh-2601\n data = \"65248E10 11\\n55555E55 22\\n\"\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data), header=None, sep=sep)\n expected = DataFrame([[6.5248e14, 11], [5.5555e59, 22]])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_catch_too_many_names(all_parsers):\n # see gh-5156\n data = \"\"\"\\\n1,2,3\n4,,6\n7,8,9\n10,11,12\\n\"\"\"\n parser = all_parsers\n msg = (\n \"Too many columns specified: expected 4 and found 3\"\n if parser.engine == \"c\"\n else \"Number of passed names did not match \"\n \"number of header fields in the file\"\n )\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(StringIO(data), header=0, names=[\"a\", \"b\", \"c\", \"d\"])\n\n\ndef test_ignore_leading_whitespace(all_parsers):\n # see gh-3374, gh-6607\n parser = all_parsers\n data = \" a b c\\n 1 2 3\\n 4 5 6\\n 7 8 9\"\n result = parser.read_csv(StringIO(data), sep=r\"\\s+\")\n\n expected = DataFrame({\"a\": [1, 4, 7], \"b\": [2, 5, 8], \"c\": [3, 6, 9]})\n tm.assert_frame_equal(result, expected)\n\n\ndef test_chunk_begins_with_newline_whitespace(all_parsers):\n # see gh-10022\n parser = all_parsers\n data = \"\\n hello\\nworld\\n\"\n\n result = parser.read_csv(StringIO(data), header=None)\n expected = DataFrame([\" hello\", \"world\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_with_index(all_parsers):\n # see gh-10184\n data = \"x,y\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=0)\n\n expected = DataFrame(columns=[\"y\"], index=Index([], name=\"x\"))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_with_multi_index(all_parsers):\n # see gh-10467\n data = \"x,y,z\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=[\"x\", \"y\"])\n\n expected = DataFrame(\n columns=[\"z\"], index=MultiIndex.from_arrays([[]] * 2, names=[\"x\", \"y\"])\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_empty_with_reversed_multi_index(all_parsers):\n data = \"x,y,z\"\n parser = all_parsers\n result = parser.read_csv(StringIO(data), index_col=[1, 0])\n\n expected = DataFrame(\n columns=[\"z\"], index=MultiIndex.from_arrays([[]] * 2, names=[\"y\", \"x\"])\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_float_parser(all_parsers):\n # see gh-9565\n parser = all_parsers\n data = \"45e-1,4.5,45.,inf,-inf\"\n result = parser.read_csv(StringIO(data), header=None)\n\n expected = DataFrame([[float(s) for s in data.split(\",\")]])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_scientific_no_exponent(all_parsers):\n # see gh-12215\n df = DataFrame.from_dict({\"w\": [\"2e\"], \"x\": [\"3E\"], \"y\": [\"42e\"], \"z\": [\"632E\"]})\n data = df.to_csv(index=False)\n parser = all_parsers\n\n for precision in parser.float_precision_choices:\n df_roundtrip = parser.read_csv(StringIO(data), float_precision=precision)\n tm.assert_frame_equal(df_roundtrip, df)\n\n\[email protected](\"conv\", [None, np.int64, np.uint64])\ndef test_int64_overflow(all_parsers, conv):\n data = \"\"\"ID\n00013007854817840016671868\n00013007854817840016749251\n00013007854817840016754630\n00013007854817840016781876\n00013007854817840017028824\n00013007854817840017963235\n00013007854817840018860166\"\"\"\n parser = all_parsers\n\n if conv is None:\n # 13007854817840016671868 > UINT64_MAX, so this\n # will overflow and return object as the dtype.\n result = parser.read_csv(StringIO(data))\n expected = DataFrame(\n [\n \"00013007854817840016671868\",\n \"00013007854817840016749251\",\n \"00013007854817840016754630\",\n \"00013007854817840016781876\",\n \"00013007854817840017028824\",\n \"00013007854817840017963235\",\n \"00013007854817840018860166\",\n ],\n columns=[\"ID\"],\n )\n tm.assert_frame_equal(result, expected)\n else:\n # 13007854817840016671868 > UINT64_MAX, so attempts\n # to cast to either int64 or uint64 will result in\n # an OverflowError being raised.\n msg = (\n \"(Python int too large to convert to C long)|\"\n \"(long too big to convert)|\"\n \"(int too big to convert)\"\n )\n\n with pytest.raises(OverflowError, match=msg):\n parser.read_csv(StringIO(data), converters={\"ID\": conv})\n\n\[email protected](\n \"val\", [np.iinfo(np.uint64).max, np.iinfo(np.int64).max, np.iinfo(np.int64).min]\n)\ndef test_int64_uint64_range(all_parsers, val):\n # These numbers fall right inside the int64-uint64\n # range, so they should be parsed as string.\n parser = all_parsers\n result = parser.read_csv(StringIO(str(val)), header=None)\n\n expected = DataFrame([val])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"val\", [np.iinfo(np.uint64).max + 1, np.iinfo(np.int64).min - 1]\n)\ndef test_outside_int64_uint64_range(all_parsers, val):\n # These numbers fall just outside the int64-uint64\n # range, so they should be parsed as string.\n parser = all_parsers\n result = parser.read_csv(StringIO(str(val)), header=None)\n\n expected = DataFrame([str(val)])\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"exp_data\", [[str(-1), str(2 ** 63)], [str(2 ** 63), str(-1)]])\ndef test_numeric_range_too_wide(all_parsers, exp_data):\n # No numerical dtype can hold both negative and uint64\n # values, so they should be cast as string.\n parser = all_parsers\n data = \"\\n\".join(exp_data)\n expected = DataFrame(exp_data)\n\n result = parser.read_csv(StringIO(data), header=None)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"iterator\", [True, False])\ndef test_empty_with_nrows_chunksize(all_parsers, iterator):\n # see gh-9535\n parser = all_parsers\n expected = DataFrame(columns=[\"foo\", \"bar\"])\n\n nrows = 10\n data = StringIO(\"foo,bar\\n\")\n\n if iterator:\n result = next(iter(parser.read_csv(data, chunksize=nrows)))\n else:\n result = parser.read_csv(data, nrows=nrows)\n\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,kwargs,expected,msg\",\n [\n # gh-10728: WHITESPACE_LINE\n (\n \"a,b,c\\n4,5,6\\n \",\n dict(),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # gh-10548: EAT_LINE_COMMENT\n (\n \"a,b,c\\n4,5,6\\n#comment\",\n dict(comment=\"#\"),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_CRNL_NOP\n (\n \"a,b,c\\n4,5,6\\n\\r\",\n dict(),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_COMMENT\n (\n \"a,b,c\\n4,5,6#comment\",\n dict(comment=\"#\"),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # SKIP_LINE\n (\n \"a,b,c\\n4,5,6\\nskipme\",\n dict(skiprows=[2]),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_LINE_COMMENT\n (\n \"a,b,c\\n4,5,6\\n#comment\",\n dict(comment=\"#\", skip_blank_lines=False),\n DataFrame([[4, 5, 6]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # IN_FIELD\n (\n \"a,b,c\\n4,5,6\\n \",\n dict(skip_blank_lines=False),\n DataFrame([[\"4\", 5, 6], [\" \", None, None]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # EAT_CRNL\n (\n \"a,b,c\\n4,5,6\\n\\r\",\n dict(skip_blank_lines=False),\n DataFrame([[4, 5, 6], [None, None, None]], columns=[\"a\", \"b\", \"c\"]),\n None,\n ),\n # ESCAPED_CHAR\n (\n \"a,b,c\\n4,5,6\\n\\\\\",\n dict(escapechar=\"\\\\\"),\n None,\n \"(EOF following escape character)|(unexpected end of data)\",\n ),\n # ESCAPE_IN_QUOTED_FIELD\n (\n 'a,b,c\\n4,5,6\\n\"\\\\',\n dict(escapechar=\"\\\\\"),\n None,\n \"(EOF inside string starting at row 2)|(unexpected end of data)\",\n ),\n # IN_QUOTED_FIELD\n (\n 'a,b,c\\n4,5,6\\n\"',\n dict(escapechar=\"\\\\\"),\n None,\n \"(EOF inside string starting at row 2)|(unexpected end of data)\",\n ),\n ],\n ids=[\n \"whitespace-line\",\n \"eat-line-comment\",\n \"eat-crnl-nop\",\n \"eat-comment\",\n \"skip-line\",\n \"eat-line-comment\",\n \"in-field\",\n \"eat-crnl\",\n \"escaped-char\",\n \"escape-in-quoted-field\",\n \"in-quoted-field\",\n ],\n)\ndef test_eof_states(all_parsers, data, kwargs, expected, msg):\n # see gh-10728, gh-10548\n parser = all_parsers\n\n if expected is None:\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), **kwargs)\n else:\n result = parser.read_csv(StringIO(data), **kwargs)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"usecols\", [None, [0, 1], [\"a\", \"b\"]])\ndef test_uneven_lines_with_usecols(all_parsers, usecols):\n # see gh-12203\n parser = all_parsers\n data = r\"\"\"a,b,c\n0,1,2\n3,4,5,6,7\n8,9,10\"\"\"\n\n if usecols is None:\n # Make sure that an error is still raised\n # when the \"usecols\" parameter is not provided.\n msg = r\"Expected \\d+ fields in line \\d+, saw \\d+\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data))\n else:\n expected = DataFrame({\"a\": [0, 3, 8], \"b\": [1, 4, 9]})\n\n result = parser.read_csv(StringIO(data), usecols=usecols)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,kwargs,expected\",\n [\n # First, check to see that the response of parser when faced with no\n # provided columns raises the correct error, with or without usecols.\n (\"\", dict(), None),\n (\"\", dict(usecols=[\"X\"]), None),\n (\n \",,\",\n dict(names=[\"Dummy\", \"X\", \"Dummy_2\"], usecols=[\"X\"]),\n DataFrame(columns=[\"X\"], index=[0], dtype=np.float64),\n ),\n (\n \"\",\n dict(names=[\"Dummy\", \"X\", \"Dummy_2\"], usecols=[\"X\"]),\n DataFrame(columns=[\"X\"]),\n ),\n ],\n)\ndef test_read_empty_with_usecols(all_parsers, data, kwargs, expected):\n # see gh-12493\n parser = all_parsers\n\n if expected is None:\n msg = \"No columns to parse from file\"\n with pytest.raises(EmptyDataError, match=msg):\n parser.read_csv(StringIO(data), **kwargs)\n else:\n result = parser.read_csv(StringIO(data), **kwargs)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"kwargs,expected\",\n [\n # gh-8661, gh-8679: this should ignore six lines, including\n # lines with trailing whitespace and blank lines.\n (\n dict(\n header=None,\n delim_whitespace=True,\n skiprows=[0, 1, 2, 3, 5, 6],\n skip_blank_lines=True,\n ),\n DataFrame([[1.0, 2.0, 4.0], [5.1, np.nan, 10.0]]),\n ),\n # gh-8983: test skipping set of rows after a row with trailing spaces.\n (\n dict(\n delim_whitespace=True, skiprows=[1, 2, 3, 5, 6], skip_blank_lines=True\n ),\n DataFrame({\"A\": [1.0, 5.1], \"B\": [2.0, np.nan], \"C\": [4.0, 10]}),\n ),\n ],\n)\ndef test_trailing_spaces(all_parsers, kwargs, expected):\n data = \"A B C \\nrandom line with trailing spaces \\nskip\\n1,2,3\\n1,2.,4.\\nrandom line with trailing tabs\\t\\t\\t\\n \\n5.1,NaN,10.0\\n\" # noqa\n parser = all_parsers\n\n result = parser.read_csv(StringIO(data.replace(\",\", \" \")), **kwargs)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_raise_on_sep_with_delim_whitespace(all_parsers):\n # see gh-6607\n data = \"a b c\\n1 2 3\"\n parser = all_parsers\n\n with pytest.raises(ValueError, match=\"you can only specify one\"):\n parser.read_csv(StringIO(data), sep=r\"\\s\", delim_whitespace=True)\n\n\[email protected](\"delim_whitespace\", [True, False])\ndef test_single_char_leading_whitespace(all_parsers, delim_whitespace):\n # see gh-9710\n parser = all_parsers\n data = \"\"\"\\\nMyColumn\na\nb\na\nb\\n\"\"\"\n\n expected = DataFrame({\"MyColumn\": list(\"abab\")})\n result = parser.read_csv(\n StringIO(data), skipinitialspace=True, delim_whitespace=delim_whitespace\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"sep,skip_blank_lines,exp_data\",\n [\n (\",\", True, [[1.0, 2.0, 4.0], [5.0, np.nan, 10.0], [-70.0, 0.4, 1.0]]),\n (r\"\\s+\", True, [[1.0, 2.0, 4.0], [5.0, np.nan, 10.0], [-70.0, 0.4, 1.0]]),\n (\n \",\",\n False,\n [\n [1.0, 2.0, 4.0],\n [np.nan, np.nan, np.nan],\n [np.nan, np.nan, np.nan],\n [5.0, np.nan, 10.0],\n [np.nan, np.nan, np.nan],\n [-70.0, 0.4, 1.0],\n ],\n ),\n ],\n)\ndef test_empty_lines(all_parsers, sep, skip_blank_lines, exp_data):\n parser = all_parsers\n data = \"\"\"\\\nA,B,C\n1,2.,4.\n\n\n5.,NaN,10.0\n\n-70,.4,1\n\"\"\"\n\n if sep == r\"\\s+\":\n data = data.replace(\",\", \" \")\n\n result = parser.read_csv(StringIO(data), sep=sep, skip_blank_lines=skip_blank_lines)\n expected = DataFrame(exp_data, columns=[\"A\", \"B\", \"C\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_whitespace_lines(all_parsers):\n parser = all_parsers\n data = \"\"\"\n\n\\t \\t\\t\n\\t\nA,B,C\n\\t 1,2.,4.\n5.,NaN,10.0\n\"\"\"\n expected = DataFrame([[1, 2.0, 4.0], [5.0, np.nan, 10.0]], columns=[\"A\", \"B\", \"C\"])\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"data,expected\",\n [\n (\n \"\"\" A B C D\na 1 2 3 4\nb 1 2 3 4\nc 1 2 3 4\n\"\"\",\n DataFrame(\n [[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]],\n columns=[\"A\", \"B\", \"C\", \"D\"],\n index=[\"a\", \"b\", \"c\"],\n ),\n ),\n (\n \" a b c\\n1 2 3 \\n4 5 6\\n 7 8 9\",\n DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]], columns=[\"a\", \"b\", \"c\"]),\n ),\n ],\n)\ndef test_whitespace_regex_separator(all_parsers, data, expected):\n # see gh-6607\n parser = all_parsers\n result = parser.read_csv(StringIO(data), sep=r\"\\s+\")\n tm.assert_frame_equal(result, expected)\n\n\ndef test_verbose_read(all_parsers, capsys):\n parser = all_parsers\n data = \"\"\"a,b,c,d\none,1,2,3\none,1,2,3\n,1,2,3\none,1,2,3\n,1,2,3\n,1,2,3\none,1,2,3\ntwo,1,2,3\"\"\"\n\n # Engines are verbose in different ways.\n parser.read_csv(StringIO(data), verbose=True)\n captured = capsys.readouterr()\n\n if parser.engine == \"c\":\n assert \"Tokenization took:\" in captured.out\n assert \"Parser memory cleanup took:\" in captured.out\n else: # Python engine\n assert captured.out == \"Filled 3 NA values in column a\\n\"\n\n\ndef test_verbose_read2(all_parsers, capsys):\n parser = all_parsers\n data = \"\"\"a,b,c,d\none,1,2,3\ntwo,1,2,3\nthree,1,2,3\nfour,1,2,3\nfive,1,2,3\n,1,2,3\nseven,1,2,3\neight,1,2,3\"\"\"\n\n parser.read_csv(StringIO(data), verbose=True, index_col=0)\n captured = capsys.readouterr()\n\n # Engines are verbose in different ways.\n if parser.engine == \"c\":\n assert \"Tokenization took:\" in captured.out\n assert \"Parser memory cleanup took:\" in captured.out\n else: # Python engine\n assert captured.out == \"Filled 1 NA values in column a\\n\"\n\n\ndef test_iteration_open_handle(all_parsers):\n parser = all_parsers\n kwargs = dict(squeeze=True, header=None)\n\n with tm.ensure_clean() as path:\n with open(path, \"w\") as f:\n f.write(\"AAA\\nBBB\\nCCC\\nDDD\\nEEE\\nFFF\\nGGG\")\n\n with open(path) as f:\n for line in f:\n if \"CCC\" in line:\n break\n\n result = parser.read_csv(f, **kwargs)\n expected = Series([\"DDD\", \"EEE\", \"FFF\", \"GGG\"], name=0)\n tm.assert_series_equal(result, expected)\n\n\[email protected](\n \"data,thousands,decimal\",\n [\n (\n \"\"\"A|B|C\n1|2,334.01|5\n10|13|10.\n\"\"\",\n \",\",\n \".\",\n ),\n (\n \"\"\"A|B|C\n1|2.334,01|5\n10|13|10,\n\"\"\",\n \".\",\n \",\",\n ),\n ],\n)\ndef test_1000_sep_with_decimal(all_parsers, data, thousands, decimal):\n parser = all_parsers\n expected = DataFrame({\"A\": [1, 10], \"B\": [2334.01, 13], \"C\": [5, 10.0]})\n\n result = parser.read_csv(\n StringIO(data), sep=\"|\", thousands=thousands, decimal=decimal\n )\n tm.assert_frame_equal(result, expected)\n\n\ndef test_euro_decimal_format(all_parsers):\n parser = all_parsers\n data = \"\"\"Id;Number1;Number2;Text1;Text2;Number3\n1;1521,1541;187101,9543;ABC;poi;4,738797819\n2;121,12;14897,76;DEF;uyt;0,377320872\n3;878,158;108013,434;GHI;rez;2,735694704\"\"\"\n\n result = parser.read_csv(StringIO(data), sep=\";\", decimal=\",\")\n expected = DataFrame(\n [\n [1, 1521.1541, 187101.9543, \"ABC\", \"poi\", 4.738797819],\n [2, 121.12, 14897.76, \"DEF\", \"uyt\", 0.377320872],\n [3, 878.158, 108013.434, \"GHI\", \"rez\", 2.735694704],\n ],\n columns=[\"Id\", \"Number1\", \"Number2\", \"Text1\", \"Text2\", \"Number3\"],\n )\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"na_filter\", [True, False])\ndef test_inf_parsing(all_parsers, na_filter):\n parser = all_parsers\n data = \"\"\"\\\n,A\na,inf\nb,-inf\nc,+Inf\nd,-Inf\ne,INF\nf,-INF\ng,+INf\nh,-INf\ni,inF\nj,-inF\"\"\"\n expected = DataFrame(\n {\"A\": [float(\"inf\"), float(\"-inf\")] * 5},\n index=[\"a\", \"b\", \"c\", \"d\", \"e\", \"f\", \"g\", \"h\", \"i\", \"j\"],\n )\n result = parser.read_csv(StringIO(data), index_col=0, na_filter=na_filter)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"na_filter\", [True, False])\ndef test_infinity_parsing(all_parsers, na_filter):\n parser = all_parsers\n data = \"\"\"\\\n,A\na,Infinity\nb,-Infinity\nc,+Infinity\n\"\"\"\n expected = DataFrame(\n {\"A\": [float(\"infinity\"), float(\"-infinity\"), float(\"+infinity\")]},\n index=[\"a\", \"b\", \"c\"],\n )\n result = parser.read_csv(StringIO(data), index_col=0, na_filter=na_filter)\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\"nrows\", [0, 1, 2, 3, 4, 5])\ndef test_raise_on_no_columns(all_parsers, nrows):\n parser = all_parsers\n data = \"\\n\" * nrows\n\n msg = \"No columns to parse from file\"\n with pytest.raises(EmptyDataError, match=msg):\n parser.read_csv(StringIO(data))\n\n\[email protected]_file_leaks\ndef test_memory_map(all_parsers, csv_dir_path):\n mmap_file = os.path.join(csv_dir_path, \"test_mmap.csv\")\n parser = all_parsers\n\n expected = DataFrame(\n {\"a\": [1, 2, 3], \"b\": [\"one\", \"two\", \"three\"], \"c\": [\"I\", \"II\", \"III\"]}\n )\n\n result = parser.read_csv(mmap_file, memory_map=True)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_null_byte_char(all_parsers):\n # see gh-2741\n data = \"\\x00,foo\"\n names = [\"a\", \"b\"]\n parser = all_parsers\n\n if parser.engine == \"c\":\n expected = DataFrame([[np.nan, \"foo\"]], columns=names)\n out = parser.read_csv(StringIO(data), names=names)\n tm.assert_frame_equal(out, expected)\n else:\n msg = \"NULL byte detected\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), names=names)\n\n\ndef test_temporary_file(all_parsers):\n # see gh-13398\n parser = all_parsers\n data = \"0 0\"\n\n with tm.ensure_clean(mode=\"w+\", return_filelike=True) as new_file:\n new_file.write(data)\n new_file.flush()\n new_file.seek(0)\n\n result = parser.read_csv(new_file, sep=r\"\\s+\", header=None)\n\n expected = DataFrame([[0, 0]])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_internal_eof_byte(all_parsers):\n # see gh-5500\n parser = all_parsers\n data = \"a,b\\n1\\x1a,2\"\n\n expected = DataFrame([[\"1\\x1a\", 2]], columns=[\"a\", \"b\"])\n result = parser.read_csv(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_internal_eof_byte_to_file(all_parsers):\n # see gh-16559\n parser = all_parsers\n data = b'c1,c2\\r\\n\"test \\x1a test\", test\\r\\n'\n expected = DataFrame([[\"test \\x1a test\", \" test\"]], columns=[\"c1\", \"c2\"])\n path = f\"__{tm.rands(10)}__.csv\"\n\n with tm.ensure_clean(path) as path:\n with open(path, \"wb\") as f:\n f.write(data)\n\n result = parser.read_csv(path)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_sub_character(all_parsers, csv_dir_path):\n # see gh-16893\n filename = os.path.join(csv_dir_path, \"sub_char.csv\")\n expected = DataFrame([[1, 2, 3]], columns=[\"a\", \"\\x1ab\", \"c\"])\n\n parser = all_parsers\n result = parser.read_csv(filename)\n tm.assert_frame_equal(result, expected)\n\n\ndef test_file_handle_string_io(all_parsers):\n # gh-14418\n #\n # Don't close user provided file handles.\n parser = all_parsers\n data = \"a,b\\n1,2\"\n\n fh = StringIO(data)\n parser.read_csv(fh)\n assert not fh.closed\n\n\ndef test_file_handles_with_open(all_parsers, csv1):\n # gh-14418\n #\n # Don't close user provided file handles.\n parser = all_parsers\n\n for mode in [\"r\", \"rb\"]:\n with open(csv1, mode) as f:\n parser.read_csv(f)\n assert not f.closed\n\n\ndef test_invalid_file_buffer_class(all_parsers):\n # see gh-15337\n class InvalidBuffer:\n pass\n\n parser = all_parsers\n msg = \"Invalid file path or buffer object type\"\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(InvalidBuffer())\n\n\ndef test_invalid_file_buffer_mock(all_parsers):\n # see gh-15337\n parser = all_parsers\n msg = \"Invalid file path or buffer object type\"\n\n class Foo:\n pass\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(Foo())\n\n\ndef test_valid_file_buffer_seems_invalid(all_parsers):\n # gh-16135: we want to ensure that \"tell\" and \"seek\"\n # aren't actually being used when we call `read_csv`\n #\n # Thus, while the object may look \"invalid\" (these\n # methods are attributes of the `StringIO` class),\n # it is still a valid file-object for our purposes.\n class NoSeekTellBuffer(StringIO):\n def tell(self):\n raise AttributeError(\"No tell method\")\n\n def seek(self, pos, whence=0):\n raise AttributeError(\"No seek method\")\n\n data = \"a\\n1\"\n parser = all_parsers\n expected = DataFrame({\"a\": [1]})\n\n result = parser.read_csv(NoSeekTellBuffer(data))\n tm.assert_frame_equal(result, expected)\n\n\[email protected](\n \"kwargs\",\n [dict(), dict(error_bad_lines=True)], # Default is True. # Explicitly pass in.\n)\[email protected](\n \"warn_kwargs\", [dict(), dict(warn_bad_lines=True), dict(warn_bad_lines=False)]\n)\ndef test_error_bad_lines(all_parsers, kwargs, warn_kwargs):\n # see gh-15925\n parser = all_parsers\n kwargs.update(**warn_kwargs)\n data = \"a\\n1\\n1,2,3\\n4\\n5,6,7\"\n\n msg = \"Expected 1 fields in line 3, saw 3\"\n with pytest.raises(ParserError, match=msg):\n parser.read_csv(StringIO(data), **kwargs)\n\n\ndef test_warn_bad_lines(all_parsers, capsys):\n # see gh-15925\n parser = all_parsers\n data = \"a\\n1\\n1,2,3\\n4\\n5,6,7\"\n expected = DataFrame({\"a\": [1, 4]})\n\n result = parser.read_csv(StringIO(data), error_bad_lines=False, warn_bad_lines=True)\n tm.assert_frame_equal(result, expected)\n\n captured = capsys.readouterr()\n assert \"Skipping line 3\" in captured.err\n assert \"Skipping line 5\" in captured.err\n\n\ndef test_suppress_error_output(all_parsers, capsys):\n # see gh-15925\n parser = all_parsers\n data = \"a\\n1\\n1,2,3\\n4\\n5,6,7\"\n expected = DataFrame({\"a\": [1, 4]})\n\n result = parser.read_csv(\n StringIO(data), error_bad_lines=False, warn_bad_lines=False\n )\n tm.assert_frame_equal(result, expected)\n\n captured = capsys.readouterr()\n assert captured.err == \"\"\n\n\[email protected](\"filename\", [\"sé-es-vé.csv\", \"ru-sй.csv\", \"中文文件名.csv\"])\ndef test_filename_with_special_chars(all_parsers, filename):\n # see gh-15086.\n parser = all_parsers\n df = DataFrame({\"a\": [1, 2, 3]})\n\n with tm.ensure_clean(filename) as path:\n df.to_csv(path, index=False)\n\n result = parser.read_csv(path)\n tm.assert_frame_equal(result, df)\n\n\ndef test_read_csv_memory_growth_chunksize(all_parsers):\n # see gh-24805\n #\n # Let's just make sure that we don't crash\n # as we iteratively process all chunks.\n parser = all_parsers\n\n with tm.ensure_clean() as path:\n with open(path, \"w\") as f:\n for i in range(1000):\n f.write(str(i) + \"\\n\")\n\n result = parser.read_csv(path, chunksize=20)\n\n for _ in result:\n pass\n\n\ndef test_read_csv_raises_on_header_prefix(all_parsers):\n # gh-27394\n parser = all_parsers\n msg = \"Argument prefix must be None if argument header is not None\"\n\n s = StringIO(\"0,1\\n2,3\")\n\n with pytest.raises(ValueError, match=msg):\n parser.read_csv(s, header=0, prefix=\"_X\")\n\n\ndef test_unexpected_keyword_parameter_exception(all_parsers):\n # GH-34976\n parser = all_parsers\n\n msg = \"{}\\\$\\\$ got an unexpected keyword argument 'foo'\"\n with pytest.raises(TypeError, match=msg.format(\"read_csv\")):\n parser.read_csv(\"foo.csv\", foo=1)\n with pytest.raises(TypeError, match=msg.format(\"read_table\")):\n parser.read_table(\"foo.tsv\", foo=1)\n\n\ndef test_read_table_same_signature_as_read_csv(all_parsers):\n # GH-34976\n parser = all_parsers\n\n table_sign = signature(parser.read_table)\n csv_sign = signature(parser.read_csv)\n\n assert table_sign.parameters.keys() == csv_sign.parameters.keys()\n assert table_sign.return_annotation == csv_sign.return_annotation\n\n for key, csv_param in csv_sign.parameters.items():\n table_param = table_sign.parameters[key]\n if key == \"sep\":\n assert csv_param.default == \",\"\n assert table_param.default == \"\\t\"\n assert table_param.annotation == csv_param.annotation\n assert table_param.kind == csv_param.kind\n continue\n else:\n assert table_param == csv_param\n\n\ndef test_read_table_equivalency_to_read_csv(all_parsers):\n # see gh-21948\n # As of 0.25.0, read_table is undeprecated\n parser = all_parsers\n data = \"a\\tb\\n1\\t2\\n3\\t4\"\n expected = parser.read_csv(StringIO(data), sep=\"\\t\")\n result = parser.read_table(StringIO(data))\n tm.assert_frame_equal(result, expected)\n\n\ndef test_first_row_bom(all_parsers):\n # see gh-26545\n parser = all_parsers\n data = '''\\ufeff\"Head1\"\t\"Head2\"\t\"Head3\"'''\n\n result = parser.read_csv(StringIO(data), delimiter=\"\\t\")\n expected = DataFrame(columns=[\"Head1\", \"Head2\", \"Head3\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_first_row_bom_unquoted(all_parsers):\n # see gh-36343\n parser = all_parsers\n data = \"\"\"\\ufeffHead1\tHead2\tHead3\"\"\"\n\n result = parser.read_csv(StringIO(data), delimiter=\"\\t\")\n expected = DataFrame(columns=[\"Head1\", \"Head2\", \"Head3\"])\n tm.assert_frame_equal(result, expected)\n\n\ndef test_integer_precision(all_parsers):\n # Gh 7072\n s = \"\"\"1,1;0;0;0;1;1;3844;3844;3844;1;1;1;1;1;1;0;0;1;1;0;0,,,4321583677327450765\n5,1;0;0;0;1;1;843;843;843;1;1;1;1;1;1;0;0;1;1;0;0,64.0,;,4321113141090630389\"\"\"\n parser = all_parsers\n result = parser.read_csv(StringIO(s), header=None)[4]\n expected = Series([4321583677327450765, 4321113141090630389], name=4)\n tm.assert_series_equal(result, expected)\n\n\ndef test_file_descriptor_leak(all_parsers):\n # GH 31488\n\n parser = all_parsers\n with tm.ensure_clean() as path:\n\n def test():\n with pytest.raises(EmptyDataError, match=\"No columns to parse from file\"):\n parser.read_csv(path)\n\n td.check_file_leaks(test)()\n\n\[email protected](\"nrows\", range(1, 6))\ndef test_blank_lines_between_header_and_data_rows(all_parsers, nrows):\n # GH 28071\n ref = DataFrame(\n [[np.nan, np.nan], [np.nan, np.nan], [1, 2], [np.nan, np.nan], [3, 4]],\n columns=list(\"ab\"),\n )\n csv = \"\\nheader\\n\\na,b\\n\\n\\n1,2\\n\\n3,4\"\n parser = all_parsers\n df = parser.read_csv(StringIO(csv), header=3, nrows=nrows, skip_blank_lines=False)\n tm.assert_frame_equal(df, ref[:nrows])\n\n\ndef test_no_header_two_extra_columns(all_parsers):\n # GH 26218\n column_names = [\"one\", \"two\", \"three\"]\n ref = DataFrame([[\"foo\", \"bar\", \"baz\"]], columns=column_names)\n stream = StringIO(\"foo,bar,baz,bam,blah\")\n parser = all_parsers\n df = parser.read_csv(stream, header=None, names=column_names, index_col=False)\n tm.assert_frame_equal(df, ref)\n\n\ndef test_read_csv_names_not_accepting_sets(all_parsers):\n # GH 34946\n data = \"\"\"\\\n 1,2,3\n 4,5,6\\n\"\"\"\n parser = all_parsers\n with pytest.raises(ValueError, match=\"Names should be an ordered collection.\"):\n parser.read_csv(StringIO(data), names=set(\"QAZ\"))\n\n\ndef test_read_csv_with_use_inf_as_na(all_parsers):\n # https://github.com/pandas-dev/pandas/issues/35493\n parser = all_parsers\n data = \"1.0\\nNaN\\n3.0\"\n with option_context(\"use_inf_as_na\", True):\n result = parser.read_csv(StringIO(data), header=None)\n expected = DataFrame([1.0, np.nan, 3.0])\n tm.assert_frame_equal(result, expected)\n" ]

[ [ "pandas.Series", "pandas.MultiIndex.from_tuples", "pandas.DataFrame", "pandas.io.parsers.TextParser", "numpy.iinfo", "pandas._testing.assert_frame_equal", "pandas.util._test_decorators.check_file_leaks", "pandas.Index", "pandas._libs.tslib.Timestamp", "pandas._testing.makeDataFrame", "pandas._testing.assert_series_equal", "pandas.concat", "pandas._testing.assert_produces_warning", "pandas.compat.is_platform_windows", "pandas.option_context", "pandas.DataFrame.from_dict", "pandas.MultiIndex.from_arrays", "pandas._testing.ensure_clean", "pandas.io.parsers.CParserWrapper._set_noconvert_columns", "pandas._testing.rands" ] ]

ThomasFavrel/Simple_Deep_NN_Numpy

[ "fe2080bfb5fec6e986294939cf253e6864abdd56" ]

[ "utils.py" ]

[ "import numpy as np\nimport matplotlib.pyplot as plt\nimport h5py\n\n\ndef sigmoid(Z):\n \"\"\"\n Implements the sigmoid activation in numpy\n \n Arguments:\n Z -- numpy array of any shape\n \n Returns:\n A -- output of sigmoid(z), same shape as Z\n cache -- returns Z as well, useful during backpropagation\n \"\"\"\n \n A = 1/(1+np.exp(-Z))\n cache = Z\n \n return A, cache\n\ndef relu(Z):\n \"\"\"\n Implement the RELU function.\n\n Arguments:\n Z -- Output of the linear layer, of any shape\n\n Returns:\n A -- Post-activation parameter, of the same shape as Z\n cache -- a python dictionary containing \"A\" ; stored for computing the backward pass efficiently\n \"\"\"\n \n A = np.maximum(0,Z)\n \n assert(A.shape == Z.shape)\n \n cache = Z \n return A, cache\n\n\ndef relu_backward(dA, cache):\n \"\"\"\n Implement the backward propagation for a single RELU unit.\n\n Arguments:\n dA -- post-activation gradient, of any shape\n cache -- 'Z' where we store for computing backward propagation efficiently\n\n Returns:\n dZ -- Gradient of the cost with respect to Z\n \"\"\"\n \n Z = cache\n dZ = np.array(dA, copy=True) # just converting dz to a correct object.\n \n # When z <= 0, you should set dz to 0 as well. \n dZ[Z <= 0] = 0\n \n assert (dZ.shape == Z.shape)\n \n return dZ\n\ndef sigmoid_backward(dA, cache):\n \"\"\"\n Implement the backward propagation for a single SIGMOID unit.\n\n Arguments:\n dA -- post-activation gradient, of any shape\n cache -- 'Z' where we store for computing backward propagation efficiently\n\n Returns:\n dZ -- Gradient of the cost with respect to Z\n \"\"\"\n \n Z = cache\n \n s = 1/(1+np.exp(-Z))\n dZ = dA * s * (1-s)\n \n assert (dZ.shape == Z.shape)\n \n return dZ\n\n\ndef load_data():\n train_dataset = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n\n test_dataset = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n\n classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n \n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n \n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\n\n\ndef initialize_parameters(n_x, n_h, n_y):\n \"\"\"\n Argument:\n n_x -- size of the input layer\n n_h -- size of the hidden layer\n n_y -- size of the output layer\n \n Returns:\n parameters -- python dictionary containing your parameters:\n W1 -- weight matrix of shape (n_h, n_x)\n b1 -- bias vector of shape (n_h, 1)\n W2 -- weight matrix of shape (n_y, n_h)\n b2 -- bias vector of shape (n_y, 1)\n \"\"\"\n \n np.random.seed(1)\n \n W1 = np.random.randn(n_h, n_x)*0.01\n b1 = np.zeros((n_h, 1))\n W2 = np.random.randn(n_y, n_h)*0.01\n b2 = np.zeros((n_y, 1))\n \n assert(W1.shape == (n_h, n_x))\n assert(b1.shape == (n_h, 1))\n assert(W2.shape == (n_y, n_h))\n assert(b2.shape == (n_y, 1))\n \n parameters = {\"W1\": W1,\n \"b1\": b1,\n \"W2\": W2,\n \"b2\": b2}\n \n return parameters \n\n\n" ]

[ [ "numpy.maximum", "numpy.random.seed", "numpy.random.randn", "numpy.exp", "numpy.array", "numpy.zeros" ] ]

kake777/python_sample

[ "3e69c0e89a67f81ced56193524c2f69913262dda" ]

[ "algorithm/deep_learning/gradient3.py" ]

[ "#勾配のグラフ\nimport numpy as np\nimport matplotlib.pylab as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom common_function import numerical_gradient, function_2\n\ndef tangent_line(f, x):\n d = numerical_gradient(f, x)\n print(d)\n y = f(x) - d*x\n return lambda t: d*t + y\n\nif __name__ == '__main__':\n x0 = np.arange(-2, 2.5, 0.25)\n x1 = np.arange(-2, 2.5, 0.25)\n X, Y = np.meshgrid(x0, x1)\n \n X = X.flatten()\n Y = Y.flatten()\n\n grad = numerical_gradient(function_2, np.array([X, Y]).T).T\n\n plt.figure()\n plt.quiver(X, Y, -grad[0], -grad[1], angles=\"xy\",color=\"#666666\")\n plt.xlim([-2, 2])\n plt.ylim([-2, 2])\n plt.xlabel('x0')\n plt.ylabel('x1')\n plt.grid()\n plt.draw()\n plt.show()\n" ]

[ [ "matplotlib.pylab.show", "matplotlib.pylab.grid", "matplotlib.pylab.xlim", "numpy.arange", "matplotlib.pylab.draw", "matplotlib.pylab.xlabel", "matplotlib.pylab.figure", "matplotlib.pylab.ylabel", "matplotlib.pylab.ylim", "matplotlib.pylab.quiver", "numpy.array", "numpy.meshgrid" ] ]

craigbig/allennlp

[ "3f15a8bdcae366f3ef732eec1e9df26d91521582" ]

[ "allennlp/modules/token_embedders/pretrained_transformer_embedder.py" ]

[ "import math\nfrom typing import Optional, Tuple\n\nfrom overrides import overrides\n\nimport torch\nimport torch.nn.functional as F\nfrom transformers.modeling_auto import AutoModel\n\nfrom allennlp.data.tokenizers import PretrainedTransformerTokenizer\nfrom allennlp.modules.token_embedders.token_embedder import TokenEmbedder\nfrom allennlp.nn.util import batched_index_select\n\n\[email protected](\"pretrained_transformer\")\nclass PretrainedTransformerEmbedder(TokenEmbedder):\n \"\"\"\n Uses a pretrained model from `transformers` as a `TokenEmbedder`.\n\n # Parameters\n\n model_name : `str`\n The name of the `transformers` model to use. Should be the same as the corresponding\n `PretrainedTransformerIndexer`.\n max_length : `int`, optional (default = None)\n If positive, folds input token IDs into multiple segments of this length, pass them\n through the transformer model independently, and concatenate the final representations.\n Should be set to the same value as the `max_length` option on the\n `PretrainedTransformerIndexer`.\n \"\"\"\n\n def __init__(self, model_name: str, max_length: int = None) -> None:\n super().__init__()\n self.transformer_model = AutoModel.from_pretrained(model_name)\n self._max_length = max_length\n # I'm not sure if this works for all models; open an issue on github if you find a case\n # where it doesn't work.\n self.output_dim = self.transformer_model.config.hidden_size\n\n tokenizer = PretrainedTransformerTokenizer(model_name)\n self._num_added_start_tokens = tokenizer.num_added_start_tokens\n self._num_added_end_tokens = tokenizer.num_added_end_tokens\n self._num_added_tokens = self._num_added_start_tokens + self._num_added_end_tokens\n\n @overrides\n def get_output_dim(self):\n return self.output_dim\n\n def _number_of_token_type_embeddings(self):\n config = self.transformer_model.config\n if hasattr(config, \"type_vocab_size\"):\n return config.type_vocab_size\n else:\n return 0\n\n @overrides\n def forward(\n self,\n token_ids: torch.LongTensor,\n mask: torch.LongTensor,\n type_ids: Optional[torch.LongTensor] = None,\n segment_concat_mask: Optional[torch.LongTensor] = None,\n ) -> torch.Tensor: # type: ignore\n \"\"\"\n # Parameters\n\n token_ids: torch.LongTensor\n Shape: [\n batch_size, num_wordpieces if max_length is None else num_segment_concat_wordpieces\n ].\n num_segment_concat_wordpieces is num_wordpieces plus special tokens inserted in the\n middle, e.g. the length of: \"[CLS] A B C [SEP] [CLS] D E F [SEP]\" (see indexer logic).\n mask: torch.LongTensor\n Shape: [batch_size, num_wordpieces].\n type_ids: Optional[torch.LongTensor]\n Shape: [\n batch_size, num_wordpieces if max_length is None else num_segment_concat_wordpieces\n ].\n segment_concat_mask: Optional[torch.LongTensor]\n Shape: [batch_size, num_segment_concat_wordpieces].\n\n # Returns:\n\n Shape: [batch_size, num_wordpieces, embedding_size].\n \"\"\"\n\n # Some of the huggingface transformers don't support type ids at all and crash when you supply them. For\n # others, you can supply a tensor of zeros, and if you don't, they act as if you did. There is no practical\n # difference to the caller, so here we pretend that one case is the same as another case.\n if type_ids is not None:\n max_type_id = type_ids.max()\n if max_type_id == 0:\n type_ids = None\n else:\n if max_type_id >= self._number_of_token_type_embeddings():\n raise ValueError(\"Found type ids too large for the chosen transformer model.\")\n assert token_ids.shape == type_ids.shape\n\n if self._max_length is not None:\n batch_size, num_segment_concat_wordpieces = token_ids.size()\n token_ids, segment_concat_mask, type_ids = self._fold_long_sequences(\n token_ids, segment_concat_mask, type_ids\n )\n\n transformer_mask = segment_concat_mask if self._max_length is not None else mask\n # Shape: [batch_size, num_wordpieces, embedding_size],\n # or if self._max_length is not None:\n # [batch_size * num_segments, self._max_length, embedding_size]\n\n # We call this with kwargs because some of the huggingface models don't have the token_type_ids parameter\n # and fail even when it's given as None.\n parameters = {\"input_ids\": token_ids, \"attention_mask\": transformer_mask}\n if type_ids is not None:\n parameters[\"token_type_ids\"] = type_ids\n embeddings = self.transformer_model(**parameters)[0]\n\n if self._max_length is not None:\n embeddings = self._unfold_long_sequences(\n embeddings, segment_concat_mask, batch_size, num_segment_concat_wordpieces\n )\n\n return embeddings\n\n def _fold_long_sequences(\n self,\n token_ids: torch.LongTensor,\n mask: torch.LongTensor,\n type_ids: Optional[torch.LongTensor] = None,\n ) -> Tuple[torch.LongTensor, torch.LongTensor, Optional[torch.LongTensor]]:\n \"\"\"\n We fold 1D sequences (for each element in batch), returned by `PretrainedTransformerIndexer`\n that are in reality multiple segments concatenated together, to 2D tensors, e.g.\n\n [ [CLS] A B C [SEP] [CLS] D E [SEP] ]\n -> [ [ [CLS] A B C [SEP] ], [ [CLS] D E [SEP] [PAD] ] ]\n The [PAD] positions can be found in the returned `mask`.\n\n # Parameters\n\n token_ids: `torch.LongTensor`\n Shape: [batch_size, num_segment_concat_wordpieces].\n num_segment_concat_wordpieces is num_wordpieces plus special tokens inserted in the\n middle, i.e. the length of: \"[CLS] A B C [SEP] [CLS] D E F [SEP]\" (see indexer logic).\n mask: `torch.LongTensor`\n Shape: [batch_size, num_segment_concat_wordpieces].\n The mask for the concatenated segments of wordpieces. The same as `segment_concat_mask`\n in `forward()`.\n type_ids: Optional[torch.LongTensor]\n Shape: [batch_size, num_segment_concat_wordpieces].\n\n # Returns:\n\n token_ids: `torch.LongTensor`\n Shape: [batch_size * num_segments, self._max_length].\n mask: `torch.LongTensor`\n Shape: [batch_size * num_segments, self._max_length].\n \"\"\"\n num_segment_concat_wordpieces = token_ids.size(1)\n num_segments = math.ceil(num_segment_concat_wordpieces / self._max_length)\n padded_length = num_segments * self._max_length\n length_to_pad = padded_length - num_segment_concat_wordpieces\n\n def fold(tensor): # Shape: [batch_size, num_segment_concat_wordpieces]\n # Shape: [batch_size, num_segments * self._max_length]\n tensor = F.pad(tensor, [0, length_to_pad], value=0)\n # Shape: [batch_size * num_segments, self._max_length]\n return tensor.reshape(-1, self._max_length)\n\n return fold(token_ids), fold(mask), fold(type_ids) if type_ids is not None else None\n\n def _unfold_long_sequences(\n self,\n embeddings: torch.FloatTensor,\n mask: torch.LongTensor,\n batch_size: int,\n num_segment_concat_wordpieces: int,\n ) -> torch.FloatTensor:\n \"\"\"\n We take 2D segments of a long sequence and flatten them out to get the whole sequence\n representation while remove unnecessary special tokens.\n\n [ [ [CLS]_emb A_emb B_emb C_emb [SEP]_emb ], [ [CLS]_emb D_emb E_emb [SEP]_emb [PAD]_emb ] ]\n -> [ [CLS]_emb A_emb B_emb C_emb D_emb E_emb [SEP]_emb ]\n\n We truncate the start and end tokens for all segments, recombine the segments,\n and manually add back the start and end tokens.\n\n # Parameters\n\n embeddings: `torch.FloatTensor`\n Shape: [batch_size * num_segments, self._max_length, embedding_size].\n mask: `torch.LongTensor`\n Shape: [batch_size * num_segments, self._max_length].\n The mask for the concatenated segments of wordpieces. The same as `segment_concat_mask`\n in `forward()`.\n batch_size: `int`\n num_segment_concat_wordpieces: `int`\n The length of the original \"[ [CLS] A B C [SEP] [CLS] D E F [SEP] ]\", i.e.\n the original `token_ids.size(1)`.\n\n # Returns:\n\n embeddings: `torch.FloatTensor`\n Shape: [batch_size, self._num_wordpieces, embedding_size].\n \"\"\"\n\n def lengths_to_mask(lengths, max_len, device):\n return torch.arange(max_len, device=device).expand(\n lengths.size(0), max_len\n ) < lengths.unsqueeze(1)\n\n device = embeddings.device\n num_segments = int(embeddings.size(0) / batch_size)\n embedding_size = embeddings.size(2)\n\n # We want to remove all segment-level special tokens but maintain sequence-level ones\n num_wordpieces = num_segment_concat_wordpieces - (num_segments - 1) * self._num_added_tokens\n\n embeddings = embeddings.reshape(batch_size, num_segments * self._max_length, embedding_size)\n mask = mask.reshape(batch_size, num_segments * self._max_length)\n # We assume that all 1s in the mask preceed all 0s, and add an assert for that.\n # Open an issue on GitHub if this breaks for you.\n # Shape: (batch_size,)\n seq_lengths = mask.sum(-1)\n if not (lengths_to_mask(seq_lengths, mask.size(1), device) == mask).all():\n raise ValueError(\n \"Long sequence splitting only supports masks with all 1s preceding all 0s.\"\n )\n # Shape: (batch_size, self._num_added_end_tokens); this is a broadcast op\n end_token_indices = (\n seq_lengths.unsqueeze(-1) - torch.arange(self._num_added_end_tokens, device=device) - 1\n )\n\n # Shape: (batch_size, self._num_added_start_tokens, embedding_size)\n start_token_embeddings = embeddings[:, : self._num_added_start_tokens, :]\n # Shape: (batch_size, self._num_added_end_tokens, embedding_size)\n end_token_embeddings = batched_index_select(embeddings, end_token_indices)\n\n embeddings = embeddings.reshape(batch_size, num_segments, self._max_length, embedding_size)\n embeddings = embeddings[\n :, :, self._num_added_start_tokens : -self._num_added_end_tokens, :\n ] # truncate segment-level start/end tokens\n embeddings = embeddings.reshape(batch_size, -1, embedding_size) # flatten\n\n # Now try to put end token embeddings back which is a little tricky.\n\n # The number of segment each sequence spans, excluding padding. Mimicking ceiling operation.\n # Shape: (batch_size,)\n num_effective_segments = (seq_lengths + self._max_length - 1) / self._max_length\n # The number of indices that end tokens should shift back.\n num_removed_non_end_tokens = (\n num_effective_segments * self._num_added_tokens - self._num_added_end_tokens\n )\n # Shape: (batch_size, self._num_added_end_tokens)\n end_token_indices -= num_removed_non_end_tokens.unsqueeze(-1)\n assert (end_token_indices >= self._num_added_start_tokens).all()\n # Add space for end embeddings\n embeddings = torch.cat([embeddings, torch.zeros_like(end_token_embeddings)], 1)\n # Add end token embeddings back\n embeddings.scatter_(\n 1, end_token_indices.unsqueeze(-1).expand_as(end_token_embeddings), end_token_embeddings\n )\n\n # Now put back start tokens. We can do this before putting back end tokens, but then\n # we need to change `num_removed_non_end_tokens` a little.\n embeddings = torch.cat([start_token_embeddings, embeddings], 1)\n\n # Truncate to original length\n embeddings = embeddings[:, :num_wordpieces, :]\n return embeddings\n" ]

[ [ "torch.zeros_like", "torch.arange", "torch.nn.functional.pad", "torch.cat" ] ]

Maarten7/neural-network-arca

[ "1ed80519bcfbfa871c30d28f7bc2cc3f35dfbd17" ]

[ "models/toy_model.py" ]

[ "import numpy as np\n\ndef get_random_xyz():\n x = np.random.randint(13)\n y = np.random.randint(13)\n z = np.random.randint(18)\n return x, y, z\n\n\ndef get_event_klass_label(num_mini_timeslices):\n event = np.zeros((num_mini_timeslices, 13, 13, 18, 3))\n klass = np.random.randint(3) \n label = np.zeros(3)\n label[klass] = 1\n return event, klass, label\n \n\ndef get_start(klass, num_mini_timeslices):\n x, y, z = get_random_xyz()\n j = np.random.randint(num_mini_timeslices-18)\n \n if klass == 0:\n z = 0\n elif klass == 1:\n z = 17\n else:\n z = 10\n\n return j, x, y, z \n\n\ndef fill_noise(event, num_mini_timeslices):\n for i in range(num_mini_timeslices):\n x, y, z = get_random_xyz()\n event[i, x, y, z, :] += .30\n return event\n\n\ndef get_next_weird_xyz(x, y, z, klass):\n if klass == 0:\n z = z + 1\n elif klass == 1:\n z = z - 1\n\n if np.random.randint(3) == 0:\n x = x + 1\n elif np.random.randint(3) == 2:\n x = x - 1\n\n if np.random.randint(3) == 0:\n y = y + 1\n elif np.random.randint(3) == 2:\n y = y - 1\n \n x = 0 if x < 0 else x\n y = 0 if y < 0 else y\n x = 12 if 12 < x else x\n y = 12 if 12 < y else y\n return x, y, z\n\ndef get_line_start(klass, num_mini_timeslices):\n j = np.random.randint(num_mini_timeslices-18)\n x, y, z = get_random_xyz()\n if klass == 0:\n x = 0\n elif klass == 1:\n y = 0\n elif klass == 2:\n z = 0\n return j, x, y, z\n \n\ndef fill_noise(event, num_mini_timeslices):\n for i in range(num_mini_timeslices):\n x, y, z = get_random_xyz()\n event[i, x, y, z, :] += .30\n return event\n\n\ndef fill_event(event, label, num_mini_timeslices):\n j, x, y, z = get_start(label, num_mini_timeslices)\n for i in range(18):\n event[j + i, x, y, z, :] += .30\n x, y, z = get_next_xyz(x, y, z, label)\n return event\n\n\ndef random_line(num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n for _ in range(10):\n event = fill_event(event, label)\n event = fill_noise(event, num_mini_timeslices)\n \n\ndef get_next_line_xyz(x, y, z, klass):\n if klass == 0:\n x += 1\n elif klass == 1:\n y += 1\n else:\n z += 1 \n if x == 13: x = 0\n if y == 13: y = 0\n return x, y, z\n\n\ndef random_movement(n_lines, n_noise, num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n for _ in range(n_lines):\n j, x, y, z = get_start(klass, num_mini_timeslices)\n for i in range(18):\n event[j + i, x, y, z, :] += .30\n x, y, z = get_next_weird_xyz(x, y, z, klass)\n for _ in range(n_noise):\n event = fill_noise(event, num_mini_timeslices)\n\n return event, label\n\ndef fill_matrix(num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n if klass == 0:\n event[:, :, :, :, :] = 1.\n if klass == 1:\n event[:, :, :, :, :] = 0.5\n if klass == 2:\n event[:, :, :, :, :] = 0.\n\n return event, label\n\n\ndef add_line(num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n x, y, z = get_random_xyz()\n if klass == 0:\n event[:, x, y, :, :] = 1.\n elif klass == 1:\n event[:, x, :, z, :] = 1.\n elif klass == 2:\n event[:, :, y, z, :] = 1.\n\n return event, label\n\n\ndef add_line_in_steps(n_lines, num_mini_timeslices):\n event, klass, label = get_event_klass_label(num_mini_timeslices)\n for _ in range(n_lines):\n j, x, y, z = get_line_start(klass, num_mini_timeslices)\n for i in range(18):\n event[j + i, x, y, z, :] = 1.\n x, y, z = get_next_line_xyz(x, y, z, klass)\n return event, label\n\n\ndef make_toy(num_mini_timeslices):\n# return add_line_in_steps(10, num_mini_timeslices)\n# return fill_matrix() \n# return all_line_in_steps()\n return random_movement(25, 5, num_mini_timeslices)\n" ]

[ [ "numpy.zeros", "numpy.random.randint" ] ]

startnew/auto_work_tools

[ "169832fd9fa2f2f397f1605be4823eeee2e4a83a" ]

[ "auto_test/gen_data_csv.py" ]

[ "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Time : 2020/11/9 14:19\n# @Author : zhuzhaowen\n# @email : [email protected]\n# @File : gen_data_csv.py\n# @Software: PyCharm\n# @desc : \"获取导入的信息并筛选\"\n\nimport pandas as pd\nimport urllib\nimport pypinyin\nimport time\nfrom util.util import base64_to_image, image_to_base64, exc_time\nimport numpy as np\nimport cv2\nfrom auto_search_address import get_key_words_adname\n\n\nclass dataProcess():\n def __init__(self):\n\n self.ad_name_map_dict = {}\n\n def processOriData(self, data_path, save_data=\"./data/test\"):\n data = pd.read_excel(data_path)\n self.data = data\n print(self.data.shape)\n self.clean_data()\n self.data = self.data[:]\n\n print(self.data.shape)\n if self.data.shape[0] > 0:\n self.add_adname()\n self.add_img_info()\n self.save_data(save_data)\n\n def processOriDatas(self, data_paths, save_data=\"./data/test_union\", has_cache=False):\n datas = []\n for data_path in data_paths:\n try:\n print(data_path)\n data = pd.read_excel(data_path)\n print(data.columns[0], data.shape[1])\n if int(data.shape[1]) == 14 and data.columns[0] != \"城市\":\n data = pd.read_excel(data_path, header=None, names= \\\n [\"城市\", \"楼盘\", \"类型\", \"单价\", \"总价\", \"项目地址\", \"最新开盘\", \"全部图片url\", \"户型\",\n \"户型图\", \"居室\", \"建面\", \"均价\",\n \"状态\"])\n print(data.head())\n elif int(data.shape[1]) == 5 and data.columns[0] == \"house_id\":\n data = pd.read_excel(data_path)\n data[\"楼盘\"] = \"威尼斯水城\"\n data[\"name\"] = data[\"house_id\"].map(lambda x: \"house_id_{}\".format(x))\n data[\"城市\"] = \"南京市\"\n data[\"类型\"] = \"住宅\"\n data[\"项目地址\"] = \"威尼斯水城\"\n data[\"居室\"] = data[\"structure_name\"]\n data[\"建面\"] = data[\"area\"]\n data[\"户型\"] =data[\"house_id\"].map(lambda x: \"house_id_{}\".format(x))\n\n\n\n\n\n self.data = data\n print(self.data.shape)\n self.clean_data()\n if self.data.shape[0]<1:\n continue\n # self.data = self.data[:]\n\n print(self.data.shape)\n self.add_adname()\n self.add_img_info()\n datas.append(self.data)\n except Exception as e:\n print(\"ERROR {}\".format(e))\n continue\n union_pd = pd.concat(datas)\n self.data = union_pd\n self.clean_data()\n print(\"合并后的尺寸大小\", union_pd.shape)\n # 去重后的尺寸大小\n print(len(union_pd.户型图.unique()))\n union_pd.drop_duplicates(\"户型图\", \"first\", inplace=True)\n self.data = union_pd\n print(\"去重后尺寸大小\", union_pd.shape)\n limit = False\n downImg = False\n if limit:\n name = \"建业\"\n data_junfa = self.data[self.data.楼盘.str.contains(name)]\n\n print(\"junfa的户型数据\", )\n # print(data_建业.head())\n self.data[\"junfa与否\"] = self.data.楼盘.str.contains(name)\n\n\n self.data = data_junfa\n\n if has_cache and os.path.exists(save_data+\".pkl\"):\n print(\"使用cache\")\n\n cache_data = pd.read_pickle(save_data + \".pkl\")\n\n self.add_adname(cache=cache_data)\n if downImg:self.add_img_info(cache=cache_data)\n else:\n self.add_adname()\n if downImg:self.add_img_info()\n # self.data = self.data[self.data.cityname.str.contains(\"成都\")]\n #print(\"{}的个数:{}\".format(name, self.data.shape))\n print(self.data.shape)\n\n self.save_data(save_data)\n\n def save_data(self, path):\n self.data.to_excel(path + \".xlsx\")\n self.data.to_csv(path + \".csv\")\n self.data.to_pickle(path + \".pkl\")\n\n @exc_time\n def clean_data(self):\n self.data = self.data[self.data[\"户型图\"].notna()]\n self.data = self.data[self.data[\"楼盘\"].notna()]\n self.data = self.data[self.data[\"项目地址\"].notna()]\n self.data = self.data[self.data[\"户型\"].notna()]\n\n @exc_time\n def add_adname(self,cache=None):\n self.data[\"区\"] = self.data.apply(lambda x: self.map_adname(x[\"楼盘\"], x[\"城市\"],cache), axis=1)\n self.data[\"cityname\"] = self.data.apply(lambda x: self.map_cityname(x[\"楼盘\"], x[\"城市\"],cache), axis=1)\n self.data[\"pname\"] = self.data.apply(lambda x: self.map_pname(x[\"楼盘\"], x[\"城市\"],cache), axis=1)\n self.data[\"location\"] = self.data.apply(lambda x: self.map_location(x[\"楼盘\"], x[\"城市\"], cache), axis=1)\n\n\n def map_adname(self, x, city,cache=None):\n k = str(x) + str(city)\n\n if cache is not None:\n try:\n select_df = cache[(cache.楼盘.str.contains(x)) & (cache.城市.str.contains(city))]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"区\" in select_df.columns:\n if len(select_df[\"区\"].values[0]) != 0:\n # print(select_df[\"图片编码\"].values[0])\n print(\"SUCCESS from cache file LOCPOS{}\".format(type(select_df[\"区\"].values[0])))\n\n return select_df[\"区\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n\n print(\"Error {}:x{} city:{} \".format(e, x, city))\n #raise e\n\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"adname\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"adname\")\n\n def map_pname(self, x, city,cache=None):\n k = str(x) + str(city)\n if cache is not None:\n try:\n select_df = cache[(cache.楼盘.str.contains(x)) & (cache.城市.str.contains(city))]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"pname\" in select_df.columns:\n if len(select_df[\"pname\"].values[0]) != 0:\n\n print(\"SUCCESS from cache file LOCPOS {}\".format(type(select_df[\"pname\"].values[0])))\n\n return select_df[\"pname\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n print(\"Error {}:x{} city:{} \".format(e,x,city))\n\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"pname\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"pname\")\n\n def map_location(self, x, city, cache):\n k = str(x) + str(city)\n if cache is not None:\n try:\n select_df = cache[(cache.楼盘.str.contains(x)) & (cache.城市.str.contains(city))]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"location\" in select_df.columns:\n if len(select_df[\"location\"].values[0]) != 0:\n\n print(\"SUCCESS from cache file LOCPOS {}\".format(type(select_df[\"pname\"].values[0])))\n\n return select_df[\"location\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n print(\"Error {}:x{} city:{} \".format(e, x, city))\n\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"location\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"location\")\n\n def map_cityname(self, x, city,cache):\n k = str(x) + str(city)\n if cache is not None:\n try:\n select_df = cache[cache.楼盘.str.contains(x) & cache.城市.str.contains(city)]\n # print(select_df.shape)\n if select_df.shape[0] > 0:\n if \"cityname\" in select_df.columns:\n if len(select_df[\"cityname\"].values[0]) != 0:\n\n print(\"SUCCESS from cache file {} LOCPOS\".format(type(select_df[\"cityname\"].values[0])))\n\n return select_df[\"cityname\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url获取并编码\")\n else:\n print(\"cache中没有指定字段使用api数据\")\n else:\n print(\"没有找到url符合的使用api数据\")\n except Exception as e:\n print(\"ERROR {}\".format(e))\n if k in self.ad_name_map_dict.keys():\n return self.ad_name_map_dict.get(k).get(\"cityname\")\n else:\n r = get_key_words_adname(x, city=city)\n self.ad_name_map_dict[k] = r\n return r.get(\"cityname\")\n @exc_time\n def add_img_info(self, cache=None):\n self.data[\"图片编码\"] = self.data.户型图.map(lambda x: self.down_and_encode(x,cache))\n\n def gen_name(x, y, z):\n try:\n return str(x) + str(y) + str(z)\n except:\n return str(x)\n\n self.data[\"house_name\"] = self.data.apply(lambda x: gen_name(x[\"户型\"], x[\"类型\"], x[\"居室\"]), axis=1)\n self.data[\"county_name\"] = self.data[\"区\"]\n self.data[\"community_name\"] = self.data[\"楼盘\"]\n if \"全部图片url\" in self.data.columns:\n self.data = self.data.drop([\"全部图片url\"], axis=1)\n\n def down_and_encode(self, imgurl,cache_data):\n #print(imgurl)\n\n num = 0\n try:\n if cache_data is not None:\n select_df = cache_data[cache_data.户型图.str.contains(imgurl)]\n #print(select_df.shape)\n if select_df.shape[0]>0:\n if \"图片编码\" in select_df.columns:\n if len(select_df[\"图片编码\"].values[0]) != 0:\n #print(select_df[\"图片编码\"].values[0])\n print(\"SUCCESS from cache file {}\".format(type(select_df[\"图片编码\"].values[0])))\n\n return select_df[\"图片编码\"].values[0]\n else:\n print(\"cache中指定字段值为空使用url下载并编码\")\n else:\n print(\"cache中没有指定字段使用下载数据\")\n else:\n print(\"没有找到url符合的使用下载数据\")\n print(imgurl)\n r = self.down_load_url(imgurl)\n r = self.encodeImg(r)\n print(\"SUCCESS\")\n except Exception as e:\n # raise e\n print(\"ERROR {}\".format(e))\n r = ''\n if r == '' and \"original\" not in imgurl:\n return self.down_and_encode(imgurl+\"!original\",cache_data)\n return r\n\n def down_load_url(self, imageUrl):\n resp = urllib.request.urlopen(imageUrl)\n image = np.asarray(bytearray(resp.read()), dtype=\"uint8\")\n\n image = cv2.imdecode(image, cv2.IMREAD_COLOR)\n return image\n\n def encodeImg(self, image):\n return image_to_base64(image)\n\n def decodeImg(self, str64):\n return base64_to_image(str64)\n\n\nif __name__ == \"__main__\":\n dp = dataProcess()\n import os\n\n dir_name = r\"D:\\workspace\\2020\\标准户型库\"\n paths = []\n for root, dirs, files in os.walk(dir_name):\n for name in files:\n if name.endswith(\".xlsx\") or name.endswith(\".xls\"):\n k = os.path.join(root, name)\n # if \"河南\" in k:\n paths.append(k)\n\n print(paths)\n # dp.processOriData(r\"D:\\workspace\\2020\\标准户型库\\南京\\贝壳找房-南京-2020-11-06-house.xlsx.xlsx\")\n dp.processOriDatas(paths,save_data=\"./data/test_union\",has_cache=True)\n #dp.processOriDatas(paths, save_data=\"./data/test_jianye\", has_cache=False)\n print(dp.data.head())\n print(dp.data.columns)\n" ]

[ [ "pandas.concat", "pandas.read_excel", "pandas.read_pickle" ] ]

s-gupta/fast-rcnn

[ "da935a12be8078c4d8684100016f82b5a4b02afc" ]

[ "lib/fast_rcnn/config.py" ]

[ "# --------------------------------------------------------\n# Fast R-CNN\n# Copyright (c) 2015 Microsoft\n# Licensed under The MIT License [see LICENSE for details]\n# Written by Ross Girshick\n# --------------------------------------------------------\n\n\"\"\"Fast R-CNN config system.\n\nThis file specifies default config options for Fast R-CNN. You should not\nchange values in this file. Instead, you should write a config file (in yaml)\nand use cfg_from_file(yaml_file) to load it and override the default options.\n\nMost tools in $ROOT/tools take a --cfg option to specify an override file.\n - See tools/{train,test}_net.py for example code that uses cfg_from_file()\n - See experiments/cfgs/*.yml for example YAML config override files\n\"\"\"\n\nimport os\nimport os.path as osp\nimport numpy as np\n# `pip install easydict` if you don't have it\nfrom easydict import EasyDict as edict\n\n__C = edict()\n# Consumers can get config by:\n# from fast_rcnn_config import cfg\ncfg = __C\n\n#\n# Training options\n#\n\n__C.TRAIN = edict()\n\n# Scales to use during training (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TRAIN.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TRAIN.MAX_SIZE = 1000\n\n# Images to use per minibatch\n__C.TRAIN.IMS_PER_BATCH = 2\n\n# Minibatch size (number of regions of interest [ROIs])\n__C.TRAIN.BATCH_SIZE = 128\n\n# Fraction of minibatch that is labeled foreground (i.e. class > 0)\n__C.TRAIN.FG_FRACTION = 0.25\n\n# Overlap threshold for a ROI to be considered foreground (if >= FG_THRESH)\n__C.TRAIN.FG_THRESH = 0.5\n\n# Overlap threshold for a ROI to be considered background (class = 0 if\n# overlap in [LO, HI))\n__C.TRAIN.BG_THRESH_HI = 0.5\n__C.TRAIN.BG_THRESH_LO = 0.1\n\n# Use horizontally-flipped images during training?\n__C.TRAIN.USE_FLIPPED = True\n\n# Train bounding-box regressors\n__C.TRAIN.BBOX_REG = True\n\n# Overlap required between a ROI and ground-truth box in order for that ROI to\n# be used as a bounding-box regression training example\n__C.TRAIN.BBOX_THRESH = 0.5\n\n# Iterations between snapshots\n__C.TRAIN.SNAPSHOT_ITERS = 10000\n\n# solver.prototxt specifies the snapshot path prefix, this adds an optional\n# infix to yield the path: <prefix>[_<infix>]_iters_XYZ.caffemodel\n__C.TRAIN.SNAPSHOT_INFIX = ''\n\n# Use a prefetch thread in roi_data_layer.layer\n# So far I haven't found this useful; likely more engineering work is required\n__C.TRAIN.USE_PREFETCH = False\n\n# What fields are storing bounding box regression parameters\n__C.TRAIN.BBOX_PRED_PARAM_NAMES = ['bbox_pred']\n\n#\n# Testing options\n#\n\n__C.TEST = edict()\n\n# Scales to use during testing (can list multiple scales)\n# Each scale is the pixel size of an image's shortest side\n__C.TEST.SCALES = (600,)\n\n# Max pixel size of the longest side of a scaled input image\n__C.TEST.MAX_SIZE = 1000\n\n# Overlap threshold used for non-maximum suppression (suppress boxes with\n# IoU >= this threshold)\n__C.TEST.NMS = 0.3\n\n# Experimental: treat the (K+1) units in the cls_score layer as linear\n# predictors (trained, eg, with one-vs-rest SVMs).\n__C.TEST.SVM = False\n\n# Test using bounding-box regressors\n__C.TEST.BBOX_REG = True\n\n__C.TEST.MAX_PER_IMAGE = 100\n__C.TEST.MAX_PER_SET_F = 40\n__C.TEST.DET_SALT = ''\n__C.TEST.EVAL_SALT = ''\n\n#\n# MISC\n#\n\n# The mapping from image coordinates to feature map coordinates might cause\n# some boxes that are distinct in image space to become identical in feature\n# coordinates. If DEDUP_BOXES > 0, then DEDUP_BOXES is used as the scale factor\n# for identifying duplicate boxes.\n# 1/16 is correct for {Alex,Caffe}Net, VGG_CNN_M_1024, and VGG16\n__C.DEDUP_BOXES = 1./16.\n\n# Pixel mean values (BGR order) as a (1, 1, 3) array\n# These are the values originally used for training VGG16\n__C.PIXEL_MEANS = np.array([[[102.9801, 115.9465, 122.7717]]])\n\n# For reproducibility\n__C.RNG_SEED = 3\n\n# A small number that's used many times\n__C.EPS = 1e-14\n\n# Root directory of project\n__C.ROOT_DIR = osp.abspath(osp.join(osp.dirname(__file__), '..', '..'))\n\n# Place outputs under an experiments directory\n__C.EXP_DIR = 'default'\n\ndef get_output_dir(imdb, net):\n \"\"\"Return the directory where experimental artifacts are placed.\n\n A canonical path is built using the name from an imdb and a network\n (if not None).\n \"\"\"\n path = osp.abspath(osp.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name))\n if net is None:\n return path\n else:\n return osp.join(path, net.name)\n\ndef _merge_a_into_b(a, b):\n \"\"\"Merge config dictionary a into config dictionary b, clobbering the\n options in b whenever they are also specified in a.\n \"\"\"\n if type(a) is not edict:\n return\n\n for k, v in a.iteritems():\n # a must specify keys that are in b\n if not b.has_key(k):\n raise KeyError('{} is not a valid config key'.format(k))\n\n # the types must match, too\n if type(b[k]) is not type(v):\n raise ValueError(('Type mismatch ({} vs. {}) '\n 'for config key: {}').format(type(b[k]),\n type(v), k))\n\n # recursively merge dicts\n if type(v) is edict:\n try:\n _merge_a_into_b(a[k], b[k])\n except:\n print('Error under config key: {}'.format(k))\n raise\n else:\n b[k] = v\n\ndef cfg_from_file(filename):\n \"\"\"Load a config file and merge it into the default options.\"\"\"\n import yaml\n with open(filename, 'r') as f:\n yaml_cfg = edict(yaml.load(f))\n\n _merge_a_into_b(yaml_cfg, __C)\n" ]

[ [ "numpy.array" ] ]

Griffin98/fsgan

[ "c4e54cf0579ef95b3ef14174441d66f7b119e06f" ]

[ "preprocess/preprocess_video.py" ]

[ "\"\"\" Video preprocessing.\n\nThis script implements all preprocessing required for both training and inference.\nThe preprocessing information will be cached in a directory by the file's name without the extension,\nresiding in the same directory as the file. The information contains: face detections, face sequences,\nand cropped videos per sequence. In addition for each cropped video, the corresponding pose, landmarks, and\nsegmentation masks will be computed and cached.\n\"\"\"\n\nimport os\nimport argparse\nimport sys\nimport pickle\nfrom tqdm import tqdm\nimport numpy as np\nimport cv2\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import DataLoader\nimport torchvision.transforms as transforms\nfrom face_detection_dsfd.face_detector import FaceDetector\nfrom fsgan.utils.utils import set_device, load_model\nfrom fsgan.preprocess.detections2sequences_center import main as detections2sequences_main\nfrom fsgan.preprocess.crop_video_sequences import main as crop_video_sequences_main\nfrom fsgan.preprocess.crop_image_sequences import main as crop_image_sequences_main\nfrom fsgan.datasets.video_inference_dataset import VideoInferenceDataset\nimport fsgan.datasets.img_landmarks_transforms as img_landmarks_transforms\nfrom fsgan.datasets.img_landmarks_transforms import Resize, ToTensor\nfrom fsgan.utils.temporal_smoothing import TemporalSmoothing\nfrom fsgan.utils.landmarks_utils import LandmarksHeatMapEncoder, smooth_landmarks_98pts\nfrom fsgan.utils.seg_utils import encode_binary_mask, remove_inner_mouth\nfrom fsgan.utils.batch import main as batch\n\n\nbase_parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter, add_help=False)\n\ngeneral = base_parser.add_argument_group('general')\ngeneral.add_argument('-r', '--resolution', default=256, type=int, metavar='N',\n help='finest processing resolution')\ngeneral.add_argument('-cs', '--crop_scale', default=1.2, type=float, metavar='F',\n help='crop scale relative to bounding box')\ngeneral.add_argument('--gpus', default=None, nargs='+', type=int, metavar='N',\n help='list of gpu ids to use')\ngeneral.add_argument('--cpu_only', action='store_true',\n help='force cpu only')\ngeneral.add_argument('-d', '--display', action='store_true',\n help='display the rendering')\ngeneral.add_argument('-v', '--verbose', default=0, type=int, metavar='N',\n help='verbose level')\ngeneral.add_argument('-ec', '--encoder_codec', default='avc1', metavar='STR',\n help='encoder codec code')\n\ndetection = base_parser.add_argument_group('detection')\ndetection.add_argument('-dm', '--detection_model', metavar='PATH', default='../weights/WIDERFace_DSFD_RES152.pth',\n help='path to face detection model')\ndetection.add_argument('-db', '--det_batch_size', default=8, type=int, metavar='N',\n help='detection batch size')\ndetection.add_argument('-dp', '--det_postfix', default='_dsfd.pkl', metavar='POSTFIX',\n help='detection file postfix')\n\nsequences = base_parser.add_argument_group('sequences')\nsequences.add_argument('-it', '--iou_thresh', default=0.75, type=float,\n metavar='F', help='IOU threshold')\nsequences.add_argument('-ml', '--min_length', default=10, type=int,\n metavar='N', help='minimum sequence length')\nsequences.add_argument('-ms', '--min_size', default=64, type=int,\n metavar='N', help='minimum sequence average bounding box size')\nsequences.add_argument('-ck', '--center_kernel', default=25, type=int,\n metavar='N', help='center average kernel size')\nsequences.add_argument('-sk', '--size_kernel', default=51, type=int,\n metavar='N', help='size average kernel size')\nsequences.add_argument('-dsd', '--disable_smooth_det', dest='smooth_det', action='store_false',\n help='disable smoothing the detection bounding boxes')\nsequences.add_argument('-sp', '--seq_postfix', default='_dsfd_seq.pkl', metavar='POSTFIX',\n help='sequence file postfix')\nsequences.add_argument('-we', '--write_empty', action='store_true',\n help='write empty sequence lists to file')\n\npose = base_parser.add_argument_group('pose')\npose.add_argument('-pm', '--pose_model', default='../weights/hopenet_robust_alpha1.pth', metavar='PATH',\n help='path to face pose model file')\npose.add_argument('-pb', '--pose_batch_size', default=128, type=int, metavar='N',\n help='pose batch size')\npose.add_argument('-pp', '--pose_postfix', default='_pose.npz', metavar='POSTFIX',\n help='pose file postfix')\npose.add_argument('-cp', '--cache_pose', action='store_true',\n help='Toggle whether to cache pose')\npose.add_argument('-cf', '--cache_frontal', action='store_true',\n help='Toggle whether to cache frontal images for each sequence')\npose.add_argument('-spo', '--smooth_poses', default=5, type=int, metavar='N',\n help='poses temporal smoothing kernel size')\n\nlandmarks = base_parser.add_argument_group('landmarks')\nlandmarks.add_argument('-lm', '--lms_model', default='../weights/hr18_wflw_landmarks.pth', metavar='PATH',\n help='landmarks model')\nlandmarks.add_argument('-lb', '--lms_batch_size', default=64, type=int, metavar='N',\n help='landmarks batch size')\nlandmarks.add_argument('-lp', '--landmarks_postfix', default='_lms.npz', metavar='POSTFIX',\n help='landmarks file postfix')\nlandmarks.add_argument('-cl', '--cache_landmarks', action='store_true',\n help='Toggle whether to cache landmarks')\nlandmarks.add_argument('-sl', '--smooth_landmarks', default=7, type=int, metavar='N',\n help='landmarks temporal smoothing kernel size')\n\nsegmentation = base_parser.add_argument_group('segmentation')\nsegmentation.add_argument('-sm', '--seg_model', default='../weights/celeba_unet_256_1_2_segmentation_v2.pth',\n metavar='PATH', help='segmentation model')\nsegmentation.add_argument('-sb', '--seg_batch_size', default=32, type=int, metavar='N',\n help='segmentation batch size')\nsegmentation.add_argument('-sep', '--segmentation_postfix', default='_seg.pkl', metavar='POSTFIX',\n help='segmentation file postfix')\nsegmentation.add_argument('-cse', '--cache_segmentation', action='store_true',\n help='Toggle whether to cache segmentation')\nsegmentation.add_argument('-sse', '--smooth_segmentation', default=5, type=int, metavar='N',\n help='segmentation temporal smoothing kernel size')\nsegmentation.add_argument('-srm', '--seg_remove_mouth', action='store_true',\n help='if true, the inner part of the mouth will be removed from the segmentation')\n\nparser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n parents=[base_parser])\nparser.add_argument('input', metavar='VIDEO', nargs='+',\n help='path to input video')\nparser.add_argument('-o', '--output', metavar='DIR',\n help='output directory')\nd = parser.get_default\n\n\nclass VideoProcessBase(object):\n def __init__(self, resolution=d('resolution'), crop_scale=d('crop_scale'), gpus=d('gpus'),\n cpu_only=d('cpu_only'), display=d('display'), verbose=d('verbose'), encoder_codec=d('encoder_codec'),\n # Detection arguments:\n detection_model=d('detection_model'), det_batch_size=d('det_batch_size'), det_postfix=d('det_postfix'),\n # Sequence arguments:\n iou_thresh=d('iou_thresh'), min_length=d('min_length'), min_size=d('min_size'),\n center_kernel=d('center_kernel'), size_kernel=d('size_kernel'), smooth_det=d('smooth_det'),\n seq_postfix=d('seq_postfix'), write_empty=d('write_empty'),\n # Pose arguments:\n pose_model=d('pose_model'), pose_batch_size=d('pose_batch_size'), pose_postfix=d('pose_postfix'),\n cache_pose=d('cache_pose'), cache_frontal=d('cache_frontal'), smooth_poses=d('smooth_poses'),\n # Landmarks arguments:\n lms_model=d('lms_model'), lms_batch_size=d('lms_batch_size'), landmarks_postfix=d('landmarks_postfix'),\n cache_landmarks=d('cache_landmarks'), smooth_landmarks=d('smooth_landmarks'),\n # Segmentation arguments:\n seg_model=d('seg_model'), seg_batch_size=d('seg_batch_size'), segmentation_postfix=d('segmentation_postfix'),\n cache_segmentation=d('cache_segmentation'), smooth_segmentation=d('smooth_segmentation'),\n seg_remove_mouth=d('seg_remove_mouth')):\n # General\n self.resolution = resolution\n self.crop_scale = crop_scale\n self.display = display\n self.verbose = verbose\n\n # Detection\n self.face_detector = FaceDetector(det_postfix, detection_model, gpus, det_batch_size, display)\n self.det_postfix = det_postfix\n\n # Sequences\n self.iou_thresh = iou_thresh\n self.min_length = min_length\n self.min_size = min_size\n self.center_kernel = center_kernel\n self.size_kernel = size_kernel\n self.smooth_det = smooth_det\n self.seq_postfix = seq_postfix\n self.write_empty = write_empty\n\n # Pose\n self.pose_batch_size = pose_batch_size\n self.pose_postfix = pose_postfix\n self.cache_pose = cache_pose\n self.cache_frontal = cache_frontal\n self.smooth_poses = smooth_poses\n\n # Landmarks\n self.smooth_landmarks = smooth_landmarks\n self.landmarks_postfix = landmarks_postfix\n self.cache_landmarks = cache_landmarks\n self.lms_batch_size = lms_batch_size\n\n # Segmentation\n self.smooth_segmentation = smooth_segmentation\n self.segmentation_postfix = segmentation_postfix\n self.cache_segmentation = cache_segmentation\n self.seg_batch_size = seg_batch_size\n self.seg_remove_mouth = seg_remove_mouth and cache_landmarks\n\n # Initialize device\n torch.set_grad_enabled(False)\n self.device, self.gpus = set_device(gpus, not cpu_only)\n\n # Load models\n self.face_pose = load_model(pose_model, 'face pose', self.device) if cache_pose else None\n self.L = load_model(lms_model, 'face landmarks', self.device) if cache_landmarks else None\n self.S = load_model(seg_model, 'face segmentation', self.device) if cache_segmentation else None\n\n # Initialize heatmap encoder\n self.heatmap_encoder = LandmarksHeatMapEncoder().to(self.device)\n\n # Initialize normalization tensors\n # Note: this is necessary because of the landmarks model\n self.img_mean = torch.as_tensor([0.5, 0.5, 0.5], device=self.device).view(1, 3, 1, 1)\n self.img_std = torch.as_tensor([0.5, 0.5, 0.5], device=self.device).view(1, 3, 1, 1)\n self.context_mean = torch.as_tensor([0.485, 0.456, 0.406], device=self.device).view(1, 3, 1, 1)\n self.context_std = torch.as_tensor([0.229, 0.224, 0.225], device=self.device).view(1, 3, 1, 1)\n\n # Support multiple GPUs\n if self.gpus and len(self.gpus) > 1:\n self.face_pose = nn.DataParallel(self.face_pose, self.gpus) if self.face_pose is not None else None\n self.L = nn.DataParallel(self.L, self.gpus) if self.L is not None else None\n self.S = nn.DataParallel(self.S, self.gpus) if self.S is not None else None\n\n # Initialize temportal smoothing\n if smooth_segmentation > 0:\n self.smooth_seg = TemporalSmoothing(3, smooth_segmentation).to(self.device)\n else:\n self.smooth_seg = None\n\n # Initialize output videos format\n self.encoder_codec = encoder_codec\n self.fourcc = cv2.VideoWriter_fourcc(*encoder_codec)\n\n def process_pose(self, input_path, output_dir, seq_file_path):\n if not self.cache_pose:\n return\n input_path_no_ext, input_ext = os.path.splitext(input_path)\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # Initialize transforms\n img_transforms = img_landmarks_transforms.Compose([\n Resize(224), ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.basename(input_path_no_ext) + '_seq%02d%s' % (seq.id, input_ext)\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_pose_path = os.path.splitext(curr_vid_path)[0] + self.pose_postfix\n\n if os.path.isfile(curr_pose_path):\n continue\n print('=> Computing face poses for video: \"%s\"...' % curr_vid_name)\n\n # Initialize input video\n in_vid = VideoInferenceDataset(curr_vid_path, transform=img_transforms)\n in_vid_loader = DataLoader(in_vid, batch_size=self.pose_batch_size, num_workers=1, pin_memory=True,\n drop_last=False, shuffle=False)\n\n # For each batch of frames in the input video\n seq_poses = []\n for i, frame in enumerate(tqdm(in_vid_loader, unit='batches', file=sys.stdout)):\n frame = frame.to(self.device)\n poses = self.face_pose(frame).div_(99.) # Yaw, Pitch, Roll\n seq_poses.append(poses.cpu().numpy())\n seq_poses = np.concatenate(seq_poses)\n\n # Save poses to file\n seq_poses_smoothed = smooth_poses(seq_poses, self.smooth_poses)\n np.savez_compressed(curr_pose_path, poses=seq_poses, poses_smoothed=seq_poses_smoothed)\n\n def extract_frontal_images(self, input_path, output_dir, seq_file_path, out_postfix='.jpg', resolution=None):\n if not self.cache_frontal:\n return\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.splitext(os.path.basename(input_path))[0] + '_seq%02d.mp4' % seq.id\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_pose_path = os.path.splitext(curr_vid_path)[0] + self.pose_postfix\n curr_frontal_path = os.path.splitext(curr_vid_path)[0] + out_postfix\n\n if os.path.isfile(curr_frontal_path):\n continue\n\n # Open current video file\n vid = cv2.VideoCapture(curr_vid_path)\n if not vid.isOpened():\n raise RuntimeError('Failed to read video: ' + curr_vid_path)\n\n # Load current sequence poses\n curr_poses = np.load(curr_pose_path)['poses_smoothed']\n\n # Read frontal image from video\n frontal_index = np.argmin(np.linalg.norm(curr_poses, axis=1))\n vid.set(cv2.CAP_PROP_POS_FRAMES, frontal_index)\n ret, frontal_bgr = vid.read()\n\n # Resize image\n if resolution is not None:\n frontal_bgr = cv2.resize(frontal_bgr, (resolution, resolution), interpolation=cv2.INTER_CUBIC)\n\n # Write frontal image to file\n cv2.imwrite(curr_frontal_path, frontal_bgr)\n\n def process_landmarks(self, input_path, output_dir, seq_file_path):\n if not self.cache_landmarks:\n return\n input_path_no_ext, input_ext = os.path.splitext(input_path)\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # Initialize transforms\n img_transforms = img_landmarks_transforms.Compose([\n ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.basename(input_path_no_ext) + '_seq%02d%s' % (seq.id, input_ext)\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_lms_path = os.path.splitext(curr_vid_path)[0] + self.landmarks_postfix\n\n if os.path.isfile(curr_lms_path):\n continue\n print('=> Computing face landmarks for video: \"%s\"...' % curr_vid_name)\n\n # Initialize input video\n in_vid = VideoInferenceDataset(curr_vid_path, transform=img_transforms)\n in_vid_loader = DataLoader(in_vid, batch_size=self.lms_batch_size, num_workers=1, pin_memory=True,\n drop_last=False, shuffle=False)\n\n # For each batch of frames in the input video\n seq_landmarks = []\n for i, frame in enumerate(tqdm(in_vid_loader, unit='batches', file=sys.stdout)):\n frame = frame.to(self.device)\n H = self.L(frame)\n landmarks = self.heatmap_encoder(H)\n seq_landmarks.append(landmarks.cpu().numpy())\n seq_landmarks = np.concatenate(seq_landmarks)\n\n # Save landmarks to file\n seq_landmarks_smoothed = smooth_landmarks_98pts(seq_landmarks, self.smooth_landmarks)\n np.savez_compressed(curr_lms_path, landmarks=seq_landmarks, landmarks_smoothed=seq_landmarks_smoothed)\n\n def process_segmentation(self, input_path, output_dir, seq_file_path):\n if not self.cache_segmentation:\n return\n input_path_no_ext, input_ext = os.path.splitext(input_path)\n\n # Load sequences from file\n with open(seq_file_path, \"rb\") as fp: # Unpickling\n seq_list = pickle.load(fp)\n\n # Initialize transforms\n img_transforms = img_landmarks_transforms.Compose([\n ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])\n\n # For each sequence\n for seq in seq_list:\n curr_vid_name = os.path.basename(input_path_no_ext) + '_seq%02d%s' % (seq.id, input_ext)\n curr_vid_path = os.path.join(output_dir, curr_vid_name)\n curr_seg_path = os.path.splitext(curr_vid_path)[0] + self.segmentation_postfix\n\n if self.seg_remove_mouth:\n curr_lms_path = os.path.splitext(curr_vid_path)[0] + self.landmarks_postfix\n landmarks = np.load(curr_lms_path)['landmarks_smoothed']\n frame_count = 0\n\n if os.path.isfile(curr_seg_path):\n continue\n print('=> Computing face segmentation for video: \"%s\"...' % curr_vid_name)\n\n # Initialize input video\n in_vid = VideoInferenceDataset(curr_vid_path, transform=img_transforms)\n in_vid_loader = DataLoader(in_vid, batch_size=self.seg_batch_size, num_workers=1, pin_memory=True,\n drop_last=False, shuffle=False)\n\n # For each batch of frames in the input video\n pbar = tqdm(in_vid_loader, unit='batches', file=sys.stdout)\n prev_segmentation = None\n r = self.smooth_seg.kernel_radius\n encoded_segmentations = []\n pad_prev, pad_next = r, r # This initialization is only relevant if there is a leftover from last batch\n for i, frame in enumerate(pbar):\n print(frame.shape)\n frame = frame.to(self.device)\n\n # Compute segmentation\n raw_segmentation = self.S(frame)\n segmentation = torch.cat((prev_segmentation, raw_segmentation), dim=0) \\\n if prev_segmentation is not None else raw_segmentation\n if segmentation.shape[0] > r:\n pad_prev, pad_next = r if prev_segmentation is None else 0, min(r, self.seg_batch_size - frame.shape[0])\n segmentation = self.smooth_seg(segmentation, pad_prev=pad_prev, pad_next=pad_next)\n\n # Note: the pad_next value here is only relevant if there is a leftover from last batch\n prev_segmentation = raw_segmentation[-(r * 2 - pad_next):]\n\n mask = segmentation.argmax(1) == 1\n\n # Encode segmentation\n for b in range(mask.shape[0]):\n curr_mask = mask[b].cpu().numpy()\n if self.seg_remove_mouth:\n curr_mask = remove_inner_mouth(curr_mask, landmarks[frame_count])\n frame_count += 1\n encoded_segmentations.append(encode_binary_mask(curr_mask))\n\n # Final iteration if we have leftover unsmoothed segmentations from the last batch\n if pad_next < r:\n # Compute segmentation\n segmentation = self.smooth_seg(prev_segmentation, pad_prev=pad_prev, pad_next=r)\n mask = segmentation.argmax(1) == 1\n\n # Encode segmentation\n for b in range(mask.shape[0]):\n curr_mask = mask[b].cpu().numpy()\n if self.seg_remove_mouth:\n curr_mask = remove_inner_mouth(curr_mask, landmarks[frame_count])\n frame_count += 1\n encoded_segmentations.append(encode_binary_mask(curr_mask))\n\n # Write to file\n with open(curr_seg_path, \"wb\") as fp: # Pickling\n pickle.dump(encoded_segmentations, fp)\n\n\n def cache(self, input_path, output_dir=None):\n # Validation\n assert os.path.isfile(input_path), 'Input path \"%s\" does not exist' % input_path\n assert output_dir is None or os.path.isdir(output_dir), 'Output path \"%s\" must be a directory' % output_dir\n is_vid = os.path.splitext(input_path)[1] == '.mp4'\n\n # Set paths\n output_dir = os.path.splitext(input_path)[0] if output_dir is None else output_dir\n det_file_path = os.path.splitext(input_path)[0] + self.det_postfix\n if not os.path.isfile(det_file_path): # Check if there is a detection file in the same directory as the video\n det_file_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] +\n self.det_postfix)\n seq_file_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] + self.seq_postfix)\n first_cropped_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] +\n '_seq00' + os.path.splitext(input_path)[1])\n pose_file_path = os.path.join(output_dir, os.path.splitext(os.path.basename(input_path))[0] + self.pose_postfix)\n\n # Create directory\n if not os.path.isdir(output_dir):\n os.mkdir(output_dir)\n\n # Face detection\n if not os.path.isfile(det_file_path):\n self.face_detector(input_path, det_file_path)\n\n # Detections to sequences\n if not os.path.isfile(seq_file_path):\n detections2sequences_main(input_path, seq_file_path, det_file_path, self.iou_thresh, self.min_length,\n self.min_size, self.crop_scale, self.center_kernel, self.size_kernel,\n self.smooth_det, self.display, self.write_empty)\n\n # Crop video sequences\n if not os.path.isfile(first_cropped_path):\n if is_vid:\n crop_video_sequences_main(input_path, output_dir, seq_file_path, self.seq_postfix, self.resolution,\n self.crop_scale, select='all', disable_tqdm=False,\n encoder_codec=self.encoder_codec)\n else:\n crop_image_sequences_main(input_path, output_dir, seq_file_path, self.seq_postfix, '.jpg',\n self.resolution, self.crop_scale)\n\n # Face poses\n # if not os.path.isfile(pose_file_path) and is_vid:\n # self.process_pose(input_path, output_dir, seq_file_path, pose_file_path)\n # if is_vid:\n self.process_pose(input_path, output_dir, seq_file_path)\n\n # Extract frontal images\n # if self.cache_pose and self.cache_frontal and is_vid:\n # self.extract_frontal_images(input_path, output_dir, pose_file_path)\n if self.cache_pose and self.cache_frontal and is_vid:\n self.extract_frontal_images(input_path, output_dir, seq_file_path)\n\n # Cache landmarks\n self.process_landmarks(input_path, output_dir, seq_file_path)\n\n # Cache segmentation\n self.process_segmentation(input_path, output_dir, seq_file_path)\n\n return output_dir, seq_file_path, pose_file_path if self.cache_pose and is_vid else None\n\n\nclass VideoProcessCallable(VideoProcessBase):\n def __init__(self, *args, **kwargs):\n super(VideoProcessCallable, self).__init__(*args, **kwargs)\n\n def __call__(self, input_path, output_dir=None):\n return self.cache(input_path, output_dir)\n\n\ndef smooth_poses(poses, kernel_size=5):\n out_poses = poses.copy() if isinstance(poses, np.ndarray) else np.array(poses)\n\n # Prepare smoothing kernel\n # w = np.hamming(kernel_size)\n w = np.ones(kernel_size)\n w /= w.sum()\n\n # Smooth poses\n poses_padded = np.pad(out_poses, ((kernel_size // 2, kernel_size // 2), (0, 0)), 'reflect')\n for i in range(out_poses.shape[1]):\n out_poses[:, i] = np.convolve(w, poses_padded[:, i], mode='valid')\n\n return out_poses\n\n\ndef main(input, output=d('output'), resolution=d('resolution'), crop_scale=d('crop_scale'), gpus=d('gpus'),\n cpu_only=d('cpu_only'), display=d('display'), verbose=d('verbose'), encoder_codec=d('encoder_codec'),\n # Detection arguments:\n detection_model=d('detection_model'), det_batch_size=d('det_batch_size'), det_postfix=d('det_postfix'),\n # Sequence arguments:\n iou_thresh=d('iou_thresh'), min_length=d('min_length'), min_size=d('min_size'),\n center_kernel=d('center_kernel'), size_kernel=d('size_kernel'), smooth_det=d('smooth_det'),\n seq_postfix=d('seq_postfix'), write_empty=d('write_empty'),\n # Pose arguments:\n pose_model=d('pose_model'), pose_batch_size=d('pose_batch_size'), pose_postfix=d('pose_postfix'),\n cache_pose=d('cache_pose'), cache_frontal=d('cache_frontal'), smooth_poses=d('smooth_poses'),\n # Landmarks arguments:\n lms_model=d('lms_model'), lms_batch_size=d('lms_batch_size'), landmarks_postfix=d('landmarks_postfix'),\n cache_landmarks=d('cache_landmarks'), smooth_landmarks=d('smooth_landmarks'),\n # Segmentation arguments:\n seg_model=d('seg_model'), seg_batch_size=d('seg_batch_size'), segmentation_postfix=d('segmentation_postfix'),\n cache_segmentation=d('cache_segmentation'), smooth_segmentation=d('smooth_segmentation'),\n seg_remove_mouth=d('seg_remove_mouth')):\n video_process = VideoProcessCallable(\n resolution, crop_scale, gpus, cpu_only, display, verbose, encoder_codec,\n detection_model=detection_model, det_batch_size=det_batch_size, det_postfix=det_postfix,\n iou_thresh=iou_thresh, min_length=min_length, min_size=min_size, center_kernel=center_kernel,\n size_kernel=size_kernel, smooth_det=smooth_det, seq_postfix=seq_postfix, write_empty=write_empty,\n pose_model=pose_model, pose_batch_size=pose_batch_size, pose_postfix=pose_postfix, cache_pose=cache_pose,\n cache_frontal=cache_frontal, smooth_poses=smooth_poses, lms_model=lms_model, lms_batch_size=lms_batch_size,\n landmarks_postfix=landmarks_postfix, cache_landmarks=cache_landmarks, smooth_landmarks=smooth_landmarks,\n seg_model=seg_model, seg_batch_size=seg_batch_size, segmentation_postfix=segmentation_postfix,\n cache_segmentation=cache_segmentation, smooth_segmentation=smooth_segmentation,\n seg_remove_mouth=seg_remove_mouth)\n if len(input) == 1 and os.path.isfile(input[0]):\n video_process.cache(input, output)\n else:\n batch(input, None, output, video_process, postfix='.mp4')\n\n\nif __name__ == \"__main__\":\n main(**vars(parser.parse_args()))\n" ]

[ [ "numpy.convolve", "numpy.pad", "torch.cat", "torch.utils.data.DataLoader", "numpy.linalg.norm", "numpy.ones", "numpy.concatenate", "numpy.savez_compressed", "torch.set_grad_enabled", "numpy.load", "torch.nn.DataParallel", "numpy.array", "torch.as_tensor" ] ]

RobbeElsermans/GestureControl

[ "c66f4d19fbf9ad785f4a8c721e7c6f8ba8425f4f" ]

[ "Code PlatformIO/Gesture Control PCBV0.3_F302RET6/python/showDataCSV.py" ]

[ "#!/usr/bin/python\nfrom csv import reader\nimport matplotlib.pyplot as plt\n\nfileName = \"links_zonder_duim\"\n\nfile = open(\"Software_Opstelling/\" + fileName + \".csv\", 'r', newline='')\n\ndata = reader(file, delimiter=',')\n\nleft=[]\ncenter=[]\nright=[]\n\nfor items in data:\n if not(\"LEFT\" in items[0]):\n left.append(int(items[0]))\n center.append(int(items[1]))\n right.append(int(items[2]))\n\n#aanmaken x as\nx = range(len(left))\n\nplt.plot(x,left,label=\"left\")\nplt.plot(x,center,label=\"center\")\nplt.plot(x,right,label=\"right\")\nplt.legend()\nplt.show()" ]

[ [ "matplotlib.pyplot.plot", "matplotlib.pyplot.legend", "matplotlib.pyplot.show" ] ]

Yard1/pycaret

[ "b6a0168d9479c7778aea8f07cf1e14b3da169045" ]

[ "pycaret/arules.py" ]

[ "# Module: Association Rules Mining\n# Author: Moez Ali <[email protected]>\n# License: MIT\n# Release: PyCaret 2.0x\n# Last modified : 30/07/2020\n\ndef setup(data, \n transaction_id, \n item_id,\n ignore_items = None,\n session_id = None):\n \n \"\"\"\n \n Description:\n ------------\n This function initializes the environment in pycaret. setup() must called before\n executing any other function in pycaret. It takes three mandatory parameters:\n (i) dataframe {array-like, sparse matrix}, (ii) transaction_id param identifying \n basket and (iii) item_id param used to create rules. These three params are \n normally found in any transactional dataset. pycaret will internally convert the\n dataframe into a sparse matrix which is required for association rules mining.\n \n Example\n -------\n from pycaret.datasets import get_data\n france get_data('france')\n \n experiment_name = setup(data = data, transaction_id = 'InvoiceNo', \n item_id = 'ProductName')\n \n Parameters\n ----------\n data : {array-like, sparse matrix}, shape (n_samples, n_features) where n_samples \n is the number of samples and n_features is the number of features.\n\n transaction_id: string\n Name of column representing transaction id. This will be used to pivot the matrix.\n\n item_id: string\n Name of column used for creation of rules. Normally, this will be the variable of\n interest.\n \n ignore_items: list, default = None\n list of strings to be ignored when considering rule mining.\n\n session_id: int, default = None\n If None, a random seed is generated and returned in the Information grid. The \n unique number is then distributed as a seed in all functions used during the \n experiment. This can be used for later reproducibility of the entire experiment.\n\n Returns:\n --------\n\n info grid: Information grid is printed.\n ----------- \n\n environment: This function returns various outputs that are stored in variable\n ----------- as tuple. They are used by other functions in pycaret.\n \n \n \"\"\"\n \n #exception checking \n import sys\n \n #ignore warnings\n import warnings\n warnings.filterwarnings('ignore') \n \n #load dependencies\n import random\n import pandas as pd\n import numpy as np\n from IPython.display import display, HTML, clear_output, update_display\n \n global X, txid, iid, ignore_list, seed, experiment__\n \n #create an empty list for pickling later.\n experiment__ = []\n \n #storing items in variable\n X = data\n txid = transaction_id\n iid = item_id\n ignore_list = ignore_items\n \n #generate seed to be used globally\n if session_id is None:\n seed = random.randint(150,9000)\n else:\n seed = session_id\n \n #display info grid\n \n #transactions\n \n tx_unique = len(data[transaction_id].unique()) \n item_unique = len(data[item_id].unique()) \n if ignore_items is None:\n ignore_flag = 'None'\n else:\n ignore_flag = ignore_items \n \n functions = pd.DataFrame ( [ ['session_id', seed ],\n ['# Transactions', tx_unique ], \n ['# Items', item_unique ],\n ['Ignore Items', ignore_flag ],\n ], columns = ['Description', 'Value'] )\n\n functions_ = functions.style.hide_index()\n display(functions_)\n \n return X, txid, iid, ignore_list, seed, experiment__\n\ndef create_model(metric='confidence',\n threshold = 0.5,\n min_support = 0.05,\n round = 4):\n \n \"\"\" \n \n Description:\n ------------\n This function creates an association rules model using data and identifiers \n passed at setup stage. This function internally transforms the data for \n association rule mining.\n\n setup() function must be called before using create_model()\n\n Example\n -------\n from pycaret.datasets import get_data\n france get_data('france') \n experiment_name = setup(data = data, transaction_id = 'InvoiceNo', \n item_id = 'ProductName')\n\n This will return dataframe containing rules sorted by metric param. \n\n Parameters\n ----------\n metric : string, default = 'confidence'\n Metric to evaluate if a rule is of interest. Default is set to confidence. \n Other available metrics include 'support', 'lift', 'leverage', 'conviction'. \n These metrics are computed as follows:\n\n - support(A->C) = support(A+C) [aka 'support'], range: [0, 1]\n\n - confidence(A->C) = support(A+C) / support(A), range: [0, 1]\n\n - lift(A->C) = confidence(A->C) / support(C), range: [0, inf]\n\n - leverage(A->C) = support(A->C) - support(A)*support(C),\n range: [-1, 1]\n\n - conviction = [1 - support(C)] / [1 - confidence(A->C)],\n range: [0, inf]\n \n threshold : float, default = 0.5\n Minimal threshold for the evaluation metric, via the `metric` parameter,\n to decide whether a candidate rule is of interest.\n \n min_support : float, default = 0.05\n A float between 0 and 1 for minumum support of the itemsets returned.\n The support is computed as the fraction `transactions_where_item(s)_occur /\n total_transactions`.\n \n round: integer, default = 4\n Number of decimal places metrics in score grid will be rounded to. \n\n\n Returns:\n --------\n\n DataFrame: Dataframe containing rules of interest with all metrics\n --------- including antecedents, consequents, antecedent support,\n consequent support, support, confidence, lift, leverage,\n conviction.\n\n Warnings:\n ---------\n\n - Setting low values for min_support may increase training time.\n \n \n \"\"\"\n \n \n #loading dependencies\n import pandas as pd\n from IPython.display import display, HTML, clear_output, update_display\n from mlxtend.frequent_patterns import apriori\n from mlxtend.frequent_patterns import association_rules\n \n #reshaping the dataframe\n basket = X.groupby([txid, iid])[iid].count().unstack().reset_index().fillna(0).set_index(txid)\n if ignore_list is not None:\n basket = basket.drop(ignore_list, axis=1) \n \n def encode_units(x):\n \n if x <= 0:\n return 0\n if x >= 1:\n return 1\n\n basket = basket.applymap(encode_units)\n \n frequent_itemsets = apriori(basket, min_support=min_support, use_colnames=True)\n rules = association_rules(frequent_itemsets, metric=metric, min_threshold=threshold)\n rules = rules.sort_values(by=[metric],ascending=False).reset_index(drop=True)\n rules = rules.round(round)\n \n #storing into experiment\n tup = ('Basket',basket)\n experiment__.append(tup)\n \n tup = ('Frequent Itemsets',frequent_itemsets)\n experiment__.append(tup)\n\n tup = ('Rules',rules)\n experiment__.append(tup)\n \n \n return(rules)\n\ndef plot_model(model,\n plot = '2d'):\n \n \"\"\"\n \n Description:\n ------------\n This function takes a model dataframe returned by create_model() function. \n '2d' and '3d' plots are available.\n\n Example:\n --------\n \n rule1 = create_model(metric='confidence', threshold=0.7, min_support=0.05)\n plot_model(rule1, plot='2d')\n plot_model(rule1, plot='3d')\n\n Parameters\n ----------\n\n model : DataFrame, default = none\n DataFrame returned by trained model using create_model(). \n\n plot : string, default = '2d'\n Enter abbreviation of type of plot. The current list of plots supported are:\n\n Name Abbreviated String \n --------- ------------------ \n Support, Confidence and Lift (2d) '2d'\n Support, Confidence and Lift (3d) '3d'\n \n \n Returns:\n --------\n\n Visual Plot: Prints the visual plot. \n ------------\n \n \"\"\"\n \n #loading libraries\n import numpy as np\n import pandas as pd\n import plotly.express as px\n from IPython.display import display, HTML, clear_output, update_display\n \n #import cufflinks\n import cufflinks as cf\n cf.go_offline()\n cf.set_config_file(offline=False, world_readable=True)\n \n #copy dataframe\n data_ = model.copy()\n \n antecedents = []\n for i in data_['antecedents']:\n i = str(i)\n a = i.split(sep=\"'\")\n a = a[1]\n antecedents.append(a)\n\n data_['antecedents'] = antecedents\n\n antecedents_short = []\n\n for i in antecedents:\n a = i[:10]\n antecedents_short.append(a)\n\n data_['antecedents_short'] = antecedents_short\n\n consequents = []\n for i in data_['consequents']:\n i = str(i)\n a = i.split(sep=\"'\")\n a = a[1]\n consequents.append(a)\n\n data_['consequents'] = consequents\n \n if plot == '2d':\n\n fig = px.scatter(data_, x=\"support\", y=\"confidence\", text=\"antecedents_short\", log_x=True, size_max=600, color='lift', \n hover_data = ['antecedents', 'consequents'], opacity=0.5, )\n\n fig.update_traces(textposition='top center')\n fig.update_layout(plot_bgcolor='rgb(240,240,240)')\n\n fig.update_layout(\n height=800,\n title_text='2D Plot of Support, Confidence and Lift'\n )\n\n fig.show()\n \n \n if plot == '3d':\n \n fig = px.scatter_3d(data_, x='support', y='confidence', z='lift',\n color='antecedent support', title='3d Plot for Rule Mining', opacity=0.7, width=900, height=800,\n hover_data = ['antecedents', 'consequents' ])\n fig.show() \n\ndef get_rules(data, \n transaction_id, \n item_id,\n ignore_items = None,\n metric='confidence',\n threshold = 0.5,\n min_support = 0.05):\n \n \"\"\"\n Magic function to get Association Rules in Power Query / Power BI. \n \n \"\"\"\n \n s = setup(data=data, transaction_id=transaction_id, item_id=item_id, ignore_items = ignore_items)\n dataset = create_model(metric=metric, threshold=threshold, min_support=min_support, round=4)\n \n return dataset" ]

[ [ "pandas.DataFrame" ] ]

ruarai/epifx.covid

[ "be7aecbf9e86c3402f6851ea65f6705cdb59f3cf" ]

[ "local_epifx/tests/test_select.py" ]

[ "import logging\nimport os\nimport warnings\nimport numpy as np\nimport pypfilt\nimport pypfilt.sweep\nimport epifx\nimport epifx.select\n\n\ndef test_select():\n logging.basicConfig(level=logging.INFO)\n logger = logging.getLogger(\"epifx.select\")\n logger.setLevel(logging.DEBUG)\n out_file = 'test_select_samples.ssv'\n\n # Define the PRNG seed for the selection process.\n seed = 2020\n\n # Draw proposals from the prior distributions defined in the simulation\n # parameters.\n proposal = epifx.select.DefaultProposal()\n\n # Peak times and sizes based on weekly numbers of seasonal influenza case\n # notifications for metropolitan Melbourne over 2012-2017.\n peak_times = np.array([[136, 177, 176, 182, 187, 193]])\n peak_sizes = np.array([360, 417, 691, 1329, 975, 2036])\n target = epifx.select.TargetPeakMVN(peak_sizes, peak_times)\n\n # Write an empty observations file, otherwise an exception will be raised\n # when attempting to load the observations.\n obs_file = 'no-observations.ssv'\n with open(obs_file, 'w') as f:\n f.write('date count\\n')\n\n config = pypfilt.config.from_string(config_str())\n with warnings.catch_warnings():\n # NOTE: pypfilt.sweep() will read the observations date file, which\n # makes numpy.loadtxt() produce a warning about an empty data file.\n # We can suppress this with warnings.filterwarnings().\n warnings.filterwarnings('ignore',\n message='loadtxt: Empty input file:',\n category=UserWarning)\n forecasts = list(pypfilt.sweep.forecasts(config))\n params = forecasts[0].params\n\n # Select particles according to the peak size and time target.\n vec = epifx.select.select(params, proposal, target, seed)\n\n # Retrieve the parameter columns from these particles.\n sample_cols = params['component']['model'].sample_columns()\n column_names = list(sample_cols.keys())\n column_ixs = np.array([sample_cols[n] for n in column_names])\n tbl = vec[:, column_ixs]\n\n # Save the sampled parameter values.\n logger.debug(\"Saving samples to {}\".format(out_file))\n np.savetxt(out_file, tbl, header=' '.join(column_names), comments='')\n\n # Remove the empty observations file.\n os.remove(obs_file)\n # Leave the sampled parameter file for now.\n # os.remove(out_file)\n\n\ndef config_str():\n \"\"\"Define forecast scenarios for these test cases.\"\"\"\n return \"\"\"\n [components]\n model = \"epifx.det.SEIR\"\n time = \"pypfilt.Datetime\"\n summary = \"epifx.summary.make\"\n\n [parameters]\n particles = 2000\n prng_seed = 3001\n steps_per_unit = 1\n last_n_periods = 1\n data_dir = \".\"\n tmp_dir = \".\"\n out_dir = \".\"\n json_dir = \".\"\n max_days = 7\n resample.threshold = 0.25\n resample.regularisation = true\n time.start = \"2020-03-01\"\n time.until = \"2020-12-31\"\n summary.from_first_day = true\n summary.only_forecasts = true\n summary.metadata.packages = [ \"epifx\" ]\n fresh_cache = true\n remove_cache = true\n\n [model.bounds]\n R0 = { min = 1.2, max = 1.6 }\n sigma = { min = 0.1, max = 10.0 }\n gamma = { min = 0.1, max = 10.0 }\n eta = { min = 1.0, max = 1.0 }\n alpha = { min = -0.2, max = 0.0 }\n t0 = { min = 0, max = 60 }\n\n [model.priors]\n R0 = { function = \"uniform\", args.low = 1.2, args.high = 1.6 }\n sigma = { function = \"inverse_uniform\", args.low = 0.5, args.high = 4.0 }\n gamma = { function = \"inverse_uniform\", args.low = 0.5, args.high = 4.0 }\n eta = { function = \"uniform\", args.low = 1.0, args.high = 1.0 }\n alpha = { function = \"uniform\", args.low = 0.0, args.high = 0.0 }\n t0 = { function = \"uniform\", args.low = 0, args.high = 60 }\n\n [summary.init]\n default = true\n\n [scenario.Melbourne]\n name = \"Melbourne\"\n parameters.model.population_size = 5_191_000\n\n [observations.Notifications]\n model = \"epifx.obs.PopnCounts\"\n file = \"no-observations.ssv\"\n init.obs_period = 7\n file_args.time_col = \"date\"\n file_args.value_col = \"count\"\n parameters.bg_obs = 70\n parameters.bg_var = 80\n parameters.pr_obs = 0.00275\n parameters.disp = 100\n format = { bg_obs = \"3.0f\", bg_var = \"03.0f\", pr_obs = \"0.5f\", disp = \"03.0f\" }\n name = { bg_obs = \"bg\", bg_var = \"bgvar\", pr_obs = \"pr\", disp = \"disp\" }\n \"\"\"\n" ]

[ [ "numpy.array" ] ]

huillll/deepface

[ "f17e63b8c8edc989d2d5d0d0861fe976c359d922" ]

[ "deepface/basemodels/OpenFace.py" ]

[ "import os\nfrom pathlib import Path\nimport gdown\n\nimport tensorflow as tf\nimport keras\nfrom keras.models import Model, Sequential\nfrom keras.layers import Conv2D, ZeroPadding2D, Activation, Input, concatenate\nfrom keras.layers.core import Dense, Activation, Lambda, Flatten\nfrom keras.layers.pooling import MaxPooling2D, AveragePooling2D\nfrom keras.layers.merge import Concatenate\nfrom keras.layers.normalization import BatchNormalization\nfrom keras.models import load_model\nfrom keras import backend as K\n\n#---------------------------------------\n\ndef loadModel():\n\tmyInput = Input(shape=(96, 96, 3))\n\n\tx = ZeroPadding2D(padding=(3, 3), input_shape=(96, 96, 3))(myInput)\n\tx = Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x)\n\tx = BatchNormalization(axis=3, epsilon=0.00001, name='bn1')(x)\n\tx = Activation('relu')(x)\n\tx = ZeroPadding2D(padding=(1, 1))(x)\n\tx = MaxPooling2D(pool_size=3, strides=2)(x)\n\tx = Lambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name='lrn_1')(x)\n\tx = Conv2D(64, (1, 1), name='conv2')(x)\n\tx = BatchNormalization(axis=3, epsilon=0.00001, name='bn2')(x)\n\tx = Activation('relu')(x)\n\tx = ZeroPadding2D(padding=(1, 1))(x)\n\tx = Conv2D(192, (3, 3), name='conv3')(x)\n\tx = BatchNormalization(axis=3, epsilon=0.00001, name='bn3')(x)\n\tx = Activation('relu')(x)\n\tLambda(lambda x: tf.nn.lrn(x, alpha=1e-4, beta=0.75), name='lrn_2')(x)\n\tx = ZeroPadding2D(padding=(1, 1))(x)\n\tx = MaxPooling2D(pool_size=3, strides=2)(x)\n\n\t# Inception3a\n\tinception_3a_3x3 = Conv2D(96, (1, 1), name='inception_3a_3x3_conv1')(x)\n\tinception_3a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_3x3_bn1')(inception_3a_3x3)\n\tinception_3a_3x3 = Activation('relu')(inception_3a_3x3)\n\tinception_3a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3a_3x3)\n\tinception_3a_3x3 = Conv2D(128, (3, 3), name='inception_3a_3x3_conv2')(inception_3a_3x3)\n\tinception_3a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_3x3_bn2')(inception_3a_3x3)\n\tinception_3a_3x3 = Activation('relu')(inception_3a_3x3)\n\n\tinception_3a_5x5 = Conv2D(16, (1, 1), name='inception_3a_5x5_conv1')(x)\n\tinception_3a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_5x5_bn1')(inception_3a_5x5)\n\tinception_3a_5x5 = Activation('relu')(inception_3a_5x5)\n\tinception_3a_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3a_5x5)\n\tinception_3a_5x5 = Conv2D(32, (5, 5), name='inception_3a_5x5_conv2')(inception_3a_5x5)\n\tinception_3a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_5x5_bn2')(inception_3a_5x5)\n\tinception_3a_5x5 = Activation('relu')(inception_3a_5x5)\n\n\tinception_3a_pool = MaxPooling2D(pool_size=3, strides=2)(x)\n\tinception_3a_pool = Conv2D(32, (1, 1), name='inception_3a_pool_conv')(inception_3a_pool)\n\tinception_3a_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_pool_bn')(inception_3a_pool)\n\tinception_3a_pool = Activation('relu')(inception_3a_pool)\n\tinception_3a_pool = ZeroPadding2D(padding=((3, 4), (3, 4)))(inception_3a_pool)\n\n\tinception_3a_1x1 = Conv2D(64, (1, 1), name='inception_3a_1x1_conv')(x)\n\tinception_3a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3a_1x1_bn')(inception_3a_1x1)\n\tinception_3a_1x1 = Activation('relu')(inception_3a_1x1)\n\n\tinception_3a = concatenate([inception_3a_3x3, inception_3a_5x5, inception_3a_pool, inception_3a_1x1], axis=3)\n\n\t# Inception3b\n\tinception_3b_3x3 = Conv2D(96, (1, 1), name='inception_3b_3x3_conv1')(inception_3a)\n\tinception_3b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_3x3_bn1')(inception_3b_3x3)\n\tinception_3b_3x3 = Activation('relu')(inception_3b_3x3)\n\tinception_3b_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3b_3x3)\n\tinception_3b_3x3 = Conv2D(128, (3, 3), name='inception_3b_3x3_conv2')(inception_3b_3x3)\n\tinception_3b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_3x3_bn2')(inception_3b_3x3)\n\tinception_3b_3x3 = Activation('relu')(inception_3b_3x3)\n\n\tinception_3b_5x5 = Conv2D(32, (1, 1), name='inception_3b_5x5_conv1')(inception_3a)\n\tinception_3b_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_5x5_bn1')(inception_3b_5x5)\n\tinception_3b_5x5 = Activation('relu')(inception_3b_5x5)\n\tinception_3b_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3b_5x5)\n\tinception_3b_5x5 = Conv2D(64, (5, 5), name='inception_3b_5x5_conv2')(inception_3b_5x5)\n\tinception_3b_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_5x5_bn2')(inception_3b_5x5)\n\tinception_3b_5x5 = Activation('relu')(inception_3b_5x5)\n\n\tinception_3b_pool = Lambda(lambda x: x**2, name='power2_3b')(inception_3a)\n\tinception_3b_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_3b_pool)\n\tinception_3b_pool = Lambda(lambda x: x*9, name='mult9_3b')(inception_3b_pool)\n\tinception_3b_pool = Lambda(lambda x: K.sqrt(x), name='sqrt_3b')(inception_3b_pool)\n\tinception_3b_pool = Conv2D(64, (1, 1), name='inception_3b_pool_conv')(inception_3b_pool)\n\tinception_3b_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_pool_bn')(inception_3b_pool)\n\tinception_3b_pool = Activation('relu')(inception_3b_pool)\n\tinception_3b_pool = ZeroPadding2D(padding=(4, 4))(inception_3b_pool)\n\n\tinception_3b_1x1 = Conv2D(64, (1, 1), name='inception_3b_1x1_conv')(inception_3a)\n\tinception_3b_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3b_1x1_bn')(inception_3b_1x1)\n\tinception_3b_1x1 = Activation('relu')(inception_3b_1x1)\n\n\tinception_3b = concatenate([inception_3b_3x3, inception_3b_5x5, inception_3b_pool, inception_3b_1x1], axis=3)\n\n\t# Inception3c\n\tinception_3c_3x3 = Conv2D(128, (1, 1), strides=(1, 1), name='inception_3c_3x3_conv1')(inception_3b)\n\tinception_3c_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_3x3_bn1')(inception_3c_3x3)\n\tinception_3c_3x3 = Activation('relu')(inception_3c_3x3)\n\tinception_3c_3x3 = ZeroPadding2D(padding=(1, 1))(inception_3c_3x3)\n\tinception_3c_3x3 = Conv2D(256, (3, 3), strides=(2, 2), name='inception_3c_3x3_conv'+'2')(inception_3c_3x3)\n\tinception_3c_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_3x3_bn'+'2')(inception_3c_3x3)\n\tinception_3c_3x3 = Activation('relu')(inception_3c_3x3)\n\n\tinception_3c_5x5 = Conv2D(32, (1, 1), strides=(1, 1), name='inception_3c_5x5_conv1')(inception_3b)\n\tinception_3c_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_5x5_bn1')(inception_3c_5x5)\n\tinception_3c_5x5 = Activation('relu')(inception_3c_5x5)\n\tinception_3c_5x5 = ZeroPadding2D(padding=(2, 2))(inception_3c_5x5)\n\tinception_3c_5x5 = Conv2D(64, (5, 5), strides=(2, 2), name='inception_3c_5x5_conv'+'2')(inception_3c_5x5)\n\tinception_3c_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_3c_5x5_bn'+'2')(inception_3c_5x5)\n\tinception_3c_5x5 = Activation('relu')(inception_3c_5x5)\n\n\tinception_3c_pool = MaxPooling2D(pool_size=3, strides=2)(inception_3b)\n\tinception_3c_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_3c_pool)\n\n\tinception_3c = concatenate([inception_3c_3x3, inception_3c_5x5, inception_3c_pool], axis=3)\n\n\t#inception 4a\n\tinception_4a_3x3 = Conv2D(96, (1, 1), strides=(1, 1), name='inception_4a_3x3_conv'+'1')(inception_3c)\n\tinception_4a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_3x3_bn'+'1')(inception_4a_3x3)\n\tinception_4a_3x3 = Activation('relu')(inception_4a_3x3)\n\tinception_4a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4a_3x3)\n\tinception_4a_3x3 = Conv2D(192, (3, 3), strides=(1, 1), name='inception_4a_3x3_conv'+'2')(inception_4a_3x3)\n\tinception_4a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_3x3_bn'+'2')(inception_4a_3x3)\n\tinception_4a_3x3 = Activation('relu')(inception_4a_3x3)\n\n\tinception_4a_5x5 = Conv2D(32, (1,1), strides=(1,1), name='inception_4a_5x5_conv1')(inception_3c)\n\tinception_4a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_5x5_bn1')(inception_4a_5x5)\n\tinception_4a_5x5 = Activation('relu')(inception_4a_5x5)\n\tinception_4a_5x5 = ZeroPadding2D(padding=(2,2))(inception_4a_5x5)\n\tinception_4a_5x5 = Conv2D(64, (5,5), strides=(1,1), name='inception_4a_5x5_conv'+'2')(inception_4a_5x5)\n\tinception_4a_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_5x5_bn'+'2')(inception_4a_5x5)\n\tinception_4a_5x5 = Activation('relu')(inception_4a_5x5)\n\n\tinception_4a_pool = Lambda(lambda x: x**2, name='power2_4a')(inception_3c)\n\tinception_4a_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_4a_pool)\n\tinception_4a_pool = Lambda(lambda x: x*9, name='mult9_4a')(inception_4a_pool)\n\tinception_4a_pool = Lambda(lambda x: K.sqrt(x), name='sqrt_4a')(inception_4a_pool)\n\n\tinception_4a_pool = Conv2D(128, (1,1), strides=(1,1), name='inception_4a_pool_conv'+'')(inception_4a_pool)\n\tinception_4a_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_pool_bn'+'')(inception_4a_pool)\n\tinception_4a_pool = Activation('relu')(inception_4a_pool)\n\tinception_4a_pool = ZeroPadding2D(padding=(2, 2))(inception_4a_pool)\n\n\tinception_4a_1x1 = Conv2D(256, (1, 1), strides=(1, 1), name='inception_4a_1x1_conv'+'')(inception_3c)\n\tinception_4a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4a_1x1_bn'+'')(inception_4a_1x1)\n\tinception_4a_1x1 = Activation('relu')(inception_4a_1x1)\n\n\tinception_4a = concatenate([inception_4a_3x3, inception_4a_5x5, inception_4a_pool, inception_4a_1x1], axis=3)\n\n\t#inception4e\n\tinception_4e_3x3 = Conv2D(160, (1,1), strides=(1,1), name='inception_4e_3x3_conv'+'1')(inception_4a)\n\tinception_4e_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_3x3_bn'+'1')(inception_4e_3x3)\n\tinception_4e_3x3 = Activation('relu')(inception_4e_3x3)\n\tinception_4e_3x3 = ZeroPadding2D(padding=(1, 1))(inception_4e_3x3)\n\tinception_4e_3x3 = Conv2D(256, (3,3), strides=(2,2), name='inception_4e_3x3_conv'+'2')(inception_4e_3x3)\n\tinception_4e_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_3x3_bn'+'2')(inception_4e_3x3)\n\tinception_4e_3x3 = Activation('relu')(inception_4e_3x3)\n\n\tinception_4e_5x5 = Conv2D(64, (1,1), strides=(1,1), name='inception_4e_5x5_conv'+'1')(inception_4a)\n\tinception_4e_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_5x5_bn'+'1')(inception_4e_5x5)\n\tinception_4e_5x5 = Activation('relu')(inception_4e_5x5)\n\tinception_4e_5x5 = ZeroPadding2D(padding=(2, 2))(inception_4e_5x5)\n\tinception_4e_5x5 = Conv2D(128, (5,5), strides=(2,2), name='inception_4e_5x5_conv'+'2')(inception_4e_5x5)\n\tinception_4e_5x5 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_4e_5x5_bn'+'2')(inception_4e_5x5)\n\tinception_4e_5x5 = Activation('relu')(inception_4e_5x5)\n\n\tinception_4e_pool = MaxPooling2D(pool_size=3, strides=2)(inception_4a)\n\tinception_4e_pool = ZeroPadding2D(padding=((0, 1), (0, 1)))(inception_4e_pool)\n\n\tinception_4e = concatenate([inception_4e_3x3, inception_4e_5x5, inception_4e_pool], axis=3)\n\n\t#inception5a\n\tinception_5a_3x3 = Conv2D(96, (1,1), strides=(1,1), name='inception_5a_3x3_conv'+'1')(inception_4e)\n\tinception_5a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_3x3_bn'+'1')(inception_5a_3x3)\n\tinception_5a_3x3 = Activation('relu')(inception_5a_3x3)\n\tinception_5a_3x3 = ZeroPadding2D(padding=(1, 1))(inception_5a_3x3)\n\tinception_5a_3x3 = Conv2D(384, (3,3), strides=(1,1), name='inception_5a_3x3_conv'+'2')(inception_5a_3x3)\n\tinception_5a_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_3x3_bn'+'2')(inception_5a_3x3)\n\tinception_5a_3x3 = Activation('relu')(inception_5a_3x3)\n\n\tinception_5a_pool = Lambda(lambda x: x**2, name='power2_5a')(inception_4e)\n\tinception_5a_pool = AveragePooling2D(pool_size=(3, 3), strides=(3, 3))(inception_5a_pool)\n\tinception_5a_pool = Lambda(lambda x: x*9, name='mult9_5a')(inception_5a_pool)\n\tinception_5a_pool = Lambda(lambda x: K.sqrt(x), name='sqrt_5a')(inception_5a_pool)\n\n\tinception_5a_pool = Conv2D(96, (1,1), strides=(1,1), name='inception_5a_pool_conv'+'')(inception_5a_pool)\n\tinception_5a_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_pool_bn'+'')(inception_5a_pool)\n\tinception_5a_pool = Activation('relu')(inception_5a_pool)\n\tinception_5a_pool = ZeroPadding2D(padding=(1,1))(inception_5a_pool)\n\n\tinception_5a_1x1 = Conv2D(256, (1,1), strides=(1,1), name='inception_5a_1x1_conv'+'')(inception_4e)\n\tinception_5a_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5a_1x1_bn'+'')(inception_5a_1x1)\n\tinception_5a_1x1 = Activation('relu')(inception_5a_1x1)\n\n\tinception_5a = concatenate([inception_5a_3x3, inception_5a_pool, inception_5a_1x1], axis=3)\n\n\t#inception_5b\n\tinception_5b_3x3 = Conv2D(96, (1,1), strides=(1,1), name='inception_5b_3x3_conv'+'1')(inception_5a)\n\tinception_5b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_3x3_bn'+'1')(inception_5b_3x3)\n\tinception_5b_3x3 = Activation('relu')(inception_5b_3x3)\n\tinception_5b_3x3 = ZeroPadding2D(padding=(1,1))(inception_5b_3x3)\n\tinception_5b_3x3 = Conv2D(384, (3,3), strides=(1,1), name='inception_5b_3x3_conv'+'2')(inception_5b_3x3)\n\tinception_5b_3x3 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_3x3_bn'+'2')(inception_5b_3x3)\n\tinception_5b_3x3 = Activation('relu')(inception_5b_3x3)\n\n\tinception_5b_pool = MaxPooling2D(pool_size=3, strides=2)(inception_5a)\n\n\tinception_5b_pool = Conv2D(96, (1,1), strides=(1,1), name='inception_5b_pool_conv'+'')(inception_5b_pool)\n\tinception_5b_pool = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_pool_bn'+'')(inception_5b_pool)\n\tinception_5b_pool = Activation('relu')(inception_5b_pool)\n\n\tinception_5b_pool = ZeroPadding2D(padding=(1, 1))(inception_5b_pool)\n\n\tinception_5b_1x1 = Conv2D(256, (1,1), strides=(1,1), name='inception_5b_1x1_conv'+'')(inception_5a)\n\tinception_5b_1x1 = BatchNormalization(axis=3, epsilon=0.00001, name='inception_5b_1x1_bn'+'')(inception_5b_1x1)\n\tinception_5b_1x1 = Activation('relu')(inception_5b_1x1)\n\n\tinception_5b = concatenate([inception_5b_3x3, inception_5b_pool, inception_5b_1x1], axis=3)\n\n\tav_pool = AveragePooling2D(pool_size=(3, 3), strides=(1, 1))(inception_5b)\n\treshape_layer = Flatten()(av_pool)\n\tdense_layer = Dense(128, name='dense_layer')(reshape_layer)\n\tnorm_layer = Lambda(lambda x: K.l2_normalize(x, axis=1), name='norm_layer')(dense_layer)\n\n\t# Final Model\n\tmodel = Model(inputs=[myInput], outputs=norm_layer)\n\t\n\t#-----------------------------------\n\t\n\thome = str(Path.home())\n\t\n\tif os.path.isfile(home+'/.deepface/weights/openface_weights.h5') != True:\n\t\tprint(\"openface_weights.h5 will be downloaded...\")\n\t\t\n\t\turl = 'https://drive.google.com/uc?id=1LSe1YCV1x-BfNnfb7DFZTNpv_Q9jITxn'\n\t\toutput = home+'/.deepface/weights/openface_weights.h5'\n\t\tgdown.download(url, output, quiet=False)\n\t\n\t#-----------------------------------\n\t\n\tmodel.load_weights(home+'/.deepface/weights/openface_weights.h5')\n\t\n\t#-----------------------------------\n\t\n\treturn model" ]

[ [ "tensorflow.nn.lrn" ] ]

gvisco/ossom

[ "77a455f467eb21e9a0cefdc5447d05f86cd090ec" ]

[ "ossom/som.py" ]

[ "import math\n\nimport scipy\nfrom scipy.spatial.distance import euclidean\n\n\ndef similarity(x, y):\n return euclidean(x, y)\n\n\ndef neighborhood_kernel(radius, i, j, ii, jj):\n \"\"\"Grid distance explained:\n http://keekerdc.com/2011/03/hexagon-grids-coordinate-systems-and-distance-calculations/\n\n \"\"\"\n x1, y1, z1 = hex_3d_coordinates(i, j)\n x2, y2, z2 = hex_3d_coordinates(ii, jj)\n grid_distance = max(abs(x1 - x2), abs(y1 - y2), abs(z1 - z2))\n return math.exp(- grid_distance ** 2 / (2 * radius ** 2))\n\n\ndef hex_3d_coordinates(i, j):\n hex_i = - i / 2\n hex_j = j\n return hex_i, hex_j, -(hex_i + hex_j)\n\n\ndef exponential_decay(initial_value, decay, time):\n return initial_value * math.exp(- float(time) / decay)\n\n\nclass Som(object):\n def __init__(self, width, height, input_size, learning_rate=1.0, radius=2.0, learning_rate_decay=1.0,\n radius_decay=1.0):\n self.lattice = [[scipy.random.uniform(-1.0, 1.0, input_size) for _ in range(width)] for _ in range(height)]\n self.lattice_width = width\n self.lattice_height = height\n self.learning_rate = learning_rate\n self.update_radius = radius\n self.learning_rate_decay = learning_rate_decay\n self.radius_decay = radius_decay\n\n def train(self, x, epoch):\n winner_row, winner_column, winner_weight, winner_distance = self.__compete(x)\n self.__cooperate(epoch, winner_row, winner_column, x)\n return winner_row, winner_column, winner_weight, winner_distance\n\n def classify(self, x):\n return self.__compete(x)\n\n def __compete(self, x):\n winner_row, winner_column, winner_distance = (-1, -1, float('inf'))\n for row in range(self.lattice_height):\n for column in range(self.lattice_width):\n candidate = self.lattice[row][column]\n distance = similarity(candidate, x)\n if distance < winner_distance:\n winner_row, winner_column, winner_distance = (row, column, distance)\n return winner_row, winner_column, self.lattice[winner_row][winner_column], winner_distance\n\n def __cooperate(self, epoch, winner_row, winner_column, x):\n for row in range(self.lattice_height):\n for column in range(self.lattice_width):\n learning = exponential_decay(self.learning_rate, self.learning_rate_decay, epoch)\n radius = exponential_decay(self.update_radius, self.radius_decay, epoch)\n neighborhood = neighborhood_kernel(radius, row, column, winner_row, winner_column)\n\n neuron = self.lattice[row][column]\n weight_increment = learning * neighborhood * (x - neuron)\n neuron += weight_increment\n\n def __str__(self):\n return '\\n'.join([''.join([str(neuron).ljust(10) for neuron in row]) for row in self.lattice])\n" ]

[ [ "scipy.random.uniform", "scipy.spatial.distance.euclidean" ] ]

leroidauphin/agents

[ "858ee36aaaea6fbcf0e5ab1c12929c77bd17abae" ]

[ "tf_agents/environments/parallel_py_environment.py" ]

[ "# coding=utf-8\n# Copyright 2018 The TF-Agents Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Runs multiple environments in parallel processes and steps them in batch.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\n# Using Type Annotations.\nfrom __future__ import print_function\n\nimport atexit\nimport sys\nimport traceback\nfrom typing import Any, Callable, Sequence, Text, Union\n\nfrom absl import logging\n\nimport cloudpickle\nimport gin\nimport numpy as np\nimport tensorflow as tf # pylint: disable=g-explicit-tensorflow-version-import\n\nfrom tf_agents.environments import py_environment\nfrom tf_agents.system import system_multiprocessing as multiprocessing\nfrom tf_agents.trajectories import time_step as ts\nfrom tf_agents.typing import types\nfrom tf_agents.utils import nest_utils\n\n\n# Worker polling period in seconds.\n_POLLING_PERIOD = 0.1\n\nEnvConstructor = Callable[[], py_environment.PyEnvironment]\nPromise = Callable[[], Any]\n\n\[email protected]\nclass ParallelPyEnvironment(py_environment.PyEnvironment):\n \"\"\"Batch together environments and simulate them in external processes.\n\n The environments are created in external processes by calling the provided\n callables. This can be an environment class, or a function creating the\n environment and potentially wrapping it. The returned environment should not\n access global variables.\n \"\"\"\n\n def __init__(self,\n env_constructors: Sequence[EnvConstructor],\n start_serially: bool = True,\n blocking: bool = False,\n flatten: bool = False):\n \"\"\"Batch together environments and simulate them in external processes.\n\n The environments can be different but must use the same action and\n observation specs.\n\n Args:\n env_constructors: List of callables that create environments.\n start_serially: Whether to start environments serially or in parallel.\n blocking: Whether to step environments one after another.\n flatten: Boolean, whether to use flatten action and time_steps during\n communication to reduce overhead.\n\n Raises:\n ValueError: If the action or observation specs don't match.\n \"\"\"\n super(ParallelPyEnvironment, self).__init__()\n self._envs = [ProcessPyEnvironment(ctor, flatten=flatten)\n for ctor in env_constructors]\n self._num_envs = len(env_constructors)\n self._blocking = blocking\n self._start_serially = start_serially\n self.start()\n self._action_spec = self._envs[0].action_spec()\n self._observation_spec = self._envs[0].observation_spec()\n self._time_step_spec = self._envs[0].time_step_spec()\n self._parallel_execution = True\n if any(env.action_spec() != self._action_spec for env in self._envs):\n raise ValueError('All environments must have the same action spec.')\n if any(env.time_step_spec() != self._time_step_spec for env in self._envs):\n raise ValueError('All environments must have the same time_step_spec.')\n self._flatten = flatten\n\n def start(self) -> None:\n logging.info('Spawning all processes.')\n for env in self._envs:\n env.start(wait_to_start=self._start_serially)\n if not self._start_serially:\n logging.info('Waiting for all processes to start.')\n for env in self._envs:\n env.wait_start()\n logging.info('All processes started.')\n\n @property\n def batched(self) -> bool:\n return True\n\n @property\n def batch_size(self) -> int:\n return self._num_envs\n\n @property\n def envs(self):\n return self._envs\n\n def observation_spec(self) -> types.NestedArraySpec:\n return self._observation_spec\n\n def action_spec(self) -> types.NestedArraySpec:\n return self._action_spec\n\n def time_step_spec(self) -> ts.TimeStep:\n return self._time_step_spec\n\n def _reset(self):\n \"\"\"Reset all environments and combine the resulting observation.\n\n Returns:\n Time step with batch dimension.\n \"\"\"\n time_steps = [env.reset(self._blocking) for env in self._envs]\n if not self._blocking:\n time_steps = [promise() for promise in time_steps]\n return self._stack_time_steps(time_steps)\n\n def _step(self, actions):\n \"\"\"Forward a batch of actions to the wrapped environments.\n\n Args:\n actions: Batched action, possibly nested, to apply to the environment.\n\n Raises:\n ValueError: Invalid actions.\n\n Returns:\n Batch of observations, rewards, and done flags.\n \"\"\"\n time_steps = [\n env.step(action, self._blocking)\n for env, action in zip(self._envs, self._unstack_actions(actions))]\n # When blocking is False we get promises that need to be called.\n if not self._blocking:\n time_steps = [promise() for promise in time_steps]\n return self._stack_time_steps(time_steps)\n\n def close(self) -> None:\n \"\"\"Close all external process.\"\"\"\n logging.info('Closing all processes.')\n for env in self._envs:\n env.close()\n logging.info('All processes closed.')\n\n def _stack_time_steps(self, time_steps):\n \"\"\"Given a list of TimeStep, combine to one with a batch dimension.\"\"\"\n if self._flatten:\n return nest_utils.fast_map_structure_flatten(\n lambda *arrays: np.stack(arrays), self._time_step_spec, *time_steps)\n else:\n return nest_utils.fast_map_structure(\n lambda *arrays: np.stack(arrays), *time_steps)\n\n def _unstack_actions(self, batched_actions):\n \"\"\"Returns a list of actions from potentially nested batch of actions.\"\"\"\n flattened_actions = tf.nest.flatten(batched_actions)\n if self._flatten:\n unstacked_actions = zip(*flattened_actions)\n else:\n unstacked_actions = [\n tf.nest.pack_sequence_as(batched_actions, actions)\n for actions in zip(*flattened_actions)\n ]\n return unstacked_actions\n\n def seed(self, seeds: Sequence[types.Seed]) -> Sequence[Any]:\n \"\"\"Seeds the parallel environments.\"\"\"\n if len(seeds) != len(self._envs):\n raise ValueError(\n 'Number of seeds should match the number of parallel_envs.')\n\n promises = [env.call('seed', seed) for seed, env in zip(seeds, self._envs)]\n # Block until all envs are seeded.\n return [promise() for promise in promises]\n\n\nclass ProcessPyEnvironment(object):\n \"\"\"Step a single env in a separate process for lock free paralellism.\"\"\"\n\n # Message types for communication via the pipe.\n _READY = 1\n _ACCESS = 2\n _CALL = 3\n _RESULT = 4\n _EXCEPTION = 5\n _CLOSE = 6\n\n def __init__(self, env_constructor: EnvConstructor, flatten: bool = False):\n \"\"\"Step environment in a separate process for lock free paralellism.\n\n The environment is created in an external process by calling the provided\n callable. This can be an environment class, or a function creating the\n environment and potentially wrapping it. The returned environment should\n not access global variables.\n\n Args:\n env_constructor: Callable that creates and returns a Python environment.\n flatten: Boolean, whether to assume flattened actions and time_steps\n during communication to avoid overhead.\n\n Attributes:\n observation_spec: The cached observation spec of the environment.\n action_spec: The cached action spec of the environment.\n time_step_spec: The cached time step spec of the environment.\n \"\"\"\n # NOTE(ebrevdo): multiprocessing uses the standard py3 pickler which does\n # not support anonymous lambdas. Folks usually pass anonymous lambdas as\n # env constructors. Here we work around this by manually pickling\n # the constructor using cloudpickle; which supports these. In the\n # new process, we'll unpickle this constructor and run it.\n self._pickled_env_constructor = cloudpickle.dumps(env_constructor)\n self._flatten = flatten\n self._observation_spec = None\n self._action_spec = None\n self._time_step_spec = None\n\n def start(self, wait_to_start: bool = True) -> None:\n \"\"\"Start the process.\n\n Args:\n wait_to_start: Whether the call should wait for an env initialization.\n \"\"\"\n mp_context = multiprocessing.get_context()\n self._conn, conn = mp_context.Pipe()\n self._process = mp_context.Process(target=self._worker, args=(conn,))\n atexit.register(self.close)\n self._process.start()\n if wait_to_start:\n self.wait_start()\n\n def wait_start(self) -> None:\n \"\"\"Wait for the started process to finish initialization.\"\"\"\n result = self._conn.recv()\n if isinstance(result, Exception):\n self._conn.close()\n self._process.join(5)\n raise result\n assert result == self._READY, result\n\n def observation_spec(self) -> types.NestedArraySpec:\n if not self._observation_spec:\n self._observation_spec = self.call('observation_spec')()\n return self._observation_spec\n\n def action_spec(self) -> types.NestedArraySpec:\n if not self._action_spec:\n self._action_spec = self.call('action_spec')()\n return self._action_spec\n\n def time_step_spec(self) -> ts.TimeStep:\n if not self._time_step_spec:\n self._time_step_spec = self.call('time_step_spec')()\n return self._time_step_spec\n\n def __getattr__(self, name: Text) -> Any:\n \"\"\"Request an attribute from the environment.\n\n Note that this involves communication with the external process, so it can\n be slow.\n\n This method is only called if the attribute is not found in the dictionary\n of `ParallelPyEnvironment`'s definition.\n\n Args:\n name: Attribute to access.\n\n Returns:\n Value of the attribute.\n \"\"\"\n # Private properties are always accessed on this object, not in the\n # wrapped object in another process. This includes properties used\n # for pickling (incl. __getstate__, __setstate__, _conn, _ACCESS, _receive),\n # as well as private properties and methods created and used by subclasses\n # of this class. Allowing arbitrary private attributes to be requested\n # from the other process can lead to deadlocks.\n if name.startswith('_'):\n return super(ProcessPyEnvironment, self).__getattribute__(name)\n\n # All other requests get sent to the worker.\n self._conn.send((self._ACCESS, name))\n return self._receive()\n\n def call(self, name: Text, *args, **kwargs) -> Promise:\n \"\"\"Asynchronously call a method of the external environment.\n\n Args:\n name: Name of the method to call.\n *args: Positional arguments to forward to the method.\n **kwargs: Keyword arguments to forward to the method.\n\n Returns:\n The attribute.\n \"\"\"\n payload = name, args, kwargs\n self._conn.send((self._CALL, payload))\n return self._receive\n\n def access(self, name: Text) -> Any:\n \"\"\"Access an attribute of the external environment.\n\n This method blocks.\n\n Args:\n name: Name of the attribute to access.\n\n Returns:\n The attribute value.\n \"\"\"\n self._conn.send((self._ACCESS, name))\n return self._receive()\n\n def close(self) -> None:\n \"\"\"Send a close message to the external process and join it.\"\"\"\n try:\n self._conn.send((self._CLOSE, None))\n self._conn.close()\n except IOError:\n # The connection was already closed.\n pass\n if self._process.is_alive():\n self._process.join(5)\n\n def step(self,\n action: types.NestedArray,\n blocking: bool = True) -> Union[ts.TimeStep, Promise]:\n \"\"\"Step the environment.\n\n Args:\n action: The action to apply to the environment.\n blocking: Whether to wait for the result.\n\n Returns:\n time step when blocking, otherwise callable that returns the time step.\n \"\"\"\n promise = self.call('step', action)\n if blocking:\n return promise()\n else:\n return promise\n\n def reset(self, blocking: bool = True) -> Union[ts.TimeStep, Promise]:\n \"\"\"Reset the environment.\n\n Args:\n blocking: Whether to wait for the result.\n\n Returns:\n New observation when blocking, otherwise callable that returns the new\n observation.\n \"\"\"\n promise = self.call('reset')\n if blocking:\n return promise()\n else:\n return promise\n\n def _receive(self):\n \"\"\"Wait for a message from the worker process and return its payload.\n\n Raises:\n Exception: An exception was raised inside the worker process.\n KeyError: The reveived message is of an unknown type.\n\n Returns:\n Payload object of the message.\n \"\"\"\n message, payload = self._conn.recv()\n # Re-raise exceptions in the main process.\n if message == self._EXCEPTION:\n stacktrace = payload\n raise Exception(stacktrace)\n if message == self._RESULT:\n return payload\n self.close()\n raise KeyError('Received message of unexpected type {}'.format(message))\n\n def _worker(self, conn):\n \"\"\"The process waits for actions and sends back environment results.\n\n Args:\n conn: Connection for communication to the main process.\n\n Raises:\n KeyError: When receiving a message of unknown type.\n \"\"\"\n try:\n env = cloudpickle.loads(self._pickled_env_constructor)()\n action_spec = env.action_spec()\n conn.send(self._READY) # Ready.\n while True:\n try:\n # Only block for short times to have keyboard exceptions be raised.\n if not conn.poll(_POLLING_PERIOD):\n continue\n message, payload = conn.recv()\n except (EOFError, KeyboardInterrupt):\n break\n if message == self._ACCESS:\n name = payload\n result = getattr(env, name)\n conn.send((self._RESULT, result))\n continue\n if message == self._CALL:\n name, args, kwargs = payload\n if self._flatten and name == 'step':\n args = [tf.nest.pack_sequence_as(action_spec, args[0])]\n result = getattr(env, name)(*args, **kwargs)\n if self._flatten and name in ['step', 'reset']:\n result = tf.nest.flatten(result)\n conn.send((self._RESULT, result))\n continue\n if message == self._CLOSE:\n assert payload is None\n env.close()\n break\n raise KeyError('Received message of unknown type {}'.format(message))\n except Exception: # pylint: disable=broad-except\n etype, evalue, tb = sys.exc_info()\n stacktrace = ''.join(traceback.format_exception(etype, evalue, tb))\n message = 'Error in environment process: {}'.format(stacktrace)\n logging.error(message)\n conn.send((self._EXCEPTION, stacktrace))\n finally:\n conn.close()\n" ]

[ [ "tensorflow.nest.flatten", "tensorflow.nest.pack_sequence_as", "numpy.stack" ] ]

rainzhop/ConvNetQuake

[ "a3e6de3f7992eac72f1b9883fec36b8c7fdefd48" ]

[ "openquake.hazardlib/openquake/hazardlib/gsim/fukushima_tanaka_1990.py" ]

[ "# -*- coding: utf-8 -*-\n# vim: tabstop=4 shiftwidth=4 softtabstop=4\n#\n# Copyright (C) 2014-2016 GEM Foundation\n#\n# OpenQuake is free software: you can redistribute it and/or modify it\n# under the terms of the GNU Affero General Public License as published\n# by the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# OpenQuake is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU Affero General Public License for more details.\n#\n# You should have received a copy of the GNU Affero General Public License\n# along with OpenQuake. If not, see <http://www.gnu.org/licenses/>.\n\n\"\"\"\nModule exports :class:'FukushimaTanaka1990' and :class:\n'FukushimaTanakaSite1990'\n\"\"\"\nfrom __future__ import division\nimport numpy as np\n# standard acceleration of gravity in m/s**2\nfrom scipy.constants import g\n\n\nfrom openquake.hazardlib.gsim.base import GMPE, CoeffsTable\nfrom openquake.hazardlib import const\nfrom openquake.hazardlib.imt import PGA\n\n\nclass FukushimaTanaka1990(GMPE):\n \"\"\"\n Implements the PGA GMPE of Fukushima and Tanaka (1990)\n Fukushima, Y. and Tanaka, T. (1990) A New Attenuation Relation for Peak\n Horizontal Acceleration of Strong Earthquake Ground Motion in Japan.\n Bulletin of the Seismological Society of America, 80(4), 757 - 783\n \"\"\"\n #: The GMPE is derived from shallow earthquakes in California and Japan\n DEFINED_FOR_TECTONIC_REGION_TYPE = const.TRT.ACTIVE_SHALLOW_CRUST\n\n #: Supported intensity measure types are peak ground acceleration\n DEFINED_FOR_INTENSITY_MEASURE_TYPES = set([\n PGA,\n ])\n\n #: Supported intensity measure component is the average horizontal\n #: component\n #: :attr:`openquake.hazardlib.const.IMC.AVERAGE_HORIZONTAL`,\n DEFINED_FOR_INTENSITY_MEASURE_COMPONENT = const.IMC.AVERAGE_HORIZONTAL\n\n #: Supported standard deviation types is total.\n DEFINED_FOR_STANDARD_DEVIATION_TYPES = set([\n const.StdDev.TOTAL\n ])\n\n #: Required site parameters. The GMPE was developed for an ''average''\n #: site conditions. The authors specify that for rock sites the\n #: values should be lowered by 40 % and for soil site they should be\n #: raised by 40 %. For greatest consistencty the site condition is\n #: neglected currently but a site-dependent GMPE may be implemented\n #: inside a subclass.\n REQUIRES_SITES_PARAMETERS = set(())\n\n #: Required rupture parameters are magnitude\n REQUIRES_RUPTURE_PARAMETERS = set(('mag', ))\n\n #: Required distance measure is rupture distance\n REQUIRES_DISTANCES = set(('rrup',))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n\n C = self.COEFFS[imt]\n\n imean = (self._compute_magnitude_scaling(C, rup.mag) +\n self._compute_distance_scaling(C, dists.rrup, rup.mag))\n # Original GMPE returns log10 acceleration in cm/s/s\n # Converts to natural logarithm of g\n mean = np.log((10.0 ** (imean - 2.0)) / g)\n istddevs = self._compute_stddevs(\n C, dists.rrup.shape, stddev_types\n )\n # Convert from common logarithm to natural logarithm\n stddevs = np.log(10 ** np.array(istddevs))\n return mean, stddevs\n\n def _compute_magnitude_scaling(self, C, mag):\n \"\"\"\n Returns the magnitude scaling term\n \"\"\"\n return C[\"c1\"] * mag + C[\"c5\"]\n\n def _compute_distance_scaling(self, C, rrup, mag):\n \"\"\"\n Returns the distance scaling term\n \"\"\"\n rscale1 = rrup + C[\"c2\"] * (10.0 ** (C[\"c3\"] * mag))\n return -np.log10(rscale1) - (C[\"c4\"] * rrup)\n\n def _compute_stddevs(self, C, num_sites, stddev_types):\n \"\"\"\n Return total standard deviation.\n \"\"\"\n std_total = C['sigma']\n\n stddevs = []\n for _ in stddev_types:\n stddevs.append(np.zeros(num_sites) + std_total)\n return stddevs\n\n COEFFS = CoeffsTable(sa_damping=5, table=\"\"\"\n IMT c1 c2 c3 c4 c5 sigma\n pga 0.41 0.032 0.41 0.0034 1.30 0.21\n \"\"\")\n\n\nclass FukushimaTanakaSite1990(FukushimaTanaka1990):\n \"\"\"\n Implements the Fukushima and Tanaka (1990) model correcting for\n site class. The authors specify that the ground motions should\n be raised by 40 % on soft soil sites and reduced by 40 % on rock sites.\n The specific site classification is not known, so it is assumed that\n in this context \"average\" site conditions refer to NEHRP C, rock conditions\n to NEHRP A and B, and soft soil conditions to NEHRP D and E\n\n \"\"\"\n #: Input sites as vs30 although only three classes considered\n REQUIRES_SITES_PARAMETERS = set((\"vs30\",))\n\n def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types):\n \"\"\"\n See :meth:`superclass method\n <.base.GroundShakingIntensityModel.get_mean_and_stddevs>`\n for spec of input and result values.\n \"\"\"\n assert all(stddev_type in self.DEFINED_FOR_STANDARD_DEVIATION_TYPES\n for stddev_type in stddev_types)\n\n C = self.COEFFS[imt]\n\n imean = (self._compute_magnitude_scaling(C, rup.mag) +\n self._compute_distance_scaling(C, dists.rrup, rup.mag))\n # Original GMPE returns log10 acceleration in cm/s/s\n # Converts to natural logarithm of g\n mean = np.log((10.0 ** (imean - 2.0)) / g)\n mean = self._compute_site_scaling(sites.vs30, mean)\n istddevs = self._compute_stddevs(\n C, dists.rrup.shape, stddev_types\n )\n # Convert from common logarithm to natural logarithm\n stddevs = np.log(10 ** np.array(istddevs))\n return mean, stddevs\n\n def _compute_site_scaling(self, vs30, mean):\n \"\"\"\n Scales the ground motions by increasing 40 % on NEHRP class D/E sites,\n and decreasing by 40 % on NEHRP class A/B sites\n \"\"\"\n site_factor = np.ones(len(vs30), dtype=float)\n idx = vs30 <= 360.\n site_factor[idx] = 1.4\n idx = vs30 > 760.0\n site_factor[idx] = 0.6\n return np.log(np.exp(mean) * site_factor)\n" ]

[ [ "numpy.log", "numpy.log10", "numpy.array", "numpy.exp", "numpy.zeros" ] ]

kirkjens/sarpy_apps

[ "e38402b1591512081a83d0f31e6ded325ae196e8" ]

[ "sarpy_apps/supporting_classes/image_reader.py" ]

[ "\"\"\"\nHelper classes mapping the sarpy readers into the CanvasImageReader pattern.\n\"\"\"\n\n__classification__ = \"UNCLASSIFIED\"\n__author__ = \"Thomas McCullough\"\n\n\nimport logging\nimport numpy\nfrom typing import List, Tuple\nimport gc\n\nfrom tk_builder.image_reader import CanvasImageReader\n\nfrom sarpy.io.general.base import AbstractReader, SarpyIOError\nfrom sarpy.visualization.remap import get_remap_list, get_registered_remap, RemapFunction\n\nfrom sarpy.io.complex.converter import open_complex\nfrom sarpy.io.complex.base import SICDTypeReader\nfrom sarpy.io.complex.aggregate import AggregateComplexReader\nfrom sarpy.io.complex.sicd_elements.SICD import SICDType\n\nfrom sarpy.io.product.converter import open_product\nfrom sarpy.io.product.base import SIDDTypeReader\nfrom sarpy.io.product.sidd1_elements.SIDD import SIDDType as SIDDType1\nfrom sarpy.io.product.sidd2_elements.SIDD import SIDDType as SIDDType2\n\n\nfrom sarpy.io.phase_history.converter import open_phase_history\nfrom sarpy.io.phase_history.base import CPHDTypeReader\nfrom sarpy.io.phase_history.cphd1_elements.CPHD import CPHDType as CPHDType1\nfrom sarpy.io.phase_history.cphd0_3_elements.CPHD import CPHDType as CPHDType0_3\n\nfrom sarpy.io.received.converter import open_received\nfrom sarpy.io.received.base import CRSDTypeReader\nfrom sarpy.io.received.crsd1_elements.CRSD import CRSDType\n\nfrom sarpy.io.general.converter import open_general\n\n\ndef _get_default_remap():\n \"\"\"\n Gets the default remap function.\n\n Returns\n -------\n RemapFunction\n \"\"\"\n\n return get_remap_list()[0][1]\n\n\n#######\n# general reader\n\nclass GeneralCanvasImageReader(CanvasImageReader):\n \"\"\"\n This is a general image reader of unknown type. There may be trouble\n with the image segments of unexpected type.\n \"\"\"\n\n __slots__ = ('_base_reader', '_chippers', '_index', '_data_size', '_remap_function')\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str|AbstractReader\n The reader, or path to appropriate data file.\n \"\"\"\n\n # initialize\n self._base_reader = None\n self._chippers = None\n self._data_size = None\n self._index = None\n self._remap_function = _get_default_remap()\n # set the reader\n self.base_reader = reader\n\n @property\n def base_reader(self):\n # type: () -> AbstractReader\n \"\"\"\n AbstractReader: The reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n value = open_general(value)\n if not isinstance(value, AbstractReader):\n raise TypeError('base_reader must be of type AbstractReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self.index = 0\n\n @property\n def reader_type(self):\n \"\"\"\n str: The reader type.\n \"\"\"\n\n return self.base_reader.reader_type\n\n @property\n def index(self):\n \"\"\"\n int: The reader index.\n \"\"\"\n\n return self._index\n\n @index.setter\n def index(self, value):\n value = int(value)\n data_sizes = self.base_reader.get_data_size_as_tuple()\n if not (0 <= value < len(data_sizes)):\n logging.error(\n 'The index property must be 0 <= index < {}, '\n 'and got argument {}. Setting to 0.'.format(len(data_sizes), value))\n value = 0\n self._index = value\n self._data_size = data_sizes[value]\n\n @property\n def file_name(self):\n return None if self.base_reader is None else self.base_reader.file_name\n\n @property\n def remapable(self):\n return True\n\n @property\n def remap_function(self):\n return self._remap_function\n\n @property\n def image_count(self):\n return 0 if self._chippers is None else len(self._chippers)\n\n def get_meta_data(self):\n \"\"\"\n Gets one of a varieties of metadata structure.\n\n Returns\n -------\n Any\n \"\"\"\n\n if isinstance(self.base_reader, SICDTypeReader):\n if self._index is None:\n return None\n # noinspection PyUnresolvedReferences\n return self.base_reader.get_sicds_as_tuple()[self._index]\n elif isinstance(self.base_reader, SIDDTypeReader):\n if self._index is None:\n return None\n # noinspection PyUnresolvedReferences\n return self.base_reader.get_sidds_as_tuple()[self._index]\n elif isinstance(self.base_reader, CPHDTypeReader):\n # noinspection PyUnresolvedReferences\n return self.base_reader.cphd_meta\n elif isinstance(self.base_reader, CRSDTypeReader):\n # noinspection PyUnresolvedReferences\n return self.base_reader.crsd_meta\n return None\n\n def __getitem__(self, item):\n data = self._chippers[self.index].__getitem__(item)\n return self.remap_data(data)\n\n def __del__(self):\n # noinspection PyBroadException\n try:\n del self._chippers\n gc.collect()\n except Exception:\n pass\n\n def remap_data(self, data):\n \"\"\"\n Remap the given data according to the current remap function, unless it has\n dtype uint8.\n\n Parameters\n ----------\n data : numpy.ndarray\n\n Returns\n -------\n numpy.ndarray\n \"\"\"\n\n if self._remap_function is None or data.dtype.name == 'uint8':\n return data\n return self._remap_function(data)\n\n def set_remap_type(self, remap_type):\n if callable(remap_type):\n self._remap_function = remap_type\n elif isinstance(remap_type, str):\n self._remap_function = get_registered_remap(remap_type, _get_default_remap())\n else:\n default_remap = _get_default_remap()\n logging.error(\n 'Got unexpected value for remap `{}`, using `{}`'.format(remap_type, default_remap.name))\n self._remap_function = default_remap\n\n\n########\n# general complex type reader structure - really just sets the remap\n\nclass ComplexCanvasImageReader(GeneralCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str|AbstractReader\n The complex valued reader, or path to appropriate data file.\n \"\"\"\n\n self._remap_function = _get_default_remap()\n GeneralCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> AbstractReader\n \"\"\"\n AbstractReader: The complex-valued reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n\n # try to open as sicd type\n try:\n reader = open_complex(value)\n except SarpyIOError:\n pass\n\n # try to open as phase_history\n if reader is None:\n try:\n reader = open_phase_history(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n try:\n reader = open_received(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a one of the complex type readers'.format(value))\n value = reader\n elif isinstance(value, (tuple, list)):\n value = AggregateComplexReader(value)\n\n if not isinstance(value, AbstractReader):\n raise TypeError('base_reader must be of type AbstractReader, got type {}'.format(type(value)))\n if value.reader_type not in [\"SICD\", \"CPHD\", \"CRSD\"]:\n raise SarpyIOError(\n 'base_reader.reader_type must be \"SICD\", \"CPHD\", or \"CRSD\", got {}'.format(value.reader_type))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n\n########\n# SICD specific type readers\n\nclass SICDTypeCanvasImageReader(ComplexCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str|SICDTypeReader\n The sicd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> SICDTypeReader\n \"\"\"\n SICDTypeReader: The complex-valued reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n try:\n reader = open_complex(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a SICD type reader'.format(value))\n value = reader\n elif isinstance(value, (tuple, list)):\n value = AggregateComplexReader(value)\n\n if not isinstance(value, SICDTypeReader):\n raise TypeError('base_reader must be a SICDTypeReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_sicd(self):\n \"\"\"\n Gets the relevant SICD structure.\n\n Returns\n -------\n None|SICDType\n \"\"\"\n\n if self._index is None:\n return None\n return self.base_reader.get_sicds_as_tuple()[self._index]\n\n def transform_coordinates(self, image_coordinates):\n sicd = self.get_sicd()\n if sicd is None:\n return None, 'NONE'\n\n return sicd.project_image_to_ground_geo(image_coordinates, projection_type='HAE'), 'LLH_HAE'\n\n\nclass QuadPolCanvasImageReader(ComplexCanvasImageReader):\n __slots__ = (\n '_base_reader', '_chippers', '_sicd_partitions', '_index', '_index_ordering',\n '_data_size', '_remap_function')\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str|SICDTypeReader\n The sicd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> SICDTypeReader\n \"\"\"\n SICDTypeReader: The complex-valued reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n value = open_complex(value)\n elif isinstance(value, (list, tuple)):\n value = AggregateComplexReader(value)\n if not isinstance(value, SICDTypeReader):\n raise TypeError('Requires that the input is a sicd type reader object. Got type {}'.format(type(value)))\n\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._sicd_partitions = value.get_sicd_partitions()\n try:\n self.index = 0\n except ValueError:\n # the index will be uninitialized\n pass\n\n @property\n def sicd_partition(self):\n \"\"\"\n Tuple[Tuple[int]]: The partitioning of the reader indices into matching components.\n \"\"\"\n\n return self._sicd_partitions\n\n @property\n def index(self):\n \"\"\"\n int: the SICD partition index.\n \"\"\"\n\n return self._index\n\n @index.setter\n def index(self, value):\n if self._sicd_partitions is None:\n return\n\n value = int(value)\n if not (0 <= value < len(self.sicd_partition)):\n raise ValueError('index must be on the range 0 <= index < {}'.format(len(self.sicd_partition)))\n indices = self.sicd_partition[value]\n # determine appropriate ordering for index collection\n data_sizes = self.base_reader.get_data_size_as_tuple()\n data_size = data_sizes[indices[0]]\n for entry in indices:\n if data_sizes[entry] != data_size:\n raise ValueError(\n 'All entries of sicd partition {} do not yield sicd elements of '\n 'the same row/column size.'.format(value))\n self._index = value\n self._data_size = data_size\n self._order_indices(value, indices)\n\n def _order_indices(self, index, indices):\n \"\"\"\n Determine the appropriate ordering for indices.\n\n Parameters\n ----------\n index : int\n indices : Tuple[int]\n\n Returns\n -------\n None\n \"\"\"\n\n def revert():\n self._index = None\n self._index_ordering = None\n self._data_size = None\n\n if len(indices) == 1:\n self._index_ordering = indices\n return\n\n sicds = self.base_reader.get_sicds_as_tuple()\n our_sicds = [sicds[entry] for entry in indices] # type: List[SICDType]\n pols = [entry.ImageFormation.TxRcvPolarizationProc for entry in our_sicds]\n if len(indices) == 2:\n pols_set = set(pols)\n if len(pols_set) != 2:\n ordered_indices = None\n else:\n ordered_indices = None\n for desired_order in [['CV', 'CH'], ['VV', 'HH']]:\n if pols_set == set(desired_order):\n ordered_indices = [pols.index(entry) for entry in desired_order]\n break\n elif len(indices) == 4:\n pols_set = set(pols)\n if len(pols_set) != 4:\n ordered_indices = None\n else:\n ordered_indices = None\n for desired_order in [['VV', 'VH', 'HV', 'HH'], ]:\n if pols_set == set(desired_order):\n ordered_indices = [pols.index(entry) for entry in desired_order]\n break\n else:\n ordered_indices = None\n\n if ordered_indices is None:\n revert()\n raise ValueError(\n 'Got unhandled polarization states for partition {}'.format(pols, index))\n self._index_ordering = ordered_indices\n\n def __getitem__(self, item):\n def get_cdata(the_index):\n return self._chippers[the_index].__getitem__(item)\n\n if self._index_ordering is None:\n return None\n if len(self._index_ordering) == 1:\n complex_data = get_cdata(self._index_ordering[0])\n return self._remap_function(complex_data)\n\n complex_data = [get_cdata(entry) for entry in self._index_ordering]\n out_size = complex_data[0].shape\n for entry in complex_data:\n if entry.shape != out_size:\n raise ValueError('Got unexpected mismatch in sizes {} and {}'.format(entry.shape, out_size))\n data_mean = float(max(numpy.mean(numpy.abs(entry)) for entry in complex_data))\n rgb_image = numpy.zeros(out_size + (3, ), dtype='uint8')\n if len(self._index_ordering) == 2:\n try:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0], data_mean=data_mean)\n rgb_image[:, :, 2] = self._remap_function(complex_data[1], data_mean=data_mean)\n except Exception:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0])\n rgb_image[:, :, 2] = self._remap_function(complex_data[1])\n elif len(self._index_ordering) == 4:\n try:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0], data_mean=data_mean)\n rgb_image[:, :, 1] = self._remap_function(complex_data[1], data_mean=data_mean)/2 + \\\n self._remap_function(complex_data[2], data_mean=data_mean)/2\n rgb_image[:, :, 2] = self._remap_function(complex_data[3], data_mean=data_mean)\n except Exception:\n rgb_image[:, :, 0] = self._remap_function(complex_data[0])\n rgb_image[:, :, 1] = self._remap_function(complex_data[1])/2 + \\\n self._remap_function(complex_data[2])/2\n rgb_image[:, :, 2] = self._remap_function(complex_data[3])\n else:\n raise ValueError('Got unhandled case for collection {}'.format(self._index_ordering))\n return rgb_image\n\n def get_sicd(self):\n \"\"\"\n Gets the relevant SICD structure.\n\n Returns\n -------\n None|SICDType\n \"\"\"\n\n if self._index is None:\n return None\n return self.base_reader.get_sicds_as_tuple()[self._index]\n\n def transform_coordinates(self, image_coordinates):\n sicd = self.get_sicd()\n if sicd is None:\n return None, 'NONE'\n\n return sicd.project_image_to_ground_geo(image_coordinates, projection_type='HAE'), 'LLH_HAE'\n\n\n#######\n# Phase history specific type reader\n\nclass CPHDTypeCanvasImageReader(ComplexCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str|CPHDTypeReader\n The cphd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> CPHDTypeReader\n \"\"\"\n CPHDTypeReader: The cphd reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n try:\n reader = open_phase_history(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a CPHD reader'.format(value))\n value = reader\n\n if not isinstance(value, CPHDTypeReader):\n raise TypeError('base_reader must be a CPHDReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_cphd(self):\n \"\"\"\n Gets the relevant CPHD structure.\n\n Returns\n -------\n None|CPHDType1|CPHDType0_3\n \"\"\"\n\n return self.base_reader.cphd_meta\n\n\n#######\n# Received data specific type reader\n\nclass CRSDTypeCanvasImageReader(ComplexCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str|CRSDTypeReader\n The crsd type reader, or path to appropriate data file.\n \"\"\"\n\n ComplexCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> CRSDTypeReader\n \"\"\"\n CRSDTypeReader: The crsd reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n reader = None\n try:\n reader = open_received(value)\n except SarpyIOError:\n pass\n\n if reader is None:\n raise SarpyIOError('Could not open file {} as a CRSD reader'.format(value))\n value = reader\n\n if not isinstance(value, CRSDTypeReader):\n raise TypeError('base_reader must be a CRSDReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_crsd(self):\n \"\"\"\n Gets the relevant CRSD structure.\n\n Returns\n -------\n None|CRSDType\n \"\"\"\n\n return self.base_reader.crsd_meta\n\n\n######\n# SIDD specific type reader\n\nclass DerivedCanvasImageReader(GeneralCanvasImageReader):\n\n def __init__(self, reader):\n \"\"\"\n\n Parameters\n ----------\n reader : str|SIDDTypeReader\n The sidd type reader, or path to appropriate data file.\n \"\"\"\n\n GeneralCanvasImageReader.__init__(self, reader)\n\n @property\n def base_reader(self):\n # type: () -> SIDDTypeReader\n \"\"\"\n SIDDTypeReader: The SIDD based reader object\n \"\"\"\n\n return self._base_reader\n\n @base_reader.setter\n def base_reader(self, value):\n if isinstance(value, str):\n value = open_product(value)\n if not isinstance(value, SIDDTypeReader):\n raise TypeError('base_reader must be a SIDDTypeReader, got type {}'.format(type(value)))\n self._base_reader = value\n # noinspection PyProtectedMember\n self._chippers = value._get_chippers_as_tuple()\n self._index = 0\n self._data_size = value.get_data_size_as_tuple()[0]\n\n def get_sidd(self):\n \"\"\"\n Gets the relevant SIDD structure.\n\n Returns\n -------\n None|SIDDType1|SIDDType2\n \"\"\"\n\n if self._index is None:\n return None\n return self.base_reader.get_sidds_as_tuple()[self._index]\n\n def transform_coordinates(self, image_coordinates):\n sidd = self.get_sidd()\n if sidd is None:\n return None, 'NONE'\n\n return sidd.project_image_to_ground_geo(image_coordinates, projection_type='HAE'), 'LLH_HAE'\n" ]

[ [ "numpy.zeros", "numpy.abs" ] ]

al093/pytorch_connectomics

[ "52821951233b061102380fc0d2521843652c580a" ]

[ "torch_connectomics/utils/net/serialSampler.py" ]

[ "from collections import deque\nimport numpy as np\n\nimport torch\n\nfrom torch_connectomics.data.dataset.misc import crop_volume\nfrom torch_connectomics.data.utils.functional_collate import collate_fn_test_2, collate_fn_test\n\nclass SerialSampler():\n\n def __init__(self, dataset, batch_size, pad_size, init_seed_points, in_channel):\n self.dataset = dataset\n self.pos_queue = deque()\n self.pos_processed = deque()\n self.batch_size = batch_size\n self.pad_size = pad_size\n self.sel = np.ones((3, 3, 3), dtype=bool)\n for sp_idx in range(init_seed_points.shape[0]):\n self.pos_queue.append(init_seed_points[sp_idx])\n if in_channel == 1:\n self.need_past_pred = False\n else:\n self.need_past_pred = True\n\n def set_out_array(self, segmentation):\n self.seg = segmentation\n self.seg_shape = segmentation.shape\n\n def compute_new_pos(self, mask, edge_pos, pos):\n # mask_eroded = binary_erosion(mask, structure=self.sel).astype(bool)\n # mask[mask_eroded] = 0\n\n print(\"Num Prospective Positions: \", edge_pos.shape[0])\n for new_pos_id in range(edge_pos.shape[0]):\n new_pos = edge_pos[new_pos_id]\n\n is_edge = False\n if np.all(new_pos == self.dataset.sample_input_size - 1):\n is_edge = True\n\n new_pos += pos # now point is wrt to the origin of the entire padded input vol\n\n # print('----------------For position: ', new_pos)\n # check if the new_pos is already inside the fov of some pos in the queue\n already_covered = False\n for old_pos in reversed(self.pos_queue):\n if np.all(np.abs(new_pos - old_pos, dtype=np.int32) < (self.dataset.half_input_sz // 6)):\n already_covered = True\n # print('A point exists in the NON Processed Queue')\n break\n if not already_covered: # check in the processed queue\n for old_pos in reversed(self.pos_processed):\n if np.all(np.abs(new_pos - old_pos, dtype=np.int32) < (self.dataset.half_input_sz // 6)):\n already_covered = True\n # print('A point exists in the Processed Queue')\n break\n\n if not already_covered:\n # check if the new pos is inside the unpadded region\n if np.all(new_pos >= self.pad_size) and np.all(new_pos < (self.seg_shape - self.pad_size)):\n # print('Is outside padded region.')\n\n # check if the new pos has some neighbouring pixels which are not marked as object?\n # if not then it may be a voxel inside the segmentation\n if (not np.all(self.seg[new_pos[0]-7:new_pos[0]+8,\n new_pos[1]-7:new_pos[1]+8,\n new_pos[2]-7:new_pos[2]+8])) \\\n or is_edge:\n\n # Pos is the center around which the input should be sampled\n self.pos_queue.append(new_pos)\n # print('Position Added')\n # else:\n # print('All points in the surrounding are 1')\n # else:\n # print('Pos inside the padded region')\n print('..Done')\n def get_input_data(self):\n input_batch = []\n pos_batch = []\n past_pred_batch = []\n\n if len(self.pos_queue) > self.batch_size:\n num_data_points = self.batch_size\n else:\n num_data_points = len(self.pos_queue)\n\n for _ in range(num_data_points):\n pos = np.array([0, 0, 0, 0], dtype=np.uint32)\n pos[1:] = self.pos_queue.pop()\n self.pos_processed.append(pos[1:].copy()) # add pos into the processed queue\n pos[1:] = pos[1:] - self.dataset.half_input_sz # since pos was the center shifting it to origin of sampling volume\n # print('Position: ', pos)\n input_batch.append(self.dataset.get_vol(pos))\n pos_batch.append(pos)\n if self.need_past_pred:\n past_pred_cpu = crop_volume(self.seg, self.dataset.sample_input_size, pos[1:])\n past_pred_batch.append((torch.from_numpy(past_pred_cpu.copy().astype(np.float32))).unsqueeze(0))\n return collate_fn_test_2(zip(pos_batch, input_batch, past_pred_batch))\n else:\n return collate_fn_test(zip(pos_batch, input_batch))\n\n def remaining_pos(self):\n return len(self.pos_queue)" ]

[ [ "numpy.all", "numpy.array", "numpy.abs", "numpy.ones" ] ]

democheng/PythonRobotics

[ "0734c14ab7cd6daf9be307693b674e20a676bebb", "0734c14ab7cd6daf9be307693b674e20a676bebb" ]

[ "Localization/legacy/KalmanFilterAnimation.py", "Localization/histogramfilter_robot.py" ]

[ "import sys\nimport math\nimport numpy as np\nfrom scipy.stats import norm\nimport matplotlib.pyplot as plt\nimport mpl_toolkits.mplot3d.axes3d as p3\nfrom matplotlib.animation import FuncAnimation\n\ndef gaussian(x, mu, sig):\n return norm.pdf(x, mu, sig)\n\ndef gaussian_histogram(bin_num, mu, sig):\n sig3 = 3.0 * sig\n step = 2.0 * sig3 / bin_num\n x = np.arange(mu - sig3, mu + sig3 + step, step)\n y = gaussian(x, mu, sig)\n data = np.zeros((2, len(x)))\n data[0, :] = x\n data[1, :] = y\n return data\n\ndef gaussian_entropy(mu, var):\n sig = np.sqrt(var)\n entropy = np.log(sig * np.sqrt(2 * np.pi * np.e))\n return np.array([[mu],[entropy]])\n\ndef gaussian_update(mu0, var0, mu1, var1):\n mu = (mu0 * var1 + mu1 * var0) / (var0 + var1)\n std = 1.0 / (1.0 / var0 + 1.0 / var1)\n return mu, std\n\ndef gaussin_predict(mu0, var0, mu1, var1):\n mu = mu0 + mu1\n var = var0 + var1\n return mu, var\n\ndef draw_one_door(cur_pos):\n w = 1.0\n left_down_x = cur_pos - w\n left_down_y = 1.5\n left_up_x = left_down_x\n left_up_y = 1.5 + 0.3\n right_up_x = cur_pos + w\n right_up_y = left_up_y\n right_down_x = right_up_x\n right_down_y = left_down_y\n return np.array([[left_down_x, left_up_x, right_up_x, right_down_x], \n [left_down_y, left_up_y, right_up_y, right_down_y]])\n\ndef draw_robot(cur_pos):\n p0_x = cur_pos\n p0_y = 1.5\n p1_x = cur_pos\n p1_y = 1.5 + 0.15\n p2_x = cur_pos - 0.1\n p2_y = 1.5 + 0.15\n p3_x = cur_pos\n p3_y = 1.5 + 0.25\n p4_x = cur_pos + 0.1\n p4_y = 1.5 + 0.15\n p5_x = p1_x\n p5_y = p1_y\n return np.array([[p0_x, p1_x, p2_x, p3_x, p4_x, p5_x], \n [p0_y, p1_y, p2_y, p3_y, p4_y, p5_y]])\n\n\nclass update_prob(object):\n def __init__(self, ax, trajectory, doors, total_length, doors_geometry, robot_geometry, robot_pos_entropy):\n # The first is for robot, the second is for the doors\n self.lines = [ax.plot([], [], color='b')[0], # robot_pos_prob\n ax.plot([], [], color='g')[0], # door_pos_prob\n ax.plot([], [], color='black')[0], # road\n ax.plot([], [], color='black')[0], # doors\n ax.plot([], [], color='r')[0], \n ax.plot([], [], color='gray')[0]] # robot entropy\n self.ax = ax\n self.ax.grid(True)\n self.trajectory = trajectory\n self.total_length = total_length\n self.doors = doors[0]\n for door in doors[1:]:\n self.doors = np.concatenate((self.doors, door), axis=1)\n self.doors_geometry = doors_geometry[0]\n for door in doors_geometry[1:]:\n self.doors_geometry = np.concatenate((self.doors_geometry, door), axis=1)\n self.robot_geometry = robot_geometry\n \n self.robot_pos_entropy = robot_pos_entropy[0]\n for entropy in robot_pos_entropy[1:]:\n self.robot_pos_entropy = np.concatenate((self.robot_pos_entropy, entropy), axis=1)\n self.robot_pos_entropy[1,:] -= self.robot_pos_entropy[1,np.argmax(self.robot_pos_entropy[1,:])]\n ## Setting the axes properties\n ax.set_xlim([-0, 50])\n ax.set_xlabel('X')\n ax.set_ylim([-1.5, 3.5])\n ax.set_ylabel('Y')\n ax.set_title('kalman filter')\n\n def init(self):\n for line in self.lines:\n line.set_data([], [])\n return self.lines\n\n def __call__(self, i):\n # This way the plot can continuously run and we just keep\n # watching new realizations of the process\n self.lines[0].set_data(self.trajectory[i])\n self.lines[1].set_data(self.doors)\n self.lines[2].set_data([0, self.total_length], [1.5, 1.5])\n self.lines[3].set_data(self.doors_geometry)\n self.lines[4].set_data(self.robot_geometry[i])\n self.lines[5].set_data(self.robot_pos_entropy[0, 0:i], self.robot_pos_entropy[1, 0:i])\n return self.lines\n\ndef main():\n smp_num = 100\n door_positions = np.array([5.0, 10.0, 15.0, 25.0, 40.0])\n door_stds = np.array([0.5, 0.5, 0.5, 0.5, 0.5])\n door_vars = door_stds ** 2\n doors = []\n doors_geometry = []\n for mu, std in zip(door_positions, door_stds):\n doors.append(gaussian_histogram(smp_num, mu, std))\n doors_geometry.append(draw_one_door(mu))\n step_num = 100\n step_length = 0.5\n step_var = 0.04\n\n total_length = step_num * step_length\n\n cur_pos = 0.0\n cur_var = 0.09\n\n robot_trajectory = []\n robot_geometry = []\n robot_pos_entropy = []\n for step in range(step_num):\n # do measure, update\n for door_pos, door_var in zip(door_positions, door_vars):\n if np.abs(cur_pos - door_pos) < 0.01:\n cur_pos, cur_var = gaussian_update(cur_pos, cur_var, door_pos, door_var)\n robot_pos_entropy.append(gaussian_entropy(cur_pos, cur_var))\n robot_trajectory.append(gaussian_histogram(smp_num, cur_pos, cur_var))\n robot_geometry.append(draw_robot(cur_pos))\n # do move, predict\n cur_pos, cur_var = gaussin_predict(cur_pos, cur_var, step_length, step_var)\n robot_pos_entropy.append(gaussian_entropy(cur_pos, cur_var))\n robot_trajectory.append(gaussian_histogram(smp_num, cur_pos, cur_var))\n robot_geometry.append(draw_robot(cur_pos))\n # more specifical geometry\n # print(robot_trajectory)\n # First set up the figure, the axis, and the plot element we want to animate\n fig = plt.figure()\n ax = plt.axes(xlim=(0, 2), ylim=(0, 20))\n\n up = update_prob(ax, robot_trajectory, doors, total_length, doors_geometry, robot_geometry, robot_pos_entropy)\n # call the animator. blit=True means only re-draw the parts that have changed.\n anim = FuncAnimation(fig, up, frames=len(robot_trajectory), interval=200, blit=True)\n # anim.save('kalmanfilter.gif', dpi=80, writer='imagemagick')\n plt.show()\n\nif __name__ == '__main__':\n main()", "import sys\nimport math\nimport copy\nimport numpy as np\nfrom scipy.stats import norm\nfrom scipy.ndimage import gaussian_filter1d\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.animation import FuncAnimation\n\nclass grid_map():\n def __init__(self, minx, maxx, resolution):\n self.minx = minx\n self.maxx = maxx\n self.resolution = resolution\n self.widthx = int(round((self.maxx - self.minx) / self.resolution))\n self.probability = np.ones(self.widthx) * (1.0 / self.widthx)\n \n def init(self):\n self.minx = 0.0\n self.maxx = 2.5\n self.resolution = 0.5\n self.widthx = int(round((self.maxx - self.minx) / self.resolution))\n self.probability = np.ones(self.widthx) * (1.0 / self.widthx)\n \n def print(self):\n print('[minx, max] = [', self.minx, ',', self.maxx, ']')\n print('resolution = ', self.resolution)\n print('widthx = ', self.widthx)\n print('probability = ', self.probability)\n\n def normalize_probability(self):\n self.probability /= np.sum(self.probability)\n \n def current_position(self):\n position = 0.0\n for i in range(self.widthx):\n cur_pos = self.minx + i * self.resolution\n position += cur_pos * self.probability[i]\n return position\n \n def motion_predict(self, move_length, motion_noise):\n step = round(move_length / self.resolution) * self.resolution\n self.minx += step\n self.maxx += step\n print('before:', self.probability)\n self.probability = gaussian_filter1d(self.probability, motion_noise)\n print('after:', self.probability)\n # there is no need for total probability, I do this just for security\n self.normalize_probability()\n return self.current_position()\n \n def measurement_update(self, min_distance, map_data, measurement_noise):\n # min_distance has been added some noise\n for i in range(self.widthx): # loop all the estimated positions\n cur_pos = self.minx + i * self.resolution\n min_dis = 1e3\n for j in range(len(map_data)):\n delta = np.abs(cur_pos - map_data[j])\n if delta < min_dis:\n min_dis = delta\n # likelihood\n pdf = 1.0 - norm.cdf(np.abs(min_dis - min_distance), 0.0, measurement_noise)\n self.probability[i] *= pdf\n self.normalize_probability()\n return self.current_position()\n\nclass hfrobot(object):\n def __init__(self, \n start_position, \n end_position, \n velocity, \n motion_noise, \n measurement_noise, \n sensor_range,\n map_data, \n grid_map):\n self.start_position = start_position # m\n self.end_position = end_position # m\n self.velocity = velocity # m/s\n\n self.groundtruth = start_position\n\n self.motion_noise = motion_noise\n self.measurement_noise = measurement_noise\n\n self.sensor_range = sensor_range\n self.map = map_data\n\n self.grid_map = copy.deepcopy(grid_map)\n self.position = self.grid_map.current_position()\n \n def init(self):\n self.position = 0.0\n self.start_position = 0.0\n self.end_position = 0.0\n self.groundtruth = 0.0\n\n self.velocity = 0.0\n\n self.motion_noise = 0.0\n self.measurement_noise = 0.0\n \n self.sensor_range = 0.0\n self.map = np.array([0.0])\n\n self.grid_map = copy.deepcopy(grid_map(0.0, 10.0, 1.0))\n \n def motion(self):\n self.groundtruth += self.velocity * 1.0\n \n def motion_predict(self):\n self.motion()\n # print('motion_predict:current position', self.position)\n # print('motion_predict:groundtruth', self.groundtruth)\n move_length = self.velocity * 1.0 + np.random.randn() * self.motion_noise\n self.position = self.grid_map.motion_predict(move_length, self.motion_noise)\n \n def measurement(self):\n # find what the robot senses\n min_distance = 1e3\n min_door = 1e3\n ret = False\n for item in self.map:\n delta = np.abs(item - self.groundtruth)\n if delta <= self.sensor_range and delta < min_distance:\n ret = True\n min_distance = delta\n min_door = item\n return ret, min_distance, min_door\n \n def measurement_update(self):\n ret, min_distance, _ = self.measurement()\n if ret:\n print('measurement success')\n min_distance += np.random.randn() * self.measurement_noise\n self.position = self.grid_map.measurement_update(min_distance, self.map, self.measurement_noise)\n return ret\n\ndef draw_robot(cur_pos, road_line):\n p0_x = cur_pos\n p0_y = road_line\n p1_x = cur_pos\n p1_y = road_line + 0.15\n p2_x = cur_pos - 0.1\n p2_y = road_line + 0.15\n p3_x = cur_pos\n p3_y = road_line + 0.25\n p4_x = cur_pos + 0.1\n p4_y = road_line + 0.15\n p5_x = p1_x\n p5_y = p1_y\n return np.array([[p0_x, p1_x, p2_x, p3_x, p4_x, p5_x], \n [p0_y, p1_y, p2_y, p3_y, p4_y, p5_y]])\n\ndef draw_gaussian(bin_num, mu, sig):\n sig3 = 3.0 * sig\n step = 2.0 * sig3 / bin_num\n x = np.arange(mu - sig3, mu + sig3 + step, step)\n y = norm.pdf(x, mu, sig)\n data = np.zeros((2, len(x)))\n data[0, :] = x\n data[1, :] = y\n return data\n\ndef draw_robot_groundtruths(robot_groundtruths, road_line):\n res = []\n for item in robot_groundtruths:\n res.append(draw_robot(item, road_line))\n return res\n\ndef draw_robot_groundtruths_with(robot_groundtruths):\n res = []\n for item in robot_groundtruths:\n res.append(np.array([[item, item], [0.0, 1.0]]))\n return res\n\ndef draw_robot_positions(robot_positions_with_noise, road_line):\n res = []\n for item in robot_positions_with_noise:\n res.append(draw_robot(item[0], road_line))\n return res\n\ndef histogram_entropy(grid_map):\n min_prob = 1e-9\n res = 0.0\n for item in grid_map.probability:\n if item > min_prob:\n res += item * np.log(item)\n return -res\n\ndef draw_robot_entropy(robot_groundtruths, robot_positions_with_noise):\n res = np.zeros((2, len(robot_groundtruths)))\n for idx in range(res.shape[1]):\n res[0, idx] = robot_groundtruths[idx]\n item = copy.deepcopy(robot_positions_with_noise[idx])\n res[1, idx] = histogram_entropy(item[1])\n return res\n\ndef draw_robot_grid_map(grid_map):\n res = np.zeros((2, 4 * grid_map.widthx))\n index = 0\n for i in range(grid_map.widthx):\n x = grid_map.minx + i * grid_map.resolution\n y = 0\n res[0, index] = x\n res[1, index] = y\n index += 1\n\n res[0, index] = x\n res[1, index] = y + grid_map.probability[i]\n index += 1\n\n res[0, index] = x + grid_map.resolution\n res[1, index] = y + grid_map.probability[i]\n index += 1\n\n res[0, index] = x + grid_map.resolution\n res[1, index] = y\n index += 1\n return res\n\ndef draw_robot_positions_with_noise(robot_positions_with_noise):\n res = []\n for item in robot_positions_with_noise:\n res.append(draw_robot_grid_map(item[1]))\n return res\n\ndef draw_door(cur_pos, road_line):\n w = 1.0\n h = 0.3\n left_down_x = cur_pos - w\n left_down_y = road_line\n left_up_x = left_down_x\n left_up_y = road_line + h\n right_up_x = cur_pos + w\n right_up_y = left_up_y\n right_down_x = right_up_x\n right_down_y = left_down_y\n return np.array([[left_down_x, left_up_x, right_up_x, right_down_x], \n [left_down_y, left_up_y, right_up_y, right_down_y]])\n\ndef draw_doors(doors, road_line):\n res = draw_door(doors[0], road_line)\n for item in doors[1:]:\n res = np.concatenate((res, draw_door(item, road_line)), axis=1)\n return res\n\ndef draw_doors_with_noise(doors, measurement_noise):\n bin_num = 50\n res = draw_gaussian(bin_num, doors[0], measurement_noise)\n for item in doors[1:]:\n res = np.concatenate((res, draw_gaussian(bin_num, item, measurement_noise)), axis=1)\n return res\n\ndef draw_road_line(start_position, end_position, road_line):\n return np.array([[start_position, end_position], \n [road_line, road_line]])\n\nclass update_draw(object):\n def __init__(self, ax, \n start_position, end_position,\n groundtruth, groundtruth_with, positions, doors, road_line,\n positions_with_noise, doors_with_noise, entropy):\n self.groundtruth = groundtruth\n self.groundtruth_with = groundtruth_with\n self.positions = positions\n self.doors = doors\n self.road_line = road_line\n self.positions_with_noise = positions_with_noise\n self.doors_with_noise = doors_with_noise\n self.entropy = entropy\n\n ## Setting the axes properties\n ax.set_xlim([start_position, end_position])\n ax.set_xlabel('X')\n ax.set_ylim([0, self.road_line[1, 0] * 2])\n ax.set_ylabel('Y')\n ax.set_title('kalman filter')\n\n self.lines = [ax.plot([], [], color='b')[0], # groundtruth\n ax.plot([], [], color='b')[0], # groundtruth_with\n ax.plot([], [], color='g')[0], # positions\n ax.plot([], [], color='black')[0], # doors\n ax.plot([], [], color='black')[0], # road_line\n ax.plot([], [], color='g')[0], # positions_with_noise\n ax.plot([], [], color='black')[0], # doors_with_noise\n ax.plot([], [], color='gray')[0]] # entropy\n ax.legend((self.lines[0], self.lines[2], self.lines[3], self.lines[7]), \n ('groundtruth', 'positions with uncertainty', 'doors', 'entropy'))\n \n def init(self):\n for line in self.lines:\n line.set_data([], [])\n return self.lines\n \n def __call__(self, i):\n # This way the plot can continuously run and we just keep\n # watching new realizations of the process\n self.lines[0].set_data(self.groundtruth[i])\n self.lines[1].set_data(self.groundtruth_with[i])\n self.lines[2].set_data(self.positions[i])\n self.lines[3].set_data(self.doors)\n self.lines[4].set_data(self.road_line)\n self.lines[5].set_data(self.positions_with_noise[i])\n self.lines[6].set_data(self.doors_with_noise)\n self.lines[7].set_data(self.entropy[:, :i + 1])\n return self.lines\n\ndef main():\n start_position = 0.0\n end_position = 50.0\n velocity = 0.5\n motion_noise = np.sqrt(0.1)\n measurement_noise = np.sqrt(0.5)\n sensor_range = 0.1\n doors = np.array([5.0, 10.0, 15.0, 25.0, 40.0])\n\n road_line = 1.5\n\n hf_grid_map = copy.deepcopy(grid_map(0.0, 9.5, 0.5))\n\n hf_robot = hfrobot(start_position, \n end_position, \n velocity, \n motion_noise, \n measurement_noise, \n sensor_range,\n doors,\n hf_grid_map)\n\n loop_num = int((end_position - start_position) / velocity)\n\n # dynamic\n robot_positions_with_noise = []\n robot_groundtruths = []\n # hf_robot.grid_map.print()\n robot_positions_with_noise.append(np.array([hf_robot.position, copy.deepcopy(hf_robot.grid_map) ]))\n robot_groundtruths.append(hf_robot.groundtruth)\n\n for loop in range(loop_num):\n # print(hf_robot.position)\n ret = hf_robot.measurement_update()\n if ret:\n # hf_robot.grid_map.print()\n robot_positions_with_noise.append(np.array([hf_robot.position, copy.deepcopy(hf_robot.grid_map) ]))\n robot_groundtruths.append(hf_robot.groundtruth)\n \n hf_robot.motion_predict()\n # hf_robot.grid_map.print()\n robot_positions_with_noise.append(np.array([hf_robot.position, copy.deepcopy(hf_robot.grid_map) ]))\n robot_groundtruths.append(hf_robot.groundtruth)\n \n # convert data for drawing\n d_groundtruths = draw_robot_groundtruths(robot_groundtruths, road_line)\n d_groundtruths_with = draw_robot_groundtruths_with(robot_groundtruths)\n d_robot_positions = draw_robot_positions(robot_positions_with_noise, road_line)\n d_road_line = draw_road_line(start_position, end_position, road_line)\n d_doors = draw_doors(doors, road_line)\n d_positions_with_noise = draw_robot_positions_with_noise(robot_positions_with_noise)\n d_doors_with_noise = draw_doors_with_noise(doors, measurement_noise)\n d_entropy = draw_robot_entropy(robot_groundtruths, robot_positions_with_noise)\n # draw\n fig = plt.figure()\n ax = plt.axes()\n\n ud = update_draw(ax, start_position, end_position,\n d_groundtruths, d_groundtruths_with, d_robot_positions, d_doors, d_road_line,\n d_positions_with_noise, d_doors_with_noise, d_entropy)\n # call the animator. blit=True means only re-draw the parts that have changed.\n anim = FuncAnimation(fig, ud, frames=loop_num, interval=200, blit=True)\n # anim.save('histogramfilter.gif', dpi=80, writer='imagemagick')\n plt.show()\n\nif __name__ == '__main__':\n main()" ]

[ [ "numpy.sqrt", "scipy.stats.norm.pdf", "numpy.abs", "numpy.arange", "matplotlib.pyplot.axes", "numpy.concatenate", "numpy.argmax", "numpy.array", "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ], [ "numpy.log", "numpy.sqrt", "scipy.stats.norm.pdf", "numpy.abs", "numpy.arange", "scipy.ndimage.gaussian_filter1d", "numpy.ones", "matplotlib.pyplot.axes", "numpy.random.randn", "matplotlib.animation.FuncAnimation", "numpy.array", "numpy.zeros", "numpy.sum", "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ] ]

JDE65/StockAnalysis

[ "6423e05f46fa4630d1c8a03e1630ea6e630b5a8f" ]

[ "util_model.py" ]

[ "# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Sun Aug 2 23:16:50 2020\r\n\r\nUtility functions for financial analysis to prepare X and Y matrices\r\n 1. LSTM_cleanXset(X_raw, trigger) => return X_clean\r\n 2. create_dataset(dataX, dataY, seq_length, step) => return Xs, ys as np.array\r\n 3. LSTM_train_test_size(dataX, dataY, lstmStart, lstmSize, proportionTrain, classRegr) => return (X_train, y_train), (X_test, y_test), (res_train, res_test)\r\n 4. LSTM_clean_traintest(X_train, X_test, trigger) => return X_train, X_test\r\n 5. LSTM_scaleX(X_train, X_test) => return Xs_train, Xs_test\r\n 6. => return \r\n \r\n@author: JDE65\r\n\"\"\"\r\n# ==== PART 0. Installing libraries ============\r\n\r\nimport pandas as pd\r\nimport numpy as np\r\nfrom sklearn import preprocessing\r\nfrom sklearn.preprocessing import StandardScaler\r\nfrom sklearn.metrics import confusion_matrix\r\nimport seaborn as sns\r\nimport matplotlib.pyplot as plt\r\nfrom matplotlib import rc\r\nimport tensorflow as tf\r\n\r\nimport tensorflow.keras\r\nfrom tensorflow.keras import backend as K\r\n\r\n###--- 2. Custom loss functions for training ---###\r\ndef custom_return_loss_function(y_actual, y_predicted):\r\n diff_y = K.square(y_actual- np.squeeze(y_predicted))\r\n bool_idx = K.greater(diff_y, K.square(y_actual))\r\n loss1 = tf.math.scalar_mul(2, diff_y)\r\n y_diff = K.switch(bool_idx, loss1, diff_y)\r\n #diff_y[(y_actual > 0) & (np.squeeze(y_predicted) < 0)] *= 2\r\n #diff_y[(y_actual < 0) & (np.squeeze(y_predicted) > 0)] *= 3\r\n #diff_y = K.constant(diff_y)\r\n custom_return_loss_value = K.mean(y_diff)\r\n return custom_return_loss_value\r\n\r\n\r\ndef custom_price_loss_function(y_actual, y_predicted): ### To be IMPROVED\r\n diff_y = np.abs(y_actual- np.squeeze(y_predicted))\r\n diff_y[(y_actual > 0) & (np.squeeze(y_predicted) < 0)] *= 2\r\n diff_y[(y_actual < 0) & (np.squeeze(y_predicted) > 0)] *= 3\r\n custom_price_loss_value = K.mean(diff_y)\r\n return custom_price_loss_value\r\n\r\n###--- 3. Compile model for training ---###\r\ndef model_compile_train(model, loss, optimizer, X_train, y_train, epochs, batch_size, validation_split, verbose = 0):\r\n model.compile(loss = loss, optimizer = optimizer, metrics=['accuracy'])\r\n history = model.fit(X_train, y_train, epochs = epochs, batch_size = batch_size, validation_split = validation_split, verbose = verbose)\r\n return model, history\r\n\r\n\r\n###--- 4. evaluate, predict and assess \r\ndef model_predict(model, history, X_train, y_train, X_test, y_test):\r\n eval_train = model.evaluate(X_train, y_train)\r\n eval_test = model.evaluate(X_test, y_test)\r\n y_pred = model.predict(X_test)\r\n return eval_train, eval_test, y_pred\r\n\r\n\r\n###--- 4. evaluate, predict and assess \r\n## Analysis for regression on price value\r\ndef model_eval_price(X_ref, y_test, y_pred, eval_trigger):\r\n y_testdec = (y_test - X_ref) / X_ref\r\n y_predict = (y_pred[:,0] - X_ref) / X_ref\r\n y_predict[y_predict[:,] > eval_trigger] = 1 # predicted price > close_price by expected trigger => buy\r\n y_predict[y_predict[:,] <= eval_trigger] = 0 # predicted price < close_price by expected trigger => NO buy\r\n y_testdec[y_testdec[:,] > eval_trigger] = 1 # future price > close_price by expected trigger => buy\r\n y_testdec[y_testdec[:,] <= eval_trigger] = 0\r\n confmat = confusion_matrix(y_testdec, y_predict)\r\n return y_testdec, y_predict, confmat\r\n\r\n## Analysis of classification if only very strong performance is selected\r\ndef model_eval_return(y_test, y_pred, eval_trigger, modeRC, nb_classes, trig_up = 0):\r\n y_testdec = y_test[:,0]\r\n y_predict = y_pred[:,0] * 1\r\n if (modeRC== 'class') & (nb_classes > 2):\r\n if trig_up > 0:\r\n y_testdec = y_test[:,0] + y_test[:,2]\r\n y_predict = y_pred[:,0] + y_pred[:,2]\r\n y_predict[y_predict[:,] >= eval_trigger] = 1 # predicted price > close_price by expected trigger => buy\r\n y_predict[y_predict[:,] < eval_trigger] = 0 # predicted price < close_price by expected trigger => NO buy\r\n confmat = confusion_matrix(y_testdec, y_predict)\r\n if (modeRC== 'class') & (nb_classes > 2):\r\n if trig_up > 0:\r\n y_predict[y_pred[:,2]>eval_trigger] += 1\r\n return y_testdec, y_predict, confmat\r\n\r\n## Analysis of classification if only very strong performance is selected\r\ndef model3D_eval_topreturn(y_test, y_pred, eval_trigger, modeRC, nb_classes, trig_up = 0):\r\n y_testdec = y_test[:,0]\r\n y_predict = y_pred[:,0] * 1\r\n if (modeRC== 'class') & (nb_classes > 2):\r\n if trig_up > 0:\r\n y_testdec = y_test[:,2]\r\n y_predict = y_pred[:,2]\r\n y_predict[y_predict[:,] >= eval_trigger] = 1 # predicted price > close_price by expected trigger => buy\r\n y_predict[y_predict[:,] < eval_trigger] = 0 # predicted price < close_price by expected trigger => NO buy\r\n confmat = confusion_matrix(y_testdec, y_predict)\r\n return y_testdec, y_predict, confmat\r\n\r\n###--- 5. Analyse prediction F1\r\ndef get_F1(confmat): \r\n true_neg = confmat[0,0]\r\n true_pos = confmat[1,1]\r\n false_neg = confmat[1,0]\r\n false_pos = confmat[0,1]\r\n precis = true_pos / (true_pos + false_pos)\r\n recall = true_pos / (true_pos + false_neg)\r\n F1 = 2 * precis * recall / (precis + recall)\r\n \r\n return precis, recall, F1\r\n\r\ndef model_eval_result(y_testdec, y_predict, res_test):\r\n test_result, pred_result = [], []\r\n test_res = np.multiply(y_testdec[:,], res_test[:])\r\n pred_res = np.multiply(res_test[:], y_predict[:,])\r\n test_result = test_res.sum()\r\n pred_result = pred_res.sum()\r\n bhst_result = res_test.sum()\r\n nbDeals_test = y_testdec[y_testdec == 1].sum()\r\n nbDeals_pred = y_predict[y_predict == 1].sum()\r\n nbDeals_bhst = len(y_testdec) \r\n \r\n return (nbDeals_bhst, nbDeals_test, nbDeals_pred), (bhst_result, test_result, pred_result)\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n###--- 3. Cleanup X for missing values ---###\r\n\r\ndef LSTM_clean_traintest(X_train, X_test, trigger):\r\n nanc = X_train.isna().sum()\r\n for i in range(len(nanc)):\r\n ananc = nanc.iloc[i]/len(X_train)\r\n if ananc > trigger:\r\n X_train = X_train.drop(columns = i)\r\n X_test = X_test.drop(columns = i)\r\n X_train = X_train.T.reset_index(drop = True).T\r\n X_test = X_test.T.reset_index(drop = True).T\r\n return X_train, X_test\r\n\r\n\r\n\r\n\r\n\r\n###--- 5. Analyse NN efficiency\r\ndef get_stat_NN(y_train, y_test, y_pred, y_testdec) :\r\n #res_train = confusion_matrix(y_train, y_pred)\r\n res_test = confusion_matrix(y_test, y_testdec)\r\n TPt = np.sum(res_test[1:, 1:]) # + res_train[2, 2] + res_train[1, 2] + res_train[2, 1] # true positive includes exact prediction as well as event happening but sooner or later\r\n FPt = np.sum(res_test[0, 1:]) # event announced but not happening\r\n FNt = np.sum(res_test[1:, 0]) # event unannounced\r\n \r\n if ((TPt + FPt)!= 0):\r\n prect = TPt / (TPt + FPt)\r\n recallt = TPt / (TPt + FNt)\r\n F1t = 2 * prect * recallt / (prect + recallt)\r\n testAcc = (res_test[0, 0] + TPt) / np.sum(res_test)\r\n testAccDet = np.trace(res_test) / np.sum(res_test)\r\n else:\r\n prect = 0\r\n recallt = 0\r\n F1t = 0\r\n testAcc = (res_test[0, 0] + TPt) / np.sum(res_test)\r\n testAccDet = np.trace(res_test) / np.sum(res_test)\r\n\r\n return (prect, recallt, F1t), (testAcc, testAccDet)" ]

[ [ "numpy.multiply", "numpy.squeeze", "numpy.trace", "tensorflow.math.scalar_mul", "sklearn.metrics.confusion_matrix", "tensorflow.keras.backend.square", "tensorflow.keras.backend.mean", "tensorflow.keras.backend.switch", "numpy.sum" ] ]

JohnlNguyen/FLSim

[ "a5ed7c0b84499cd9dbc5fe95f8bcb4ba8ab5a5cb" ]

[ "flsim/privacy/tests/test_user_update_clipper.py" ]

[ "#!/usr/bin/env python3\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under the BSD-style license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport pytest\nimport torch\nfrom flsim.common.pytest_helper import (\n assertAlmostEqual,\n assertTrue,\n assertEqual,\n assertFalse,\n)\nfrom flsim.privacy.user_update_clip import UserUpdateClipper\nfrom flsim.tests import utils\n\n\[email protected](scope=\"class\")\ndef prepare_user_update_clipper_test(request) -> None:\n request.cls.user_update_clipper = UserUpdateClipper()\n\n def _init_user_model(param_value):\n user_model = utils.TwoFC()\n user_model.fill_all(param_value) # fill all parameters with a number\n return user_model\n\n request.cls.previous_user_model = _init_user_model(param_value=6.0)\n request.cls.updated_user_model = _init_user_model(param_value=7.0)\n request.cls.original_model_diff = request.cls.user_update_clipper.calc_model_diff(\n request.cls.updated_user_model, request.cls.previous_user_model\n )\n request.cls.original_model_diff_params = [\n p for p in request.cls.original_model_diff.parameters() if p.requires_grad\n ]\n\n\[email protected](\"prepare_user_update_clipper_test\")\nclass TestUserUpdateClipper:\n def _init_clipped_model_diff(self, max_norm):\n clipped_model_diff = utils.TwoFC()\n clipped_model_diff.load_state_dict(self.original_model_diff.state_dict())\n\n self.user_update_clipper.clip(clipped_model_diff, max_norm)\n return clipped_model_diff\n\n def test_calc_clip_factor(self) -> None:\n \"\"\"\n Tests that the clip factor for user updates is calculated correctly.\n \"\"\"\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `user_update_clipper`.\n clip_factor = self.user_update_clipper._calc_clip_factor(\n max_norm=5, per_user_norm=10\n )\n assertAlmostEqual(clip_factor, 0.5, places=3)\n\n clip_factor = self.user_update_clipper._calc_clip_factor(\n max_norm=1, per_user_norm=1\n )\n assertAlmostEqual(clip_factor, 1, places=3)\n\n clip_factor = self.user_update_clipper._calc_clip_factor(\n max_norm=2, per_user_norm=0.8\n )\n assertAlmostEqual(clip_factor, 1, places=3)\n\n def test_calc_user_update_norm(self) -> None:\n \"\"\"\n Tests that the user update l-2 norms are calculated correctly.\n \"\"\"\n model = utils.TwoFC()\n model.fill_all(2.0)\n model_params = model.parameters()\n # norm = sqrt(21*2^2)=sqrt(84)=9.16515138991168\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `user_update_clipper`.\n norm = self.user_update_clipper._calc_norm(model_params)\n assertTrue(torch.allclose(norm, torch.tensor(9.16515138991168), rtol=1e-06))\n\n model.fill_all(1.0)\n model_params = model.parameters()\n # norm = sqrt(21*1^2)=sqrt(21)=4.58257569495584\n norm = self.user_update_clipper._calc_norm(model_params)\n assertTrue(torch.allclose(norm, torch.tensor(4.58257569495584), rtol=1e-06))\n\n def test_clipped_updates_are_smaller(self) -> None:\n \"\"\"\n Tests that user updates are clipped and their value is smaller than\n the original updates\n \"\"\"\n\n # assert the parameters of model_diff are all = (7 - 6 = 1)\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `original_model_diff_params`.\n for p in self.original_model_diff_params:\n assertTrue(torch.allclose(p.float(), torch.tensor(1.0)))\n\n clipped_model_diff = self._init_clipped_model_diff(0.0003)\n clipped_model_diff_params = [\n p for p in clipped_model_diff.parameters() if p.requires_grad\n ]\n for original, clipped in zip(\n self.original_model_diff_params, clipped_model_diff_params\n ):\n assertTrue(torch.all(original.gt(clipped)))\n\n def test_clipped_user_updates_non_zero(self) -> None:\n \"\"\"\n Tests that user updates are not zero by clipping\n \"\"\"\n clipped_model_diff = self._init_clipped_model_diff(0.0003)\n clipped_model_diff_params = [\n p for p in clipped_model_diff.parameters() if p.requires_grad\n ]\n for clipped in clipped_model_diff_params:\n allzeros = torch.zeros_like(clipped)\n assertFalse(torch.allclose(clipped, allzeros))\n\n def test_clipping_to_high_value_does_not_clip(self) -> None:\n \"\"\"\n Tests that when clip value is set too high, user\n updates are not clipped\n \"\"\"\n clipped_model_diff = self._init_clipped_model_diff(9999)\n mismatched = utils.verify_models_equivalent_after_training(\n # pyre-fixme[16]: `TestUserUpdateClipper` has no attribute\n # `original_model_diff`.\n self.original_model_diff,\n clipped_model_diff,\n )\n assertEqual(mismatched, \"\")\n" ]

[ [ "torch.allclose", "torch.zeros_like", "torch.tensor" ] ]

KhronosGroup/NNEF-Tools

[ "0295fdedddcb316afd9c8092934c62ca84b39439" ]

[ "nnef_tools/conversion/tflite_to_nnef.py" ]

[ "# Copyright (c) 2020 The Khronos Group Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom __future__ import division, print_function, absolute_import\nfrom .converter import Converter as _Converter, Transform, ConversionError\nfrom .tf_to_nnef import Converter as _TFConverter, _Transforms as _TFTransforms, _RELU6_FRAGMENT\nfrom ..model import Tensor, Operation\nfrom ..utils import types\nfrom ..io.tf.lite import CustomOptionsKey\nimport numpy as np\nimport copy\n\n\n_DETECTION_POSTPROCESS_FRAGMENT = \"\"\"\nfragment TFLite_Detection_PostProcess( \n boxes: tensor<scalar>, \n scores: tensor<scalar>, \n anchors: tensor<scalar>, \n detections_per_class: integer,\n max_classes_per_detection: integer,\n max_detections: integer, \n nms_iou_threshold: scalar, \n nms_score_threshold: scalar, \n num_classes: integer, \n use_regular_nms: logical, \n h_scale: scalar,\n w_scale: scalar, \n x_scale: scalar, \n y_scale: scalar ) \n-> ( \n detection_boxes: tensor<scalar>, \n detection_classes: tensor<scalar>, \n detection_scores: tensor<scalar>, \n num_detections: tensor<scalar> );\n\"\"\"\n\n\nclass Converter(_TFConverter):\n\n _ConvOpTypes = ['CONV_1D', 'CONV_2D', 'CONV_3D', 'TRANSPOSE_CONV', 'DEPTHWISE_CONV_2D']\n\n _ActivationOpTypes = {\n 'ELU': 'elu',\n 'RELU': 'relu',\n 'RELU6': 'relu6',\n 'LOGISTIC': 'sigmoid',\n 'TANH': 'tanh',\n }\n\n @staticmethod\n def defined_operations():\n return {\n 'relu6': _RELU6_FRAGMENT,\n 'TFLite_Detection_PostProcess': _DETECTION_POSTPROCESS_FRAGMENT,\n }\n\n def __init__(self, io_transpose=False, custom_transforms=None, custom_functions=None,\n mirror_unsupported=False, keep_io_names=False):\n _Converter.__init__(self, transforms=self.merge_transforms(_Transforms, custom_transforms),\n functions=custom_functions, mirror_unsupported=mirror_unsupported)\n self._io_transpose = io_transpose\n self._keep_io_names = keep_io_names\n\n def __call__(self, graph):\n graph = _TFConverter.__call__(self, graph)\n self._fix_custom_options(graph)\n return graph\n\n def _global_attribs(self):\n return {'_lite_': True}\n\n def _prepare(self, graph):\n self._fix_quantization_attribs(graph)\n self._fix_quantized_dtypes(graph)\n self._insert_externals_and_constants(graph)\n self._transpose_externals(graph)\n\n def _is_constant(self, tensor):\n return tensor.producer is None and tensor.data is not None\n\n def _read_constant(self, tensor, type=None):\n if tensor.producer is None:\n return types.from_numpy(tensor.data, type=type)\n else:\n raise ConversionError('trying to evaluate non-constant tensor')\n\n def _transpose_externals(self, graph):\n for op in graph.operations:\n if op.type == 'external':\n if self.needs_io_transpose(op.output):\n shape = self.nxc_to_ncx(op.output.shape)\n op.attribs['shape'] = list(shape)\n self._transposes[op.output] = shape\n\n def _fix_quantized_dtypes(self, graph):\n for tensor in graph.tensors:\n if tensor.quant:\n scale = tensor.quant.get('scale')\n if scale:\n tensor.dtype = np.float32\n else:\n tensor.quant = None\n\n def _fix_quantization_attribs(self, graph):\n for tensor in graph.tensors:\n if tensor.quant and tensor.quant.get('scale'):\n if 'min' in tensor.quant:\n del tensor.quant['min']\n if 'max' in tensor.quant:\n del tensor.quant['max']\n tensor.quant['op-name'] = 'zero_point_linear_quantize'\n tensor.quant['bits'] = 32 if self._is_conv_bias(tensor) else 8\n assert tensor.dtype == np.uint8 or tensor.dtype == np.int8 or \\\n tensor.dtype == np.uint32 or tensor.dtype == np.int32, \\\n \"unknown quantized dtype '{}'\".format(tensor.dtype)\n tensor.quant['signed'] = tensor.dtype == np.int8 or tensor.dtype == np.int32\n tensor.quant['symmetric'] = self._is_conv_filter(tensor)\n\n def _fix_custom_options(self, graph):\n for op in graph.operations:\n if op.custom:\n options = op.attribs.get(CustomOptionsKey)\n if options is not None:\n op.attribs[CustomOptionsKey] = options.hex()\n\n def _is_conv_filter(self, tensor):\n tensor = self._tensor_map.get(tensor)\n return tensor and len(tensor.consumers) > 0 and \\\n all(op.type in Converter._ConvOpTypes and op.inputs[1] is tensor for op in tensor.consumers)\n\n def _is_conv_bias(self, tensor):\n tensor = self._tensor_map.get(tensor)\n return tensor and len(tensor.consumers) > 0 and \\\n all(op.type in Converter._ConvOpTypes and op.inputs[2] is tensor for op in tensor.consumers)\n\n def activation(self, output, func):\n if func is None or func == 'NONE':\n return output\n\n if func not in self._ActivationOpTypes:\n raise ConversionError(\"Unsupported fused activation function '{}'\".format(func))\n\n input = Tensor(output.graph, dtype=output.dtype, shape=self._working_shape(output), quant=copy.deepcopy(output.quant))\n Operation(output.graph, type=self._ActivationOpTypes[func], inputs=input, outputs=output)\n return input\n\n def flat_list(self, array):\n return [item for items in array for item in items] if len(array) and isinstance(array[0], (list, tuple)) else array\n\n def flatten(self, input):\n shape = (input.shape[0], int(np.prod(input.shape[1:])))\n output = Tensor(input.graph, dtype=input.dtype, shape=shape, quant=copy.deepcopy(input.quant))\n self._reshape_operation(input, output, shape)\n return output\n\n def same_shape(self, input, output):\n return self._tensor_map[input].shape == self._tensor_map[output].shape\n\n\n_Transforms = Converter.unpack_transforms({\n ('CONV_1D', 'CONV_2D', 'CONV_3D', 'DEPTHWISE_CONV_2D'):\n Transform(\n type='conv',\n using={\n 'depthwise': '!_type_ == \"DEPTHWISE_CONV_2D\"',\n },\n inputs=(\n '!transpose_input(I[0])',\n '!transpose_filter(I[1], format=\"NXC\" if not depthwise else \"CXN\")',\n '!unsqueeze_vector(I[2])',\n ),\n outputs='!activation(transpose_output(O[0]), fused_activation_function)',\n attribs={\n 'stride': '![stride_h, stride_w]',\n 'dilation': '![dilation_h_factor, dilation_w_factor]',\n 'padding': '!convert_padding(padding, I[0].rank - 2)',\n 'groups': '!1 if not depthwise else 0',\n }\n ),\n 'TRANSPOSE_CONV':\n Transform(\n type='deconv',\n using={\n 'depthwise': False,\n },\n inputs=(\n '!transpose_input(I[2])',\n '!transpose_filter(I[1], format=\"CXN\" if not depthwise else \"NXC\")',\n ),\n outputs='!transpose_output(O[0])',\n attribs={\n 'stride': '![stride_h, stride_w]',\n 'padding': '!convert_padding(padding, I[0].rank - 2)',\n 'output_shape': '!nxc_to_ncx(as_const(I[0]))',\n 'groups': '!1 if not depthwise else 0',\n }\n ),\n ('MAX_POOL_2D', 'AVERAGE_POOL_2D'):\n Transform(\n type=('max_pool', 'avg_pool'),\n inputs=(\n '!transpose_input(I[0])',\n ),\n outputs=(\n '!transpose_output(O[0])',\n ),\n attribs={\n 'size': '![1, 1, filter_height, filter_width]',\n 'stride': '![1, 1, stride_h, stride_w]',\n 'padding': '!convert_padding(padding, I[0].rank)',\n }\n ),\n 'RESHAPE':\n Transform(\n type='reshape',\n inputs='!undo_transpose(I[0])',\n outputs='!O[0]',\n attribs={\n 'shape': '!flexible_batch(flat_list(as_const(I[1])) if len(I) > 1 else new_shape, I[0].shape[0])',\n 'dtype': '!I[0].dtype',\n }\n ),\n 'CONCATENATION':\n Transform(\n type='concat',\n inputs=['!I[:]'],\n outputs='!activation(transpose_like(O[0], I[0]), fused_activation_function)',\n attribs={\n 'axis': '!transpose_axis_like(axis, I[0], O[0].rank)',\n }\n ),\n 'FULLY_CONNECTED':\n Transform(\n type='linear',\n cond={\n '!weights_format == \"DEFAULT\"': 'wights_format must be \"DEFAULT\"',\n },\n inputs=(\n '!I[0] if keep_num_dims else flatten(I[0])',\n '!I[1]',\n '!unsqueeze_vector(I[2]) if len(I) > 2 else None',\n ),\n outputs='!activation(O[0], fused_activation_function)',\n ),\n 'L2_NORMALIZATION':\n Transform(\n type='l2_normalization',\n inputs='!I[0]',\n outputs='!transpose_like(O[0], I[0])',\n attribs={\n 'axes': '!list(range(I[0].rank))',\n }\n ),\n 'PRELU':\n Transform(\n type='prelu',\n inputs=('!I[0]', '!I[1]'),\n outputs='!transpose_like(O[0], I[0])',\n ),\n ('PAD', 'MIRROR_PAD'):\n Transform(\n type='pad',\n cond={\n '!mode < 2': 'mode must be 0 or 1',\n },\n defaults={\n 'mode': None,\n },\n using={\n 'paddings': '!transpose_list_like(as_const(I[1]), ref=I[0])',\n },\n inputs='!I[0]',\n outputs='!transpose_like(O[0], I[0])',\n attribs={\n 'padding': '![tuple(item) for item in paddings]',\n 'border': '!\"reflect\" if mode == 0 else \"reflect-even\" if mode == 1 else \"constant\"',\n }\n ),\n 'GATHER':\n Transform(\n type='gather',\n inputs=('!I[0]', '!I[1]'),\n outputs='!transpose_like(O[0], I[0])',\n attribs={\n 'axis': '!transpose_axis_like(axis, I[0])',\n },\n ),\n 'IDENTITY': _TFTransforms['Identity'],\n 'TRANSPOSE': _TFTransforms['Transpose'],\n 'SPLIT': _TFTransforms['Split'],\n 'SPLIT_V': _TFTransforms['SplitV'],\n 'PACK': _TFTransforms['Pack'],\n 'UNPACK': _TFTransforms['Unpack'],\n 'TILE': _TFTransforms['Tile'],\n 'SQUEEZE': _TFTransforms['Squeeze'],\n 'EXPAND_DIMS': _TFTransforms['ExpandDims'],\n 'SLICE': _TFTransforms['Slice'],\n 'STRIDED_SLICE': _TFTransforms['StridedSlice'],\n 'RELU': _TFTransforms['Relu'],\n 'RELU6': _TFTransforms['Relu6'],\n 'ELU': _TFTransforms['Elu'],\n 'LEAKY_RELU': _TFTransforms['LeakyRelu'],\n 'LOGISTIC': _TFTransforms['Sigmoid'],\n 'SIN': _TFTransforms['Sin'],\n 'COS': _TFTransforms['Cos'],\n 'TAN': _TFTransforms['Tan'],\n 'ASIN': _TFTransforms['Asin'],\n 'ACOS': _TFTransforms['Acos'],\n 'ATAN': _TFTransforms['Atan'],\n 'SINH': _TFTransforms['Sinh'],\n 'COSH': _TFTransforms['Cosh'],\n 'TANH': _TFTransforms['Tanh'],\n 'ASINH': _TFTransforms['Asinh'],\n 'ACOSH': _TFTransforms['Acosh'],\n 'ATANH': _TFTransforms['Atanh'],\n 'EXP': _TFTransforms['Exp'],\n 'LOG': _TFTransforms['Log'],\n 'ABS': _TFTransforms['Abs'],\n 'NEG': _TFTransforms['Neg'],\n 'LOGICAL_NOT': _TFTransforms['LogicalNot'],\n 'FLOOR': _TFTransforms['Floor'],\n 'CEIL': _TFTransforms['Ceil'],\n 'ROUND': _TFTransforms['Round'],\n 'SQUARE': _TFTransforms['Square'],\n 'SQRT': _TFTransforms['Sqrt'],\n 'RSQRT': _TFTransforms['Rsqrt'],\n 'ADD': _TFTransforms['Add'],\n 'SUB': _TFTransforms['Sub'],\n 'MUL': _TFTransforms['Mul'],\n 'DIV': _TFTransforms['RealDiv'],\n 'POW': _TFTransforms['Pow'],\n 'MINIMUM': _TFTransforms['Minimum'],\n 'MAXIMUM': _TFTransforms['Maximum'],\n 'LOGICAL_AND': _TFTransforms['LogicalAnd'],\n 'LOGICAL_OR': _TFTransforms['LogicalOr'],\n 'LESS': _TFTransforms['Less'],\n 'LESS_EQUAL': _TFTransforms['LessEqual'],\n 'GREATER': _TFTransforms['Greater'],\n 'GREATER_EQUAL': _TFTransforms['GreaterEqual'],\n 'EQUAL': _TFTransforms['Equal'],\n 'NOT_EQUAL': _TFTransforms['NotEqual'],\n 'SELECT': _TFTransforms['Select'],\n 'REDUCE_MIN': _TFTransforms['Min'],\n 'REDUCE_MAX': _TFTransforms['Max'],\n 'MEAN': _TFTransforms['Mean'],\n 'SUM': _TFTransforms['Sum'],\n 'REDUCE_ANY': _TFTransforms['Any'],\n 'REDUCE_ALL': _TFTransforms['All'],\n 'ARG_MIN': _TFTransforms['ArgMin'],\n 'ARG_MAX': _TFTransforms['ArgMax'],\n 'SOFTMAX': _TFTransforms['Softmax'],\n 'LOCAL_RESPONSE_NORMALIZATION': _TFTransforms['LRN'],\n 'RESIZE_NEAREST_NEIGHBOR': _TFTransforms['ResizeNearestNeighbor'],\n 'RESIZE_BILINEAR': _TFTransforms['ResizeBilinear'],\n 'ADD_N': _TFTransforms['AddN'],\n 'CAST': _TFTransforms['Cast'],\n})\n" ]

[ [ "numpy.prod" ] ]

Barkhausen-Institut/GFDM-PHY-Reference

[ "18296058ce4b3ef2fcbad977dea4bbb758322476" ]

[ "simulation/unittest/test_modulator.py" ]

[ "import unittest\r\nimport sys, os\r\n\r\nimport unittest\r\nimport numpy as np\r\n\r\nimport sys, os\r\nsys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))\r\nimport simulation.modem.util as util\r\nimport sdr_utils\r\n\r\n\r\nclass TestModulator(unittest.TestCase):\r\n \r\n def test_ofdm_modulator_demodulator(self):\r\n modulator = util.Modulator() \r\n modulator.type_ = \"ofdm\"\r\n modulator.K = 1024\r\n modulator.M = 1\r\n data = sdr_utils.get_random(1024)\r\n modulated_data = modulator.modulate(data)\r\n np.testing.assert_array_almost_equal(modulated_data, sdr_utils.norm_complex(np.fft.ifft(data)))\r\n np.testing.assert_array_almost_equal(\r\n sdr_utils.norm_complex(modulator.demodulate(modulated_data)),sdr_utils.norm_complex(data)\r\n ) \r\n def test_ofdm_modulator_demodulator_vertical_data(self):\r\n modulator = util.Modulator() \r\n data = np.array([ [ 1.+0.j],\r\n [-1.+1.j],\r\n [ 3.-1.j],\r\n [-1.-3.j], \r\n [ 3.-1.j],\r\n [-3.+3.j]])\r\n modulated_data = modulator.modulate(data)\r\n np.testing.assert_array_almost_equal(modulated_data,sdr_utils.norm_complex( np.fft.ifft(data)))\r\n np.testing.assert_array_almost_equal(\r\n sdr_utils.norm_complex(modulator.demodulate(modulated_data)),sdr_utils.norm_complex( data)\r\n ) \r\n\r\n def test_gfdm_modulator_demodulator_fd(self):\r\n K, M = 64, 16\r\n\r\n modulator = util.Modulator(K=K, M= M,type_=\"gfdm\")\r\n data = sdr_utils.get_random(K*M).reshape(K,M)\r\n data[:,-1] = 0 + 0j \r\n data[:,1] = 0 + 0j \r\n data[:,0] = 0 + 0j \r\n modulated_data = modulator.modulate(data)\r\n self.assertAlmostEqual(np.abs(modulated_data[K]),0)\r\n self.assertAlmostEqual(np.abs(modulated_data[-K]),0)\r\n self.assertAlmostEqual(np.abs(modulated_data[0]),0)\r\n self.assertAlmostEqual(np.abs(modulated_data[-1]),0,places=3)\r\n\r\n demodulated_data = modulator.demodulate(np.fft.fft(modulated_data))\r\n np.testing.assert_array_almost_equal(data, demodulated_data)\r\n\r\nif __name__ == \"__main__\":\r\n unittest.main()" ]

[ [ "numpy.abs", "numpy.fft.fft", "numpy.fft.ifft", "numpy.array", "numpy.testing.assert_array_almost_equal" ] ]

ZhongxiaYan/ray

[ "b97b8c2be1c7d01e2c93ca97a0b87120bfa2bd1a" ]

[ "python/ray/util/sgd/tests/test_pytorch.py" ]

[ "import os\nimport tempfile\nfrom unittest.mock import patch\n\nimport pytest\nimport time\nimport torch\nimport torch.nn as nn\nimport torch.distributed as dist\n\nimport ray\nfrom ray import tune\nfrom ray.tests.conftest import ray_start_2_cpus # noqa: F401\nfrom ray.util.sgd.pytorch import PyTorchTrainer, PyTorchTrainable\nfrom ray.util.sgd.pytorch.utils import (train, BATCH_COUNT, TEST_MODE,\n SCHEDULER_STEP)\nfrom ray.util.sgd.utils import check_for_failure\n\nfrom ray.util.sgd.pytorch.examples.train_example import (\n model_creator, optimizer_creator, data_creator, LinearDataset)\n\n\ndef test_test_mode(ray_start_2_cpus): # noqa: F811\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n config={TEST_MODE: True},\n num_replicas=1)\n metrics = trainer.train()\n assert metrics[BATCH_COUNT] == 1\n\n val_metrics = trainer.validate()\n assert val_metrics[BATCH_COUNT] == 1\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_train(ray_start_2_cpus, num_replicas): # noqa: F811\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n for i in range(3):\n train_loss1 = trainer.train()[\"train_loss\"]\n validation_loss1 = trainer.validate()[\"validation_loss\"]\n\n for i in range(3):\n train_loss2 = trainer.train()[\"train_loss\"]\n validation_loss2 = trainer.validate()[\"validation_loss\"]\n\n print(train_loss1, train_loss2)\n print(validation_loss1, validation_loss2)\n\n assert train_loss2 <= train_loss1\n assert validation_loss2 <= validation_loss1\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_multi_model(ray_start_2_cpus, num_replicas): # noqa: F811\n def custom_train(config, models, dataloader, criterion, optimizers,\n **kwargs):\n result = {}\n for i, (model, optimizer) in enumerate(zip(models, optimizers)):\n result[\"model_{}\".format(i)] = train(config, model, dataloader,\n criterion, optimizer)\n return result\n\n def multi_model_creator(config):\n return nn.Linear(1, 1), nn.Linear(1, 1)\n\n def multi_optimizer_creator(models, config):\n opts = [\n torch.optim.SGD(model.parameters(), lr=0.0001) for model in models\n ]\n return opts[0], opts[1]\n\n trainer1 = PyTorchTrainer(\n multi_model_creator,\n data_creator,\n multi_optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n train_function=custom_train,\n num_replicas=num_replicas)\n trainer1.train()\n\n filename = os.path.join(tempfile.mkdtemp(), \"checkpoint\")\n trainer1.save(filename)\n\n models1 = trainer1.get_model()\n\n trainer1.shutdown()\n\n trainer2 = PyTorchTrainer(\n multi_model_creator,\n data_creator,\n multi_optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n trainer2.restore(filename)\n\n os.remove(filename)\n\n models2 = trainer2.get_model()\n\n for model_1, model_2 in zip(models1, models2):\n\n model1_state_dict = model_1.state_dict()\n model2_state_dict = model_2.state_dict()\n\n assert set(model1_state_dict.keys()) == set(model2_state_dict.keys())\n\n for k in model1_state_dict:\n assert torch.equal(model1_state_dict[k], model2_state_dict[k])\n\n trainer2.shutdown()\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_multi_model_matrix(ray_start_2_cpus, num_replicas): # noqa: F811\n def custom_train(config, model, dataloader, criterion, optimizer,\n scheduler):\n if config.get(\"models\", 1) > 1:\n assert len(model) == config[\"models\"], config\n\n if config.get(\"optimizers\", 1) > 1:\n assert len(optimizer) == config[\"optimizers\"], config\n\n if config.get(\"schedulers\", 1) > 1:\n assert len(scheduler) == config[\"schedulers\"], config\n return {\"done\": 1}\n\n def multi_model_creator(config):\n models = []\n for i in range(config.get(\"models\", 1)):\n models += [nn.Linear(1, 1)]\n return models[0] if len(models) == 1 else models\n\n def multi_optimizer_creator(models, config):\n optimizers = []\n main_model = models[0] if type(models) is list else models\n for i in range(config.get(\"optimizers\", 1)):\n optimizers += [torch.optim.SGD(main_model.parameters(), lr=0.0001)]\n return optimizers[0] if len(optimizers) == 1 else optimizers\n\n def multi_scheduler_creator(optimizer, config):\n schedulers = []\n main_opt = optimizer[0] if type(optimizer) is list else optimizer\n for i in range(config.get(\"schedulers\", 1)):\n schedulers += [\n torch.optim.lr_scheduler.StepLR(\n main_opt, step_size=30, gamma=0.1)\n ]\n return schedulers[0] if len(schedulers) == 1 else schedulers\n\n for model_count in range(1, 3):\n for optimizer_count in range(1, 3):\n for scheduler_count in range(1, 3):\n trainer = PyTorchTrainer(\n multi_model_creator,\n data_creator,\n multi_optimizer_creator,\n loss_creator=nn.MSELoss,\n scheduler_creator=multi_scheduler_creator,\n train_function=custom_train,\n num_replicas=num_replicas,\n config={\n \"models\": model_count,\n \"optimizers\": optimizer_count,\n \"schedulers\": scheduler_count\n })\n trainer.train()\n trainer.shutdown()\n\n\[email protected](\"scheduler_freq\", [\"epoch\", \"batch\"])\ndef test_scheduler_freq(ray_start_2_cpus, scheduler_freq): # noqa: F811\n def custom_train(config, model, dataloader, criterion, optimizer,\n scheduler):\n assert config[SCHEDULER_STEP] == scheduler_freq\n return {\"done\": 1}\n\n def scheduler_creator(optimizer, config):\n return torch.optim.lr_scheduler.StepLR(\n optimizer, step_size=30, gamma=0.1)\n\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n scheduler_creator=scheduler_creator)\n\n for i in range(3):\n trainer.train()[\"train_loss\"]\n trainer.shutdown()\n\n\ndef test_scheduler_validate(ray_start_2_cpus): # noqa: F811\n def custom_train(config, model, dataloader, criterion, optimizer,\n scheduler):\n return {\"done\": 1}\n\n from torch.optim.lr_scheduler import ReduceLROnPlateau\n\n trainer = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n scheduler_creator=lambda optimizer, cfg: ReduceLROnPlateau(optimizer))\n trainer.update_scheduler(0.5)\n trainer.update_scheduler(0.5)\n assert all(\n trainer.apply_all_workers(lambda r: r.schedulers[0].last_epoch == 2))\n trainer.shutdown()\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_tune_train(ray_start_2_cpus, num_replicas): # noqa: F811\n\n config = {\n \"model_creator\": model_creator,\n \"data_creator\": data_creator,\n \"optimizer_creator\": optimizer_creator,\n \"loss_creator\": lambda config: nn.MSELoss(),\n \"num_replicas\": num_replicas,\n \"use_gpu\": False,\n \"batch_size\": 512,\n \"backend\": \"gloo\",\n \"config\": {\n \"lr\": 0.001\n }\n }\n\n analysis = tune.run(\n PyTorchTrainable,\n num_samples=2,\n config=config,\n stop={\"training_iteration\": 2},\n verbose=1)\n\n # checks loss decreasing for every trials\n for path, df in analysis.trial_dataframes.items():\n train_loss1 = df.loc[0, \"train_loss\"]\n train_loss2 = df.loc[1, \"train_loss\"]\n validation_loss1 = df.loc[0, \"validation_loss\"]\n validation_loss2 = df.loc[1, \"validation_loss\"]\n\n assert train_loss2 <= train_loss1\n assert validation_loss2 <= validation_loss1\n\n\[email protected](\"num_replicas\", [1, 2]\n if dist.is_available() else [1])\ndef test_save_and_restore(ray_start_2_cpus, num_replicas): # noqa: F811\n trainer1 = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n trainer1.train()\n\n filename = os.path.join(tempfile.mkdtemp(), \"checkpoint\")\n trainer1.save(filename)\n\n model1 = trainer1.get_model()\n\n trainer1.shutdown()\n\n trainer2 = PyTorchTrainer(\n model_creator,\n data_creator,\n optimizer_creator,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=num_replicas)\n trainer2.restore(filename)\n\n os.remove(filename)\n\n model2 = trainer2.get_model()\n\n model1_state_dict = model1.state_dict()\n model2_state_dict = model2.state_dict()\n\n assert set(model1_state_dict.keys()) == set(model2_state_dict.keys())\n\n for k in model1_state_dict:\n assert torch.equal(model1_state_dict[k], model2_state_dict[k])\n\n\ndef test_fail_with_recover(ray_start_2_cpus): # noqa: F811\n if not dist.is_available():\n return\n\n def single_loader(config):\n return LinearDataset(2, 5, size=1000000)\n\n def step_with_fail(self):\n worker_stats = [w.step.remote() for w in self.workers]\n if self._num_failures < 3:\n time.sleep(1) # Make the batch will fail correctly.\n self.workers[0].__ray_kill__()\n success = check_for_failure(worker_stats)\n return success, worker_stats\n\n with patch.object(PyTorchTrainer, \"_train_step\", step_with_fail):\n trainer1 = PyTorchTrainer(\n model_creator,\n single_loader,\n optimizer_creator,\n batch_size=100000,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=2)\n\n with pytest.raises(RuntimeError):\n trainer1.train(max_retries=1)\n\n\ndef test_resize(ray_start_2_cpus): # noqa: F811\n if not dist.is_available():\n return\n\n def single_loader(config):\n return LinearDataset(2, 5, size=1000000)\n\n def step_with_fail(self):\n worker_stats = [w.step.remote() for w in self.workers]\n if self._num_failures < 1:\n time.sleep(1) # Make the batch will fail correctly.\n self.workers[0].__ray_kill__()\n success = check_for_failure(worker_stats)\n return success, worker_stats\n\n with patch.object(PyTorchTrainer, \"_train_step\", step_with_fail):\n trainer1 = PyTorchTrainer(\n model_creator,\n single_loader,\n optimizer_creator,\n batch_size=100000,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=2)\n\n @ray.remote\n def try_test():\n import time\n time.sleep(100)\n\n try_test.remote()\n trainer1.train(max_retries=1)\n assert len(trainer1.workers) == 1\n\n\ndef test_fail_twice(ray_start_2_cpus): # noqa: F811\n if not dist.is_available():\n return\n\n def single_loader(config):\n return LinearDataset(2, 5, size=1000000)\n\n def step_with_fail(self):\n worker_stats = [w.step.remote() for w in self.workers]\n if self._num_failures < 2:\n time.sleep(1)\n self.workers[0].__ray_kill__()\n success = check_for_failure(worker_stats)\n return success, worker_stats\n\n with patch.object(PyTorchTrainer, \"_train_step\", step_with_fail):\n trainer1 = PyTorchTrainer(\n model_creator,\n single_loader,\n optimizer_creator,\n batch_size=100000,\n loss_creator=lambda config: nn.MSELoss(),\n num_replicas=2)\n\n trainer1.train(max_retries=2)\n" ]

[ [ "torch.optim.lr_scheduler.ReduceLROnPlateau", "torch.equal", "torch.nn.Linear", "torch.distributed.is_available", "torch.nn.MSELoss", "torch.optim.lr_scheduler.StepLR" ] ]

joep-source/minecraft_game

[ "1d2e01f18e029f547cd84913b93eca80254a5c31" ]

[ "play.py" ]

[ "import logging\nimport random\nimport sys\nfrom enum import Enum\nfrom functools import lru_cache\nfrom os import path\nfrom typing import List, Tuple, Union\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom ursina.camera import instance as camera\nfrom ursina.color import color, gray, light_gray\nfrom ursina.entity import Entity\nfrom ursina.models.procedural.grid import Grid\nfrom ursina.mouse import instance as mouse\nfrom ursina.prefabs.button import Button\nfrom ursina.prefabs.first_person_controller import FirstPersonController\nfrom ursina.prefabs.health_bar import HealthBar\nfrom ursina.prefabs.sky import Sky\nfrom ursina.scene import instance as scene\nfrom ursina.texture_importer import load_texture\nfrom ursina.ursinastuff import destroy\nfrom ursina.window import instance as window\n\nimport conf\nfrom block import Biomes\nfrom generate_world import (\n NOISE_HEAT,\n NOISE_HEIGHT_ISLAND,\n Map2D,\n combine_maps,\n convert_to_blocks_map,\n create_circular_map_mask,\n generate_noise_map,\n random_seed,\n world_map_colors,\n)\nfrom main_menu import MainMenuUrsina\nfrom utils import Z_2D, X, Y, Z, points_in_2dcircle, pos_to_xyz, setup_logger, timeit\n\n# from ursina import *\n\n\nlogger = logging.getLogger(conf.LOGGER_NAME)\n\n\nclass GameState(Enum):\n MAIN_MENU = 0\n STARTING = 1\n PLAYING = 2\n # PAUSED = 3\n\n\nclass Player(FirstPersonController):\n position: List\n position_previous: List\n\n def __init__(self, position_start, speed, enable_fly=False):\n super().__init__()\n self.enable_fly = enable_fly\n self.set_fly(on=False)\n self.speed = speed\n position_start[Y] += 3 # Let player fall on the map from sky\n self.position = self.position_previous = position_start\n logger.info(f\"Player position start {self.position}\")\n\n def delete(self):\n logger.info(\"Delete Player\")\n self.enabled = False\n self.destroy = True\n\n def input(self, key):\n if key == \"space\":\n self.jump()\n self.set_fly(on=False)\n if key == \"i\":\n logger.debug(f\"Player position is {self.position}, {self.speed=}\")\n if self.enable_fly:\n if key == \"e\":\n self.set_fly(on=True)\n self.y += 1\n if key == \"q\" and self.fly:\n self.y -= 1\n\n def has_new_position(self) -> bool:\n pos_cur = pos_to_xyz(self.position)\n pos_old = pos_to_xyz(self.position_previous)\n if (pos_cur[X], pos_cur[Z]) != (pos_old[X], pos_old[Z]):\n logger.info(f\"Player position new {pos_to_xyz(self.position)}\")\n return True\n return False\n\n def set_fly(self, on: bool):\n self.fly = on\n if self.fly:\n self.gravity = 0\n else:\n self.gravity = 1\n\n\n@lru_cache(maxsize=None)\ndef get_texture(biome: Union[str, None]):\n get_file = lambda name: path.join(\"textures\", name)\n if biome == Biomes.SEA:\n return load_texture(get_file(\"sea.png\"))\n elif biome == Biomes.LAKE:\n return load_texture(get_file(\"water.png\"))\n elif biome == Biomes.DESERT:\n return load_texture(get_file(\"sand.png\"))\n elif biome == Biomes.SAVANNA:\n return load_texture(get_file(\"savanna.png\"))\n elif biome == Biomes.PLANE:\n return load_texture(get_file(\"grass.png\"))\n elif biome == Biomes.HILL:\n return load_texture(get_file(\"grass_stone.png\"))\n elif biome == Biomes.MOUNTAIN:\n return load_texture(get_file(\"stone.png\"))\n elif biome == Biomes.MOUNTAIN_SNOW:\n return load_texture(get_file(\"snow.png\"))\n elif biome == None:\n return load_texture(get_file(\"plank.png\"))\n\n\nclass Block(Button):\n destroyable: bool = False\n destroy: bool = False\n create_position: bool = None\n is_lowest: bool = False\n fix_pos: int\n\n # By setting the parent to scene and the model to 'cube' it becomes a 3d button.\n def __init__(\n self,\n position: List[int],\n biome: str,\n is_lowest=True,\n fix_pos=0.5,\n destroyable=False,\n ):\n self.fix_pos = fix_pos\n self.biome = biome\n self.destroyable = destroyable\n position = list(position)\n position[X] += self.fix_pos\n position[Z] += self.fix_pos\n texture = get_texture(self.biome if not self.create_position else None)\n super().__init__(\n parent=scene,\n position=position,\n model=\"cube\",\n texture=texture,\n scale=1,\n color=color(0, 0, random.uniform(0.95, 1)),\n highlight_color=light_gray,\n )\n if self.biome in [Biomes.LAKE, Biomes.SEA]:\n self.collider = None\n self.is_lowest = is_lowest\n\n def delete(self):\n self.destroy = True\n\n def get_map_position(self) -> Tuple[int, int, int]:\n return (\n int(self.position.x - self.fix_pos),\n int(self.position.y),\n int(self.position.z - self.fix_pos),\n )\n\n def input(self, key):\n if self.hovered:\n if key == \"left mouse down\" and self.biome not in [Biomes.LAKE, Biomes.SEA]:\n self.create_position = self.position + mouse.normal\n if key == \"right mouse down\" and self.destroyable:\n self.delete()\n\n\nclass MiniMap:\n map: Entity\n\n def __init__(self, world_map2d, seed, world_size):\n self.world_map2d = world_map2d\n self.seed = seed\n self.world_size = world_size\n self.save_minimap()\n self.map = self.create_minimap()\n\n def delete(self):\n logger.info(\"Delete MiniMap\")\n destroy(self.map)\n\n def create_minimap(self):\n return Entity(\n parent=camera.ui,\n model=\"quad\",\n scale=(0.25, 0.25),\n x=0.75,\n y=0.35,\n texture=self.get_minimap_path(),\n )\n\n @timeit\n def save_minimap(self):\n \"\"\"Save minimap as PNG image\"\"\"\n path = self.get_minimap_path()\n img = np.array(world_map_colors(self.world_map2d))\n plt.imsave(path, img)\n\n def get_minimap_path(self):\n return path.join(\"maps\", f\"seed_{self.seed}.png\")\n\n\nclass World:\n render_size: int\n blocks: List[Block] = list()\n\n def __init__(self, world_map2d: Map2D, world_size: int, position_start, render_size: int):\n logger.info(\"Initialize World\")\n self.world_map2d = world_map2d\n self.world_size = world_size\n self.render_size = render_size\n self.hidden_floor = Entity(\n model=Grid(1, 1),\n rotation_x=90,\n collider=\"box\",\n scale=self.world_size * 2,\n position=(0, -1.9, 0),\n visible=False,\n )\n self.update(position_start, None)\n\n def delete(self):\n logger.info(\"Delete World\")\n for block in self.blocks:\n block.delete()\n self.blocks = list()\n\n def update(self, player_position_new, player_position_old):\n points_wanted_2d = points_in_2dcircle(\n radius=self.render_size,\n x_offset=int(player_position_new[X]),\n y_offset=int(player_position_new[Z]),\n )\n points_current_2d = set()\n if player_position_old:\n points_current_2d = points_in_2dcircle(\n radius=self.render_size,\n x_offset=int(player_position_old[X]),\n y_offset=int(player_position_old[Z]),\n )\n\n points_del_2d = points_current_2d.difference(points_wanted_2d)\n for block in reversed(self.blocks):\n x, _, z = block.get_map_position()\n if any(x == point[X] and z == point[Z_2D] for point in points_del_2d):\n self.blocks.remove(block)\n destroy(block)\n\n points_add_2d = points_wanted_2d.difference(points_current_2d)\n for point in points_add_2d:\n self.render_block(position=[point[X], 0, point[Z_2D]])\n\n self.fill_vertical()\n logger.debug(f\"Total blocks {len(self.blocks)}\")\n\n def render_block(self, position):\n x, y, z = pos_to_xyz(position)\n if all([0 <= pos < self.world_size for pos in (x, z)]):\n biome = self.world_map2d[x][z].biome\n y = self.world_map2d[x][z].world_height\n if biome in [Biomes.LAKE, Biomes.SEA]:\n y -= 0.3\n self.blocks.append(Block(position=(x, y, z), biome=biome))\n\n def fill_vertical(self):\n _start_blocks_count = len(self.blocks)\n self.blocks.sort(key=lambda b: b.position.y, reverse=True)\n for block in self.blocks:\n x = int(block.position.x)\n y = int(block.position.y)\n z = int(block.position.z)\n if not block.is_lowest:\n continue\n for x_diff, z_diff in [[1, 0], [-1, 0], [0, 1], [0, -1]]:\n try:\n block_around = self.world_map2d[x + x_diff][z + z_diff]\n except IndexError:\n continue\n if y - block_around.world_height < 2: # Skip high difference < 2\n continue\n self.blocks.append(Block(position=(x, y - 1, z), biome=block_around.biome))\n block.is_lowest = False\n break\n logger.debug(f\"Fill {len(self.blocks) - _start_blocks_count} blocks\")\n\n def click_handler(self):\n for block in reversed(self.blocks):\n if block.destroy:\n self.blocks.remove(block)\n destroy(block)\n elif block.create_position:\n new_block = Block(\n position=block.create_position,\n biome=None,\n is_lowest=False,\n fix_pos=0,\n destroyable=True,\n )\n self.blocks.append(new_block)\n block.create_position = None\n\n\nclass UrsinaMC(MainMenuUrsina):\n world_map2d: Map2D = None\n world = None\n player = None\n minimap = None\n game_background = None\n loading_step: int = 0\n\n def __init__(self):\n super().__init__()\n self.game_state = GameState.MAIN_MENU\n\n def start_game(self, **kwargs):\n self.game_state = GameState.STARTING\n logger.info(\"Game starting\")\n self.seed = kwargs.get(\"seed\", random_seed())\n self.world_size = kwargs.get(\"world_size\", conf.WORLD_SIZE)\n self.world_shape = (self.world_size, self.world_size)\n self.speed = kwargs.get(\"player_speed\", conf.PLAYER_SPEED)\n self.render_size = kwargs.get(\"render_size\", conf.BLOCKS_RENDER_DISTANCE)\n print(f\"Settings: {self.seed=}, {self.world_size=}, {self.speed=}, {self.render_size=}\")\n\n def load_game_sequentially(self):\n if self.loading_step == 0:\n self.game_background = Sky()\n self.loading_bar = HealthBar(\n max_value=100,\n value=1,\n position=(-0.5, -0.35, -2),\n scale_x=1,\n animation_duration=0,\n bar_color=gray,\n )\n elif self.loading_step == 10:\n # Generate map 1/3\n heigth_map = generate_noise_map(self.world_shape, self.seed, **NOISE_HEIGHT_ISLAND)\n circulair_map = create_circular_map_mask(self.world_size)\n self._heigth_map_island = combine_maps(heigth_map, circulair_map)\n elif self.loading_step == 20:\n # Generate map 2/3\n self._heat_map = generate_noise_map(self.world_shape, self.seed, **NOISE_HEAT)\n elif self.loading_step == 30:\n # Generate map 3/3\n self.world_map2d = convert_to_blocks_map(self._heigth_map_island, self._heat_map)\n elif self.loading_step == 40:\n self.start_position = self.random_start_position(world_size=self.world_size)\n self.world = World(\n self.world_map2d, self.world_size, self.start_position, self.render_size\n )\n elif self.loading_step == 50:\n self.minimap = MiniMap(self.world_map2d, self.seed, self.world_size)\n self.minimap.map.visible = False\n elif self.loading_step == 90:\n destroy(self.loading_bar)\n self.loading_bar = None\n self.minimap.map.visible = True\n self.player = Player(\n position_start=self.start_position, speed=self.speed, enable_fly=True\n )\n super().start_game()\n self.game_state = GameState.PLAYING\n logger.info(\"Game playing\")\n return\n self.loading_bar.value = self.loading_step\n self.loading_step += 2\n\n def quit_game(self):\n if self.game_state == GameState.MAIN_MENU:\n logger.info(\"Exit game\")\n sys.exit()\n logger.info(\"Quiting game\")\n self.reset_game()\n self.game_state = GameState.MAIN_MENU\n super().quit_game()\n\n def reset_game(self):\n self.world_map2d = None\n self.world.delete()\n self.world = None\n self.player.delete()\n self.player = None\n self.minimap.delete()\n self.minimap = None\n destroy(self.game_background)\n self.game_background = None\n self.loading_step = 0\n\n @timeit\n def random_start_position(self, world_size: int):\n while True:\n x = random.randint(1, world_size - 1)\n z = random.randint(1, world_size - 1)\n biome_block = self.world_map2d[x][z]\n position = [x + 0.5, biome_block.world_height, z + 0.5]\n logger.debug(f\"Random position {position=}\")\n if biome_block.biome not in [Biomes.SEA, Biomes.LAKE]:\n return position\n\n def input(self, key):\n if key == \"escape\":\n self.quit_game()\n super().input(key)\n\n def _update(self, task):\n if self.game_state == GameState.STARTING:\n self.load_game_sequentially()\n elif self.game_state == GameState.PLAYING:\n if self.player.has_new_position():\n self.world.update(self.player.position, self.player.position_previous)\n self.player.position_previous = self.player.position\n self.world.click_handler()\n return super()._update(task)\n\n\nif __name__ == \"__main__\":\n setup_logger(logger=logger)\n app = UrsinaMC()\n\n window.title = \"Mincraft Ursina\"\n window.borderless = True\n window.fullscreen = False\n window.exit_button.visible = False\n window.fps_counter.enabled = True\n\n app.run()\n" ]

[ [ "matplotlib.pyplot.imsave" ] ]

cltl/SDG-tracker

[ "f8730adbf35b01864033cc82333972019d76077a" ]

[ "classify_only/utils.py" ]

[ "import os\r\nimport random\r\nimport glob\r\nimport json\r\nimport nltk\r\nimport re\r\nimport numpy as np\r\nimport pandas as pd\r\n\r\nfrom sentence_transformers import SentenceTransformer\r\n\r\nfrom sklearn import svm\r\nfrom sklearn.svm import LinearSVC\r\nfrom sklearn.model_selection import train_test_split\r\nfrom sklearn.model_selection import cross_val_score\r\n\r\n\r\ndef BERT_encode_sentences(texts, mod=0):\r\n '''\r\n takes a list of texts and name of model as input (default model = Bert_large)\r\n returns a list of concatenated BERT embeddings and a list of mean (averaged)\r\n BERT embeddings for input as X in a classifier\r\n\r\n '''\r\n if mod == 0:\r\n model = SentenceTransformer('roberta-large-nli-mean-tokens')\r\n else:\r\n model = SentenceTransformer('bert-large-nli-mean-tokens')\r\n\r\n embedded_texts = []\r\n for text in texts:\r\n sentences = nltk.sent_tokenize(text)\r\n if len(sentences) >= 6:\r\n sentence_embeddings = model.encode(sentences[:6])\r\n else:\r\n for n in range(6-len(sentences)):\r\n sentences.append(sentences[0])\r\n sentence_embeddings = model.encode(sentences[:6])\r\n embedded_texts.append(sentence_embeddings)\r\n\r\n concatenated_X = []\r\n mean_X = []\r\n\r\n for six_embeds in embedded_texts:\r\n new = np.concatenate(six_embeds)\r\n concatenated_X.append(new)\r\n mean_embeds_per_text = np.mean(six_embeds, axis=0)\r\n mean_X.append(mean_embeds_per_text)\r\n\r\n return concatenated_X, mean_X\r\n\r\n\r\ndef prep_baseline(texts):\r\n '''\r\n takes a list of texts and creates a Bag of Words ready model with\r\n lower case characters and punctuation/ symbols removed\r\n '''\r\n\r\n # cleaning the texts for lower case words only\r\n BOW_texts_list = []\r\n\r\n for text in texts:\r\n sentences = nltk.sent_tokenize(text)\r\n\r\n new_text = []\r\n if len(sentences) >= 6:\r\n for sent in sentences[:6]:\r\n # corpus.append(sent)\r\n sent = sent.lower()\r\n sent = re.sub(r'\\W', ' ', sent)\r\n sent = re.sub(r'\\s+', ' ', sent)\r\n new_text.append(sent)\r\n # processed_corpus.append(sent)\r\n\r\n else:\r\n for sent in sentences:\r\n # corpus.append(sent)\r\n sent = sent.lower()\r\n sent = re.sub(r'\\W', ' ', sent)\r\n sent = re.sub(r'\\s+', ' ', sent)\r\n new_text.append(sent)\r\n # processed_corpus.append(sent)\r\n BOW_texts_list.append(new_text)\r\n\r\n # each text is a single string after this\r\n concatenated_sents = [''.join(item)for item in BOW_texts_list]\r\n return concatenated_sents\r\n" ]

[ [ "numpy.concatenate", "numpy.mean" ] ]

TNO/techruption-poc-odessey-hackathon-2019

[ "a7915244f4826fc9954c6b7e87ae10a8c7dbf2a3" ]

[ "data_generation/records.py" ]

[ "# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Fri Apr 12 19:11:47 2019\r\n\r\n@author: bosmanjw\r\n\"\"\"\r\n\r\nimport numpy as np\r\nimport pandas as pd\r\n# BN id 201.5 pp 52 https://zoek.officielebekendmakingen.nl/blg-784527.pdf\r\n#https://www.prorail.nl/sites/default/files/phs-folder_gevaarlijke_stoffen_web.pdf\r\n\r\ncategories = np.array([\"A\", \"B2\", \"B3\", \"C3\", \"D3\", \"D4\"])\r\nintensities = np.array([32680 ,1365 ,18120 ,2560 ,560 ,101 ,128550 ,10923 ,11820 ,1532 ,5100 ,152])\r\nintensities = np.reshape(intensities,(6,2)).T[1]\r\nprobs = intensities / intensities.sum()\r\ntotalIntensity = intensities.sum()\r\nintensities = pd.DataFrame(data=np.atleast_2d(intensities),columns=categories)\r\nsubstances={\"A\":[\"LPG\", \"propylene\", \"butadiene\", \"ethylene oxide\"],\r\n \"B2\":[\"ammonia\"],\r\n \"B3\":[\"chlorine\"],\r\n \"C3\":[\"gasoline\", \"natural-gas condensate\"],\r\n \"D3\":[\"acrylonitrile\"],\r\n \"D4\":[\"hydrogen fluoride\", \"bromide\"]\r\n }\r\nweights = np.array(\r\n [intensities[cat][0]/len(substanceList) \r\n for cat, substanceList in substances.items() \r\n for substance in substanceList])\r\nprobs = weights / weights.sum()\r\n#inhoud 14000-27000 liter (bron wiki)\r\n\r\ndef generate_container(containerID, minVolume=14, maxVolume=27):\r\n contentsList = []\r\n intensityList = []\r\n for cat, substanceList in substances.items():\r\n intensity = intensities[cat][0]/len(substanceList)\r\n for name in substanceList: \r\n record = {\"Substance category\": cat, \"Name\": name, \"Volume\": \"0\", \"Unit\": \"litre\"}\r\n contentsList.append(record)\r\n intensityList.append(intensity)\r\n intensityList = np.array(intensityList)\r\n probs = intensityList / intensityList.sum()\r\n index = np.random.choice(range(len(probs)),p=probs)\r\n vol = np.random.randint(minVolume,maxVolume+1) * 1000\r\n vol = \"{0:d}\".format(vol)\r\n contentsList[index][\"Volume\"] = vol\r\n return {\"Container ID\": containerID, \"Content\": contentsList}\r\n\r\ndef generate_containers(number, maxIdIncrement = 1):\r\n containerList = []\r\n currId = 0\r\n for i in range(number):\r\n # currId += np.random.randint(1, maxIdIncrement)\r\n # containerId = \"{0:d}\".format(currId)\r\n containerId = str(i)\r\n nextContainer = generate_container(containerId)\r\n containerList.append(nextContainer)\r\n return containerList\r\n\r\ndef generate_ships(number, maxIncrement = 10, minContainers=100, maxContainers=1000):\r\n shipList = []\r\n currId = 0\r\n counts = np.random.randint(minContainers, maxContainers+1, size=number)\r\n counts = np.atleast_1d(counts)\r\n allContainersList = generate_containers(counts.sum())\r\n containerIds = [container[\"Container ID\"] for container in allContainersList]\r\n np.random.permutation(containerIds)\r\n containerLists = np.split(containerIds, counts.cumsum()[:-1])\r\n \r\n for containerList in containerLists:\r\n currId += np.random.randint(1, maxIncrement)\r\n shipId = \"{0:d}\".format(currId)\r\n record = {\"Ship ID\": shipId , \"Container list\": containerList.tolist()}\r\n shipList.append(record)\r\n return shipList, allContainersList\r\n\r\ndef find_ship(shipList, containerId):\r\n return [ship for ship in shipList if containerId in ship[\"Container list\"]]\r\n\r\nif __name__ == \"__main__\":\r\n generate_containers(1000)\r\n \r\n\r\n" ]

[ [ "numpy.reshape", "numpy.atleast_1d", "numpy.atleast_2d", "numpy.random.permutation", "numpy.array", "numpy.random.randint" ] ]

SamsungLabs/ASAM

[ "f156a680171db16d551c0d85cba2514fa3bff6a2" ]

[ "example_cifar.py" ]

[ "import argparse\nimport torch\nimport torchvision\nfrom torch.utils.data import DataLoader\nfrom torchvision import transforms\nfrom torchvision.datasets import CIFAR10, CIFAR100\nfrom timm.loss import LabelSmoothingCrossEntropy\nfrom homura.vision.models.cifar_resnet import wrn28_2, wrn28_10, resnet20, resnet56, resnext29_32x4d\nfrom asam import ASAM, SAM\n\ndef load_cifar(data_loader, batch_size=256, num_workers=2):\n if data_loader == CIFAR10:\n mean = (0.4914, 0.4822, 0.4465)\n std = (0.2023, 0.1994, 0.2010)\n else:\n mean = (0.5071, 0.4867, 0.4408)\n std = (0.2675, 0.2565, 0.2761)\n\n # Transforms\n train_transform = transforms.Compose([transforms.RandomCrop(32, padding=4),\n transforms.RandomHorizontalFlip(),\n transforms.ToTensor(),\n transforms.Normalize(mean, std)])\n\n test_transform = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize(mean, std)\n ])\n \n # DataLoader\n train_set = data_loader(root='./data', train=True, download=True, transform=train_transform)\n test_set = data_loader(root='./data', train=False, download=True, transform=test_transform)\n train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True, \n num_workers=num_workers)\n test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False, \n num_workers=num_workers)\n return train_loader, test_loader\n \n\ndef train(args): \n # Data Loader\n train_loader, test_loader = load_cifar(eval(args.dataset), args.batch_size)\n num_classes = 10 if args.dataset == 'CIFAR10' else 100\n\n # Model\n model = eval(args.model)(num_classes=num_classes).cuda()\n\n # Minimizer\n optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, \n momentum=args.momentum, weight_decay=args.weight_decay)\n minimizer = eval(args.minimizer)(optimizer, model, rho=args.rho, eta=args.eta)\n \n # Learning Rate Scheduler\n scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(minimizer.optimizer, args.epochs)\n\n # Loss Functions\n if args.smoothing:\n criterion = LabelSmoothingCrossEntropy(smoothing=args.smoothing)\n else:\n criterion = torch.nn.CrossEntropyLoss()\n\n best_accuracy = 0.\n for epoch in range(args.epochs):\n # Train\n model.train()\n loss = 0.\n accuracy = 0.\n cnt = 0.\n for inputs, targets in train_loader:\n inputs = inputs.cuda()\n targets = targets.cuda()\n\n # Ascent Step\n predictions = model(inputs)\n batch_loss = criterion(predictions, targets)\n batch_loss.mean().backward()\n minimizer.ascent_step()\n\n # Descent Step\n criterion(model(inputs), targets).mean().backward()\n minimizer.descent_step()\n\n with torch.no_grad():\n loss += batch_loss.sum().item()\n accuracy += (torch.argmax(predictions, 1) == targets).sum().item()\n cnt += len(targets)\n loss /= cnt\n accuracy *= 100. / cnt\n print(f\"Epoch: {epoch}, Train accuracy: {accuracy:6.2f} %, Train loss: {loss:8.5f}\")\n scheduler.step()\n\n # Test\n model.eval()\n loss = 0.\n accuracy = 0.\n cnt = 0.\n with torch.no_grad():\n for inputs, targets in test_loader:\n inputs = inputs.cuda()\n targets = targets.cuda()\n predictions = model(inputs)\n loss += criterion(predictions, targets).sum().item()\n accuracy += (torch.argmax(predictions, 1) == targets).sum().item()\n cnt += len(targets)\n loss /= cnt\n accuracy *= 100. / cnt\n if best_accuracy < accuracy:\n best_accuracy = accuracy\n print(f\"Epoch: {epoch}, Test accuracy: {accuracy:6.2f} %, Test loss: {loss:8.5f}\")\n print(f\"Best test accuracy: {best_accuracy}\")\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--dataset\", default='CIFAR10', type=str, help=\"CIFAR10 or CIFAR100.\")\n parser.add_argument(\"--model\", default='wrn28_10', type=str, help=\"Name of model architecure\")\n parser.add_argument(\"--minimizer\", default='ASAM', type=str, help=\"ASAM or SAM.\")\n parser.add_argument(\"--lr\", default=0.1, type=float, help=\"Initial learning rate.\")\n parser.add_argument(\"--momentum\", default=0.9, type=float, help=\"Momentum.\")\n parser.add_argument(\"--weight_decay\", default=5e-4, type=float, help=\"Weight decay factor.\")\n parser.add_argument(\"--batch_size\", default=128, type=int, help=\"Batch size\")\n parser.add_argument(\"--epochs\", default=200, type=int, help=\"Number of epochs.\")\n parser.add_argument(\"--smoothing\", default=0.1, type=float, help=\"Label smoothing.\")\n parser.add_argument(\"--rho\", default=0.5, type=float, help=\"Rho for ASAM.\")\n parser.add_argument(\"--eta\", default=0.0, type=float, help=\"Eta for ASAM.\")\n args = parser.parse_args()\n assert args.dataset in ['CIFAR10', 'CIFAR100'], \\\n f\"Invalid data type. Please select CIFAR10 or CIFAR100\"\n assert args.minimizer in ['ASAM', 'SAM'], \\\n f\"Invalid minimizer type. Please select ASAM or SAM\"\n train(args)\n" ]

[ [ "torch.nn.CrossEntropyLoss", "torch.optim.lr_scheduler.CosineAnnealingLR", "torch.utils.data.DataLoader", "torch.no_grad", "torch.argmax" ] ]

gibsramen/umap

[ "fbd2f95f6deec70a4105091a4eaeab0e6ccbaf01" ]

[ "umap/tests/test_umap_trustworthiness.py" ]

[ "from umap import UMAP\nfrom sklearn.datasets import make_blobs\nfrom nose.tools import assert_greater_equal\nimport numpy as np\ntry:\n # works for sklearn>=0.22\n from sklearn.manifold import trustworthiness\nexcept ImportError:\n # this is to comply with requirements (scikit-learn>=0.20)\n # More recent versions of sklearn have exposed trustworthiness\n # in top level module API\n # see: https://github.com/scikit-learn/scikit-learn/pull/15337\n from sklearn.manifold.t_sne import trustworthiness\n\n# ===================================================\n# UMAP Trustworthiness Test cases\n# ===================================================\n\n\ndef test_umap_sparse_trustworthiness(sparse_test_data):\n embedding = UMAP(n_neighbors=10).fit_transform(sparse_test_data[:100])\n trust = trustworthiness(sparse_test_data[:100].toarray(), embedding, 10)\n assert_greater_equal(\n trust,\n 0.89,\n \"Insufficiently trustworthy embedding for\"\n \"sparse test dataset: {}\".format(trust),\n )\n\n\ndef test_umap_trustworthiness_fast_approx(nn_data):\n data = nn_data[:50]\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n random_state=42,\n n_epochs=100,\n force_approximation_algorithm=True,\n ).fit_transform(data)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.75,\n \"Insufficiently trustworthy embedding for\" \"nn dataset: {}\".format(trust),\n )\n\n\ndef test_umap_trustworthiness_random_init(nn_data):\n data = nn_data[:50]\n embedding = UMAP(\n n_neighbors=10, min_dist=0.01, random_state=42, init=\"random\"\n ).fit_transform(data)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.75,\n \"Insufficiently trustworthy embedding for\" \"nn dataset: {}\".format(trust),\n )\n\n\ndef test_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n embedding = UMAP(n_neighbors=10, min_dist=0.01, random_state=42).fit_transform(\n data, labels\n )\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.97,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_semisupervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n labels[10:30] = -1\n embedding = UMAP(n_neighbors=10, min_dist=0.01, random_state=42).fit_transform(\n data, labels\n )\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.97,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"l1\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_string_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n labels = np.array([\"this\", \"that\", \"other\"])[labels]\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"string\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_discrete_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"ordinal\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n\n\ndef test_count_metric_supervised_umap_trustworthiness():\n data, labels = make_blobs(50, cluster_std=0.5, random_state=42)\n labels = (labels ** 2) + 2 * labels\n embedding = UMAP(\n n_neighbors=10,\n min_dist=0.01,\n target_metric=\"count\",\n target_weight=0.8,\n n_epochs=100,\n random_state=42,\n ).fit_transform(data, labels)\n trust = trustworthiness(data, embedding, 10)\n assert_greater_equal(\n trust,\n 0.95,\n \"Insufficiently trustworthy embedding for\" \"blobs dataset: {}\".format(trust),\n )\n" ]

[ [ "numpy.array", "sklearn.manifold.t_sne.trustworthiness", "sklearn.datasets.make_blobs" ] ]

Islamsed/ai-assisted-annotation-client

[ "313da5177eba7ca94f8d76811c23e462726c978f" ]

[ "py-client/client_api.py" ]

[ "# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permitted provided that the following conditions\n# are met:\n# * Redistributions of source code must retain the above copyright\n# notice, this list of conditions and the following disclaimer.\n# * Redistributions in binary form must reproduce the above copyright\n# notice, this list of conditions and the following disclaimer in the\n# documentation and/or other materials provided with the distribution.\n# * Neither the name of NVIDIA CORPORATION nor the names of its\n# contributors may be used to endorse or promote products derived\n# from this software without specific prior written permission.\n#\n# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY\n# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY\n# OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport cgi\nimport ssl\n\ntry:\n # Python3\n # noinspection PyUnresolvedReferences\n import http.client as httplib\n # noinspection PyUnresolvedReferences,PyCompatibility\n from urllib.parse import quote_plus\n # noinspection PyUnresolvedReferences,PyCompatibility\n from urllib.parse import urlparse\nexcept ImportError as e:\n # Python2\n # noinspection PyUnresolvedReferences\n import httplib\n # noinspection PyUnresolvedReferences\n from urllib import quote_plus\n # noinspection PyUnresolvedReferences\n from urlparse import urlparse\n\nimport json\nimport logging\nimport mimetypes\nimport os\nimport sys\nimport tempfile\n\nimport SimpleITK\nimport numpy as np\n\n\nclass AIAAClient:\n \"\"\"\n The AIAAClient object is constructed with the server information\n\n :param server_url: AIAA Server URL (example: 'http://0.0.0.0:5000')\n \"\"\"\n\n def __init__(self, server_url='http://0.0.0.0:5000'):\n self._server_url = server_url\n\n def get_server_url(self):\n \"\"\"\n Get AIAA Server URL\n\n :return: returns AIAA Server URL\n \"\"\"\n return self._server_url\n\n def set_server_url(self, server_url):\n \"\"\"\n Update AIAA Server URL\n\n :param: server_url: valid url for AIAA server (example: 'http://0.0.0.0:5000')\n \"\"\"\n self._server_url = server_url\n\n def create_session(self, image_in, expiry=0):\n \"\"\"\n Create New Session\n\n :param image_in: valid image which will be stored as part of the new session\n :param expiry: expiry in seconds. min(AIAASessionExpiry, expiry) will be selected by AIAA\n :return: returns json containing **session_id** and any other details from server\n\n valid *session_id* from result can be used for future reference\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Create Session Action')\n\n selector = '/session/?expiry=' + str(expiry)\n fields = {}\n files = {'image': image_in}\n\n status, response, _ = AIAAUtils.http_multipart('PUT', self._server_url, selector, fields, files)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def get_session(self, session_id):\n \"\"\"\n Get Session Info\n\n :param session_id: valid session id\n :return: returns json containing session details if session is valid; otherwise None\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Session Details')\n\n if session_id is None:\n return None\n\n selector = '/session/' + AIAAUtils.urllib_quote_plus(session_id)\n status, response = AIAAUtils.http_method('GET', self._server_url, selector)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def close_session(self, session_id):\n \"\"\"\n Close an existing session\n\n :param session_id: valid session id\n :return: returns True if a session is closed, else False\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Session Details')\n\n if session_id is None:\n return False\n\n selector = '/session/' + AIAAUtils.urllib_quote_plus(session_id)\n\n status, response = AIAAUtils.http_method('DELETE', self._server_url, selector)\n logger.debug('Response: {}'.format(response))\n return status is 200\n\n def model(self, model):\n \"\"\"\n Get the model details\n\n :param model: A valid Model Name which exists in AIAA Server\n :return: returns json containing the model details\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Model Details')\n\n selector = '/v1/models'\n if model:\n selector += '?model=' + AIAAUtils.urllib_quote_plus(model)\n\n status, response = AIAAUtils.http_method('GET', self._server_url, selector)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def model_list(self, label=None):\n \"\"\"\n Get the current supported model list\n\n :param label: Filter models which are matching the label\n :return: returns json containing list of models and details\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Fetching Model Details')\n\n selector = '/v1/models'\n if label is not None and len(label) > 0:\n selector += '?label=' + AIAAUtils.urllib_quote_plus(label)\n\n status, response = AIAAUtils.http_method('GET', self._server_url, selector)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n\n logger.debug('Response: {}'.format(response))\n return json.loads(response)\n\n def segmentation(self, model, image_in, image_out, session_id=None):\n \"\"\"\n 2D/3D image segmentation using segmentation method\n\n :param model: model name according to the output of model_list()\n :param image_in: input 2D/3D image file name\n :param image_out: output mask will be stored\n :param session_id: if session id is provided (not None) then *image_in* will be ignored\n :return: returns json containing extreme points for the segmentation mask and other info\n\n Output 2D/3D binary mask will be saved to the specified file; Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Segmentation Action')\n\n selector = '/v1/segmentation?model=' + AIAAUtils.urllib_quote_plus(model)\n if session_id:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': '{}'}\n in_files = {'datapoint': image_in} if not session_id else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n if params is None: # v1 backward compatibility\n points = json.loads(form.get('points'))\n params = {'points': (json.loads(points) if isinstance(points, str) else points)}\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n def dextr3d(self, model, point_set, image_in, image_out, pad=20, roi_size='128x128x128',\n pre_process=True,\n session_id=None):\n \"\"\"\n 3D image annotation using DEXTR3D method\n\n :param model: model name according to the output of model_list()\n :param point_set: point set json containing the extreme points' indices\n :param image_in: input 3D image file name\n :param image_out: output mask will be stored\n :param pad: padding size (default is 20)\n :param roi_size: image resize value (default is 128x128x128)\n :param pre_process: pre-process (crop) input volume at client side for DEXTR3D action\n :param session_id: if *session_id* is not None and *pre_process* is False then *image_in* will be ignored\n\n\n Output 3D binary mask will be saved to the specified file; Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Annotation/Dextr3D Action')\n\n # Pre Process\n if pre_process:\n cropped_file = tempfile.NamedTemporaryFile(suffix='.nii.gz').name\n points, crop = AIAAUtils.image_pre_process(image_in, cropped_file, point_set, pad, roi_size)\n else:\n cropped_file = image_in\n points = point_set\n crop = None\n\n selector = '/v1/dextr3d?model=' + AIAAUtils.urllib_quote_plus(model)\n use_session_input = session_id and pre_process is False\n if use_session_input:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': json.dumps({'points': json.dumps(points)})}\n in_files = {'datapoint': cropped_file} if not use_session_input else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n params = json.loads(params) if isinstance(params, str) else params\n\n # Post Process\n if pre_process:\n os.unlink(cropped_file)\n\n cropped_out_file = tempfile.NamedTemporaryFile(suffix='.nii.gz').name\n AIAAUtils.save_result(files, cropped_out_file)\n AIAAUtils.image_post_processing(cropped_out_file, image_out, crop, image_in)\n\n os.unlink(cropped_out_file)\n else:\n AIAAUtils.save_result(files, image_out)\n return params\n\n def deepgrow(self, model, foreground, background, image_in, image_out, session_id=None):\n \"\"\"\n 2D/3D image annotation using DeepGrow method\n\n :param model: model name according to the output of model_list()\n :param foreground: foreground (+ve) clicks/points\n :param background: background (-ve) clicks/points\n :param image_in: input 2D/3D image file name\n :param image_out: output mask will be stored\n :param session_id: if session id is provided (not None) then *image_in* will be ignored\n\n Output 2D/3D binary mask will be saved to the specified file; Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for DeepGrow Action')\n\n selector = '/v1/deepgrow?model=' + AIAAUtils.urllib_quote_plus(model)\n if session_id:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': json.dumps({'foreground': foreground, 'background': background})}\n in_files = {'datapoint': image_in} if not session_id else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n def inference(self, model, params, image_in, image_out, session_id=None):\n \"\"\"\n Generic Inference for given input image and model\n\n :param model: model name according to the output of model_list()\n :param params: json input consumed by model\n :param image_in: input 2D/3D image file name\n :param image_out: output mask will be stored\n :param session_id: if session id is provided (not None) then *image_in* will be ignored\n :return: returns json produced by the model inference\n\n Output 2D/3D binary mask will be saved to the specified file; JSON results will be returned;\n Throws AIAAException in case of Error\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Inference Action')\n\n selector = '/v1/inference?model=' + AIAAUtils.urllib_quote_plus(model)\n if session_id:\n selector += '&session_id=' + AIAAUtils.urllib_quote_plus(session_id)\n\n in_fields = {'params': params if isinstance(params, str) else json.dumps(params)}\n in_files = {'datapoint': image_in} if not session_id else {}\n\n logger.debug('Using Selector: {}'.format(selector))\n logger.debug('Using Fields: {}'.format(in_fields))\n logger.debug('Using Files: {}'.format(in_files))\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, in_fields, in_files)\n if status == 440:\n raise AIAAException(AIAAError.SESSION_EXPIRED, 'Session Expired')\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params') if files else form\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n def mask2polygon(self, image_in, point_ratio):\n \"\"\"\n 3D binary mask to polygon representation conversion\n\n :param image_in: input 3D binary mask image file name\n :param point_ratio: point ratio controlling how many polygon vertices will be generated\n\n :return: A json containing the indices of all polygon vertices slice by slice.\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for Mask2Polygon Action')\n\n selector = '/v1/mask2polygon'\n params = dict()\n params['more_points'] = point_ratio\n\n fields = {'params': json.dumps(params)}\n files = {'datapoint': image_in}\n\n status, response, _ = AIAAUtils.http_multipart('POST', self._server_url, selector, fields, files)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, response))\n\n response = response.decode('utf-8') if isinstance(response, bytes) else response\n return json.loads(response)\n\n def fixpolygon(self, image_in, image_out, polygons, index, vertex_offset, propagate_neighbor):\n \"\"\"\n 2D/3D polygon update with single point edit\n\n :param image_in: input 2D/3D image file name\n :param image_out: output 2D/3D mask image file name\n :param polygons: list of polygons 2D/3D\n :param index: index of vertex which needs to be updated\n 1) for 2D [polygon_index, vertex_index]\n 2) for 3D [slice_index, polygon_index, vertex_index]\n :param vertex_offset: offset (2D/3D) needs to be added to get the updated vertex in [x,y] format\n :param propagate_neighbor: neighborhood size\n 1) for 2D: single value (polygon_neighborhood_size)\n 2) for 3D: [slice_neighborhood_size, polygon_neighborhood_size]\n :return: A json containing the indices of updated polygon vertices\n\n\n Output binary mask will be saved to the specified name\n \"\"\"\n logger = logging.getLogger(__name__)\n logger.debug('Preparing for FixPolygon Action')\n\n selector = '/v1/fixpolygon'\n\n dimension = len(index)\n\n params = dict()\n params['poly'] = polygons\n params['vertex_offset'] = vertex_offset\n params['dimension'] = dimension\n\n if dimension == 3:\n params['slice_index'] = index[0]\n params['polygon_index'] = index[1]\n params['vertex_index'] = index[2]\n params['propagate_neighbor_3d'] = propagate_neighbor[0]\n params['propagate_neighbor'] = propagate_neighbor[1]\n else:\n params['polygon_index'] = index[0]\n params['vertex_index'] = index[1]\n params['propagate_neighbor'] = propagate_neighbor\n\n fields = {'params': json.dumps(params)}\n files = {'datapoint': image_in}\n\n status, form, files = AIAAUtils.http_multipart('POST', self._server_url, selector, fields, files)\n if status != 200:\n raise AIAAException(AIAAError.SERVER_ERROR, 'Status: {}; Response: {}'.format(status, form))\n\n form = json.loads(form) if isinstance(form, str) else form\n params = form.get('params')\n params = json.loads(params) if isinstance(params, str) else params\n\n AIAAUtils.save_result(files, image_out)\n return params\n\n\nclass AIAAError:\n SESSION_EXPIRED = 1\n RESULT_NOT_FOUND = 2\n SERVER_ERROR = 3\n UNKNOWN = 4\n\n\nclass AIAAException(Exception):\n def __init__(self, error, msg):\n self.error = error\n self.msg = msg\n\n\nclass AIAAUtils:\n def __init__(self):\n pass\n\n @staticmethod\n def resample_image(itk_image, out_size, linear):\n spacing = list(itk_image.GetSpacing())\n size = list(itk_image.GetSize())\n\n out_spacing = []\n for i in range(len(size)):\n out_spacing.append(float(spacing[i]) * float(size[i]) / float(out_size[i]))\n\n resample = SimpleITK.ResampleImageFilter()\n resample.SetOutputSpacing(out_spacing)\n resample.SetSize(out_size)\n resample.SetOutputDirection(itk_image.GetDirection())\n resample.SetOutputOrigin(itk_image.GetOrigin())\n\n if linear:\n resample.SetInterpolator(SimpleITK.sitkLinear)\n else:\n resample.SetInterpolator(SimpleITK.sitkNearestNeighbor)\n return resample.Execute(itk_image)\n\n @staticmethod\n def image_pre_process(input_file, output_file, point_set, pad, roi_size):\n logger = logging.getLogger(__name__)\n logger.debug('Reading Image from: {}'.format(input_file))\n\n itk_image = SimpleITK.ReadImage(input_file)\n spacing = itk_image.GetSpacing()\n image_size = itk_image.GetSize()\n\n target_size = tuple(map(int, roi_size.split('x')))\n points = np.asanyarray(np.array(point_set).astype(int))\n\n logger.debug('Image Size: {}'.format(image_size))\n logger.debug('Image Spacing: {}'.format(spacing))\n logger.debug('Target Size: {}'.format(target_size))\n logger.debug('Input Points: {}'.format(json.dumps(points.tolist())))\n\n index_min = [sys.maxsize, sys.maxsize, sys.maxsize]\n index_max = [0, 0, 0]\n vx_pad = [0, 0, 0]\n for point in points:\n for i in range(3):\n vx_pad[i] = int((pad / spacing[i]) if spacing[i] > 0 else pad)\n index_min[i] = min(max(int(point[i] - vx_pad[i]), 0), int(index_min[i]))\n index_max[i] = max(min(int(point[i] + vx_pad[i]), int(image_size[i] - 1)), int(index_max[i]))\n\n logger.debug('Voxel Padding: {}'.format(vx_pad))\n logger.debug('Min Index: {}'.format(index_min))\n logger.debug('Max Index: {}'.format(index_max))\n\n crop_index = [0, 0, 0]\n crop_size = [0, 0, 0]\n crop = []\n for i in range(3):\n crop_index[i] = index_min[i]\n crop_size[i] = index_max[i] - index_min[i]\n crop.append([crop_index[i], crop_index[i] + crop_size[i]])\n logger.debug('crop_index: {}'.format(crop_index))\n logger.debug('crop_size: {}'.format(crop_size))\n logger.debug('crop: {}'.format(crop))\n\n # get bounding box\n x1 = crop[0][0]\n x2 = crop[0][1]\n y1 = crop[1][0]\n y2 = crop[1][1]\n z1 = crop[2][0]\n z2 = crop[2][1]\n\n # crop\n points[::, 0] = points[::, 0] - x1\n points[::, 1] = points[::, 1] - y1\n points[::, 2] = points[::, 2] - z1\n\n cropped_image = itk_image[x1:x2, y1:y2, z1:z2]\n cropped_size = cropped_image.GetSize()\n logger.debug('Cropped size: {}'.format(cropped_size))\n\n # resize\n out_image = AIAAUtils.resample_image(cropped_image, target_size, True)\n logger.debug('Cropped Image Size: {}'.format(out_image.GetSize()))\n SimpleITK.WriteImage(out_image, output_file, True)\n\n # pointsROI\n ratio = np.divide(np.asanyarray(target_size, dtype=np.float), np.asanyarray(cropped_size, dtype=np.float))\n points[::, 0] = points[::, 0] * ratio[0]\n points[::, 1] = points[::, 1] * ratio[1]\n points[::, 2] = points[::, 2] * ratio[2]\n return points.astype(int).tolist(), crop\n\n @staticmethod\n def image_post_processing(input_file, output_file, crop, orig_file):\n itk_image = SimpleITK.ReadImage(input_file)\n orig_crop_size = [crop[0][1] - crop[0][0], crop[1][1] - crop[1][0], crop[2][1] - crop[2][0]]\n resize_image = AIAAUtils.resample_image(itk_image, orig_crop_size, False)\n\n orig_image = SimpleITK.ReadImage(orig_file)\n orig_size = orig_image.GetSize()\n\n image = SimpleITK.GetArrayFromImage(resize_image)\n result = np.zeros(orig_size[::-1], np.uint8)\n result[crop[2][0]:crop[2][1], crop[1][0]:crop[1][1], crop[0][0]:crop[0][1]] = image\n\n itk_result = SimpleITK.GetImageFromArray(result)\n itk_result.SetDirection(orig_image.GetDirection())\n itk_result.SetSpacing(orig_image.GetSpacing())\n itk_result.SetOrigin(orig_image.GetOrigin())\n\n SimpleITK.WriteImage(itk_result, output_file, True)\n\n @staticmethod\n def http_method(method, server_url, selector):\n logger = logging.getLogger(__name__)\n logger.debug('{} {}{}'.format(method, server_url, selector))\n\n parsed = urlparse(server_url)\n if parsed.scheme == 'https':\n logger.debug('Using HTTPS mode')\n # noinspection PyProtectedMember\n conn = httplib.HTTPSConnection(parsed.hostname, parsed.port, context=ssl._create_unverified_context())\n else:\n conn = httplib.HTTPConnection(parsed.hostname, parsed.port)\n\n conn.request(method, selector)\n response = conn.getresponse()\n\n logger.debug('HTTP Response Code: {}'.format(response.status))\n logger.debug('HTTP Response Message: {}'.format(response.reason))\n logger.debug('HTTP Response Headers: {}'.format(response.getheaders()))\n return response.status, response.read()\n\n @staticmethod\n def http_multipart(method, server_url, selector, fields, files):\n logger = logging.getLogger(__name__)\n logger.debug('{} {}{}'.format(method, server_url, selector))\n\n parsed = urlparse(server_url)\n if parsed.scheme == 'https':\n logger.debug('Using HTTPS mode')\n # noinspection PyProtectedMember\n conn = httplib.HTTPSConnection(parsed.hostname, parsed.port, context=ssl._create_unverified_context())\n else:\n conn = httplib.HTTPConnection(parsed.hostname, parsed.port)\n\n content_type, body = AIAAUtils.encode_multipart_formdata(fields, files)\n headers = {'content-type': content_type, 'content-length': str(len(body))}\n conn.request(method, selector, body, headers)\n\n response = conn.getresponse()\n logger.debug('HTTP Response Code: {}'.format(response.status))\n logger.debug('HTTP Response Message: {}'.format(response.reason))\n logger.debug('HTTP Response Headers: {}'.format(response.getheaders()))\n\n response_content_type = response.getheader('content-type', content_type)\n logger.debug('HTTP Response Content-Type: {}'.format(response_content_type))\n\n if 'multipart' in response_content_type:\n if response.status == 200:\n form, files = AIAAUtils.parse_multipart(response.fp if response.fp else response, response.msg)\n logger.debug('Response FORM: {}'.format(form))\n logger.debug('Response FILES: {}'.format(files.keys()))\n return response.status, form, files\n else:\n return response.status, response.read(), None\n\n logger.debug('Reading status/content from simple response!')\n return response.status, response.read(), None\n\n @staticmethod\n def save_result(files, result_file):\n logger = logging.getLogger(__name__)\n\n if result_file is None:\n return\n\n if len(files) == 0:\n raise AIAAException(AIAAError.RESULT_NOT_FOUND, \"No result files found in server response!\")\n\n for name in files:\n data = files[name]\n logger.debug('Saving {} to {}; Size: {}'.format(name, result_file, len(data)))\n\n dir_path = os.path.dirname(os.path.realpath(result_file))\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)\n\n with open(result_file, \"wb\") as f:\n if isinstance(data, bytes):\n f.write(data)\n else:\n f.write(data.encode('utf-8'))\n break\n\n @staticmethod\n def encode_multipart_formdata(fields, files):\n limit = '----------lImIt_of_THE_fIle_eW_$'\n lines = []\n for (key, value) in fields.items():\n lines.append('--' + limit)\n lines.append('Content-Disposition: form-data; name=\"%s\"' % key)\n lines.append('')\n lines.append(value)\n for (key, filename) in files.items():\n lines.append('--' + limit)\n lines.append('Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"' % (key, filename))\n lines.append('Content-Type: %s' % AIAAUtils.get_content_type(filename))\n lines.append('')\n with open(filename, mode='rb') as f:\n data = f.read()\n lines.append(data)\n lines.append('--' + limit + '--')\n lines.append('')\n\n body = bytearray()\n for line in lines:\n body.extend(line if isinstance(line, bytes) else line.encode('utf-8'))\n body.extend(b'\\r\\n')\n\n content_type = 'multipart/form-data; boundary=%s' % limit\n return content_type, body\n\n @staticmethod\n def get_content_type(filename):\n return mimetypes.guess_type(filename)[0] or 'application/octet-stream'\n\n @staticmethod\n def parse_multipart(fp, headers):\n logger = logging.getLogger(__name__)\n fs = cgi.FieldStorage(\n fp=fp,\n environ={'REQUEST_METHOD': 'POST'},\n headers=headers,\n keep_blank_values=True\n )\n form = {}\n files = {}\n if hasattr(fs, 'list') and isinstance(fs.list, list):\n for f in fs.list:\n logger.debug('FILE-NAME: {}; NAME: {}; SIZE: {}'.format(f.filename, f.name, len(f.value)))\n if f.filename:\n files[f.filename] = f.value\n else:\n form[f.name] = f.value\n return form, files\n\n # noinspection PyUnresolvedReferences\n @staticmethod\n def urllib_quote_plus(s):\n return quote_plus(s)\n" ]

[ [ "numpy.array", "numpy.asanyarray", "numpy.zeros" ] ]

JeongsooHa/handRNN

[ "e289371f030858823cf4f002781fcf3fe5d7decf" ]

[ "online.py" ]

[ "\"\"\"\nRun the online classification system.\n\nCapture an image, classify, do it again.\n\"\"\"\nimport time\nfrom picamera import PiCamera\nfrom picamera.array import PiRGBArray\nimport tensorflow as tf\n\ndef get_labels():\n \"\"\"Get a list of labels so we can see if it's an ad or not.\"\"\"\n with open('../inception/retrained_labels.txt', 'r') as fin:\n labels = [line.rstrip('\\n') for line in fin]\n return labels\n\ndef run_classification(labels):\n \"\"\"Stream images off the camera and process them.\"\"\"\n\n camera = PiCamera()\n camera.resolution = (320, 240)\n camera.framerate = 2\n raw_capture = PiRGBArray(camera, size=(320, 240))\n\n # Warmup...\n time.sleep(2)\n\n # Unpersists graph from file\n with tf.gfile.FastGFile(\"../inception/retrained_graph.pb\", 'rb') as fin:\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(fin.read())\n _ = tf.import_graph_def(graph_def, name='')\n\n with tf.Session() as sess:\n # And capture continuously forever.\n softmax_tensor = sess.graph.get_tensor_by_name('final_result:0')\n for _, image in enumerate(\n camera.capture_continuous(\n raw_capture, format='bgr', use_video_port=True\n )\n ):\n # Get the numpy version of the image.\n decoded_image = image.array\n\n # Make the prediction. Big thanks to this SO answer:\n # http://stackoverflow.com/questions/34484148/feeding-image-data-in-tensorflow-for-transfer-learning\n predictions = sess.run(softmax_tensor, {'DecodeJpeg:0': decoded_image})\n prediction = predictions[0]\n\n # Get the highest confidence category.\n prediction = prediction.tolist()\n max_value = max(prediction)\n max_index = prediction.index(max_value)\n predicted_label = labels[max_index]\n\n print(\"%s (%.2f%%)\" % (predicted_label, max_value * 100))\n\n # Reset the buffer so we're ready for the next one.\n raw_capture.truncate(0)\n\nif __name__ == '__main__':\n run_classification(get_labels())\n" ]

[ [ "tensorflow.Session", "tensorflow.GraphDef", "tensorflow.import_graph_def", "tensorflow.gfile.FastGFile" ] ]

omri374/fossa

[ "0ca81ba9cceecdc942832bc46e72075278a08ffe" ]

[ "tests/test_common.py" ]

[ "\"\"\"Test common fossa functionalities.\"\"\"\n\nimport pytest\nimport pandas as pd\n\nfrom fossa import LatestWindowAnomalyDetector\n\n\ndef test_bad_data():\n clf = LatestWindowAnomalyDetector(p_threshold=0.00001)\n # bad df: one-level index\n with pytest.raises(ValueError):\n df = pd.DataFrame([[1], [4]], columns=['value'])\n clf.fit(df)\n # bad df: three-level index (too deep)\n with pytest.raises(ValueError):\n df = pd.DataFrame(\n [[1], [4]], columns=['value'],\n index=pd.MultiIndex.from_tuples([[1, 2, 3], [1, 2, 4]]))\n clf.fit(df)\n # bad df: two-level index (good) by more than one column\n with pytest.raises(ValueError):\n df = pd.DataFrame(\n [[1, 6], [4, 5]], columns=['value', 'foo'],\n index=pd.MultiIndex.from_tuples([[1, 2], [1, 3]]))\n clf.fit(df)\n # bad df: two-level index (good) w/ one column (good) but non-numeric\n with pytest.raises(ValueError):\n df = pd.DataFrame(\n [['foo'], ['bar']], columns=['value'],\n index=pd.MultiIndex.from_tuples([[1, 2], [1, 3]]))\n clf.fit(df)\n" ]

[ [ "pandas.MultiIndex.from_tuples", "pandas.DataFrame" ] ]

IQSS/workshops

[ "f060ee3b883c93cb4eb1410b13c3d9f8509233d8" ]

[ "Other/RCEintro/Python_examples/power1/power.py" ]

[ "import numpy as np\nfrom scipy import stats\n\n## function to simulate data and perform a t.test\ndef sim_ttest(mu1, mu2, sd, n1, n2):\n x = stats.norm.rvs(loc = mu1, scale = sd, size = n1)\n y = stats.norm.rvs(loc = mu2, scale = sd, size = n2)\n return(stats.ttest_ind(x, y)[1])\n\n## run the function 10,000 times\nnsims = 10000\np = [sim_ttest(1, 1.3, 1, 50, 150) for x in range(nsims)]\n## calculate proportion of significant tests\nprint(len([x for x in p if x < .05])/nsims)\n" ]

[ [ "scipy.stats.ttest_ind", "scipy.stats.norm.rvs" ] ]

maruel/ml

[ "39e1883d7ee0c4393ba0b35bd7cc9ac2066e4e72" ]

[ "notebooks/deepdream.py" ]

[ "# Copyright 2021 Marc-Antoine Ruel. All rights reserved.\n# Use of this source code is governed under the Apache License, Version 2.0\n# that can be found in the LICENSE file.\n\n\"\"\"Includes tools to deep dream an image.\n\nInspired by https://www.tensorflow.org/tutorials/generative/deepdream\n\"\"\"\n\nimport logging\nimport os\nimport urllib.parse\n\n# Tell tensorflow to shut up.\nos.environ['TF_CPP_MIN_LOG_LEVEL'] = '1' # Between '0' and '3'\n\n# https://www.tensorflow.org/api_docs/python/tf/all_symbols\nimport tensorflow as tf\n# https://numpy.org/doc/stable/user/quickstart.html\nimport numpy as np\n# https://pillow.readthedocs.io/en/stable/reference/Image.html\nimport PIL.Image\n\n\n# Do not run this by default since it slows things down slightly.\n# Reminder to make sure I properly configured my GPU:\n#if not tf.config.list_physical_devices('GPU'):\n# print('WARNING: No GPU detected')\n\n\n_SAVE_INDEX = 0\n_DEEP_DREAM = None\n_DREAM_MODEL = None\n\n\ndef download(url, max_dim=None):\n \"\"\"Opens an images and returns it as a np.array with [0, 255] range.\"\"\"\n if urllib.parse.urlparse(url).scheme:\n url = tf.keras.utils.get_file(url.split('/')[-1], origin=url)\n img = PIL.Image.open(url)\n\t# Convert indexed (gif) or RGBA (png) into RGA with a white background.\n if img.mode != \"RGB\":\n if img.mode == \"P\":\n img = img.convert(\"RGBA\")\n background = PIL.Image.new(\"RGB\", img.size, (255, 255, 255))\n background.paste(img, mask=img.split()[3])\n img = background.convert(\"RGB\")\n if max_dim:\n img.thumbnail((max_dim, max_dim))\n # Convert to numpy array.\n return np.array(img)\n\n\ndef denormalize(img):\n \"\"\"Denormalizes an image from [-1, +1] to [0, 255].\"\"\"\n return tf.cast((255/2.)*(img + 1.0), tf.uint8)\n\n\ndef save(img):\n \"\"\"Saves an image represented as a normalized uint8 ft.tensor.\"\"\"\n global _SAVE_INDEX\n _SAVE_INDEX = _SAVE_INDEX + 1\n if not os.path.isdir('out'):\n os.mkdir('out')\n p = os.path.join('out', '%03d.png' % _SAVE_INDEX)\n if os.path.isfile(p):\n os.remove(p)\n PIL.Image.fromarray(np.array(img)).save(p)\n print(\"Saving image %s\" % p)\n\n\ndef calc_loss(img, model):\n \"\"\"Pass forward the image through the model to retrieve the activations.\n\n Converts the image into a batch of size 1.\n\n Returns tf.float32.\n \"\"\"\n layer_activations = model(tf.expand_dims(img, axis=0))\n if len(layer_activations) == 1:\n layer_activations = [layer_activations]\n # Sum of the medians for each layers.\n medians = [tf.math.reduce_mean(tf.cast(act, tf.float32)) for act in layer_activations]\n return tf.math.reduce_sum(medians)\n\n\nclass DeepDream(tf.Module):\n def __init__(self, model):\n self.model = model\n\n @tf.function(\n input_signature=(\n tf.TensorSpec(shape=[None,None,3], dtype=tf.float32),\n tf.TensorSpec(shape=[], dtype=tf.int32),\n tf.TensorSpec(shape=[], dtype=tf.float32),)\n )\n def __call__(self, img, steps, step_size):\n loss = tf.constant(0.0, dtype=tf.float32)\n for n in tf.range(steps):\n with tf.GradientTape() as tape:\n # This needs gradients relative to `img`\n # `GradientTape` only watches `tf.Variable`s by default\n tape.watch(img)\n loss = calc_loss(img, self.model)\n # Calculate the gradient of the loss with respect to the pixels of the\n # input image.\n gradients = tape.gradient(loss, img)\n # Normalize the gradients.\n gradients /= tf.math.reduce_std(gradients) + 1e-8\n # In gradient ascent, the \"loss\" is maximized so that the input image\n # increasingly \"excites\" the layers. You can update the image by\n # directly adding the gradients (because they're the same shape!)\n p = gradients*step_size\n img = img + p\n img = tf.clip_by_value(img, -1, 1)\n return loss, img\n\n\ndef dream_model():\n \"\"\"Lazy create the deep dream model.\"\"\"\n global _DREAM_MODEL\n if not _DREAM_MODEL:\n # Deepdream model.\n _base_model = tf.keras.applications.InceptionV3(include_top=False, weights='imagenet')\n # Maximize the activations of these layers.\n _layers = [_base_model.get_layer(name).output for name in ['mixed3', 'mixed5']]\n # Create the feature extraction model.\n _DREAM_MODEL = tf.keras.Model(inputs=_base_model.input, outputs=_layers)\n return _DREAM_MODEL\n\n\ndef deepdream(*args, **kwargs):\n \"\"\"Runs deep dream on an image.\n\n Lazy load the model.\n \"\"\"\n global _DEEP_DREAM\n if not _DEEP_DREAM:\n _DEEP_DREAM = DeepDream(dream_model())\n return _DEEP_DREAM(*args, **kwargs)\n\n\ndef run_deep_dream_simple(img, steps, step_size, steps_per_output=100):\n \"\"\"Generates multiple deep dream images.\n\n Args:\n img: np.array\n\n Returns:\n list of normalized [-1, +1] deep dreamed images. Includes the original\n image.\n \"\"\"\n # Convert from uint8 [0, +255] to the range expected by the model, which is\n # float32 [-1, +1].\n # https://www.tensorflow.org/api_docs/python/tf/keras/applications/inception_v3/preprocess_input\n img = tf.keras.applications.inception_v3.preprocess_input(img)\n # https://www.tensorflow.org/api_docs/python/tf/convert_to_tensor\n img = tf.convert_to_tensor(img, dtype=tf.float32)\n step_size = tf.constant(step_size, dtype=tf.float32)\n steps_remaining = steps\n step = 0\n run_steps = tf.constant(steps_per_output)\n out = [img]\n while steps_remaining:\n if steps_remaining < run_steps:\n run_steps = tf.constant(steps_remaining)\n steps_remaining -= run_steps\n loss, img = deepdream(img, run_steps, step_size)\n out.append(img)\n step += run_steps\n logging.info(\"Step {}, loss {:.2f}\".format(step, loss))\n return out\n" ]

[ [ "tensorflow.convert_to_tensor", "tensorflow.clip_by_value", "tensorflow.constant", "tensorflow.range", "tensorflow.cast", "tensorflow.keras.applications.InceptionV3", "tensorflow.expand_dims", "tensorflow.keras.Model", "tensorflow.math.reduce_std", "tensorflow.math.reduce_sum", "numpy.array", "tensorflow.keras.applications.inception_v3.preprocess_input", "tensorflow.TensorSpec", "tensorflow.GradientTape" ] ]

colorfullywonderfully/RS-Inspection

[ "799e1c12a19ee13cd4a1e23760b4d4e43e5f5794" ]

[ "rail_location.py" ]

[ "\r\nimport numpy as np\r\nimport cv2\r\nfrom pylab import *\r\n\r\ndef convolution(Img):\r\n\r\n p = 50\r\n # 计数\r\n count = 0\r\n\r\n #Img = np.array(cv2.imread('1.jpeg',0),dtype= int64)#直接读为灰度图像\r\n #plt.imshow(Img,'gray')\r\n #plt.show()\r\n #print(Img)\r\n rows,cols=Img.shape ## 行列\r\n #print(rows,cols)\r\n window = []\r\n\r\n for col_index in range(cols):\r\n if (col_index + p) > cols:\r\n break\r\n \r\n temp_matrix = Img[:, (col_index) : (col_index + p)]\r\n count = count + 1\r\n M = mean(temp_matrix)\r\n window.append(M)\r\n _argmax = np.argmax(window)\r\n\r\n return _argmax\r\n\r\n" ]

[ [ "numpy.argmax" ] ]

snemistry/spotlight

[ "830a65c462119d8cd47ece104246ff16f67dcea9" ]

[ "experimental/50-3-bpr-MLP-adaptive-lr-001-mom-92-l2-04.py" ]

[ "from spotlight.cross_validation import random_train_test_split\nfrom spotlight.datasets.movielens import get_movielens_dataset\nfrom spotlight.evaluation import mrr_score\nfrom spotlight.factorization.implicit import ImplicitFactorizationModel\nfrom spotlight.interactions import Interactions\nimport pandas as pd\nfrom spotlight.evaluation import *\nfrom torch.utils.tensorboard import SummaryWriter\nimport torch\nfrom torch.utils.tensorboard import SummaryWriter\nimport logging\nfrom spotlight.factorization.representations import *\n\ntrain_sample = 1.0\nuse_cuda=True\n\ntensorboard_base_dir=\"runs\"\nmodel_alias = \"50-3-bpr-MLP-adaptive-lr-001-mom-92-l2-04\"\nmodel_store_dir=\"models\"\nnet_conf = \"50-3-bpr-MLP\"\nn_iters=30\n#loss=\"adaptive_hinge\"\nloss=\"bpr\"\nlr=1e-3\nl2=1e-4\nbetas=(0.92, 0.999)\nnum_negative_samples=5\nlog_loss_interval=100\nlog_eval_interval=5000\nbatch_size=1024\n#train_data_path = \"s3a://tubi-playground-production/smistry/emb3/train-aug-28-phase1\"\ntrain_data_path = \"data/train-aug-28-phase1\"\n\nlogging.basicConfig(filename=\"logs/\" + model_alias + '.log', \n filemode='w', \n format='%(asctime)s - %(message)s',\n level=logging.INFO)\n\nlogger = logging.getLogger()\nlogger.setLevel(logging.DEBUG)\n\noriginal_train_data = pd.read_parquet(train_data_path)\nlogger.info(\"Data is loaded\")\nwriter = SummaryWriter(log_dir='{}/{}'.format(tensorboard_base_dir, model_alias))\nwriter.add_text('alias', model_alias, 0)\n\ndef notify_loss_completion(epoch_id, batch_id, loss, net, model):\n #print(\"notify_loss_completion\")\n writer.add_scalar(\"Batch/loss\", loss, batch_id)\n logging.info('[Epoch {}] Batch {}, Loss {}'.format(epoch_id, batch_id, loss))\n\ndef notify_batch_eval_completion(epoch_id, batch_id, loss, net, model):\n #print(\"notify_batch_eval_completion\")\n pairs_ndcg = nn_pairs_ndcg_score(net)\n writer.add_scalar(\"Batch/pairs_ndcg\", pairs_ndcg, batch_id)\n logging.info('[Epoch {}] Batch {}, Embs NDCG = {:.4f}'.format(epoch_id, batch_id, pairs_ndcg))\n \ndef notify_epoch_completion(epoch_num, total_loss, net, model):\n #print(\"notify_epoch_completion\")\n writer.add_scalar(\"Epoch/loss\", total_loss, epoch_num)\n pairs_ndcg = nn_pairs_ndcg_score(net)\n writer.add_scalar(\"Epoch/pairs_ndcg\", pairs_ndcg, epoch_num)\n# hit_ratio, ndcg = evaluate_hit_ratio_and_ndcg(model)\n# writer.add_scalar(\"Epoch/HR\", hit_ratio, epoch_num)\n# writer.add_scalar(\"Epoch/NDCG\", ndcg, epoch_num)\n hit_ratio, ndcg = -1,-1\n logging.info('******** [Epoch {}] Embs NDCG {:.4f}, Hit Ratio: {:.4f}, NDCG: {:.4f}'.format(epoch_num,\n pairs_ndcg,\n hit_ratio,\n ndcg))\n torch.save(net, model_store_dir + \"/\" + model_alias + \"-\" + str(epoch_num))\n \nnum_users=len(original_train_data[\"uindex\"].unique())\nnum_items=len(original_train_data[\"vindex\"].unique())\n\ntrain_data = original_train_data.sample(frac=train_sample)\n\ninteractions = Interactions(train_data[\"uindex\"].to_numpy(),\n train_data[\"vindex\"].to_numpy(),\n train_data[\"pct_cvt\"].to_numpy(),\n train_data[\"latest_watch_time\"].to_numpy(),\n num_users=len(original_train_data[\"uindex\"].unique()),\n num_items=len(original_train_data[\"vindex\"].unique()))\n\n\nif \"-\" in net_conf:\n args = net_conf.split(\"-\")\n config = {\n \"factor_size\": int(args[0]),\n \"num_layers\": int(args[1]),\n \"loss_type\": args[2],\n \"model_type\": args[3],\n \"num_users\": num_users,\n \"num_items\": num_items,\n }\n \n num_layers = int(args[1])\n factor_size = int(args[0])\n config[\"layers\"] = [4 * factor_size] + [factor_size * (2 ** i) for i in range(num_layers - 1, -1, -1)]\n config[\"latent_dim\"] = 2 * factor_size\n writer.add_text('config', str(config), 0)\n \n rep = MLP(config)\nelse:\n rep = None\n\nmodel = ImplicitFactorizationModel(n_iter=n_iters,\n loss=loss,\n notify_loss_completion=notify_loss_completion,\n notify_batch_eval_completion=notify_batch_eval_completion,\n notify_epoch_completion=notify_epoch_completion,\n log_loss_interval=log_loss_interval,\n log_eval_interval=log_eval_interval,\n betas=betas,\n learning_rate=lr,\n batch_size=batch_size,\n random_state=np.random.RandomState(2),\n num_negative_samples=num_negative_samples,\n l2=l2,\n use_cuda=use_cuda,\n representation=rep)\nlogger.info(\"Model is initialized, now fitting..\")\nmodel.fit(interactions)" ]

[ [ "pandas.read_parquet" ] ]

DominickZhang/Distillation-Swin-Transformer

[ "6fc7b25bd558edb14e6f15715f53612c37e5166f" ]

[ "models/swin_transformer_distill_jinnian.py" ]

[ "import torch\nimport torch.nn as nn\nfrom timm.models.layers import trunc_normal_, to_2tuple, DropPath\nfrom .swin_transformer import Mlp, window_partition, window_reverse, PatchEmbed, PatchMerging\nimport torch.utils.checkpoint as checkpoint\n\n\nclass WindowAttentionDistill(nn.Module):\n r\"\"\" Window based multi-head self attention (W-MSA) module with relative position bias.\n It supports both of shifted and non-shifted window.\n\n Args:\n dim (int): Number of input channels.\n window_size (tuple[int]): The height and width of the window.\n num_heads (int): Number of attention heads.\n qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set\n attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0\n proj_drop (float, optional): Dropout ratio of output. Default: 0.0\n \"\"\"\n\n def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):\n\n super().__init__()\n self.dim = dim\n self.window_size = window_size # Wh, Ww\n self.num_heads = num_heads\n head_dim = dim // num_heads\n self.scale = qk_scale or head_dim ** -0.5\n\n # define a parameter table of relative position bias\n self.relative_position_bias_table = nn.Parameter(\n torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads)) # 2*Wh-1 * 2*Ww-1, nH\n\n # get pair-wise relative position index for each token inside the window\n coords_h = torch.arange(self.window_size[0])\n coords_w = torch.arange(self.window_size[1])\n coords = torch.stack(torch.meshgrid([coords_h, coords_w])) # 2, Wh, Ww\n coords_flatten = torch.flatten(coords, 1) # 2, Wh*Ww\n relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :] # 2, Wh*Ww, Wh*Ww\n relative_coords = relative_coords.permute(1, 2, 0).contiguous() # Wh*Ww, Wh*Ww, 2\n relative_coords[:, :, 0] += self.window_size[0] - 1 # shift to start from 0\n relative_coords[:, :, 1] += self.window_size[1] - 1\n relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1\n relative_position_index = relative_coords.sum(-1) # Wh*Ww, Wh*Ww\n self.register_buffer(\"relative_position_index\", relative_position_index)\n\n self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)\n self.attn_drop = nn.Dropout(attn_drop)\n self.proj = nn.Linear(dim, dim)\n self.proj_drop = nn.Dropout(proj_drop)\n\n trunc_normal_(self.relative_position_bias_table, std=.02)\n self.softmax = nn.Softmax(dim=-1)\n\n def forward(self, x, mask=None):\n \"\"\"\n Args:\n x: input features with shape of (num_windows*B, N, C)\n mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None\n \"\"\"\n B_, N, C = x.shape\n qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)\n q, k, v = qkv[0], qkv[1], qkv[2] # make torchscript happy (cannot use tensor as tuple)\n\n q = q * self.scale\n attn = (q @ k.transpose(-2, -1))\n\n relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(\n self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1) # Wh*Ww,Wh*Ww,nH\n relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous() # nH, Wh*Ww, Wh*Ww\n attn = attn + relative_position_bias.unsqueeze(0) #B, nHead, Wh*Ww, Wh*Ww\n\n if mask is not None:\n nW = mask.shape[0]\n attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)\n attn = attn.view(-1, self.num_heads, N, N)\n attn_logits = attn\n attn = self.softmax(attn)\n else:\n attn_logits = attn\n attn = self.softmax(attn)\n\n attn = self.attn_drop(attn)\n\n x = (attn @ v).transpose(1, 2).reshape(B_, N, C)\n x = self.proj(x)\n x = self.proj_drop(x)\n return x, attn_logits\n\n def extra_repr(self) -> str:\n return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'\n\n def flops(self, N):\n # calculate flops for 1 window with token length of N\n flops = 0\n # qkv = self.qkv(x)\n flops += N * self.dim * 3 * self.dim\n # attn = (q @ k.transpose(-2, -1))\n flops += self.num_heads * N * (self.dim // self.num_heads) * N\n # x = (attn @ v)\n flops += self.num_heads * N * N * (self.dim // self.num_heads)\n # x = self.proj(x)\n flops += N * self.dim * self.dim\n return flops\n\nclass SwinTransformerBlockDistill(nn.Module):\n r\"\"\" Swin Transformer Block.\n\n Args:\n dim (int): Number of input channels.\n input_resolution (tuple[int]): Input resulotion.\n num_heads (int): Number of attention heads.\n window_size (int): Window size.\n shift_size (int): Shift size for SW-MSA.\n mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.\n qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.\n drop (float, optional): Dropout rate. Default: 0.0\n attn_drop (float, optional): Attention dropout rate. Default: 0.0\n drop_path (float, optional): Stochastic depth rate. Default: 0.0\n act_layer (nn.Module, optional): Activation layer. Default: nn.GELU\n norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm\n \"\"\"\n\n def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,\n mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,\n act_layer=nn.GELU, norm_layer=nn.LayerNorm):\n super().__init__()\n self.dim = dim\n self.input_resolution = input_resolution\n self.num_heads = num_heads\n self.window_size = window_size\n self.shift_size = shift_size\n self.mlp_ratio = mlp_ratio\n if min(self.input_resolution) <= self.window_size:\n # if window size is larger than input resolution, we don't partition windows\n self.shift_size = 0\n self.window_size = min(self.input_resolution)\n assert 0 <= self.shift_size < self.window_size, \"shift_size must in 0-window_size\"\n\n self.norm1 = norm_layer(dim)\n self.attn = WindowAttentionDistill(\n dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,\n qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)\n\n self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()\n self.norm2 = norm_layer(dim)\n mlp_hidden_dim = int(dim * mlp_ratio)\n self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)\n\n if self.shift_size > 0:\n # calculate attention mask for SW-MSA\n H, W = self.input_resolution\n img_mask = torch.zeros((1, H, W, 1)) # 1 H W 1\n h_slices = (slice(0, -self.window_size),\n slice(-self.window_size, -self.shift_size),\n slice(-self.shift_size, None))\n w_slices = (slice(0, -self.window_size),\n slice(-self.window_size, -self.shift_size),\n slice(-self.shift_size, None))\n cnt = 0\n for h in h_slices:\n for w in w_slices:\n img_mask[:, h, w, :] = cnt\n cnt += 1\n\n mask_windows = window_partition(img_mask, self.window_size) # nW, window_size, window_size, 1\n mask_windows = mask_windows.view(-1, self.window_size * self.window_size)\n attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)\n attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))\n else:\n attn_mask = None\n\n self.register_buffer(\"attn_mask\", attn_mask)\n\n def forward(self, x):\n H, W = self.input_resolution\n B, L, C = x.shape\n assert L == H * W, \"input feature has wrong size\"\n\n shortcut = x\n x = self.norm1(x)\n x = x.view(B, H, W, C)\n\n # cyclic shift\n if self.shift_size > 0:\n shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))\n else:\n shifted_x = x\n\n # partition windows\n x_windows = window_partition(shifted_x, self.window_size) # nW*B, window_size, window_size, C\n x_windows = x_windows.view(-1, self.window_size * self.window_size, C) # nW*B, window_size*window_size, C\n\n # W-MSA/SW-MSA\n attn_windows, attn_matrices = self.attn(x_windows, mask=self.attn_mask) # nW*B, window_size*window_size, C; B, nHead, Wh*Ww, Wh*Ww\n\n # merge windows\n attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)\n shifted_x = window_reverse(attn_windows, self.window_size, H, W) # B H' W' C\n\n # reverse cyclic shift\n if self.shift_size > 0:\n x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))\n else:\n x = shifted_x\n x = x.view(B, H * W, C)\n\n # FFN\n x = shortcut + self.drop_path(x)\n x = x + self.drop_path(self.mlp(self.norm2(x)))\n\n return x, attn_matrices\n\n def extra_repr(self) -> str:\n return f\"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, \" \\\n f\"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}\"\n\n def flops(self):\n flops = 0\n H, W = self.input_resolution\n # norm1\n flops += self.dim * H * W\n # W-MSA/SW-MSA\n nW = H * W / self.window_size / self.window_size\n flops += nW * self.attn.flops(self.window_size * self.window_size)\n # mlp\n flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio\n # norm2\n flops += self.dim * H * W\n return flops\n\nclass BasicLayerDistill(nn.Module):\n \"\"\" A basic Swin Transformer layer for one stage.\n\n Args:\n dim (int): Number of input channels.\n input_resolution (tuple[int]): Input resolution.\n depth (int): Number of blocks.\n num_heads (int): Number of attention heads.\n window_size (int): Local window size.\n mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.\n qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.\n drop (float, optional): Dropout rate. Default: 0.0\n attn_drop (float, optional): Attention dropout rate. Default: 0.0\n drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0\n norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm\n downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None\n use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.\n \"\"\"\n\n def __init__(self, dim, input_resolution, depth, num_heads, window_size,\n mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,\n drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False,\n return_midlayer_num=0,\n is_student=False,\n is_return_all_layers=False,\n ):\n\n super().__init__()\n self.dim = dim\n self.input_resolution = input_resolution\n self.depth = depth\n self.use_checkpoint = use_checkpoint\n\n # build blocks\n self.blocks = nn.ModuleList([\n SwinTransformerBlockDistill(dim=dim, input_resolution=input_resolution,\n num_heads=num_heads, window_size=window_size,\n shift_size=0 if (i % 2 == 0) else window_size // 2,\n mlp_ratio=mlp_ratio,\n qkv_bias=qkv_bias, qk_scale=qk_scale,\n drop=drop, attn_drop=attn_drop,\n drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,\n norm_layer=norm_layer)\n for i in range(depth)])\n\n ## Distillation\n self.return_midlayer_num = return_midlayer_num\n self.is_student = is_student\n self.is_return_all_layers = is_return_all_layers\n if self.is_student and self.is_return_all_layers:\n self.return_id_list = list(range(self.return_midlayer_num))\n elif self.is_return_all_layers:\n ## Get uniform distributed indices of the layers to be returned\n interval = float(return_midlayer_num)/depth\n self.return_id_list = []\n count = 0\n while len(self.return_id_list) < return_midlayer_num:\n new_index = int(count*interval)\n if new_index not in self.return_id_list:\n self.return_id_list.append(new_index)\n count += 1\n else:\n self.return_id_list = []\n\n # patch merging layer\n if downsample is not None:\n self.downsample = downsample(input_resolution, dim=dim, norm_layer=norm_layer)\n else:\n self.downsample = None\n\n def forward(self, x):\n attn_outputs = []\n hidden_outputs = []\n #hidden_outputs.append(x)\n if self.is_return_all_layers:\n count = 0\n for blk in self.blocks:\n if self.use_checkpoint:\n x, attn = checkpoint.checkpoint(blk, x)\n else:\n x, attn = blk(x)\n if count in self.return_id_list:\n attn_outputs.append(attn)\n hidden_outputs.append(x)\n count += 1\n else:\n for blk in self.blocks:\n if self.use_checkpoint:\n x, attn = checkpoint.checkpoint(blk, x)\n else:\n x, attn = blk(x)\n if self.downsample is not None:\n x = self.downsample(x)\n return x, attn_outputs, hidden_outputs\n\n def extra_repr(self) -> str:\n return f\"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}\"\n\n def flops(self):\n flops = 0\n for blk in self.blocks:\n flops += blk.flops()\n if self.downsample is not None:\n flops += self.downsample.flops()\n return flops\n\n\nclass SwinTransformerDistill(nn.Module):\n r\"\"\" Swin Transformer\n A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows` -\n https://arxiv.org/pdf/2103.14030\n\n Args:\n img_size (int | tuple(int)): Input image size. Default 224\n patch_size (int | tuple(int)): Patch size. Default: 4\n in_chans (int): Number of input image channels. Default: 3\n num_classes (int): Number of classes for classification head. Default: 1000\n embed_dim (int): Patch embedding dimension. Default: 96\n depths (tuple(int)): Depth of each Swin Transformer layer.\n num_heads (tuple(int)): Number of attention heads in different layers.\n window_size (int): Window size. Default: 7\n mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4\n qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True\n qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None\n drop_rate (float): Dropout rate. Default: 0\n attn_drop_rate (float): Attention dropout rate. Default: 0\n drop_path_rate (float): Stochastic depth rate. Default: 0.1\n norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.\n ape (bool): If True, add absolute position embedding to the patch embedding. Default: False\n patch_norm (bool): If True, add normalization after patch embedding. Default: True\n use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False\n \"\"\"\n\n def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000,\n embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24],\n window_size=7, mlp_ratio=4., qkv_bias=True, qk_scale=None,\n drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,\n norm_layer=nn.LayerNorm, ape=False, patch_norm=True,\n use_checkpoint=False,\n ## The following parameters are for distillation\n is_student = False,\n fit_size_C = 192,\n fit_size_M = 6,\n return_midlayer_num = [2, 2, 6, 2],\n is_return_all_layers = False,\n **kwargs):\n super().__init__()\n\n self.num_classes = num_classes\n self.num_layers = len(depths)\n self.embed_dim = embed_dim\n self.ape = ape\n self.patch_norm = patch_norm\n self.num_features = int(embed_dim * 2 ** (self.num_layers - 1))\n self.mlp_ratio = mlp_ratio\n\n # split image into non-overlapping patches\n self.patch_embed = PatchEmbed(\n img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,\n norm_layer=norm_layer if self.patch_norm else None)\n num_patches = self.patch_embed.num_patches\n patches_resolution = self.patch_embed.patches_resolution\n self.patches_resolution = patches_resolution\n\n # absolute position embedding\n if self.ape:\n self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))\n trunc_normal_(self.absolute_pos_embed, std=.02)\n\n self.pos_drop = nn.Dropout(p=drop_rate)\n\n # stochastic depth\n dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] # stochastic depth decay rule\n\n # build layers\n self.layers = nn.ModuleList()\n for i_layer in range(self.num_layers):\n layer = BasicLayerDistill(dim=int(embed_dim * 2 ** i_layer),\n input_resolution=(patches_resolution[0] // (2 ** i_layer),\n patches_resolution[1] // (2 ** i_layer)),\n depth=depths[i_layer],\n num_heads=num_heads[i_layer],\n window_size=window_size,\n mlp_ratio=self.mlp_ratio,\n qkv_bias=qkv_bias, qk_scale=qk_scale,\n drop=drop_rate, attn_drop=attn_drop_rate,\n drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],\n norm_layer=norm_layer,\n downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,\n use_checkpoint=use_checkpoint,\n return_midlayer_num=return_midlayer_num[i_layer],\n is_return_all_layers=is_return_all_layers,\n is_student=is_student)\n self.layers.append(layer)\n\n self.norm = norm_layer(self.num_features)\n self.avgpool = nn.AdaptiveAvgPool1d(1)\n self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()\n\n ## The following sections are for initialization of distillation\n self.is_return_all_layers = is_return_all_layers\n self.is_student = is_student\n self.fit_size_C = fit_size_C\n self.fit_size_M = fit_size_M\n self.return_midlayer_num = return_midlayer_num\n self.fit_dense_C = nn.ModuleList()\n self.fit_dense_M = nn.ModuleList()\n if self.is_student:\n for i_layer in range(self.num_layers):\n self.fit_dense_C.append(nn.Linear(int(embed_dim * 2 ** i_layer), int(fit_size_C* 2 ** i_layer)))\n self.fit_dense_M.append(nn.Linear(num_heads[i_layer], int(fit_size_M* 2 ** i_layer)))\n \n self.apply(self._init_weights)\n\n def _init_weights(self, m):\n if isinstance(m, nn.Linear):\n trunc_normal_(m.weight, std=.02)\n if isinstance(m, nn.Linear) and m.bias is not None:\n nn.init.constant_(m.bias, 0)\n elif isinstance(m, nn.LayerNorm):\n nn.init.constant_(m.bias, 0)\n nn.init.constant_(m.weight, 1.0)\n\n @torch.jit.ignore\n def no_weight_decay(self):\n return {'absolute_pos_embed'}\n\n @torch.jit.ignore\n def no_weight_decay_keywords(self):\n return {'relative_position_bias_table'}\n\n def forward_features(self, x, stage=None):\n if stage is None:\n x = self.patch_embed(x)\n if self.ape:\n x = x + self.absolute_pos_embed \n x = self.pos_drop(x)\n\n for index, layer in enumerate(self.layers):\n x, _, _ = layer(x)\n\n x = self.norm(x) # B L C\n x = self.avgpool(x.transpose(1, 2)) # B C 1\n x = torch.flatten(x, 1)\n return x, [], []\n else:\n if stage > 0:\n with torch.no_grad():\n x = self.patch_embed(x) # self.patch_embed\n if self.ape:\n x = x + self.absolute_pos_embed # self.absolute_pos_embed\n x = self.pos_drop(x)\n else:\n x = self.patch_embed(x) # self.patch_embed\n if self.ape:\n x = x + self.absolute_pos_embed # self.absolute_pos_embed\n x = self.pos_drop(x)\n\n attn_list = []\n hidden_list = []\n for index, layer in enumerate(self.layers):\n if index < stage:\n with torch.no_grad():\n x, _, _ = layer(x)\n else:\n x, attn, hidden = layer(x)\n if self.is_student:\n for i, hidden_ele in enumerate(hidden):\n hidden_list.append(self.fit_dense_C[index](hidden_ele))\n for i, attn_ele in enumerate(attn):\n B, H, W, W = attn_ele.shape\n attn_ele = attn_ele.transpose(-1, -3).reshape(-1, H)\n attn_list.append(self.fit_dense_M[index](attn_ele).reshape(B, W, W, -1).transpose(-1, -3))\n else:\n attn_list += attn\n hidden_list += hidden\n if stage >= 0:\n break\n return [], attn_list, hidden_list\n\n def forward(self, x, stage=None):\n x, attn_outputs, hidden_outputs = self.forward_features(x, stage)\n if stage is None:\n return self.head(x)\n else:\n return attn_outputs, hidden_outputs\n\n def flops(self):\n flops = 0\n flops += self.patch_embed.flops()\n for i, layer in enumerate(self.layers):\n flops += layer.flops()\n flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers)\n flops += self.num_features * self.num_classes\n return flops\n" ]

[ [ "torch.nn.Softmax", "torch.nn.Dropout", "torch.zeros", "torch.nn.init.constant_", "torch.nn.ModuleList", "torch.arange", "torch.nn.Linear", "torch.nn.Identity", "torch.utils.checkpoint.checkpoint", "torch.no_grad", "torch.flatten", "torch.roll", "torch.nn.AdaptiveAvgPool1d", "torch.meshgrid" ] ]

cguevaramorel/ogs6py

[ "f6ed1d3aa694048175f59f4a467097f32332a0c0" ]

[ "ogs6py/log_parser/log_parser.py" ]

[ "#!/usr/bin/env python\n\n# Copyright (c) 2012-2021, OpenGeoSys Community (http://www.opengeosys.org)\n# Distributed under a Modified BSD License.\n# See accompanying file LICENSE.txt or\n# http://www.opengeosys.org/project/license\n\nimport re\nimport sys\nfrom dataclasses import dataclass, field\nimport pandas as pd\nfrom typing import List\n\n@dataclass\nclass ComponentConvergence(object):\n number: int\n dx: float\n x: float\n dx_relative: float\n index_name: str = \"component_convergence/\"\n\n def to_dict(self, prefix):\n yield {\n prefix + self.index_name + \"number\": self.number,\n prefix + self.index_name + \"dx\": self.dx,\n prefix + self.index_name + \"x\": self.x,\n prefix + self.index_name + \"dx_relative\": self.dx_relative,\n }\n\n\n@dataclass\nclass Iteration(object):\n number: int\n assembly_time: float # seconds\n dirichlet_bc_time: float # seconds\n linear_solver_time: float # seconds\n cpu_time: float # seconds\n component_convergence: List[ComponentConvergence] = field(default_factory=list)\n index_name: str = \"iteration/\"\n\n def _dict(self, prefix):\n return {\n prefix + self.index_name + \"number\": self.number,\n prefix + self.index_name + \"assembly_time\": self.assembly_time,\n prefix + self.index_name + \"dirichlet_bc_time\": self.dirichlet_bc_time,\n prefix + self.index_name + \"linear_solver_time\": self.linear_solver_time,\n prefix + self.index_name + \"cpu_time\": self.cpu_time,\n }\n\n def to_dict(self, prefix):\n for c in self.component_convergence:\n for d in c.to_dict(prefix + self.index_name):\n yield self._dict(prefix) | d\n\n\n@dataclass\nclass TimeStep(object):\n number: int\n t: float # simulation time\n dt: float # simulation time increment\n iterations: List[Iteration] = field(default_factory=list)\n cpu_time: float = None # seconds\n output_time: float = None # seconds\n index_name: str = \"time_step/\"\n\n def _dict(self):\n return {\n self.index_name + \"number\": self.number,\n self.index_name + \"t\": self.t,\n self.index_name + \"dt\": self.dt,\n self.index_name + \"cpu_time\": self.cpu_time,\n self.index_name + \"output_time\": self.output_time,\n }\n\n def to_dict(self, prefix):\n for i in self.iterations:\n for d in i.to_dict(self.index_name):\n yield self._dict() | d\n\n\n@dataclass\nclass Simulation(object):\n timesteps: List[TimeStep] = field(default_factory=list)\n mesh_read_time: float = None # seconds\n execution_time: float = None # seconds\n\n def __len__(self):\n \"\"\"Number of time steps\"\"\"\n return len(self.timesteps)\n\n def _dict(self):\n return {\n \"execution_time\": self.execution_time,\n }\n\n def __iter__(self):\n for t in self.timesteps:\n for d in t.to_dict(\"\"):\n yield self._dict() | d\n\n\n_re_iteration = [\n re.compile(\"info: \\[time\\] Iteration #(\\d+) took ([\\d\\.e+s]+) s\"),\n int,\n float,\n]\n_re_time_step_start = [\n re.compile(\n \"info: === Time stepping at step #(\\d+) and time ([\\d\\.e+s]+) with step size (.*)\"\n ),\n int,\n float,\n float,\n]\n_re_time_step_output = [\n re.compile(\"info: \\[time\\] Output of timestep (\\d+) took ([\\d\\.e+s]+) s\"),\n int,\n float,\n]\n_re_time_step_solution_time = [\n re.compile(\n \"info: \\[time\\] Solving process #(\\d+) took ([\\d\\.e+s]+) s in time step #(\\d+)\"\n ),\n int,\n float,\n int,\n]\n_re_time_step_finished = [\n re.compile(\"info: \\[time\\] Time step #(\\d+) took ([\\d\\.e+s]+) s\"),\n int,\n float,\n]\n\n_re_assembly_time = [re.compile(\"info: \\[time\\] Assembly took ([\\d\\.e+s]+) s\"), float]\n_re_dirichlet_bc_time = [\n re.compile(\"info: \\[time\\] Applying Dirichlet BCs took ([\\d\\.e+s]+) s\"),\n float,\n]\n_re_linear_solver_time = [\n re.compile(\"info: \\[time\\] Linear solver took ([\\d\\.e+s]+) s\"),\n float,\n]\n# _re_reading_mesh = [re.compile(\".*?time.*?Reading the mesh took ([\\d\\.e+s]+) s\"), float]\n_re_execution_time = [re.compile(\"info: \\[time\\] Execution took ([\\d\\.e+s]+) s\"), float]\n\n_re_component_convergence = [\n re.compile(\n \"info: Convergence criterion, component (\\d+): \\|dx\\|=([\\d\\.e+-]+), \\|x\\|=([\\d\\.e+-]+), \\|dx\\|/\\|x\\|=([\\d\\.e+-]+)$\"\n ),\n int,\n float,\n float,\n float,\n]\n\n\ndef _tryMatch(line: str, regex: re.Pattern, *ctors):\n if match := regex.match(line):\n return [ctor(s) for ctor, s in zip(ctors, match.groups())]\n return None\n\n\ndef parse_file(filename, maximum_timesteps=None, maximum_lines=None):\n\n tss = []\n execution_time = None\n mesh_read_time = None\n\n ts = TimeStep(\n number=0,\n t=0.0, # Note: initial time is not set correctly.\n dt=None,\n iterations=[],\n cpu_time=None,\n )\n\n assembly_time = None\n dirichlet_bc_time = None\n linear_solver_time = None\n component_convergence = []\n\n number_of_lines_read = 0\n for line in open(filename):\n number_of_lines_read += 1\n\n if r := _tryMatch(line, *_re_iteration):\n ts.iterations.append(\n Iteration(\n number=r[0],\n assembly_time=assembly_time,\n dirichlet_bc_time=dirichlet_bc_time,\n linear_solver_time=linear_solver_time,\n component_convergence=component_convergence,\n cpu_time=r[1],\n )\n )\n # Reset parsed quantities to avoid reusing old values for next iterations\n assembly_time = None\n dirichlet_bc_time = None\n linear_solver_time = None\n component_convergence = []\n continue\n\n if r := _tryMatch(line, *_re_assembly_time):\n assembly_time = r[0]\n continue\n\n if r := _tryMatch(line, *_re_dirichlet_bc_time):\n dirichlet_bc_time = r[0]\n continue\n\n if r := _tryMatch(line, *_re_linear_solver_time):\n linear_solver_time = r[0]\n continue\n\n if r := _tryMatch(line, *_re_component_convergence):\n component_convergence.append(\n ComponentConvergence(number=r[0], dx=r[1], x=r[2], dx_relative=r[3])\n )\n continue\n\n if r := _tryMatch(line, *_re_time_step_start):\n # print(\"Finished ts\", ts)\n tss.append(ts)\n ts = TimeStep(number=r[0], t=r[1], dt=r[2])\n # print(\"New timestep\", ts, \"\\n\")\n if (\n ts\n and (maximum_timesteps is not None)\n and (ts.number > maximum_timesteps)\n ) or ((maximum_lines is not None) and (number_of_lines_read >\n maximum_lines)):\n break\n continue\n\n if r := _tryMatch(line, *_re_time_step_solution_time):\n # r[0] is process number and is ignored for now.\n# if ts.number != r[2]:\n# raise RuntimeError(\n# \"Solution time for wrong time step\", r[2], \"current time step\", ts\n# )\n ts.solution_time = r[1]\n continue\n\n if r := _tryMatch(line, *_re_time_step_output):\n# if ts.number != r[0]:\n# raise RuntimeError(\n# \"Output time for wrong time step\", r[0], \"current time step\", ts\n# )\n ts.output_time = r[1]\n continue\n\n if r := _tryMatch(line, *_re_time_step_finished):\n# if ts.number != r[0]:\n# raise RuntimeError(\n# \"Total time for wrong time step\", r[0], \"current time step\", ts\n# )\n ts.cpu_time = r[1]\n continue\n\n # if r := _tryMatch(line, *_re_reading_mesh):\n # mesh_read_time = r[0]\n # continue\n\n if r := _tryMatch(line, *_re_execution_time):\n execution_time = r[0]\n\n # print(\"Finished ts\", ts)\n tss.append(ts)\n continue\n\n return Simulation(\n timesteps=tss, mesh_read_time=mesh_read_time, execution_time=execution_time\n )\nif __name__ == \"__main__\":\n filename = sys.argv[1]\n data = parse_file(sys.argv[1], maximum_timesteps=None, maximum_lines=None)\n df = pd.DataFrame(data)\n filename_prefix = filename.split('.')[0]\n df.to_csv(f\"{filename_prefix}.csv\")\n" ]

[ [ "pandas.DataFrame" ] ]

jchibane/if-net_texture

[ "989ffdc9afc0296d92a55a7a1f155c1cc3e6e5e4" ]

[ "models/training.py" ]

[ "from __future__ import division\nimport torch\nimport torch.optim as optim\nfrom torch.nn import functional as F\nimport os\nfrom glob import glob\nimport numpy as np\n\n\n\n\nclass Trainer(object):\n\n def __init__(self, model, device, train_dataset, val_dataset, exp_name, optimizer='Adam'):\n self.model = model.to(device)\n self.device = device\n if optimizer == 'Adam':\n self.optimizer = optim.Adam(self.model.parameters(), lr=1e-4)\n if optimizer == 'Adadelta':\n self.optimizer = optim.Adadelta(self.model.parameters())\n if optimizer == 'RMSprop':\n self.optimizer = optim.RMSprop(self.model.parameters(), momentum=0.9)\n\n self.train_dataset = train_dataset\n self.val_dataset = val_dataset\n self.exp_path = os.path.dirname(__file__) + '/../experiments/{}/'.format( exp_name)\n self.checkpoint_path = self.exp_path + 'checkpoints/'\n if not os.path.exists(self.checkpoint_path):\n print(self.checkpoint_path)\n os.makedirs(self.checkpoint_path)\n self.val_min = None\n\n\n def train_step(self,batch):\n self.model.train()\n self.optimizer.zero_grad()\n loss = self.compute_loss(batch)\n loss.backward()\n self.optimizer.step()\n\n return loss.item()\n\n def compute_loss(self,batch):\n device = self.device\n\n p = batch.get('grid_coords').to(device)\n gt_rgb = batch.get('rgb').to(device)\n inputs = batch.get('inputs').to(device)\n\n # print(gt_rgb)\n # p = p.unsqueeze(1).unsqueeze(1)\n # print(F.grid_sample(inputs, p, padding_mode='border'))\n # General points\n\n # print(p[:,:3])\n pred_rgb = self.model(p,inputs)\n pred_rgb = pred_rgb.transpose(-1,-2)\n # print(gt_rgb.shape)\n loss_i = torch.nn.L1Loss(reduction='none')(pred_rgb, gt_rgb) # out = (B,num_points,3)\n\n loss = loss_i.sum(-1).mean() # loss_i summed 3 rgb channels for all #num_samples samples -> out = (B,1) and mean over batch -> out = (1)\n\n return loss\n\n def train_model(self, epochs):\n loss = 0\n start = self.load_checkpoint()\n\n for epoch in range(start, epochs):\n sum_loss = 0\n print('Start epoch {}'.format(epoch))\n train_data_loader = self.train_dataset.get_loader()\n\n if epoch % 1 == 0:\n self.save_checkpoint(epoch)\n val_loss = self.compute_val_loss()\n\n if self.val_min is None:\n self.val_min = val_loss\n\n if val_loss < self.val_min:\n self.val_min = val_loss\n # for path in glob(self.exp_path + 'val_min=*'):\n # os.remove(path)\n np.save(self.exp_path + 'val_min',[epoch,val_loss])\n\n\n for batch in train_data_loader:\n loss = self.train_step(batch)\n print(\"Current loss: {}\".format(loss))\n sum_loss += loss\n\n\n\n\n def save_checkpoint(self, epoch):\n path = self.checkpoint_path + 'checkpoint_epoch_{}.tar'.format(epoch)\n if not os.path.exists(path):\n torch.save({'epoch':epoch,'model_state_dict': self.model.state_dict(),\n 'optimizer_state_dict': self.optimizer.state_dict()}, path)\n\n def load_checkpoint(self):\n checkpoints = glob(self.checkpoint_path+'/*')\n if len(checkpoints) == 0:\n print('No checkpoints found at {}'.format(self.checkpoint_path))\n return 0\n\n checkpoints = [os.path.splitext(os.path.basename(path))[0][17:] for path in checkpoints]\n checkpoints = np.array(checkpoints, dtype=int)\n checkpoints = np.sort(checkpoints)\n path = self.checkpoint_path + 'checkpoint_epoch_{}.tar'.format(checkpoints[-1])\n\n print('Loaded checkpoint from: {}'.format(path))\n checkpoint = torch.load(path)\n self.model.load_state_dict(checkpoint['model_state_dict'])\n self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])\n epoch = checkpoint['epoch']\n return epoch\n\n def compute_val_loss(self):\n self.model.eval()\n\n sum_val_loss = 0\n num_batches = 15\n for _ in range(num_batches):\n try:\n val_batch = self.val_data_iterator.next()\n except:\n self.val_data_iterator = self.val_dataset.get_loader().__iter__()\n val_batch = self.val_data_iterator.next()\n\n sum_val_loss += self.compute_loss( val_batch).item()\n\n return sum_val_loss / num_batches" ]

[ [ "torch.load", "numpy.save", "numpy.sort", "numpy.array", "torch.nn.L1Loss" ] ]

DiegoCorrea/masters-dissertation

[ "61d6e9c46da6cf1e7d904f98eb1d46d907a74576" ]

[ "src/processing/traditional_recommenders.py" ]

[ "import datetime\nimport gc\nimport logging\nimport multiprocessing\nimport os\nimport time\nfrom copy import deepcopy\n\nimport numpy as np\nimport pandas as pd\n\nfrom src.analises.popularity import count_popularity_item\nfrom src.config.labels import TRANSACTION_VALUE_LABEL, POPULARITY_LABEL, USER_LABEL, ITEM_LABEL, TOTAL_TIMES_LABEL, \\\n TRADITIONAL_RECOMMENDERS\nfrom src.config.language_strings import LANGUAGE_RECOMMENDATION, LANGUAGE_CALCULATING_USER_MODEL_WGENRE_DISTRIBUTION, \\\n LANGUAGE_LOAD_DATA_SET, LANGUAGE_RECOMMENDER_ALGORITHM_START, LANGUAGE_RECOMMENDER_ALGORITHM_STOP\nfrom src.config.path_dir_files import data_results_path\nfrom src.config.variables import K_FOLDS_VALUES, N_CORES, CANDIDATES_LIST_SIZE\nfrom src.conversions.pandas_to_models import user_transactions_df_to_item_mapping\nfrom src.models.item import create_item_mapping\nfrom src.posprocessing.bias import calculating_item_bias\nfrom src.posprocessing.distributions import get_distribution, multiprocess_get_distribution, \\\n big_genre_distribution_with_multiprocessing\nfrom src.posprocessing.step import pos_processing_calibration\nfrom src.preprocessing.load_database import load_db_and_fold, load_blocked_list\nfrom src.processing.merge_results import merge_recommender_results, k_fold_results_concat\nfrom src.processing.recommender_algorithms import split_equally\n\nlogger = logging.getLogger(__name__)\n\n\ndef ncores_traditional_recommendation_process(user_model_df, user_model_genres_distr_df, user_expected_items_df,\n items_mapping_dict, user_blocked_items_df, recommender_label,\n popularity_df, transaction_mean, control_count=None, start_time=None):\n \"\"\"\n A user by time\n Responsible for: the recommender algorithm prediction,\n the models to be used in the pos process\n and the pos processing\n :param start_time:\n :param control_count:\n :param user_blocked_items_df:\n :param transaction_mean: the users transactions mean\n :param popularity_df: DataFrame with items popularity\n :param user_model_df: All user transactions\n :param user_model_genres_distr_df: The user genres distribution\n :param user_expected_items_df: The user expected items in the final recommendation\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :return: None\n \"\"\"\n # Get known items ids by the user\n items_ids = items_mapping_dict.keys()\n know_items_ids = user_model_df[ITEM_LABEL].unique().tolist()\n blocked_items_ids = user_blocked_items_df[ITEM_LABEL].unique().tolist()\n items_ids = set(items_ids) - set(blocked_items_ids)\n # Get unknown items ids by the user\n unknowing_items_ids = list(set(items_ids) - set(know_items_ids))\n\n user_candidate_items_max_df = popularity_df[popularity_df[ITEM_LABEL].isin(unknowing_items_ids)]\n\n user_candidate_items_max_df.sort_values(by=[TRANSACTION_VALUE_LABEL], ascending=False)\n user_candidate_items_max_df = user_candidate_items_max_df[:CANDIDATES_LIST_SIZE]\n\n user_candidate_items_max_dict = user_transactions_df_to_item_mapping(user_candidate_items_max_df,\n items_mapping_dict)\n user_evaluation_results_df = pos_processing_calibration(user_model_genres_distr_df=user_model_genres_distr_df,\n candidates_items_mapping=user_candidate_items_max_dict,\n user_expected_items_ids=user_expected_items_df[\n ITEM_LABEL].tolist(),\n recommender_label=recommender_label,\n transaction_mean=transaction_mean)\n if control_count is not None and control_count % 100 == 0:\n logger.info(' '.join(['PId:', str(os.getpid()), '->', 'Total of users done:', str(control_count),\n '->', 'Total time:', str(datetime.timedelta(seconds=time.time() - start_time))]))\n return user_evaluation_results_df\n\n\ndef ncores_generate_recommendation(users_ids_list, users_model_df, users_model_genres_distr_df, users_expected_items_df,\n items_mapping_dict, users_blocked_items_df, recommender_label, popularity_df,\n transaction_mean, shared_queue):\n \"\"\"\n A user by time\n Responsible for: the recommender algorithm prediction,\n the models to be used in the pos process\n and the post processing\n :param popularity_df:\n :param users_ids_list:\n :param users_blocked_items_df:\n :param transaction_mean: the users transactions mean\n :param users_ids_list: The group of unique users identification\n :param users_model_df: All user transactions\n :param users_model_genres_distr_df: The user genres distribution\n :param users_expected_items_df: The user expected items in the final recommendation\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :param shared_queue: A shared memory to be used for all ncores process\n :return: The user results in the shared memory\n \"\"\"\n start_time = time.time()\n results = pd.concat(\n [ncores_traditional_recommendation_process(users_model_df[users_model_df[USER_LABEL] == user_id],\n users_model_genres_distr_df.loc[user_id],\n users_expected_items_df[\n users_expected_items_df[USER_LABEL] == user_id],\n items_mapping_dict,\n users_blocked_items_df[\n users_blocked_items_df[USER_LABEL] == user_id],\n recommender_label,\n popularity_df,\n transaction_mean,\n control_count, start_time) for\n control_count, user_id in enumerate(users_ids_list)], sort=False)\n finish_time = time.time()\n logger.info(\" \".join(['>', 'Time Execution:', str(datetime.timedelta(seconds=finish_time - start_time)),\n 'Total of users:', str(len(users_ids_list))]))\n shared_queue.put(deepcopy(results))\n\n\ndef ncores_traditional_recommendation(users_genres_distr_df, trainset_df, testset_df, items_mapping_dict,\n blocked_items_df, popularity_df, transaction_mean, recommender_label):\n \"\"\"\n Multiprocessing recommendations to each user do the pos process\n :param blocked_items_df:\n :param popularity_df: DataFrame with items popularity\n :param transaction_mean: the users transactions mean\n :param users_genres_distr_df: A dataframe with the users genres distributions\n :param trainset_df: A dataframe with the train set transactions\n :param testset_df: A dataframe with the test set transactions\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :return: A dataframe with the results of all used metrics\n \"\"\"\n # Preparing: users, results dataframe and shared queue over processes\n users_ids_list = users_genres_distr_df.index.values.tolist()\n # chunk_users_ids = np.array_split(users_ids_list, N_CORES)\n chunk_users_ids = split_equally(trainset_df)\n\n # Print the state of the execution\n i = len(users_ids_list)\n logger.info(str(i) + ' users to finish')\n\n manager = multiprocessing.Manager()\n shared_queue = manager.Queue()\n all_processes = list()\n\n # As long as there are users on the list to process and cores to allocate, do\n while chunk_users_ids:\n # Allocate core and select the user to pos process\n users_ids_list = chunk_users_ids.pop(0)\n\n # Prepare user data\n users_model_df = deepcopy(trainset_df[trainset_df[USER_LABEL].isin(users_ids_list)])\n users_model_genres_distr_df = deepcopy(users_genres_distr_df.loc[list(users_ids_list)])\n users_expected_items_df = deepcopy(testset_df[testset_df[USER_LABEL].isin(users_ids_list)])\n users_blocked_items_df = deepcopy(blocked_items_df[blocked_items_df[USER_LABEL].isin(users_ids_list)])\n\n # Create the process\n p = multiprocessing.Process(target=ncores_generate_recommendation,\n args=(users_ids_list,\n users_model_df, users_model_genres_distr_df, users_expected_items_df,\n items_mapping_dict, users_blocked_items_df, recommender_label, popularity_df,\n transaction_mean, shared_queue,))\n all_processes.append(p)\n # Start all process\n for p in all_processes:\n p.start()\n # Wait and close the all processes\n user_evaluation_results = list()\n for p in all_processes:\n p.join()\n # Get results from all processes\n user_evaluation_results.append(shared_queue.get())\n p.close()\n\n # Concat and resume the results\n evaluation_results_df = pd.concat(user_evaluation_results)\n return evaluation_results_df\n\n\n# #################################################################################################################### #\n# #################################################################################################################### #\n# #################################################################################################################### #\ndef traditional_generate_recommendation(user_model_df, user_model_genres_distr_df, user_expected_items_df,\n items_mapping_dict, user_blocked_items_df, recommender_label, popularity_df,\n transaction_mean,\n shared_queue):\n \"\"\"\n A user by time\n Responsible for: the recommender algorithm prediction,\n the models to be used in the pos process\n and the pos processing\n :param user_blocked_items_df:\n :param transaction_mean: the users transactions mean\n :param popularity_df: DataFrame with items popularity\n :param user_model_df: All user transactions\n :param user_model_genres_distr_df: The user genres distribution\n :param user_expected_items_df: The user expected items in the final recommendation\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :param shared_queue: A shared memory to be used for all ncores process\n :return: None\n \"\"\"\n # Get known items ids by the user\n items_ids = items_mapping_dict.keys()\n know_items_ids = user_model_df[ITEM_LABEL].unique().tolist()\n blocked_items_ids = user_blocked_items_df[ITEM_LABEL].unique().tolist()\n items_ids = set(items_ids) - set(blocked_items_ids)\n # Get unknown items ids by the user\n unknowing_items_ids = list(set(items_ids) - set(know_items_ids))\n\n user_candidate_items_max_df = popularity_df[popularity_df[ITEM_LABEL].isin(unknowing_items_ids)]\n\n user_candidate_items_max_df.sort_values(by=[TRANSACTION_VALUE_LABEL], ascending=False)\n user_candidate_items_max_df = user_candidate_items_max_df[:CANDIDATES_LIST_SIZE]\n\n user_candidate_items_max_dict = user_transactions_df_to_item_mapping(user_candidate_items_max_df,\n items_mapping_dict)\n user_evaluation_results_df = pos_processing_calibration(user_model_genres_distr_df=user_model_genres_distr_df,\n candidates_items_mapping=user_candidate_items_max_dict,\n user_expected_items_ids=user_expected_items_df[\n ITEM_LABEL].tolist(),\n recommender_label=recommender_label,\n transaction_mean=transaction_mean)\n shared_queue.put(deepcopy(user_evaluation_results_df))\n\n\ndef traditional_recommendation_process(users_genres_distr_df, trainset_df, testset_df, items_mapping_dict,\n blocked_items_df,\n popularity_df, transaction_mean, recommender_label):\n \"\"\"\n Multiprocessing recommendations to each user do the pos process\n :param popularity_df: DataFrame with items popularity\n :param transaction_mean: the users transactions mean\n :param users_genres_distr_df: A dataframe with the users genres distributions\n :param trainset_df: A dataframe with the train set transactions\n :param testset_df: A dataframe with the test set transactions\n :param items_mapping_dict: A dict with all items in the system\n :param recommender_label: The recommender algorithm label\n :return: A dataframe with the results of all used metrics\n \"\"\"\n # Preparing: users, results dataframe and shared queue over processes\n users_ids = users_genres_distr_df.index.values.tolist()\n evaluation_results_df = pd.DataFrame()\n manager = multiprocessing.Manager()\n shared_queue = manager.Queue()\n # While has users to process do in nbeans (ncores)\n while users_ids:\n cores_control = list(range(0, N_CORES))\n all_processes = list()\n\n # Print the state of the execution\n i = len(users_ids)\n print(f'\\r{i} users to finish', end='', flush=True)\n # As long as there are users on the list to process and cores to allocate, do\n while users_ids and cores_control:\n # Allocate core and select the user to pos process\n cores_control.pop(0)\n user_id = users_ids.pop(0)\n # Prepare user data\n user_model_df = deepcopy(trainset_df[trainset_df[USER_LABEL] == user_id])\n user_model_genres_distr_df = deepcopy(users_genres_distr_df.loc[user_id])\n user_expected_items_df = deepcopy(testset_df[testset_df[USER_LABEL] == user_id])\n user_blocked_items_df = deepcopy(blocked_items_df[blocked_items_df[USER_LABEL] == user_id])\n # Create the process\n p = multiprocessing.Process(target=traditional_generate_recommendation,\n args=(\n user_model_df, user_model_genres_distr_df, user_expected_items_df,\n items_mapping_dict, user_blocked_items_df, recommender_label, popularity_df,\n transaction_mean, shared_queue,))\n all_processes.append(p)\n # Start all process\n for p in all_processes:\n p.start()\n # Wait and close the all processes\n user_evaluation_results = list()\n for p in all_processes:\n p.join()\n # Get results from all processes\n user_evaluation_results.append(shared_queue.get())\n p.close()\n\n # Concat and resume the results\n evaluation_results_df = pd.concat([evaluation_results_df, pd.concat(user_evaluation_results)])\n return evaluation_results_df\n\n\ndef start_traditional_recommenders(recommenders_to_use, db):\n \"\"\"\n Start the traditional recommenders (process and post process)\n :param recommenders_to_use:\n :param db: 0 to movielens; 1 to oms;\n :return: None\n \"\"\"\n\n for label in recommenders_to_use:\n logger.info('-' * 50)\n logger.info(\" \".join([LANGUAGE_RECOMMENDER_ALGORITHM_START, \"->\", label]))\n\n # For each dataset fold do process and pos process\n for fold in range(1, K_FOLDS_VALUES + 1):\n gc.collect()\n\n # Load the fold of the dataset\n logger.info(\" \".join([\"+\", LANGUAGE_LOAD_DATA_SET, \"->\", str(fold)]))\n trainset_df, testset_df, items_df = load_db_and_fold(db, fold)\n\n # calculating the user bias\n transaction_mean = trainset_df[TRANSACTION_VALUE_LABEL].mean()\n items_mapping_dict = create_item_mapping(items_df, calculating_item_bias(trainset_df, transaction_mean))\n\n # get the users genres distribution based on they models\n logger.info(\" \".join([\"+\", LANGUAGE_CALCULATING_USER_MODEL_WGENRE_DISTRIBUTION]))\n users_prefs_distr_df = get_distribution(trainset_df, items_mapping_dict)\n\n # Start the recommendation process with the pos processing\n logger.info(\" \".join([\"+\", LANGUAGE_RECOMMENDATION]))\n if label == POPULARITY_LABEL:\n popularity_df = count_popularity_item(trainset_df)\n else:\n popularity_df = pd.DataFrame(\n data=trainset_df.groupby(by=ITEM_LABEL, as_index=False).mean())\n popularity_df.rename(inplace=True, columns={TOTAL_TIMES_LABEL: TRANSACTION_VALUE_LABEL})\n\n results_df = traditional_recommendation_process(users_prefs_distr_df, trainset_df, testset_df,\n items_mapping_dict, popularity_df,\n transaction_mean, label)\n merged_results_df = k_fold_results_concat(results_df)\n # Save the results\n path_to_save = \"\".join([data_results_path(db), label, \"/\"])\n if not os.path.exists(path_to_save):\n os.makedirs(path_to_save)\n merged_results_df.to_csv(os.path.join(path_to_save, str(fold) + \".csv\"),\n index=False)\n # Merge the recommender results into a average based in the configuration\n merge_recommender_results(label, db)\n logger.info(\" \".join([LANGUAGE_RECOMMENDER_ALGORITHM_STOP, \"->\", label]))\n logger.info('-' * 50)\n\n\ndef all_traditional_recommenders(db):\n \"\"\"\n Start all traditioinal recommenders\n :param db: 0 to movielens; 1 to oms;\n :return: None\n \"\"\"\n # Start recommender algorithms that have params\n start_traditional_recommenders(TRADITIONAL_RECOMMENDERS, db)\n\n\n# #################################################################################################################### #\n# #################################################################################################################### #\n# #################################################################################################################### #\n\n\ndef personalized_traditional_recommender(label, db, fold):\n # Load the fold of the dataset\n logger.info(\" \".join([\"+\", LANGUAGE_LOAD_DATA_SET, \"->\", str(fold)]))\n trainset_df, testset_df, items_df = load_db_and_fold(db, fold)\n blocked_items_df = load_blocked_list(db)\n\n # calculating the user bias\n transaction_mean = trainset_df[TRANSACTION_VALUE_LABEL].mean()\n items_mapping_dict = create_item_mapping(items_df, calculating_item_bias(trainset_df, transaction_mean))\n\n # get the users genres distribution based on they models\n logger.info(\" \".join([\"+\", LANGUAGE_CALCULATING_USER_MODEL_WGENRE_DISTRIBUTION]))\n # users_prefs_distr_df = get_distribution(trainset_df, items_mapping_dict)\n # users_prefs_distr_df = multiprocess_get_distribution(trainset_df, items_mapping_dict)\n users_prefs_distr_df = big_genre_distribution_with_multiprocessing(trainset_df, items_mapping_dict)\n\n # Start the recommendation process with the pos processing\n logger.info(\" \".join([\"+\", LANGUAGE_RECOMMENDATION]))\n if label == POPULARITY_LABEL:\n popularity_df = count_popularity_item(trainset_df)\n else:\n popularity_df = pd.DataFrame(\n data=trainset_df.groupby(by=ITEM_LABEL, as_index=False).mean())\n popularity_df.rename(inplace=True, columns={TOTAL_TIMES_LABEL: TRANSACTION_VALUE_LABEL})\n\n results_df = ncores_traditional_recommendation(users_prefs_distr_df, trainset_df, testset_df,\n items_mapping_dict, blocked_items_df, popularity_df,\n transaction_mean, label)\n merged_results_df = k_fold_results_concat(results_df)\n # Save the results\n path_to_save = \"\".join([data_results_path(db), label, \"/\"])\n if not os.path.exists(path_to_save):\n os.makedirs(path_to_save)\n merged_results_df.to_csv(os.path.join(path_to_save, str(fold) + \".csv\"),\n index=False)\n # Merge the recommender results into a average based in the configuration\n # merge_recommender_results(label, db)\n logger.info(\" \".join([LANGUAGE_RECOMMENDER_ALGORITHM_STOP, \"->\", label]))\n logger.info('-' * 50)\n" ]

[ [ "pandas.concat", "pandas.DataFrame" ] ]

bthorne93/freckles

[ "cacb0c3846602f13b371252876f1f8e05dca54ba" ]

[ "src/freckles/separation/components.py" ]

[ "from __future__ import print_function\nfrom numba import jit, float64\nimport numpy as np\nimport inspect\n\nclass Component(object):\n def __init__(self, comp_name):\n \"\"\" SED must be in uK_RJ units.\n \"\"\"\n self.comp_name = comp_name\n self.sed = globals()[comp_name]\n return\n\n def __call__(self, nu, args):\n \"\"\" Method to call the SED with whichi a given instance was initialized.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency or list of frequencies, in GHz, at which to evaluate the\n SED.\n args: tuple\n Tuple containing the positional parameters taken by the SED.\n \"\"\"\n return self.sed(nu, *args)\n\n def get_description(self):\n print(\"Component SED name: \", self.comp_name)\n print(self.sed.__doc__, \"\\n --------------- \\n\")\n pass\n\n def get_parameters(self):\n \"\"\" Method to fetch the keywork arguments for the various components\n and return them. This is used to build a list of possible parameters\n that may be varied by MapLike.\n \"\"\"\n sig = inspect.signature(self.sed)\n pars = list(sig.parameters.keys())\n return list(filter(lambda par: par not in ['nu', 'args', 'kwargs'], pars))\n\n\n#@jit(float64[:](float64[:]), cache=True, nopython=True, nogil=True)\ndef cmb(nu):\n \"\"\" Function to compute CMB SED.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency in GHz.\n \"\"\"\n x = 0.0176086761 * nu\n ex = np.exp(x)\n sed = ex * (x / (ex - 1)) ** 2\n return sed\n\n\n#@jit(float64[:](float64[:], float64, float64), cache=True, nopython=True,\n# nogil=True)\ndef syncpl(nu, nu_ref_s, beta_s):\n \"\"\" Function to compute synchrotron power law SED.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency in GHz.\n beta_s: float\n Power law index in RJ units.\n\n Returns\n -------\n array_like(float)\n Synchroton SED relative to reference frequency.\n \"\"\"\n x = nu / nu_ref_s\n sed = x ** beta_s\n return sed\n\n\n#@jit(float64[:](float64[:], float64, float64, float64), cache=True,\n# nopython=True, nogil=True)\ndef sync_curvedpl(nu, nu_ref_s, beta_s, beta_c):\n \"\"\" Function to compute curved synchrotron power law SED.\n\n Parameters\n ----------\n nu: float, or array_like(float)\n Frequency in GHz.\n beta_s: float\n Power law index in RJ units.\n beta_c: float\n Power law index curvature.\n\n Returns\n -------\n array_like(float)\n Synchroton SED relative to reference frequency.\n \"\"\"\n x = nu / nu_ref_s\n sed = x ** (beta_s + beta_c * np.log(nu / nu_ref_s))\n return sed\n\n\n#@jit(float64[:](float64[:], float64, float64, float64), cache=True,\n# nopython=True, nogil=True)\ndef dustmbb(nu, nu_ref_d, beta_d, T_d):\n \"\"\" Function to compute modified blackbody dust SED.\n\n Parameters\n ----------\n nu: float or array_like(float)\n Freuency at which to calculate SED.\n nu_ref_d: float\n Reference frequency in GHz.\n beta_d: float\n Power law index of dust opacity.\n T_d: float\n Temperature of the dust.\n\n Returns\n -------\n array_like(float)\n SED of dust modified black body relative to reference frequency.\n \"\"\"\n x_to = 0.0479924466 * nu / T_d\n x_from = 0.0479924466 * nu_ref_d / T_d\n sed = (nu / nu_ref_d) ** (1. + beta_d) * (np.exp(x_from) - 1) / (np.exp(x_to) - 1)\n return sed\n" ]

[ [ "numpy.log", "numpy.exp" ] ]

davanstrien/flyswot

[ "630aa4f51c4381a7832846a7ef5be7af06a4b47b" ]

[ "src/flyswot/inference.py" ]

[ "\"\"\"Inference functionality\"\"\"\nimport csv\nimport mimetypes\nimport re\nimport string\nimport time\nfrom abc import ABC\nfrom abc import abstractmethod\nfrom collections import defaultdict\nfrom collections import OrderedDict\nfrom dataclasses import asdict\nfrom dataclasses import dataclass\nfrom datetime import datetime\nfrom datetime import timedelta\nfrom functools import singledispatch\nfrom pathlib import Path\nfrom typing import Dict\nfrom typing import Iterable\nfrom typing import List\nfrom typing import Optional\nfrom typing import Union\n\nimport numpy as np\nimport onnxruntime as rt\nimport typer\nfrom PIL import Image # type: ignore\nfrom rich import print\nfrom rich.columns import Columns\nfrom rich.layout import Layout\nfrom rich.markdown import Markdown\nfrom rich.panel import Panel\nfrom rich.table import Table\nfrom rich.text import Text\nfrom toolz import itertoolz\n\nfrom flyswot import core\nfrom flyswot import models\nfrom flyswot.console import console\nfrom flyswot.logo import flyswot_logo\n\napp = typer.Typer()\n\n\n@dataclass\nclass ImagePredictionItem:\n \"\"\"Prediction for an image.\n\n Attributes:\n path: The Path to the image\n predicted_label: The predicted label i.e. the argmax value for the prediction tensor\n confidence: The confidence for `predicted_label` i.e. the max value for prediction tensor\n \"\"\"\n\n path: Path\n predicted_label: str\n confidence: float\n\n def __post_init__(self) -> Union[Path, None]:\n \"\"\"attempt to get absolute path\"\"\"\n try:\n self.path: Path = self.path.absolute()\n except AttributeError:\n pass\n\n\n@dataclass\nclass MultiLabelImagePredictionItem:\n \"\"\"Multiple predictions for a single image\"\"\"\n\n path: Path\n predictions: List[Dict[float, str]]\n\n def _get_top_labels(self) -> List[str]:\n \"\"\"Get top labels\"\"\"\n top_labels = []\n for prediction in self.predictions:\n top_label = sorted(prediction.items(), reverse=True)[0][1]\n top_labels.append(top_label)\n return top_labels\n\n # Post init that gets top prediction label from predictions\n def __post_init__(self):\n \"\"\"Get top prediction label\"\"\"\n self.predicted_labels = self._get_top_labels()\n\n\n@dataclass\nclass PredictionBatch:\n \"\"\"Container for ImagePredictionItems\"\"\"\n\n batch: List[ImagePredictionItem]\n\n def __post_init__(self):\n \"\"\"Returns a iterable of all predicted labels in batch\"\"\"\n self.batch_labels: Iterable[str] = (item.predicted_label for item in self.batch)\n\n\n@dataclass\nclass MultiPredictionBatch:\n \"\"\"Container for MultiLabelImagePredictionItems\"\"\"\n\n batch: List[MultiLabelImagePredictionItem]\n\n def _get_predicted_labels(self) -> Iterable:\n \"\"\"Returns a iterable of all predicted labels in batch\"\"\"\n return (item.predicted_labels for item in self.batch)\n\n def __post_init__(self):\n \"\"\"Returns a iterable of lists containing all predicted labels in batch\"\"\"\n # self.batch_labels: Iterable = (\n # list(itertoolz.pluck(0, pred))\n # for pred in zip(*[o.predictions for o in self.batch])\n # )\n self.batch_labels = self._get_predicted_labels()\n\n\nimage_extensions = {k for k, v in mimetypes.types_map.items() if v.startswith(\"image/\")}\n\n\[email protected]()\ndef predict_image(\n image: Path = typer.Argument(..., readable=True, resolve_path=True)\n) -> None:\n \"\"\"Predict a single image\"\"\"\n pass # pragma: no cover\n\n\ndef check_files(files: List, pattern: str, directory: Path) -> None:\n \"\"\"Check if files exist and raises error if not\"\"\"\n if not files:\n typer.echo(\n f\"Didn't find any files maching {pattern} in {directory}, please check the inputs to flyswot\"\n )\n raise typer.Exit(code=1)\n\n\[email protected](name=\"directory\")\ndef predict_directory(\n directory: Path = typer.Argument(\n ...,\n readable=True,\n resolve_path=True,\n help=\"Directory to start searching for images from\",\n ),\n csv_save_dir: Path = typer.Argument(\n ...,\n writable=True,\n resolve_path=True,\n help=\"Directory used to store the csv report\",\n ),\n pattern: str = typer.Option(\"fs\", help=\"Pattern used to filter image filenames\"),\n bs: int = typer.Option(16, help=\"Batch Size\"),\n image_format: str = typer.Option(\n \".tif\",\n help=\"Image format for flyswot to use for predictions, defaults to `*.tif`\",\n ),\n model_name: str = typer.Option(\n \"latest\", help=\"Which model flyswot should use for making predictions\"\n ),\n model_path: str = None,\n):\n \"\"\"Predicts against all images stored under DIRECTORY which match PATTERN in the filename.\n\n By default searches for filenames containing 'fs'.\n\n Creates a CSV report saved to `csv_save_dir`\n \"\"\"\n start_time = time.perf_counter()\n model_dir = models.ensure_model_dir()\n model = models.ensure_model(model_dir)\n # if model_name != \"latest\" and not model_path:\n # model_parts = models._get_model_parts(Path(model_dir / Path(model_name)))\n # if model_name != \"latest\" and model_path:\n # model_parts = models._get_model_parts(Path(model_path / Path(model_name)))\n onnxinference = OnnxInferenceSession(model.model, model.vocab)\n files = sorted(core.get_image_files_from_pattern(directory, pattern, image_format))\n check_files(files, pattern, directory)\n typer.echo(f\"Found {len(files)} files matching {pattern} in {directory}\")\n csv_fname = create_csv_fname(csv_save_dir)\n with typer.progressbar(length=len(files)) as progress:\n images_checked = 0\n for i, batch in enumerate(itertoolz.partition_all(bs, files)):\n batch_predictions = onnxinference.predict_batch(batch, bs)\n if i == 0: # pragma: no cover\n create_csv_header(batch_predictions, csv_fname)\n write_batch_preds_to_csv(batch_predictions, csv_fname)\n progress.update(len(batch))\n images_checked += len(batch)\n delta = timedelta(seconds=time.perf_counter() - start_time)\n print_inference_summary(\n str(delta), pattern, directory, csv_fname, image_format, images_checked\n )\n\n\ndef print_inference_summary(\n time_delta: str,\n pattern: str,\n directory: Path,\n csv_fname: Path,\n image_format: str,\n matched_file_count: int,\n local_model: Optional[models.LocalModel] = None,\n):\n \"\"\"prints summary report\"\"\"\n print(flyswot_logo())\n print(\n Panel(\n Text(\n f\"CSV report file at: {csv_fname.as_uri()}\",\n ),\n title=\" :clipboard: CSV report :clipboard:\",\n )\n )\n print(\n Panel(\n Text(f\"{time_delta}\", justify=\"center\", style=\"bold green\"),\n title=\":stopwatch: Time taken to run :stopwatch:\",\n )\n )\n print(\n create_file_summary_markdown(\n pattern, matched_file_count, directory, image_format\n )\n )\n inference_summary_columns = get_inference_table_columns(csv_fname)\n print(Panel(inference_summary_columns, title=\"Prediction Summary\"))\n if local_model is not None:\n print(models.show_model_card(localmodel=local_model))\n\n\ndef create_file_summary_markdown(\n pattern: str, matched_file_count: int, directory: Path, image_format: str\n) -> Panel:\n \"\"\"creates Markdown summary containing number of files checked by flyswot vs total images files under directory\"\"\"\n total_image_file_count = core.count_files_with_ext(directory, image_format)\n return Panel(\n Markdown(\n f\"\"\"\n - flyswot searched for image files by matching the patern *{pattern}*\n - flyswot search inside: `{directory}`\n - In total the directory contained **{total_image_file_count}** images\n - There were **{matched_file_count}** files matching the {pattern}* pattern which flyswot checked\n \"\"\"\n ),\n title=\":file_folder: files checked :file_folder:\",\n )\n\n\ndef get_inference_table_columns(csv_fname: Path) -> Columns:\n \"\"\"print_inference_summary from `fname`\"\"\"\n labels_to_print = labels_from_csv(csv_fname)\n tables = [\n print_table(labels, f\"Prediction summary {i+1}\", print=False)\n for i, labels in enumerate(labels_to_print)\n ]\n return Columns(tables)\n\n\nlabel_regex = re.compile(r\"prediction_label_\\D_0\")\n\n\ndef labels_from_csv(fname: Path) -> List[List[str]]:\n \"\"\"Gets top labels from csv `fname`\"\"\"\n columns = defaultdict(list)\n with open(fname, \"r\") as f:\n reader = csv.DictReader(f)\n for row in reader:\n for (k, v) in row.items():\n columns[k].append(v)\n return [columns[k] for k in columns if label_regex.match(k)]\n\n\ndef print_table(\n decoded: list, header: str = \"Prediction summary\", print: bool = True\n) -> Table:\n \"\"\"Prints table summary of predicted labels\"\"\"\n table = Table(show_header=True, title=header)\n table.add_column(\n \"Class\",\n )\n table.add_column(\"Count\")\n table.add_column(\"Percentage\")\n total = len(decoded)\n frequencies = itertoolz.frequencies(decoded)\n for is_last_element, var in core.signal_last(frequencies.items()):\n key, value = var\n count = value\n percentage = round((count / total) * 100, 2)\n if is_last_element:\n table.add_row(key, str(count), f\"{percentage}\", end_section=True)\n table.add_row(\"Total\", str(total), \"\")\n else:\n table.add_row(key, str(count), f\"{percentage}\")\n if print:\n console.print(table)\n return table\n\n\ndef make_layout():\n \"\"\"Define the layout.\"\"\"\n layout = Layout(name=\"root\")\n layout.split(Layout(name=\"header\", size=4), Layout(name=\"main\"))\n layout[\"main\"].split_column(\n Layout(name=\"info\", size=4), Layout(name=\"body\", ratio=2, minimum_size=60)\n )\n layout[\"info\"].split_row(Layout(name=\"time\"), Layout(name=\"files\"))\n return layout\n\n\n# def print_summary(columns, time, files):\n# layout = make_layout()\n# MARKDOWN = \"\"\"\n# # Prediction summary\n# \"\"\"\n# md = Markdown(MARKDOWN)\n# layout[\"header\"].update(md)\n# layout[\"body\"].update(columns)\n# layout[\"time\"].update(time)\n# layout[\"files\"].update(f\"Number of files checked {len(files)}\")\n# print(layout)\n\n\ndef create_csv_fname(csv_directory: Path) -> Path:\n \"\"\"Creates a csv filename\"\"\"\n date_now = datetime.now()\n date_now = date_now.strftime(\"%Y_%m_%d_%H_%M\")\n fname = Path(date_now + \".csv\")\n return Path(csv_directory / fname)\n\n\n@singledispatch\ndef create_csv_header(batch, csv_path) -> None:\n \"\"\"Print csv header\"\"\"\n raise NotImplementedError(f\"Not implemented for type {batch}\")\n\n\n@create_csv_header.register\ndef _(batch: PredictionBatch, csv_path):\n \"\"\"Creates a header for csv `csv_path`\"\"\"\n with open(csv_path, mode=\"w\", newline=\"\") as csv_file:\n field_names = [\"path\", \"directory\", \"prediction\", \"confidence\"]\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n writer.writeheader()\n\n\n@create_csv_header.register\ndef _(batch: MultiPredictionBatch, csv_path: Path, top_n: int = 2):\n item = batch.batch[0]\n pred = OrderedDict()\n pred[\"path\"] = asdict(item)[\"path\"]\n pred[\"directory\"] = asdict(item)[\"path\"].parent\n for i, _ in enumerate(item.predictions):\n for j in range(top_n):\n pred[f\"prediction_label_{string.ascii_letters[i]}_{j}\"] = \"\"\n pred[f\"confidence_label_{string.ascii_letters[i]}_{j}\"] = \"\"\n with open(csv_path, mode=\"w\", newline=\"\") as csv_file:\n field_names = list(pred.keys())\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n writer.writeheader()\n\n\n@singledispatch\ndef write_batch_preds_to_csv(predictions, csv_fpath: Path) -> None:\n \"\"\"print batch preds to csv\"\"\"\n raise NotImplementedError(f\"Not implemented for type {predictions}\")\n\n\n@write_batch_preds_to_csv.register\ndef _(predictions: PredictionBatch, csv_fpath: Path) -> None:\n \"\"\"Appends `predictions` batch to `csv_path`\"\"\"\n with open(csv_fpath, mode=\"a\", newline=\"\") as csv_file:\n field_names = [\"path\", \"directory\", \"predicted_label\", \"confidence\"]\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n for pred in predictions.batch:\n row = asdict(pred)\n row[\"directory\"] = pred.path.parent\n writer.writerow(row)\n\n\n@write_batch_preds_to_csv.register\ndef _(predictions: MultiPredictionBatch, csv_fpath: Path, top_n: int = 2) -> None:\n for pred in predictions.batch:\n row = OrderedDict()\n row[\"path\"] = asdict(pred)[\"path\"]\n row[\"directory\"] = asdict(pred)[\"path\"].parent\n for i, v in enumerate(pred.predictions):\n sorted_predictions = sorted(v.items(), reverse=True)\n for j in range(top_n):\n row[f\"prediction_label_{i}_{j}\"] = sorted_predictions[j][1]\n row[f\"confidence_label_{i}_{j}\"] = sorted_predictions[j][0]\n with open(csv_fpath, mode=\"a\", newline=\"\") as csv_file:\n field_names = list(row.keys())\n writer = csv.DictWriter(csv_file, fieldnames=field_names)\n writer.writerow(row)\n\n\nclass InferenceSession(ABC):\n \"\"\"Abstract class for inference sessions\"\"\"\n\n @abstractmethod\n def __init__(self, model: Path, vocab: List): # pragma: no cover\n \"\"\"Inference Sessions should init from a model file and vocab\"\"\"\n self.model = model\n self.vocab = vocab\n\n @abstractmethod\n def predict_image(self, image: Path): # pragma: no cover\n \"\"\"Predict a single image\"\"\"\n pass\n\n @abstractmethod\n def predict_batch(\n self, model: Path, batch: Iterable[Path], bs: int\n ): # pragma: no cover\n \"\"\"Predict a batch\"\"\"\n pass\n\n\ndef softmax(x):\n \"\"\"return softmax of `x`\"\"\"\n x = x.reshape(-1)\n e_x = np.exp(x - np.max(x))\n return e_x / e_x.sum(axis=0)\n\n\n# class FastaiInferenceModel(InferenceSession):\n# def __init__(self, model):\n# self.model = model\n# self.learn = load_learner(model)\n\n# def predict_image(self, image: Path) -> Any:\n# return self.learn.predict(image)\n\n# def predict_batch(self, batch: Iterable[Path], bs: int) -> PredictionBatch:\n# test_dl = self.learn.dls.test_dl(batch, bs=bs)\n# vocab = dict(enumerate(self.learn.dls.vocab))\n# with self.learn.no_bar():\n# fastai_preds: Any = self.learn.get_preds(dl=test_dl, with_decoded=True)\n# prediction_tensors: Iterable[Any] = fastai_preds[0]\n# prediction_items = []\n# for file, pred in zip(batch, prediction_tensors):\n# arg_max = int(np.array(pred).argmax())\n# predicted_label = vocab[int(arg_max)]\n# confidence = float(np.array(pred).max())\n# prediction_items.append(\n# ImagePredictionItem(file, predicted_label, confidence)\n# )\n# return PredictionBatch(prediction_items)\n\n\nclass OnnxInferenceSession(InferenceSession): # pragma: no cover\n \"\"\"onnx inference session\"\"\"\n\n def __init__(self, model: Path, vocab: Path):\n \"\"\"Create onnx session\"\"\"\n self.model = model\n self.session = rt.InferenceSession(str(model))\n\n self.vocab = models.load_vocab(vocab)\n self.vocab_mappings = [dict(enumerate(v)) for v in self.vocab]\n\n def predict_image(\n self, image: Path\n ) -> Union[ImagePredictionItem, MultiLabelImagePredictionItem]:\n \"\"\"Predict a single image\"\"\"\n img = self._load_image(image)\n output_names = [o.name for o in self.session.get_outputs()]\n raw_result = self.session.run(output_names, {\"image\": img})\n if len(self.vocab) < 2:\n pred = self._postprocess(raw_result)\n arg_max = int(np.array(pred).argmax())\n predicted_label = self.vocab_mappings[0][int(arg_max)]\n confidence = float(np.array(pred).max())\n return ImagePredictionItem(image, predicted_label, confidence)\n else:\n prediction_dicts = []\n for vocab_map, pred in zip(self.vocab_mappings, raw_result):\n predictions = self._postprocess(pred)\n prediction_dict = {\n float(prediction): vocab_map[i]\n for i, prediction in enumerate(predictions)\n }\n prediction_dicts.append(prediction_dict)\n return MultiLabelImagePredictionItem(image, prediction_dicts)\n\n def _preprocess(self, input_data: np.ndarray) -> np.ndarray:\n # converts the input data into the float32 input for onnx\n img_data = input_data.astype(\"float32\")\n\n # normalize\n mean_vec = np.array([0.485, 0.456, 0.406])\n stddev_vec = np.array([0.229, 0.224, 0.225])\n norm_img_data = np.zeros(img_data.shape).astype(\"float32\")\n for i in range(img_data.shape[0]):\n norm_img_data[i, :, :] = (\n img_data[i, :, :] / 255 - mean_vec[i]\n ) / stddev_vec[i]\n\n # add batch channel\n norm_img_data = norm_img_data.reshape(1, 3, 512, 512).astype(\"float32\")\n return norm_img_data\n\n def _load_image(self, file: Path) -> np.ndarray:\n \"\"\"loads image and carries out preprocessing for inference\"\"\"\n image = Image.open(file, mode=\"r\")\n image = image.resize((512, 512), Image.BILINEAR)\n image_data = np.array(image).transpose(2, 0, 1)\n return self._preprocess(image_data)\n\n def _postprocess(self, result: List):\n \"\"\"process results from onnx session\"\"\"\n return softmax(np.array(result)).tolist()\n\n def predict_batch(\n self, batch: Iterable[Path], bs: int\n ) -> Union[PredictionBatch, MultiPredictionBatch]:\n \"\"\"predicts a batch of images\"\"\"\n prediction_items = [self.predict_image(file) for file in batch]\n if len(self.vocab) < 2:\n return PredictionBatch(prediction_items)\n else:\n return MultiPredictionBatch(prediction_items)\n\n\nif __name__ == \"__main__\":\n app() # pragma: no cover\n" ]

[ [ "numpy.max", "numpy.array", "numpy.zeros" ] ]

vicjung/meme-glossary

[ "b502587825f3892f411a66421a7ba789c18d59cb" ]

[ "prepare_memes/xml2vec.py" ]

[ "#!/usr/bin/env python3\n'''\nGenerate .vec voca file from image xml folder. (voca format is KeyedVectors.load_word2vec_format.) [filename : vector]\nUsage : ./xml2vec --model_path=./model.bin --xml_dir=./xml_dir/ --vec_path=./voca.vec\n'''\nimport sys\nimport os\nsys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))\n\nfrom lxml import objectify\nimport numpy as np\nimport argparse\nimport re\nfrom server.nlp.model import EmbedModel\n\n# requires : sentence embedding -- input : model_bin, xml_folder, vec_out_dir\ndef get_args_parser():\n parser = argparse.ArgumentParser(description='Paths for processing')\n parser.add_argument('-m', '--model_path', type=str, default='./model.bin',\n required=True, help='Path of model.')\n parser.add_argument('-x', '--xml_dir', type=str, required=True,\n help='Directory of xml labels. e.g ./4_label_xml/')\n parser.add_argument('-v', '--vec_path', type=str, required=True,\n help='Path of output .vec file. e.g ./5_test_meme_voca.vec')\n parser.add_argument('-l', '--lang', default=None, help='if it is \"ko\", model does additional korean tokenizing')\n parser.add_argument('-n', '--include_no_text', type=bool, default=True, help='include no text images to vector as zeros.')\n \n args = parser.parse_args()\n return args\n\ndef rm_gbg_from_xml(value):\n value = str(value).replace('\\t','').replace('\\n','')\n value = re.search(r'\\s{0,}(.*)', value).group(1)\n return value\n\ndef xml2vec(args):\n model_path = os.path.abspath(args.model_path)\n xml_dir = os.path.abspath(args.xml_dir) + '/'\n out_path = os.path.abspath(args.vec_path)\n lang = args.lang\n no_txt_flag = args.include_no_text\n \n print('\\nmodel path : ', model_path)\n model = EmbedModel(lang)\n print('loading model... ')\n model.load_model(model_path)\n \n out_dir = out_path.rsplit('/',1)[0]\n if not os.path.exists(out_dir):\n os.makedirs(out_dir)\n\n # Reads xml file and generating .vec file (gensim format)\n num_word = 0\n vec_size = None\n \n # Writing to .vec file.\n vecfile_content = ''\n flag=True\n episodes = os.listdir(xml_dir)\n\n for episode in episodes:\n xmls = os.listdir(xml_dir+episode)\n print('\\n## Episode : ',episode)\n if episode == '.ipynb_checkpoints':\n continue \n \n for xml_file in xmls:\n path = xml_dir+episode+'/' + xml_file\n rel_path = episode +'/' + xml_file\n\n if not path.lower().endswith(('.xml')):\n continue\n\n # open .xml\n f = open(xml_dir+episode+'/'+str(xml_file))\n xml_string = f.read()\n if not xml_string:\n continue\n\n xml_root = objectify.fromstring(xml_string)\n # label is saved in ['object']['name'].\n q_str = rm_gbg_from_xml(xml_root['object']['name']) \n '''\n q_str = re.sub(r'\\n{1,}', ' ', q_str)\n q_str = re.sub(r'\\n{1,}', ' ', q_str)\n q_str = re.sub(r'\\s{1,}', ' ', q_str)\n q_str = re.search(r'\\s{0,}(.*)', q_str).group(1)\n '''\n if q_str or no_txt_flag:\n emb = model.embed_sentence(q_str)\n # if vector is retrieved.\n if np.any(emb) or no_txt_flag:\n if flag:\n vec_size=len(emb[0])\n flag=False\n vecfile_content += rel_path +' '\n\n for vec in emb[0]:\n vecfile_content += (str(vec) + ' ')\n vecfile_content += '\\n'\n num_word+=1\n print(str(xml_file) + ' ' + str(q_str)) \n f.close()\n\n with open(out_path, 'w') as vec_file:\n vec_file.write(str(num_word)+' '+str(vec_size) +'\\n') \n vec_file.write(vecfile_content)\n\ndef main():\n args = get_args_parser()\n xml2vec(args)\n print('\\nInclude none-text meme flag: %s' %(str(args.include_no_text)))\n print('Write done : %s\\n' %(args.vec_path))\n \nif __name__ == \"__main__\":\n main()\n" ]

[ [ "numpy.any" ] ]

jacopofar/sleep-anki-correlation

[ "ac7d152590839b3ff1ae7360d7dfc75b0ade6b41" ]

[ "activities_weekly_heatmap.py" ]

[ "from datetime import datetime\nimport json\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nHOURS = [str(x) for x in range(49)]\nWEEKDAYS = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']\n\n\ndef main():\n counts = np.zeros((len(WEEKDAYS), len(HOURS)))\n with open('activities.jsonl') as f:\n for line in f:\n ts = datetime.fromisoformat(json.loads(line)['timestamp'])\n counts[ts.weekday()][ts.hour * 2 + round(ts.minute / 30)] += 1\n\n fig, ax = plt.subplots()\n im = ax.imshow(counts, cmap=\"magma\")\n\n # We want to show all ticks...\n ax.set_yticks(np.arange(len(WEEKDAYS)))\n ax.set_xticks(np.arange(len(HOURS)))\n # ... and label them with the respective list entries\n ax.set_yticklabels(WEEKDAYS)\n ax.set_xticklabels([int(h)/2 for h in HOURS])\n\n # Rotate the tick labels and set their alignment.\n plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n\n ax.set_title(\"activities per weekday and hour\")\n fig.tight_layout()\n plt.show()\n\n\nif __name__ == '__main__':\n main()\n" ]

[ [ "matplotlib.pyplot.show", "matplotlib.pyplot.subplots" ] ]

bottydim/dginn

[ "c6b638b2df1e1fe57a76961b18c68dceee55ac38" ]

[ "dg_relevance.py" ]

[ "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nif __name__ == '__main__':\n tf.compat.v1.enable_eager_execution()\nfrom matplotlib import pyplot as plt\nfrom dginn.utils import vprint, Timer\nimport math\n\n# this should be only in the call module, all other modules should not have it!!!\n# best keep it in the main fx! \n# tf.compat.v1.enable_eager_execution()\nconfig = tf.compat.v1.ConfigProto()\n# config.gpu_options.visible_device_list = str('1')\n# config.gpu_options.per_process_gpu_memory_fraction = 0.5\nconfig.gpu_options.allow_growth = True\n\nsess = tf.compat.v1.Session(config=config)\n\nglobal verbose\nverbose = False\n\n\n##########COMPUTE##########\n# computes the importance scores of neurons to upper layer neurons \n# different methods \ndef compute_weight(model, fx_modulate=lambda x: x, verbose=False, local=False):\n '''\n model: model analyzed\n fx_module: extra weight processing\n '''\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling/concatenate/flatten \n if l.weights == []:\n vprint(l.name, verbose=verbose)\n omega_val[l] = np.array([])\n continue\n vprint(\"layer:{}\".format(l.name), verbose=verbose)\n # 1. compute values\n vprint(\"w.shape:{}\".format(l.weights[0].shape), verbose=verbose)\n score_val = l.weights[0][:, :]\n score_val = fx_modulate(score_val)\n\n # 2 aggragate across locations\n # if convolutional - check if convolutional using the shape\n # 2.1 4D input (c.f. images)\n if len(score_val.shape) > 3:\n vprint(\"\\tshape:{}\", verbose=verbose)\n vprint(\"\\tscore_val.shape:{}\".format(score_val.shape), verbose=verbose)\n score_val = np.mean(score_val, axis=(0, 1))\n elif len(score_val.shape) > 2:\n # 3D convolutional\n vprint(\"\\tshape:{}\", verbose=verbose)\n vprint(\"\\tscore_val.shape:{}\".format(score_val.shape), verbose=verbose)\n score_val = np.mean(score_val, axis=(0))\n # 3. aggregate across datapoints\n # ===redundant for weights\n # 4. Global Aggregation: tokenize values across upper layer neurons\n if not local:\n score_agg = np.mean(score_val, axis=-1)\n else:\n score_agg = score_val\n vprint(\"\\tomega_val.shape:{}\".format(score_agg.shape), verbose=verbose)\n omega_val[l] = score_agg\n\n return omega_val\n\n\ncompute_weight_abs = lambda x: compute_weight(x, fx_modulate=np.abs)\n\n\ndef compute_weights_gen(data, fx_modulate=lambda x: x, layer_start=None,\n agg_data_points=True,\n verbose=False):\n '''\n\n :param data:\n :param fx_modulate:\n :param layer_start:\n :param agg_data_points: whehter to aggragate across data points\n :param verbose:\n :return: return all neuron importance for all layers starting from layer_start\n '''\n return lambda x: compute_weight(x, fx_modulate=fx_modulate)\n\n\n### ACTIVATIONS\n\n### ACTIVATIONS ALL! \n# LOCAL computaion - rename!\n\n\n### ACTIVATIONS Global\ndef compute_activations_gen(data, fx_modulate=lambda x: x, layer_start=None,\n agg_data_points=True,\n verbose=False):\n \"\"\"\n agg_data_points: whehter to aggragate across data points\n return: return all neuron importance for all layers starting from layer_start\n \n compute_activations = compute_activations_gen(X_test)\n DG_a_mean = relevance_select_mean(compute_activations(model),input_layer=model.layers[0])\n \"\"\"\n\n def compute_activations_(model):\n omega_val = {}\n for l in model.layers[layer_start:]:\n vprint(\"layer:{}\".format(l.name), verbose=verbose)\n # 1. compute values\n # l.output vs l.input\n # l.output => omega_val[l] = NB on the same layer (which makes sense for activations)\n # conv1d_8--(2, 1170, 20) (2,32,32,20)\n # 3D shape:(2, 20)\n # omega_val.shape:(20,)\n # CHALLENGE => it doesn't make sense for the last layer\n # layer:targetPower--(1, 23)\n # omega_val.shape:(23,) => where instead we want the importance\n # l.input => omega_val[l] = NB of the previous layer\n # conv1d_8--(2, 1199, 1) \\\\ shape of previous layer!\n # 3D shape:(2, 1)\n # omega_val.shape:(1,)\n # l.input is NOT working for multi input\n # crash @concatenate\n\n # concetenates the input for concatenate layers \n if type(l) is tf.keras.layers.Concatenate:\n output = tf.keras.layers.concatenate(l.input)\n else:\n output = l.input\n # faster way is to include all layers to the output array! \n model_k = tf.keras.Model(inputs=model.inputs, outputs=[output])\n score_val = model_k.predict(data)\n score_val = fx_modulate(score_val)\n vprint(\"layer:{}--{}\".format(l.name, score_val.shape), verbose=verbose)\n # 2 aggragate across locations\n # 2.1 4D input (c.f. images)\n if len(score_val.shape) > 3:\n\n score_val = np.mean(score_val, axis=(1, 2))\n vprint(\"\\t 4D shape:{}\".format(score_val.shape), verbose=verbose)\n # 2.2 aggregate across 1D-input\n elif len(score_val.shape) > 2:\n score_val = np.mean(score_val, axis=(1))\n vprint(\"\\t 3D shape:{}\".format(score_val.shape), verbose=verbose)\n # 3. aggregate across datapoints\n # ? Why abs? naturally this affect previous experiments\n if agg_data_points:\n score_val = np.mean(np.abs(score_val), axis=0)\n\n # 4. tokenize values\n # ===redundant for activations\n omega_val[l] = score_val\n vprint(\"\\t omega_val.shape:{}\".format(score_val.shape), verbose=verbose)\n\n return omega_val\n\n return compute_activations_\n\n\n### GRADS\n\ndef compute_grads_helper(model, data, loss_, fx_modulate):\n # TODO\n raise NotImplemented\n return omega_val\n\n\ndef compute_grads_gen(data, loss_=lambda x: tf.reduce_sum(x[:, :]), fx_modulate=lambda x: x, verbose=False,\n batch_size=128):\n \"\"\"\n General idea: go through all layers, compute the derivatives of the upper layer neurons wrt current \n \n e.g. \n compute_grads = compute_grads_gen(X_test,loss_fx)\n grads = compute_grads(model)\n \"\"\"\n\n def compute_grads(model):\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n omega_val[l] = np.array([])\n continue\n # 1. compute values\n # \n model_k = tf.keras.Model(inputs=model.inputs, outputs=[l.output])\n # last layer of the new model\n inter_l = model_k.layers[-1]\n\n # NB!\n # make sure to compute gradient correctly for the last layer by chaning the activation fx \n if l == model.layers[-1]:\n activation_temp = l.activation\n if l.activation != tf.keras.activations.linear:\n l.activation = tf.keras.activations.linear\n\n score_val = np.zeros(inter_l.weights[0].shape)\n\n # handle multi-input data\n\n if type(data) is dict:\n key = list(data.keys())[0]\n data_len = data[key].shape[0]\n else:\n data_len = data.shape[0]\n\n # what do we do with multi-input data?!\n # TODO fix strange name change : vs _\n input_names = [l.name.split(\":\")[0] for l in model.inputs]\n # !!!!! FOLLOWING Line not tested\n input_names = [l.split(\"_\")[0] for l in input_names]\n # split the data into batches\n for i in range(0, data_len, batch_size):\n # TODO experiment speed if with device(cpu:0) \n with tf.GradientTape() as t:\n # for some reason requires tensor, otherwise blows up\n # c.f. that for activations we use model.predict\n if type(data) is dict:\n tensor = []\n for k in input_names:\n tensor.append(data[k][i:min(i + batch_size, data_len)].astype('float32'))\n else:\n tensor = tf.convert_to_tensor(data[i:min(i + batch_size, data_len)], dtype=tf.float32)\n current_loss = loss_(model_k(tensor))\n dW, db = t.gradient(current_loss, [*inter_l.weights])\n score_val += fx_modulate(dW)\n\n # restor output function! \n if l == model.layers[-1]:\n l.activation = activation_temp\n\n vprint(\"layer:{}--{}\".format(l.name, score_val.shape), verbose=verbose)\n # 2 aggragate across locations\n # 2.1 4D\n if len(score_val.shape) > 3:\n # (3, 3, 3, 64) -> for activations, it is not aggregated across data-points\n score_val = np.mean(score_val, axis=(0, 1))\n vprint(\"\\t 4D shape:{}\".format(score_val.shape), verbose=verbose)\n elif len(score_val.shape) > 2:\n score_val = np.mean(score_val, axis=(0))\n vprint(\"\\t 3D shape:{}\".format(score_val.shape), verbose=verbose)\n # 3. aggregate across datapoints\n\n # already produced by line 230 \n # to include data point analysis, we can use persistant gradient_tape\n # compute point by point or use the loss\n # explore this issue for efficiency gain https://github.com/tensorflow/tensorflow/issues/4897\n\n # 4. tokenize values\n mean = np.mean(score_val, axis=1)\n omega_val[l] = mean\n\n vprint(\"\\t omega_val.shape:{}\".format(mean.shape), verbose=verbose)\n return omega_val\n\n return compute_grads\n\n\n### Weights * activations\n\n\ndef compute_weight_activations_gen(data, fx_modulate=lambda x: x, verbose=verbose):\n def compute_weight_activations_(model):\n omega_val = {}\n for l in model.layers:\n\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n omega_val[l] = np.array([])\n\n continue\n\n # 1. compute values\n\n # 1.1 compute activations \n model_k = tf.keras.Model(inputs=model.inputs, outputs=[l.input])\n score_val_a = model_k.predict(data)\n\n score_val_a = fx_modulate(score_val_a)\n\n # 1.2 compute \n\n score_val_w = l.weights[0][:]\n score_val_w = fx_modulate(score_val_w)\n\n # 2 aggragate across locations\n\n # 2.1 Aggregate Across Activations\n # 2.1.1 aggregate across 4D\n if len(score_val_a.shape) > 3:\n score_val_a = np.mean(score_val_a, axis=(1, 2))\n vprint(\"\\t 4D shape:{}\".format(score_val_a.shape), verbose=verbose)\n # 2.1.2 aggregate across 3D(1D-input)\n elif len(score_val_a.shape) > 2:\n score_val_a = np.mean(score_val_a, axis=(1))\n vprint(\"\\t 3D shape:{}\".format(score_val_a.shape), verbose=verbose)\n\n # 2.2.1 aggragate across locations (WEIGHTS)\n if len(score_val_w.shape) > 3:\n vprint(\"\\tshape:{}\", verbose=verbose)\n vprint(\"\\tscore_val.shape:{}\".format(score_val_w.shape), verbose=verbose)\n score_val_w = np.mean(score_val_w, axis=(0, 1))\n elif len(score_val_w.shape) > 2:\n score_val_w = np.mean(score_val_w, axis=(0))\n\n # 3. aggregate across datapoints\n score_agg_a = np.mean(score_val_a, axis=0)\n\n # ===redundant for weights\n # 4. tokenize values\n # ===redundant for activations\n score_agg_w = np.mean(score_val_w, axis=-1)\n omega_val[l] = score_agg_a * score_agg_w\n return omega_val\n\n return compute_weight_activations_\n\n\n##### Increase Granularity: Weights Local\n\ndef compute_weight_per_channel(model, fx_modulate=lambda x: x):\n '''\n equivalent to compute_weight(model,fx_modulate=lambda x:x,verbose=False,local=True)\n '''\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n # print(l.name)\n omega_val[l] = np.array([])\n continue\n # print(\"layer:{}\".format(l.name))\n # 1. compute values\n # print(\"w.shape:{}\".format(l.weights[0].shape))\n score_val = l.weights[0][:, :]\n score_val = fx_modulate(score_val)\n\n # 1.1 aggragate across locations\n if len(score_val.shape) > 3:\n # print(\"\\tshape:{}\")\n # print(\"\\tscore_val.shape:{}\".format(score_val.shape))\n score_val = np.mean(score_val, axis=(0, 1))\n # 2. aggregate across datapoints\n # ===redundant for weights\n # 3. tokenize values across upper layer neurons\n # score_agg = np.mean(score_val,axis=-1)\n score_agg = score_val\n # print(\"\\tomega_val.shape:{}\".format(score_agg.shape))\n omega_val[l] = score_agg\n\n return omega_val\n\n\n######## Combine Compute FX\ndef combine_compute_fx(relevances_a, relevances_b):\n '''\n \n e.g.\n compute_fx = compute_activations_gen(data_set,fx_modulate=np.abs,verbose=False)\n relevances_a = compute_fx(model)\n relevances_w = compute_weight(model,fx_modulate=np.abs)\n\n compute_fx = compute_weight_activations_gen(data_set,fx_modulate=np.abs,verbose=False)\n relevances_wa = compute_fx(model)\n\n compute_fx = compute_grads_gen(data_set,fx_modulate=np.abs,verbose=False)\n relevances_g = compute_fx(model)\n\n relevances_wa_app = combine_compute_fx(relevances_a,relevances_w)\n relevances_ga_app = combine_compute_fx(relevances_a,relevances_g)\n '''\n relevances_ab_app = {}\n for k, v in relevances_a.items():\n # print(k.name,type(relevances_a[k]),type(relevances_b[k]))\n if k.weights == []:\n relevances_ab_app[k] = np.array([])\n continue\n relevances_ab_app[k] = relevances_a[k] * relevances_b[k]\n return relevances_ab_app\n\n\n######### DEPENDENCY\n\n# TODO abstract out as fx!\n# one way to do is to make all computes classes \n# give them interfaces\n\n# COULD be equivalent to compute_weight_per_channel ???!! \ndef compute_dependency_weight(model, fx_modulate=lambda x: x):\n '''\n - does not aggragate across upper layer! \n equivalent to compute_weight(model,fx_modulate=lambda x:x,verbose=False,local=True)\n \n \n '''\n omega_val = {}\n for l in model.layers:\n # skips layers w/o weights \n # e.g. input/pooling \n if l.weights == []:\n # print(l.name)\n omega_val[l] = np.array([])\n continue\n # print(\"layer:{}\".format(l.name))\n # 1. compute values\n # print(\"w.shape:{}\".format(l.weights[0].shape))\n score_val = l.weights[0][:, :]\n score_val = fx_modulate(score_val)\n\n # print(\"\\tscore_val.shape:{}\".format(score_val.shape))\n # 2 aggragate across locations\n shape_len = len(score_val.shape)\n # 2.1 4D input (c.f. images)\n if shape_len > 3:\n score_val = np.mean(score_val, axis=(0, 1))\n # 2.2 aggregate across 1D-input\n elif shape_len > 2:\n score_val = np.mean(score_val, axis=(0))\n # 3. aggregate across datapoints\n # ===redundant for weights\n # 4. tokenize values across upper layer neurons\n # score_agg = np.mean(score_val,axis=-1)\n score_agg = score_val\n # print(\"\\tomega_val.shape:{}\".format(score_agg.shape))\n omega_val[l] = score_agg\n\n return omega_val\n\n\n##########GENERATE DG##########\n# tokenize\n\n\n# functions, which handle the neuron relevance selection\ndef percentage_threshold(relevance, t):\n r = np.ravel(relevance)\n # sort args based on val, reverse, take %\n return list(reversed(np.argsort(r)))[:math.ceil(len(r) * t)]\n\n\ndef select_random(relevance, threshold):\n size = len(relevance)\n return np.random.choice(size, threshold)\n\n\ndef relevance_select_(omega_val, input_layer, select_fx_):\n relevant = {}\n\n for l, relevance in omega_val.items():\n if type(input_layer) is list and l in input_layer:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n relevant[l] = [range(relevance.shape[1]) for _ in range(relevance.shape[0])]\n else:\n relevant[l] = range(len(relevance))\n elif l == input_layer:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n relevant[l] = np.array([range(relevance.shape[1]) for _ in range(relevance.shape[0])])\n else:\n relevant[l] = np.array(range(len(relevance)))\n # process layers without weights\n elif l.weights == []:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n relevant[l] = np.array([[] for _ in range(relevance.shape[0])])\n else:\n #in the event of bugs: used to be [] vs np.array([])\n relevant[l] = np.array([])\n\n else:\n # non-aggragated data points\n if relevance.shape[0] > 1:\n # returns an array with the same number of neuron id for each dg\n # the array contains the neuron ids that were selected as relevant\n relevant[l] = np.apply_along_axis(select_fx_, 1, relevance)\n else:\n relevant[l] = []\n idx = select_fx_(relevance)\n relevant[l] = idx\n return relevant\n\n\n\n\n# 3 functions below take\n# omega value: the compute relevances from the previous step\n# input_layer: KEEP ALL neurons LAYER - either list or single layer\n# threshold: varies depending on relevance_select_fx\ndef relevance_select_random(omega_val, input_layer, threshold):\n select_fx_random = lambda relevance: select_random(relevance, threshold)\n return relevance_select_(omega_val, input_layer, select_fx_random)\n\n\ndef relevance_select(omega_val, input_layer, threshold=0.5):\n select_fx_percentage = lambda relevance: percentage_threshold(relevance, threshold)\n return relevance_select_(omega_val, input_layer, select_fx_percentage)\n\n\ndef relevance_select_mean(omega_val, input_layer):\n def select_fx_mean(relevance):\n threshold = np.mean(relevance)\n idx = np.where(relevance > threshold)[0]\n return idx\n\n return relevance_select_(omega_val, input_layer, select_fx_mean)\n\n\n##########EVAL HELPERS##########\ndef get_time_hhmmss(start):\n import time\n end = time.time()\n m, s = divmod(end - start, 60)\n h, m = divmod(m, 60)\n time_str = \"%02d:%02d:%02d\" % (h, m, s)\n return time_str\n\n\n# inverse mask of the Dependency Graph:\n# turn-off all neurons, which are not part of the DG, and execute the network!\n# the same as running just the DG (dependency graph)\ndef get_DG_exec(model, dep_graph):\n temp_store = {}\n for l in model.layers:\n import time\n start = time.time()\n # skip pooling & flatten & concatenate\n if len(l.weights) == 0:\n continue\n # drop irrelevant\n w, b = l.weights\n # this way we create a copy? [:,;]?\n temp_store[l] = w[:, :], b[:]\n # gen all neuron indices in the current layer\n # and subtract from them all relevant indices (neurons in DG)\n # -2 in order to work for both convolutional[-2] & dense layers[0]\n irrelevant = set(range(w.shape[-2])) - set(dep_graph[l])\n neurons = list(irrelevant)\n\n target = w.numpy()\n n = neurons\n # skip layers which do not require any weight changes\n # observe the BUG! \n if len(n) == 0:\n continue\n # 4D convolutional\n if len(w.shape) > 3:\n target[:, :, n, :] = 0\n elif len(w.shape) > 2:\n target[:, n, :] = 0\n target_shape = target.shape\n else:\n target[n, :] = 0\n target_shape = target.shape\n\n tf.assign(w, target)\n # don't touched the bias, as it is like another neuron for the upper layer neuron\n # print(b.shape,n)\n # tf.assign(b[n], np.zeros(b.shape))\n # print(l.name,get_time_hhmmss(start))\n return model, temp_store\n\n\ndef recover_model(model, temp_store):\n for l in model.layers:\n # skip pooling & flatten\n if len(l.weights) == 0:\n continue\n w, b = l.weights\n temp_w, temp_b = temp_store[l]\n tf.assign(w, temp_w)\n return model\n\n\n##########EVAL##########\n\n\n#### EXTREMELY INEFFICIENT WAY TO EVAL!\ndef evaluate_dg_gen(model, data):\n X_, y_ = data\n\n def eval_dep_graph(dep_graph):\n temp_store = {}\n for l in model.layers:\n # skip pooling & flatten\n if len(l.weights) == 0:\n continue\n # drop irrelevant\n w, b = l.weights\n temp_store[l] = w[:, :], b[:]\n # gen all neuron indices and subtract from them all relevant indices\n # -2 in order to work for both convolutional[-2] & dense layers[0]\n irrelevant = set(range(w.shape[-2])) - set(dep_graph[l])\n neurons = list(irrelevant)\n\n # INEFFICIENT!! \n for n in neurons:\n if len(w.shape) > 2:\n target = w[:, :, n, :]\n target_shape = target.shape\n tf.assign(target, np.zeros(target.shape[:], ))\n else:\n tf.assign(w[n, :], np.zeros(w.shape[1]))\n # don't touched the bias, as it is like another neuron for the upper layer neuron\n # print(b.shape,n)\n # tf.assign(b[n], np.zeros(b.shape))\n score = model.evaluate(X_, y_, verbose=0, batch_size=256)\n\n for l in model.layers:\n # skip pooling & flatten\n if len(l.weights) == 0:\n continue\n w, b = l.weights\n temp_w, temp_b = temp_store[l]\n tf.assign(w, temp_w)\n return score\n\n return eval_dep_graph\n\n\nevaluate_dep_graph = lambda model, DG: evaluate_dg_gen(model, (X_test, Y_test))(DG)\nevaluate_dep_graph_train = lambda model, DG: evaluate_dg_gen(model, (X_train, Y_train))(DG)\n\n\n# runs evalaution of the computed dependecy graphs computed with various compute functions across different data-sets.\ndef evaluate_across_classes_with_threshold(model, data_sets, store_DGs=False, t_lim=None, ):\n def loss_fx(x):\n return tf.reduce_mean(x[:, :])\n\n DGs = []\n\n # import pdb; pdb.set_trace()\n train_data_sets, eval_data_sets = data_sets\n print(len(train_data_sets), train_data_sets[0][0].shape)\n print(len(eval_data_sets))\n timer = Timer()\n thresholds = [(i + 1) / 10.0 for i in range(10)][::-1]\n j_len = len(train_data_sets)\n i_len = 3\n k_len = len(eval_data_sets)\n t_len = len(thresholds)\n results = np.zeros((k_len, j_len, i_len, t_len, 2))\n for j, data_set in enumerate(train_data_sets):\n\n X_temp, y_temp = data_set\n # compute_activations = compute_activations_gen(X_temp)\n compute_activations_abs = compute_activations_gen(X_temp, fx_modulate=np.abs)\n # compute_grads = compute_grads_gen(X_temp,loss_fx)\n compute_grads_abs = compute_grads_gen(X_temp, loss_fx, fx_modulate=np.abs)\n # compute_wa = compute_weight_activations_gen(X_temp)\n compute_wa_abs = compute_weight_activations_gen(X_temp, np.abs)\n\n # compute_fxs = [compute_weight, compute_weight_abs,compute_activations,compute_activations_abs,\n # compute_grads,compute_grads_abs,compute_wa,compute_wa_abs]\n compute_fxs = [compute_activations_abs,\n compute_grads_abs, compute_wa_abs]\n # compute_fxs = [compute_wa_abs]\n print(\"Generate Compute FXs-{}\".format(timer.get_time_hhmmss()))\n # eval\n\n DGs.append([])\n for i, compute_fx in enumerate(compute_fxs):\n relevances = compute_fx(model)\n DGs[j].append([])\n print(\"COMPUTATION:\", timer.get_time_hhmmss())\n for t_, t in enumerate(thresholds):\n DG = relevance_select(relevances, input_layer=model.layers[0], threshold=t)\n if store_DGs:\n DGs[j][i].append(DG)\n dg_exec, tmp = get_DG_exec(model, DG)\n for k, eval_ds in enumerate(eval_data_sets):\n eval_dg = evaluate_dg_gen(model, eval_ds)\n score = dg_exec.evaluate(*eval_ds, batch_size=256, verbose=0)\n\n results[k, j, i, t_] = score\n assert np.all(results[k, j, i, t_] == score)\n # print(timer.get_time_hhmmss())\n # print info\n recover_model(model, tmp)\n fx = compute_fxs[i]\n name = \"_\".join(str(fx).split(\" \")[1].split(\"_\")[1:2])\n print(\"{}-#{}-{}-ts={}\".format(name, j, i, t))\n print(timer.get_time_hhmmss())\n if store_DGs:\n return results, DGs\n else:\n return results\n\n\n# LEGACY\ndef analyzer_gen(model):\n def analyze_dg(compute_fx, relevance_select_fx):\n\n dg_vals = compute_fx(model)\n value = list(dg_vals.values())\n for i in range(len(value)):\n if len(value[i]) == 0:\n continue\n mean = value[i]\n order = np.flip(np.argsort(np.abs(mean)))\n # plt.figure()\n plt.scatter(np.arange(mean.shape[0]), np.abs(mean[order]))\n DG = relevance_select_fx(compute_fx(model), input_layer=model.layers[0])\n report_eval_dep_graph(model, DG)\n return DG\n\n return analyze_dg\n\n\n######## Data Set Processing\n\n### CIFAR-specific\ndef get_data_sets_cls(X, Y, d_lim=None):\n data_sets = []\n for i in range(Y.shape[1]):\n idx = np.where(Y[:, i] == 1)[0]\n X_cls_i = X[idx]\n y_cls_i = Y[idx]\n # print(X_cls_i.shape,y_cls_i.shape)\n data_sets.append((X_cls_i[0:d_lim], y_cls_i[0:d_lim]))\n return data_sets\n\n\ndef get_data_sets(data_sets, cls_eval=True, d_lim=None):\n '''\n data_sets = [(X_train[0:256],Y_train[0:256]),(X_test[0:256],Y_test[0:256])]\n a,b = get_data_sets(data_sets)\n assert len(a) == 11 and len(b) == 22\n for ds in a:\n assert len(ds)==2\n for ds in b:\n assert len(ds)==2\n '''\n data_sets = data_sets[0:d_lim]\n train_data_sets = data_sets[0:1]\n train_data_cls = cls_eval\n # gen data_sets\n # FIX, these are global vars X_train,Y_train\n if train_data_cls:\n train_data_sets += get_data_sets_cls(X_train, Y_train)\n eval_data_sets = [_ for _ in train_data_sets]\n if len(data_sets) > 1:\n eval_data_sets += [data_sets[1]]\n # data_sets = [(X_train[:100],Y_train[:100]),(X_test[:100],Y_test[:100])]\n\n test_data_cls = cls_eval\n if test_data_cls:\n X_test = data_sets[1][0]\n Y_test = data_sets[1][1]\n for i in range(Y_test.shape[1]):\n idx = np.where(Y_test[:, i] == 1)[0]\n X_cls_i = X_test[idx]\n y_cls_i = Y_test[idx]\n # print(X_cls_i.shape,y_cls_i.shape)\n eval_data_sets.append((X_cls_i, y_cls_i))\n return train_data_sets, eval_data_sets\n\n\ndef merge_data_sets(cls_ds_list, id_list, d_lim=None):\n '''\n data_sets_list: list of (X,Y) typles\n '''\n output_ds = []\n\n for cls_ds in cls_ds_list:\n data_sets_merged = []\n for i in id_list:\n data_sets_merged += cls_ds[i]\n # irrelevant of len(id_list!)\n try:\n # get every second element b.c. there are X & Y\n X_ = np.vstack(data_sets_merged[::2])\n Y_ = np.vstack(data_sets_merged[1::2])\n output_ds.append((X_, Y_))\n except:\n print(X.shape)\n for x in data_sets_merged:\n print(x.shape)\n raise \"ERROR\"\n return output_ds\n\n\n##########UTILS########## \n\n# relabel the key of the Dependency Graphs \ndef relabel(DGs):\n DG_relabelled = {}\n for j in range(shapes[1]):\n for i in range(shapes[2]):\n for t_ in range(shapes[3]):\n DG = DGs[j][i][t_]\n for k, l in enumerate(model.layers):\n try:\n temp = DG[l]\n DG_relabelled[k] = temp\n except:\n print(j, i, t_)\n return\n return DG_relabelled\n\n\n##########COMPUTE UTILS##########\n# c.f. = confer = compare\n\n### counters\ndef cf_dgs(dg_a, dg_b):\n '''\n count number of shared neurons\n '''\n total = 0\n for (k, v) in dg_a.items():\n a = set(v)\n b = set(dg_b[k])\n r = len(a.intersection(b))\n total += r\n return total\n\n\n# count unique!\ndef cf_dgs_unique(dg_a, dg_b):\n total = 0\n for (k, v) in dg_a.items():\n a = set(v)\n b = set(dg_b[k])\n c = a - b\n r = len(c)\n total += r\n return total\n\n\n### DG extractors\ndef cf_dgs_intersect(dgs):\n '''\n dgs: list of dependency graphs\n return: intersection b/t all dgs\n '''\n total = 0\n import copy\n dg_ = copy.copy(dgs[0])\n for dg_b in dgs[1:]:\n for (k, v) in dg_.items():\n a = set(v)\n b = set(dg_b[k])\n c = a.intersection(b)\n dg_[k] = c\n return dg_\n\n\ndef cf_dgs_union(dgs):\n '''\n dgs: list of dependency graphs\n return: union b/t all dgs\n '''\n total = 0\n import copy\n dg_ = copy.copy(dgs[0])\n for dg_b in dgs[1:]:\n for (k, v) in dg_.items():\n a = set(v)\n b = set(dg_b[k])\n c = a.union(b)\n dg_[k] = c\n return dg_\n\n\ndef cf_dgs_diff(dg_a, dg_b, skip_layers=[]):\n '''\n dg_a: minuend\n dg_b: subtrahend\n skip_layers: input layers to skip, if execution of the graph is required! \n '''\n import copy\n dg_ = copy.copy(dg_a)\n for (k, v) in dg_a.items():\n if k in skip_layers:\n continue\n a = set(v)\n b = set(dg_b[k])\n c = a - b\n dg_[k] = c\n return dg_\n\n\ndef report_eval_dep_graph(model, dep_graph):\n print(evaluate_dep_graph(model, dep_graph))\n print(count_dep_graph(model, dep_graph))\n\n\ndef len_dep_graph(DG):\n total = 0\n for l, neurons in DG.items():\n total += len(neurons)\n return total\n\n\ndef count_dep_graph(model, dep_graph):\n total_slct, total_all = 0, 0\n for l in model.layers:\n if len(l.weights) == 0:\n continue\n n_slct = len(dep_graph[l])\n n_total = len(omega_val[l])\n print(\"{}/{}={:2.1f}%\".format(n_slct, n_total, 100 * n_slct / float(n_total)))\n total_slct += n_slct\n total_all += n_total\n return total_slct, total_all\n\n\ndef visualise_layers_DG(DG, DG_full, model, percentage=False, skip_layers=[]):\n layer_vals = []\n layer_size = []\n layer_names = []\n for l in model.layers:\n if l.name in skip_layers:\n continue\n layer_vals.append(len(DG[l])) #\n layer_names.append(l.name)\n layer_size.append(len(DG_full[l]))\n if percentage:\n layer_vals = np.array(layer_vals) / np.array(layer_size) * 100\n N = len(layer_vals)\n fig, ax = plt.subplots(figsize=(10, 5))\n ind = np.arange(N) # the x locations for the groups\n width = 0.50 # the width of the bars\n p1 = ax.barh(ind, layer_vals, width, )\n if percentage:\n ax.set_xlim(0, 100)\n ax.set_yticks(range(len(layer_names)))\n ax.set_yticklabels(layer_names)\n\n\n# ax.invert_yaxis()\n\ndef get_input_layers(model, include_adjacent=True):\n if include_adjacent:\n input_layers = []\n for l in model.layers:\n if l.input in model.inputs:\n input_layers.append(l)\n else:\n input_layers = list(filter(lambda x: type(x) == type(model.layers[0]), model.layers))\n return input_layers\n\n\ndef view_input_layers(relevances, input_layers):\n '''\n return: the importance of the input layers\n e.g. \n aggPower [33.246933]\n aggDiffWave [0.05136125]\n aggNoMinWave [0.23131992]\n '''\n for l in input_layers:\n print(l.name, relevances[l])\n\n\ndef view_layer_importance(relevances_a, model, ax=None, logy=True, summary_fx=np.mean):\n '''\n return: the importance of the input layers\n e.g.\n aggPower [33.246933]\n aggDiffWave [0.05136125]\n aggNoMinWave [0.23131992]\n '''\n layer_importance = []\n for l in model.layers:\n layer_importance.append(summary_fx(relevances_a[l]))\n\n layer_names = [l.name for l in model.layers]\n df = pd.DataFrame(zip(layer_importance, layer_names))\n df = df.set_index(df[1])\n ax = df[0].plot(kind=\"bar\", logy=logy, ax=ax)\n\n\ndef visualise_kernel_dependence(importance_kernels_1, sharey=False, log=False):\n n_rows = 10\n n_cols = int(int(importance_kernels_1.shape[-1]) / n_rows)\n fig, axes = plt.subplots(n_rows, n_cols, figsize=(20, 10), sharey=sharey)\n for i in range(n_rows):\n for j in range(n_cols):\n idx = n_cols * i + j\n y_axis_ = np.abs(importance_kernels_1[:, idx])\n line = axes[i, j].bar(np.arange(y_axis_.shape[0]), y_axis_, log=log)\n axes[i, j].set_title(\"Kernel #:{}\".format(idx))\n\n\ndef layer_importance_strategies(model,relevance_strategies, relevance_names, logy=False, sharey=False):\n \"\"\"\n relevance_strategies: a list of \n \"\"\"\n # TODO fix number! to be dynamic based on input\n n_rows = 3\n n_cols = 2\n fig, axes = plt.subplots(n_rows, n_cols, figsize=(20, 10), sharey=sharey)\n for i, r in enumerate(relevance_strategies):\n x = i // n_cols\n y = i % n_cols\n ax = axes[x, y]\n view_layer_importance(r, model, logy=logy, ax=ax)\n ax.set_title(relevance_names[i])\n plt.tight_layout()\n\n\ndef run_dgs(DG_eval, data_sets, model):\n \"\"\"\n return: a list for each DG where each element is the output of the corresponding DG on a particular data_set\n \"\"\"\n results_all = []\n my_timer = Timer()\n for i, DG in enumerate(DG_eval):\n results_list = []\n print(\"DG_{}_{}\".format(i, my_timer.get_time_hhmmss()))\n for j in range(len(data_sets)):\n X_eval = data_sets[j]\n dg_exec, tmp = get_DG_exec(model, DG)\n # FIX: y_eval is a global var! \n # ?? batch_size=WHY? y_eval.shape[0]\n results = dg_exec.predict(X_eval, batch_size=128, verbose=0)\n recover_model(model, tmp)\n\n results_list.append(results)\n results_all.append(results_list)\n return results_all\n\n\n###### Predictions Analysis (potentially INFORMETIS specific)\n\ndef get_overall_predictions(results_list, results_orig):\n pred_orig = argmax_predictions(results_orig)\n pred_dg = argmax_predictions(results_list)\n return pred_dg, pred_orig\n\n\ndef mean_predictions(results_list):\n \"\"\"\n results_list: list of multiple DG run results\n return: mean prediction for each DG\n \"\"\"\n pred = []\n N = len(results_list)\n for i in range(N):\n results_mean = np.mean(results_list[i], axis=0)\n pred.append(np.argmax(results_mean))\n return pred\n\n\ndef argmax_predictions(results_list):\n \"\"\"\n results_list: list of multiple DG run results\n return: argmax prediction per sample for each DG\n \"\"\"\n pred = []\n N = len(results_list)\n for i in range(N):\n results = np.argmax(results_list[i], axis=1)\n bins = np.bincount(results, minlength=results_list[i].shape[1])\n pred.append(np.argmax(bins))\n return pred\n\n\ndef get_pred_dist(results_list):\n \"\"\"\n return: distribution of predictions in hist form c.f. bins\n based on argmax_predictions\n \"\"\"\n pred_dist = []\n N = len(results_list)\n for i in range(N):\n results = np.argmax(results_list[i], axis=1)\n pred_dist.append(np.unique(results, return_counts=True))\n return pred_dist\n\n\ndef total_prediction_count(results_list):\n \"\"\"\n return: counts # predictions for each class across result_list of DGs\n \"\"\"\n num_cls = results_list[0].shape[1]\n acc_array = np.zeros(num_cls)\n N = len(results_list)\n for i in range(N):\n results = np.argmax(results_list[i], axis=1)\n bins = np.bincount(results, minlength=num_cls)\n acc_array += bins\n return acc_array\n\n\ndef count_correct_pred(results_list, current_labels):\n correct_counter = []\n for i in range(len(results_list)):\n results = np.argmax(results_list[i], axis=1)\n bins = np.bincount(results, minlength=results_list[i].shape[1])\n dg_correct = bins[current_labels[i]]\n correct_counter.append(dg_correct)\n return correct_counter\n\n\n#### Secondary Analysis\n\n# un-tested functions\n\ndef plot_input_importance(relevance_list, input_layers, data_set_cls_dict):\n bars = {k.name: [] for k in input_layers}\n for r in relevance_list:\n for l in input_layers:\n bars[l.name].extend(r[l])\n N = len(relevance_list)\n fig, ax = plt.subplots()\n plots = []\n for i, k in enumerate(bars.keys()):\n ind = np.arange(N) * 2 # the x locations for the groups\n width = 0.50 # the width of the bars\n p1 = ax.bar(ind + i * width, bars[k], width, bottom=0)\n plots.append(p1[0])\n ax.set_title('Relevance by input layer and class type')\n ax.set_xticks(ind + width / 3)\n class_names = [cls for cls in data_set_cls_dict.keys()]\n ax.set_xticklabels(class_names)\n input_layer_labels = [l for l in bars.keys()]\n ax.legend(plots, input_layer_labels)\n\n\ndef main():\n from mnist_loader import load_mnist, build_sample_model\n from dataset_utils import filter_dataset\n from core import Activations_Computer\n import os\n\n # Load dataset\n X_train, y_train, X_test, y_test = load_mnist()\n\n # Filter out subset of classes\n selected_classes = [0, 1, 2, 3]\n X_train, y_train = filter_dataset((X_train, y_train), selected_classes)\n X_test, y_test = filter_dataset((X_test, y_test), selected_classes)\n\n # Create model\n input_shape = X_train.shape[1:]\n model = build_sample_model(input_shape)\n\n model_save_path = \"./mnist_model.h5\"\n if not os.path.exists(model_save_path):\n # Train model\n model.fit(x=X_train, y=y_train, epochs=2)\n model.save_weights(model_save_path)\n else:\n model.load_weights(model_save_path)\n\n compute_fx = Activations_Computer(model=model, agg_data_points=False)\n relevances = compute_fx(X_train[0:100, :])\n dgs = relevance_select(relevances, input_layer=compute_fx.model.layers[0], threshold=0.20)\n\n\nif __name__ == '__main__':\n main()" ]

[ [ "tensorflow.reduce_sum", "tensorflow.compat.v1.enable_eager_execution", "numpy.all", "numpy.mean", "numpy.where", "matplotlib.pyplot.tight_layout", "numpy.unique", "numpy.arange", "numpy.argmax", "numpy.apply_along_axis", "numpy.ravel", "numpy.zeros", "numpy.random.choice", "tensorflow.keras.Model", "numpy.argsort", "numpy.array", "tensorflow.GradientTape", "tensorflow.compat.v1.ConfigProto", "numpy.abs", "tensorflow.reduce_mean", "tensorflow.assign", "matplotlib.pyplot.subplots", "tensorflow.keras.layers.concatenate", "tensorflow.compat.v1.Session", "numpy.bincount", "numpy.vstack" ] ]

kazuhitogo/amazon-redshift-police

[ "287e62725f7ef039ee074aaa157952a8448138a2" ]

[ "src/generate_image.py" ]

[ "from random import randint,seed\nfrom PIL import Image,ImageDraw,ImageFont\nfrom os import makedirs, path, listdir\nfrom glob import glob\nimport argparse\nimport numpy as np\nimport matplotlib.font_manager as fm\nseed(1234) # 結果を再現できるようにするために乱数のシードを固定\ndef main(output_dir,check_name_list):\n system_font_list = fm.findSystemFonts()\n system_font_list = [font.replace('\\\\','/') for font in system_font_list]\n # 文字化けするfontを除外\n NG_FONT_LIST = ['BSSYM7.TTF','holomdl2.ttf','marlett.ttf','MTEXTRA.TTF','OUTLOOK.TTF','REFSPCL.TTF','segmdl2.ttf','symbol.ttf','TSPECIAL1.TTF','webdings.ttf','wingding.ttf','WINGDNG2.TTF','WINGDNG3.TTF','Webdings.ttf']\n font_list = []\n for font in system_font_list:\n if font.split('/')[-1] not in NG_FONT_LIST:\n font_list.append(font)\n print(f'found fonts: {len(font_list)}')\n print(font_list)\n tmp_img_dir = './img/'\n makedirs(tmp_img_dir, exist_ok=True)\n seed(1234) # 結果を再現できるようにするために乱数のシードを固定\n pixel_size = (700,50)\n\n for text in check_name_list:\n for i in range(5):\n for font_path in font_list:\n font = ImageFont.truetype(font_path, randint(20,30))\n font = ImageFont.truetype(font_path, 30)\n img = Image.new('L', (pixel_size[0],pixel_size[1]),(255))\n d = ImageDraw.Draw(img)\n d.text((0, 0), text, font=font, fill=(0))\n\n # 描画部分だけ切り出し\n img_array = np.array(img)\n w,h=0,0\n for j in range(pixel_size[0]-1,-1,-1):\n if not (np.all(img_array[:,j]==255)):\n w = j+1\n break\n for j in range(pixel_size[1]-1,-1,-1):\n if not (np.all(img_array[j,:]==255)):\n h = j+1\n break\n img_array = img_array[0:h,0:w]\n max_pad_h = pixel_size[1] - img_array.shape[0]\n max_pad_w = pixel_size[0] - img_array.shape[1]\n pad_h = randint(0,max_pad_h)\n pad_w = randint(0,max_pad_w)\n # 真っ白なキャンバスを作成\n canvas_array = np.ones((pixel_size[1],pixel_size[0]),dtype=np.uint8)*255\n # 文字をランダムに移植\n canvas_array[pad_h:pad_h+img_array.shape[0],pad_w:pad_w+img_array.shape[1]] = img_array\n img = Image.fromarray(canvas_array)\n\n file_path = tmp_img_dir + text.replace(' ','') + '_' +font_path.split('/')[-1] + str(i) + '.png'\n img.save(file_path)\n img_file_list = sorted(glob('./img/*.png'))\n train_X = np.zeros((len(img_file_list),pixel_size[1],pixel_size[0]),dtype=np.uint8)\n train_y = np.zeros((len(img_file_list)),dtype=np.float32)\n\n for i,img_file in enumerate(img_file_list):\n img = Image.open(img_file)\n img_array = np.array(img)\n train_X[i,:,:] = img_array\n if check_name_list[1].replace(' ','') in img_file:\n train_y[i] = 1\n train_X = ((train_X-127.5)/127.5).astype(np.float32)\n \n makedirs(output_dir, exist_ok=True)\n train_X_path = path.join(output_dir,'train_X.npy')\n train_y_path = path.join(output_dir,'train_y.npy')\n \n print(f'train_x save: {train_X_path}')\n np.save(train_X_path,train_X)\n print(f'train_x save: {train_y_path}')\n np.save(train_y_path,train_y)\n \n\nif __name__=='__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--output-dir', type=str, default='/workspace/data')\n parser.add_argument('--check-names', type=str,default=\"Amazon ElastiCache/Amazon ElasticCache\")\n args, _ = parser.parse_known_args()\n check_name_list = args.check_names.split('/')\n print(check_name_list)\n main(args.output_dir,check_name_list)" ]

[ [ "numpy.save", "numpy.ones", "numpy.all", "numpy.array", "matplotlib.font_manager.findSystemFonts" ] ]

yasudakn/CIHP_PGN

[ "71a1aae3b507cdbf47cab6a12e2e8bdef68273bb" ]

[ "utils/image_reader.py" ]

[ "import os\n\nimport numpy as np\nimport tensorflow as tf\nimport random\n\nIGNORE_LABEL = 255\nIMG_MEAN = np.array((125.0, 114.4, 107.9), dtype=np.float32)\n\ndef image_scaling(img, label, edge):\n \"\"\"\n Randomly scales the images between 0.5 to 1.5 times the original size.\n Args:\n img: Training image to scale.\n label: Segmentation mask to scale.\n \"\"\"\n \n scale = tf.random_uniform([1], minval=0.5, maxval=2.0, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[0]), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[1]), scale))\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(img, new_shape)\n label = tf.image.resize_nearest_neighbor(tf.expand_dims(label, 0), new_shape)\n label = tf.squeeze(label, squeeze_dims=[0])\n edge = tf.image.resize_nearest_neighbor(tf.expand_dims(edge, 0), new_shape)\n edge = tf.squeeze(edge, squeeze_dims=[0])\n \n return img, label, edge\n\ndef only_image_scaling(img):\n \"\"\"\n Randomly scales the images between 0.5 to 1.5 times the original size.\n Args:\n img: Training image to scale.\n label: Segmentation mask to scale.\n \"\"\"\n \n scale = tf.random_uniform([1], minval=0.5, maxval=2.0, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[0]), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(tf.shape(img)[1]), scale))\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(img, new_shape)\n \n return img\n\ndef image_mirroring(img, label, edge):\n \"\"\"\n Randomly mirrors the images.\n Args:\n img: Training image to mirror.\n label: Segmentation mask to mirror.\n \"\"\"\n \n distort_left_right_random = tf.random_uniform([1], 0, 1.0, dtype=tf.float32)[0]\n mirror = tf.less(tf.stack([1.0, distort_left_right_random, 1.0]), 0.5)\n mirror = tf.boolean_mask([0, 1, 2], mirror)\n img = tf.reverse(img, mirror)\n label = tf.reverse(label, mirror)\n edge = tf.reverse(edge, mirror)\n return img, label, edge\n\ndef only_image_mirroring(img):\n \"\"\"\n Randomly mirrors the images.\n Args:\n img: Training image to mirror.\n label: Segmentation mask to mirror.\n \"\"\"\n \n distort_left_right_random = tf.random_uniform([1], 0, 1.0, dtype=tf.float32)[0]\n mirror = tf.less(tf.stack([1.0, distort_left_right_random, 1.0]), 0.5)\n mirror = tf.boolean_mask([0, 1, 2], mirror)\n img = tf.reverse(img, mirror)\n return img\n\ndef random_resize_only_img_labels(image, resized_h, resized_w):\n\n scale = tf.random_uniform([1], minval=0.75, maxval=1.25, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(resized_h), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(resized_w), scale))\n\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(image, new_shape)\n return img\n\ndef random_resize_img_labels(image, label, resized_h, resized_w):\n\n scale = tf.random_uniform([1], minval=0.75, maxval=1.25, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(resized_h), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(resized_w), scale))\n\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(image, new_shape)\n label = tf.image.resize_nearest_neighbor(tf.expand_dims(label, 0), new_shape)\n label = tf.squeeze(label, squeeze_dims=[0])\n return img, label\n\ndef random_resize_only_img_labels(image, resized_h, resized_w):\n\n scale = tf.random_uniform([1], minval=0.75, maxval=1.25, dtype=tf.float32, seed=None)\n h_new = tf.to_int32(tf.multiply(tf.to_float(resized_h), scale))\n w_new = tf.to_int32(tf.multiply(tf.to_float(resized_w), scale))\n\n new_shape = tf.squeeze(tf.stack([h_new, w_new]), squeeze_dims=[1])\n img = tf.image.resize_images(image, new_shape)\n return img\n\ndef resize_img_labels(image, label, resized_h, resized_w):\n\n new_shape = tf.stack([tf.to_int32(resized_h), tf.to_int32(resized_w)])\n img = tf.image.resize_images(image, new_shape)\n label = tf.image.resize_nearest_neighbor(tf.expand_dims(label, 0), new_shape)\n label = tf.squeeze(label, squeeze_dims=[0])\n return img, label\n\ndef resize_only_img_labels(image, resized_h, resized_w):\n\n new_shape = tf.stack([tf.to_int32(resized_h), tf.to_int32(resized_w)])\n img = tf.image.resize_images(image, new_shape)\n return img\n\ndef random_crop_and_pad_image_and_labels(image, label, edge, crop_h, crop_w, ignore_label=255):\n \"\"\"\n Randomly crop and pads the input images.\n Args:\n image: Training image to crop/ pad.\n label: Segmentation mask to crop/ pad.\n crop_h: Height of cropped segment.\n crop_w: Width of cropped segment.\n ignore_label: Label to ignore during the training.\n \"\"\"\n\n label = tf.cast(label, dtype=tf.float32)\n label = label - ignore_label # Needs to be subtracted and later added due to 0 padding.\n edge = tf.cast(edge, dtype=tf.float32)\n edge = edge - 0\n\n combined = tf.concat([image, label, edge], 2) \n image_shape = tf.shape(image)\n combined_pad = tf.image.pad_to_bounding_box(combined, 0, 0, tf.maximum(crop_h, image_shape[0]), tf.maximum(crop_w, image_shape[1]))\n \n last_image_dim = tf.shape(image)[-1]\n last_label_dim = tf.shape(label)[-1]\n combined_crop = tf.random_crop(combined_pad, [crop_h,crop_w,4+1])\n img_crop = combined_crop[:, :, :last_image_dim]\n label_crop = combined_crop[:, :, last_image_dim:last_image_dim+last_label_dim]\n edge_crop = combined_crop[:, :, last_image_dim+last_label_dim:]\n label_crop = label_crop + ignore_label\n label_crop = tf.cast(label_crop, dtype=tf.uint8)\n edge_crop = edge_crop + 0\n edge_crop = tf.cast(edge_crop, dtype=tf.uint8)\n \n # Set static shape so that tensorflow knows shape at compile time. \n img_crop.set_shape((crop_h, crop_w, 3))\n label_crop.set_shape((crop_h,crop_w, 1))\n edge_crop.set_shape((crop_h, crop_w, 1))\n return img_crop, label_crop, edge_crop\n\n\ndef random_crop_and_pad_image(image, crop_h, crop_w, ignore_label=255):\n \"\"\"\n Randomly crop and pads the input images.\n Args:\n image: Training image to crop/ pad.\n label: Segmentation mask to crop/ pad.\n crop_h: Height of cropped segment.\n crop_w: Width of cropped segment.\n ignore_label: Label to ignore during the training.\n \"\"\"\n# combined = tf.concat([image, label, edge], 2) \n image_shape = tf.shape(image)\n# combined_pad = tf.image.pad_to_bounding_box(combined, 0, 0, tf.maximum(crop_h, image_shape[0]), tf.maximum(crop_w, image_shape[1]))\n image_pad = tf.image.pad_to_bounding_box(image, 0, 0, tf.maximum(crop_h, image_shape[0]), tf.maximum(crop_w, image_shape[1]))\n \n last_image_dim = tf.shape(image)[-1]\n\n# combined_crop = tf.random_crop(combined_pad, [crop_h,crop_w,4+1])\n# img_crop = combined_crop[:, :, :last_image_dim]\n img_crop = tf.random_crop(image_pad, [crop_h,crop_w,4+1])\n# label_crop = combined_crop[:, :, last_image_dim:last_image_dim+last_label_dim]\n# edge_crop = combined_crop[:, :, last_image_dim+last_label_dim:]\n# label_crop = label_crop + ignore_label\n# label_crop = tf.cast(label_crop, dtype=tf.uint8)\n# edge_crop = edge_crop + 0\n# edge_crop = tf.cast(edge_crop, dtype=tf.uint8)\n \n # Set static shape so that tensorflow knows shape at compile time. \n img_crop.set_shape((crop_h, crop_w, 3))\n# label_crop.set_shape((crop_h,crop_w, 1))\n# edge_crop.set_shape((crop_h, crop_w, 1))\n return img_crop\n\ndef read_labeled_image_reverse_list(data_dir, data_list):\n \"\"\"Reads txt file containing paths to images and ground truth masks.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n \n Returns:\n Two lists with all file names for images and masks, respectively.\n \"\"\"\n f = open(data_list, 'r')\n images = []\n masks = []\n masks_rev = []\n for line in f:\n try:\n image, mask, mask_rev = line.strip(\"\\n\").split(' ')\n except ValueError: # Adhoc for test.\n image = mask = mask_rev = line.strip(\"\\n\")\n images.append(data_dir + image)\n masks.append(data_dir + mask)\n masks_rev.append(data_dir + mask_rev)\n return images, masks, masks_rev\n\n\ndef read_labeled_image_list(data_dir, data_list):\n \"\"\"Reads txt file containing paths to images and ground truth masks.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n \n Returns:\n Two lists with all file names for images and masks, respectively.\n \"\"\"\n f = open(data_list, 'r')\n images = []\n masks = []\n for line in f:\n try:\n image, mask = line.strip(\"\\n\").split(' ')\n except ValueError: # Adhoc for test.\n image = mask = line.strip(\"\\n\")\n images.append(data_dir + image)\n masks.append(data_dir + mask)\n return images, masks\n\ndef read_edge_list(data_dir, data_id_list):\n f = open(data_id_list, 'r')\n edges = []\n for line in f:\n edge = line.strip(\"\\n\")\n edges.append(data_dir + '/edges/' + edge + '.png')\n return edges\n\ndef read_images_from_disk(input_queue, input_size, random_scale, random_mirror=False): # optional pre-processing arguments\n \"\"\"Read one image and its corresponding mask with optional pre-processing.\n \n Args:\n input_queue: tf queue with paths to the image and its mask.\n input_size: a tuple with (height, width) values.\n If not given, return images of original size.\n random_scale: whether to randomly scale the images prior\n to random crop.\n random_mirror: whether to randomly mirror the images prior\n to random crop.\n \n Returns:\n Two tensors: the decoded image and its mask.\n \"\"\"\n\n img_contents = tf.read_file(input_queue[0])\n label_contents = tf.read_file(input_queue[1])\n edge_contents = tf.read_file(input_queue[2])\n\n \n img = tf.image.decode_jpeg(img_contents, channels=3)\n img_r, img_g, img_b = tf.split(value=img, num_or_size_splits=3, axis=2)\n img = tf.cast(tf.concat([img_b, img_g, img_r], 2), dtype=tf.float32)\n # Extract mean.\n img -= IMG_MEAN\n label = tf.image.decode_png(label_contents, channels=1)\n edge = tf.image.decode_png(edge_contents, channels=1)\n\n if input_size is not None:\n h, w = input_size\n\n # Randomly scale the images and labels.\n if random_scale:\n img, label, edge = image_scaling(img, label, edge)\n\n # Randomly mirror the images and labels.\n if random_mirror:\n img, label, edge = image_mirroring(img, label, edge)\n\n # Randomly crops the images and labels.\n img, label, edge = random_crop_and_pad_image_and_labels(img, label, edge, h, w, IGNORE_LABEL)\n\n\n return img, label, edge\n\ndef read_only_images_from_disk(input_queue, input_size, random_scale, random_mirror=False): # optional pre-processing arguments\n \"\"\"Read one image and its corresponding mask with optional pre-processing.\n \n Args:\n input_queue: tf queue with paths to the image and its mask.\n input_size: a tuple with (height, width) values.\n If not given, return images of original size.\n random_scale: whether to randomly scale the images prior\n to random crop.\n random_mirror: whether to randomly mirror the images prior\n to random crop.\n \n Returns:\n Two tensors: the decoded image and its mask.\n \"\"\"\n\n img_contents = tf.read_file(input_queue[0])\n\n \n img = tf.image.decode_jpeg(img_contents, channels=3)\n img_r, img_g, img_b = tf.split(value=img, num_or_size_splits=3, axis=2)\n img = tf.cast(tf.concat([img_b, img_g, img_r], 2), dtype=tf.float32)\n # Extract mean.\n img -= IMG_MEAN\n\n if input_size is not None:\n h, w = input_size\n\n # Randomly scale the images and labels.\n if random_scale:\n img = only_image_scaling(img)\n\n # Randomly mirror the images and labels.\n if random_mirror:\n img = only_image_mirroring(img)\n\n # Randomly crops the images and labels.\n img = random_crop_and_pad_image(img, h, w, IGNORE_LABEL)\n\n return img\n\n\nclass ImageReader(object):\n '''Generic ImageReader which reads images and corresponding segmentation\n masks from the disk, and enqueues them into a TensorFlow queue.\n '''\n\n def __init__(self, data_dir, data_list, data_id_list, input_size, random_scale,\n random_mirror, shuffle, coord):\n '''Initialise an ImageReader.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n data_id_list: path to the file of image id.\n input_size: a tuple with (height, width) values, to which all the images will be resized.\n random_scale: whether to randomly scale the images prior to random crop.\n random_mirror: whether to randomly mirror the images prior to random crop.\n coord: TensorFlow queue coordinator.\n '''\n self.data_dir = data_dir\n self.data_list = data_list\n self.data_id_list = data_id_list\n self.input_size = input_size\n self.coord = coord\n\n\n self.image_list, self.label_list = read_labeled_image_list(self.data_dir, self.data_list)\n self.edge_list = read_edge_list(self.data_dir, self.data_id_list)\n self.images = tf.convert_to_tensor(self.image_list, dtype=tf.string)\n self.labels = tf.convert_to_tensor(self.label_list, dtype=tf.string)\n self.edges = tf.convert_to_tensor(self.edge_list, dtype=tf.string)\n self.queue = tf.train.slice_input_producer([self.images, self.labels, self.edges], shuffle=shuffle) \n self.image, self.label, self.edge = read_images_from_disk(self.queue, self.input_size, random_scale, random_mirror) \n\n def dequeue(self, num_elements):\n '''Pack images and labels into a batch.\n \n Args:\n num_elements: the batch size.\n \n Returns:\n Two tensors of size (batch_size, h, w, {3, 1}) for images and masks.'''\n batch_list = [self.image, self.label, self.edge]\n image_batch, label_batch, edge_batch = tf.train.batch([self.image, self.label, self.edge], num_elements)\n return image_batch, label_batch, edge_batch\n\n\nclass ImageReaderInference(object):\n '''Generic ImageReader which reads images and corresponding segmentation\n masks from the disk, and enqueues them into a TensorFlow queue.\n '''\n\n def __init__(self, data_dir, data_list, data_id_list, input_size, random_scale,\n random_mirror, shuffle, coord):\n '''Initialise an ImageReader.\n \n Args:\n data_dir: path to the directory with images and masks.\n data_list: path to the file with lines of the form '/path/to/image /path/to/mask'.\n data_id_list: path to the file of image id.\n input_size: a tuple with (height, width) values, to which all the images will be resized.\n random_scale: whether to randomly scale the images prior to random crop.\n random_mirror: whether to randomly mirror the images prior to random crop.\n coord: TensorFlow queue coordinator.\n '''\n self.data_dir = data_dir\n self.data_list = data_list\n self.data_id_list = data_id_list\n self.input_size = input_size\n self.coord = coord\n\n\n self.image_list, self.label_list = read_labeled_image_list(self.data_dir, self.data_list)\n self.edge_list = read_edge_list(self.data_dir, self.data_id_list)\n self.images = tf.convert_to_tensor(self.image_list, dtype=tf.string)\n# self.labels = tf.convert_to_tensor(self.label_list, dtype=tf.string)\n# self.edges = tf.convert_to_tensor(self.edge_list, dtype=tf.string)\n# self.queue = tf.train.slice_input_producer([self.images, self.labels, self.edges], shuffle=shuffle) \n self.queue = tf.train.slice_input_producer([self.images], shuffle=shuffle) \n self.image = read_only_images_from_disk(self.queue, self.input_size, random_scale, random_mirror) \n\n def dequeue(self, num_elements):\n '''Pack images and labels into a batch.\n \n Args:\n num_elements: the batch size.\n \n Returns:\n Two tensors of size (batch_size, h, w, {3, 1}) for images and masks.'''\n batch_list = [self.image]\n image_batch = tf.train.batch([self.image], num_elements)\n return image_batch\n" ]

[ [ "tensorflow.convert_to_tensor", "tensorflow.concat", "tensorflow.stack", "tensorflow.image.decode_png", "tensorflow.cast", "tensorflow.train.batch", "tensorflow.to_int32", "tensorflow.boolean_mask", "tensorflow.read_file", "tensorflow.squeeze", "tensorflow.to_float", "tensorflow.image.decode_jpeg", "tensorflow.reverse", "tensorflow.shape", "tensorflow.image.resize_images", "tensorflow.split", "numpy.array", "tensorflow.maximum", "tensorflow.expand_dims", "tensorflow.random_crop", "tensorflow.train.slice_input_producer", "tensorflow.random_uniform" ] ]

blueenvelope31/pandas

[ "6e1f41b45a0d08f662b794ed98695b8595f39023" ]

[ "pandas/tests/arrays/categorical/test_subclass.py" ]

[ "# -*- coding: utf-8 -*-\n\nimport pandas.util.testing as tm\nfrom pandas import Categorical\n\n\nclass TestCategoricalSubclassing(object):\n\n def test_constructor(self):\n sc = tm.SubclassedCategorical(['a', 'b', 'c'])\n assert isinstance(sc, tm.SubclassedCategorical)\n tm.assert_categorical_equal(sc, Categorical(['a', 'b', 'c']))\n\n def test_from_codes(self):\n sc = tm.SubclassedCategorical.from_codes([1, 0, 2], ['a', 'b', 'c'])\n assert isinstance(sc, tm.SubclassedCategorical)\n exp = Categorical.from_codes([1, 0, 2], ['a', 'b', 'c'])\n tm.assert_categorical_equal(sc, exp)\n\n def test_map(self):\n sc = tm.SubclassedCategorical(['a', 'b', 'c'])\n res = sc.map(lambda x: x.upper())\n assert isinstance(res, tm.SubclassedCategorical)\n exp = Categorical(['A', 'B', 'C'])\n tm.assert_categorical_equal(res, exp)\n" ]

[ [ "pandas.Categorical.from_codes", "pandas.util.testing.assert_categorical_equal", "pandas.Categorical", "pandas.util.testing.SubclassedCategorical.from_codes", "pandas.util.testing.SubclassedCategorical" ] ]

thunfischtoast/tf_netbuilder

[ "728826ac5e4e58a39ea862cecc86ad249a19e278" ]

[ "tf_netbuilder/activations.py" ]

[ "from typing import Callable\nimport tensorflow as tf\nimport numpy as np\n\n\ndef hard_swish(x: tf.Tensor):\n with tf.name_scope('hard_swish'):\n return x * tf.nn.relu6(x + np.float32(3)) * np.float32(1. / 6.)\n\n\nclass FuncAsLayer:\n \"\"\"\n This wrapper is a common denominator for function activations and layer activations. In tensorflow we have\n the activation PReLU which doesn't have function counterpart\n \"\"\"\n def __init__(self, func: Callable):\n self.func = func\n\n def __call__(self):\n return tf.keras.layers.Activation(self.func)\n\n\nACTIVATION_FUNCS = dict(\n re=tf.keras.layers.ReLU,\n r6=FuncAsLayer(tf.nn.relu6),\n pre=tf.keras.layers.PReLU,\n hs=FuncAsLayer(hard_swish),\n sw=FuncAsLayer(tf.nn.swish)\n)\n" ]

[ [ "tensorflow.keras.layers.Activation", "tensorflow.name_scope", "numpy.float32" ] ]

ChristopherBrix/Debona

[ "f000f3d483b2cc592233d0ba2a1a0327210562c8" ]

[ "src/vnnlib.py" ]

[ "'''\nvnnlib simple utilities\n\nStanley Bak\nJune 2021\n'''\n\nfrom copy import deepcopy\n\nimport numpy as np\nimport re\n\n\ndef read_statements(vnnlib_filename):\n '''process vnnlib and return a list of strings (statements)\n\n useful to get rid of comments and blank lines and combine multi-line statements\n '''\n\n with open(vnnlib_filename, 'r') as f:\n lines = f.readlines()\n\n lines = [line.strip() for line in lines]\n assert len(lines) > 0\n\n # combine lines if case a single command spans multiple lines\n open_parentheses = 0\n statements = []\n current_statement = ''\n\n for line in lines:\n comment_index = line.find(';')\n\n if comment_index != -1:\n line = line[:comment_index].rstrip()\n\n if not line:\n continue\n\n new_open = line.count('(')\n new_close = line.count(')')\n\n open_parentheses += new_open - new_close\n\n assert open_parentheses >= 0, \"mismatched parenthesis in vnnlib file\"\n\n # add space\n current_statement += ' ' if current_statement else ''\n current_statement += line\n\n if open_parentheses == 0:\n statements.append(current_statement)\n current_statement = ''\n\n if current_statement:\n statements.append(current_statement)\n\n # remove repeated whitespace characters\n statements = [\" \".join(s.split()) for s in statements]\n\n # remove space after '('\n statements = [s.replace('( ', '(') for s in statements]\n\n # remove space after ')'\n statements = [s.replace(') ', ')') for s in statements]\n\n return statements\n\n\ndef update_rv_tuple(rv_tuple, op, first, second, num_inputs, num_outputs):\n 'update tuple from rv in read_vnnlib_simple, with the passed in constraint \"(op first second)\"'\n\n if first.startswith(\"X_\"):\n # Input constraints\n index = int(first[2:])\n\n assert not second.startswith(\"X\") and not second.startswith(\"Y\"), \\\n f\"input constraints must be box ({op} {first} {second})\"\n assert 0 <= index < num_inputs\n\n limits = rv_tuple[0][index]\n\n if op == \"<=\":\n limits[1] = min(float(second), limits[1])\n else:\n limits[0] = max(float(second), limits[0])\n\n assert limits[0] <= limits[1], f\"{first} range is empty: {limits}\"\n\n else:\n # output constraint\n if op == \">=\":\n # swap order if op is >=\n first, second = second, first\n\n row = [0.0] * num_outputs\n rhs = 0.0\n\n # assume op is <=\n if first.startswith(\"Y_\") and second.startswith(\"Y_\"):\n index1 = int(first[2:])\n index2 = int(second[2:])\n\n row[index1] = 1\n row[index2] = -1\n elif first.startswith(\"Y_\"):\n index1 = int(first[2:])\n row[index1] = 1\n rhs = float(second)\n else:\n assert second.startswith(\"Y_\")\n index2 = int(second[2:])\n row[index2] = -1\n rhs = -1 * float(first)\n\n mat, rhs_list = rv_tuple[1], rv_tuple[2]\n mat.append(row)\n rhs_list.append(rhs)\n\n\ndef make_input_box_dict(num_inputs):\n 'make a dict for the input box'\n rv = {i: [-np.inf, np.inf] for i in range(num_inputs)}\n\n return rv\n\n\ndef read_vnnlib_simple(vnnlib_filename, num_inputs, num_outputs):\n '''process in a vnnlib file\n\n this is not a general parser, and assumes files are provided in a 'nice' format. Only a single disjunction\n is allowed\n\n output a list containing 2-tuples:\n 1. input ranges (box), list of pairs for each input variable\n 2. specification, provided as a list of pairs (mat, rhs), as in: mat * y <= rhs, where y is the output. \n Each element in the list is a term in a disjunction for the specification.\n '''\n\n # example: \"(declare-const X_0 Real)\"\n regex_declare = re.compile(r\"^\$declare-const (X|Y)_(\\S+) Real\$$\")\n regex_declare_input = re.compile(r\"^\$declare-const X_(\\S+) Real\$$\")\n regex_declare_output = re.compile(r\"^\$declare-const Y_(\\S+) Real\$$\")\n\n # comparison sub-expression\n # example: \"(<= Y_0 Y_1)\" or \"(<= Y_0 10.5)\"\n comparison_str = r\"\$(<=|>=) (\\S+) (\\S+)\$\"\n\n # example: \"(and (<= Y_0 Y_2)(<= Y_1 Y_2))\"\n dnf_clause_str = r\"\$and (\" + comparison_str + r\")+\$\"\n\n # example: \"(assert (<= Y_0 Y_1))\"\n regex_simple_assert = re.compile(r\"^\$assert \" + comparison_str + r\"\$$\")\n\n # disjunctive-normal-form\n # (assert (or (and (<= Y_3 Y_0)(<= Y_3 Y_1)(<= Y_3 Y_2))(and (<= Y_4 Y_0)(<= Y_4 Y_1)(<= Y_4 Y_2))))\n regex_dnf = re.compile(r\"^\$assert \\(or (\" + dnf_clause_str + r\")+\$\\)$\")\n\n rv = [] # list of 3-tuples, (box-dict, mat, rhs)\n rv.append((make_input_box_dict(num_inputs), [], []))\n\n lines = read_statements(vnnlib_filename)\n\n assert num_inputs == sum(len(regex_declare_input.findall(line)) for line in lines)\n assert num_outputs == sum(len(regex_declare_output.findall(line)) for line in lines)\n\n for line in lines:\n #print(f\"Line: {line}\")\n\n if len(regex_declare.findall(line)) > 0:\n continue\n\n groups = regex_simple_assert.findall(line)\n\n if groups:\n assert len(groups[0]) == 3, f\"groups was {groups}: {line}\"\n op, first, second = groups[0]\n\n for rv_tuple in rv:\n update_rv_tuple(rv_tuple, op, first, second, num_inputs, num_outputs)\n\n continue\n\n ################\n groups = regex_dnf.findall(line)\n assert groups, f\"failed parsing line: {line}\"\n\n tokens = line.replace(\"(\", \" \").replace(\")\", \" \").split()\n tokens = tokens[2:] # skip 'assert' and 'or'\n\n conjuncts = \" \".join(tokens).split(\"and\")[1:]\n\n old_rv = rv\n rv = []\n\n for rv_tuple in old_rv:\n for c in conjuncts:\n rv_tuple_copy = deepcopy(rv_tuple)\n rv.append(rv_tuple_copy)\n\n c_tokens = [s for s in c.split(\" \") if len(s) > 0]\n\n count = len(c_tokens) // 3\n\n for i in range(count):\n op, first, second = c_tokens[3 * i:3 * (i + 1)]\n\n update_rv_tuple(rv_tuple_copy, op, first, second, num_inputs, num_outputs)\n\n # merge elements of rv with the same input spec\n merged_rv = {}\n\n for rv_tuple in rv:\n boxdict = rv_tuple[0]\n matrhs = (rv_tuple[1], rv_tuple[2])\n\n key = str(boxdict) # merge based on string representation of input box... accurate enough for now\n\n if key in merged_rv:\n merged_rv[key][1].append(matrhs)\n else:\n merged_rv[key] = (boxdict, [matrhs])\n\n # finalize objects (convert dicts to lists and lists to np.array)\n final_rv = []\n\n for rv_tuple in merged_rv.values():\n box_dict = rv_tuple[0]\n\n box = []\n\n for d in range(num_inputs):\n r = box_dict[d]\n\n assert r[0] != -np.inf and r[1] != np.inf, f\"input X_{d} was unbounded: {r}\"\n box.append(r)\n\n spec_list = []\n\n for matrhs in rv_tuple[1]:\n mat = np.array(matrhs[0], dtype=float)\n rhs = np.array(matrhs[1], dtype=float)\n spec_list.append((mat, rhs))\n\n final_rv.append((box, spec_list))\n\n #for i, (box, spec_list) in enumerate(final_rv):\n # print(f\"-----\\n{i+1}. {box}\\nspec:{spec_list}\")\n\n return final_rv\n" ]

[ [ "numpy.array" ] ]

dewloosh/dewloosh-geom

[ "5c97fbab4b68f4748bf4309184b9e0e877f94cd6" ]

[ "src/dewloosh/geom/tri/triplot.py" ]

[ "# -*- coding: utf-8 -*-\nfrom typing import Callable, Iterable\nimport numpy as np\nfrom functools import partial\n\nfrom dewloosh.core.tools import issequence\n\nfrom .triang import triobj_to_mpl, get_triobj_data, triangulate\nfrom .triutils import offset_tri\nfrom ..utils import cells_coords, explode_mesh_data_bulk\n\nfrom ..config import __hasmatplotlib__\nif __hasmatplotlib__:\n import matplotlib.pyplot as plt\n from matplotlib.patches import Polygon\n from mpl_toolkits.axes_grid1 import make_axes_locatable\n from matplotlib.collections import PatchCollection\n\n\n__all__ = ['triplot']\n\n\ndef triplot(triobj, *args, hinton=False, data=None, title=None,\n label=None, fig=None, ax=None, axes=None, **kwargs):\n fig, axes = get_fig_axes(*args, data=data, ax=ax, axes=axes,\n fig=fig, **kwargs)\n if isinstance(triobj, tuple):\n coords, topo = triobj\n triobj = triangulate(points=coords[:, :2], triangles=topo)[-1]\n coords, topo = None, None\n pdata = partial(triplot_data, triobj)\n pgeom = partial(triplot_geom, triobj)\n phint = partial(triplot_hinton, triobj)\n if data is not None:\n assert len(data.shape) <= 2, \\\n \"Data must be a 1 or 2 dimensional array.\"\n nD = 1 if len(data.shape) == 1 else data.shape[1]\n data = data.reshape((data.shape[0], nD))\n if not issequence(title):\n title = nD * (title, )\n if not issequence(label):\n label = nD * (label, )\n pfnc = phint if hinton else pdata\n axobj = [pfnc(ax, data[:, i], *args, fig=fig, title=title[i],\n label=label[i], **kwargs)\n for i, ax in enumerate(axes)]\n if nD == 1:\n data = data.reshape(data.shape[0])\n else:\n axobj = pgeom(axes[0], *args, fig=fig, title=title, **kwargs)\n return axobj\n\n\nclass TriPatchCollection(PatchCollection):\n\n def __init__(self, cellcoords, *args, **kwargs):\n pmap = map(lambda i: cellcoords[i], np.arange(len(cellcoords)))\n def fnc(points): return Polygon(points, closed=True)\n patches = list(map(fnc, pmap))\n super().__init__(patches, *args, **kwargs)\n\n\ndef triplot_hinton(triobj, ax, data, *args, lw=0.5, fcolor='b',\n ecolor='k', title=None, suptitle=None, label=None,\n **kwargs):\n axobj = None\n tri = triobj_to_mpl(triobj)\n points, triangles = get_triobj_data(tri, *args, trim2d=True, **kwargs)\n cellcoords = offset_tri(points, triangles, data)\n axobj = TriPatchCollection(cellcoords, fc=fcolor, ec=ecolor, lw=lw)\n ax.add_collection(axobj)\n _decorate_(ax=ax, points=points, title=title, suptitle=suptitle,\n label=label, **kwargs)\n return axobj\n\n\ndef triplot_geom(triobj, ax, *args, lw=0.5, marker='b-',\n zorder=None, fcolor=None, ecolor='k',\n fig=None, title=None, suptitle=None, label=None,\n **kwargs):\n axobj = None\n tri = triobj_to_mpl(triobj)\n points, triangles = get_triobj_data(tri, *args, trim2d=True, **kwargs)\n\n if fcolor is None:\n if zorder is not None:\n axobj = ax.triplot(tri, marker, lw=lw, zorder=zorder, **kwargs)\n else:\n axobj = ax.triplot(tri, marker, lw=lw, **kwargs)\n else:\n cellcoords = cells_coords(points, triangles)\n axobj = TriPatchCollection(cellcoords, fc=fcolor, ec=ecolor, lw=lw)\n ax.add_collection(axobj)\n _decorate_(fig=fig, ax=ax, points=points, title=title,\n suptitle=suptitle, label=label, **kwargs)\n return axobj\n\n\ndef triplot_data(triobj, ax, data, *args, cmap='winter', fig=None,\n ecolor='k', lw=0.1, title=None, suptitle=None,\n label=None, **kwargs):\n\n axobj = None\n tri = triobj_to_mpl(triobj)\n points, triangles = get_triobj_data(tri, *args, trim2d=True, **kwargs)\n\n nData = len(data)\n if nData == len(triangles):\n nD = len(data.shape)\n if nD == 1:\n axobj = ax.tripcolor(tri, facecolors=data, cmap=cmap,\n edgecolors=ecolor, lw=lw)\n elif nD == 2 and data.shape[1] == 3:\n nT, nN = data.shape\n points, triangles, data = \\\n explode_mesh_data_bulk(points, triangles, data)\n triobj = triangulate(points=points, triangles=triangles)[-1]\n tri = triobj_to_mpl(triobj)\n axobj = ax.tripcolor(tri, data, cmap=cmap,\n edgecolors=ecolor, lw=lw)\n elif nData == len(points):\n axobj = ax.tripcolor(tri, data, cmap=cmap,\n edgecolors=ecolor, lw=lw)\n\n assert axobj is not None, \"Failed to handle the provided data.\"\n divider = make_axes_locatable(ax)\n cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n fig.colorbar(axobj, cax=cax)\n\n _decorate_(fig=fig, ax=ax, points=points, title=title,\n suptitle=suptitle, label=label, **kwargs)\n return axobj\n\n\ndef get_fig_axes(*args, data=None, fig=None, axes=None, shape=None,\n horizontal=False, ax=None, **kwargs):\n if fig is not None:\n if axes is not None:\n return fig, axes\n elif ax is not None:\n return fig, (ax,)\n else:\n if data is not None:\n nD = 1 if len(data.shape) == 1 else data.shape[1]\n if nD == 1:\n try:\n aspect = kwargs.get('aspect', 'equal')\n args[0].set_aspect(aspect)\n ax = args[0]\n except Exception:\n fig, ax = plt.subplots()\n return fig, (ax,)\n if fig is None or axes is None:\n if shape is not None:\n if isinstance(shape, int):\n shape = (shape, 1) if horizontal else (1, shape)\n assert nD == (shape[0] * shape[1]), \\\n \"Mismatch in shape and data.\"\n else:\n shape = (nD, 1) if horizontal else (1, nD)\n fig, axes = plt.subplots(*shape)\n if not isinstance(axes, Iterable):\n axes = (axes,)\n return fig, axes\n else:\n try:\n aspect = kwargs.get('aspect', 'equal')\n args[0].set_aspect(aspect)\n ax = args[0]\n except Exception:\n fig, ax = plt.subplots()\n return fig, (ax,)\n return None, None\n\n\ndef _decorate_(*args, fig=None, ax=None, aspect='equal', xlim=None,\n ylim=None, axis='on', offset=0.05, points=None,\n axfnc: Callable = None, title=None, suptitle=None,\n label=None, **kwargs):\n assert ax is not None, \"A matplotlib Axes object must be provided as \" \\\n \"keyword argument 'ax'!\"\n if axfnc is not None:\n try:\n axfnc(ax)\n except Exception:\n raise RuntimeError('Something went wrong when calling axfnc.')\n if xlim is None:\n if points is not None:\n xlim = points[:, 0].min(), points[:, 0].max()\n if offset is not None:\n dx = np.abs(xlim[1] - xlim[0])\n xlim = xlim[0] - offset*dx, xlim[1] + offset*dx\n if ylim is None:\n if points is not None:\n ylim = points[:, 1].min(), points[:, 1].max()\n if offset is not None:\n dx = np.abs(ylim[1] - ylim[0])\n ylim = ylim[0] - offset*dx, ylim[1] + offset*dx\n ax.set_aspect(aspect)\n ax.axis(axis)\n if xlim is not None:\n ax.set_xlim(*xlim)\n if ylim is not None:\n ax.set_ylim(*ylim)\n if title is not None:\n ax.set_title(title)\n if label is not None:\n ax.set_xlabel(label)\n if fig is not None and suptitle is not None:\n fig.suptitle(suptitle)\n return ax\n\n\nif __name__ == '__main__':\n pass\n" ]

[ [ "numpy.abs", "matplotlib.patches.Polygon", "matplotlib.pyplot.subplots" ] ]

dlinde/disaster_response_pipeline

[ "e1f5f8e3f666830d29351396bb343001d5fe330d" ]

[ "models/title_transformer.py" ]

[ "from sklearn.base import BaseEstimator, TransformerMixin\nimport pandas as pd\n\nclass TitleCount(BaseEstimator, TransformerMixin):\n\n\n def fit(self, x, y=None):\n return self\n\n def transform(self, X):\n X_tagged = pd.Series(X).apply(lambda x: len([\n wrd for wrd in x.split() if wrd.istitle()]))\n X_tagged = X_tagged.map(lambda x: 5 if x>5 else x)\n return pd.DataFrame(X_tagged)\n" ]

[ [ "pandas.Series", "pandas.DataFrame" ] ]

JIC-Image-Analysis/point-picker

[ "b2d94520c2b6ee0a323c4a7021f03709ac9db82a" ]

[ "scripts/point_picker.py" ]

[ "import sys\nimport logging\n\nfrom vispy import scene\nfrom vispy.scene.visuals import Text\nfrom vispy import app\nimport numpy as np\n\nimport pandas as pd\n\nfrom imageio import imread\n\nimport click\n\nfrom skimage.draw import circle\n\ncanvas = scene.SceneCanvas(keys='interactive')\ncanvas.size = 800, 600\ncanvas.show()\n\n# Set up a viewbox to display the image with interactive pan/zoom\nview = canvas.central_widget.add_view()\n\n\[email protected]()\[email protected]('image_fpath')\[email protected]('input_points_fpath')\[email protected]('output_points_fpath', required=False)\ndef main(image_fpath, input_points_fpath, output_points_fpath):\n global canvas\n\n logging.basicConfig(level=logging.INFO)\n\n im = imread(image_fpath)\n logging.info(f\"Loaded image with shape {im.shape}\")\n image = scene.visuals.Image(im, parent=view.scene)\n\n app.current_pos = None\n\n if output_points_fpath:\n df = pd.read_csv(input_points_fpath)\n points = [(p.X, p.Y) for p in df.itertuples()]\n output_fpath = output_points_fpath\n else:\n points = []\n output_fpath = input_points_fpath\n \n\n @canvas.events.mouse_press.connect\n def on_mouse_press(event):\n # print(\"Press pos:\", event.pos)\n # get transform mapping from canvas to image\n tr = view.node_transform(image)\n # print(\"Image pos:\", tr.map(event.pos)[:2])\n x, y = tr.map(event.pos)[:2]\n\n print(\"Click at \", x, y)\n\n # c, r = int(x), int(y)\n\n # points.append(np.array((r, c)))\n\n # rr, cc = circle(r, c, 5)\n # im[rr, cc] = 255, 0, 0\n # image.set_data(im)\n # canvas.update()\n\n @canvas.connect\n def on_mouse_move(event):\n app.current_pos = event.pos\n\n def update_drawing():\n draw_im = im.copy()\n for r, c in points:\n rr, cc = circle(r, c, 3)\n try:\n draw_im[rr, cc] = 255 #, 0, 0\n except IndexError:\n print(f\"Point at {r}, {c} out of bounds\")\n raise\n \n image.set_data(draw_im)\n canvas.update()\n\n @canvas.events.key_press.connect\n def key_event(event):\n\n if event.key.name == 'Escape':\n app.quit()\n\n if event.key.name == 'P':\n print(\"Added point\")\n tr = view.node_transform(image)\n x, y = tr.map(app.current_pos)[:2]\n c, r = int(x), int(y)\n points.append(np.array((r, c)))\n update_drawing()\n\n if event.key.name == 'D':\n tr = view.node_transform(image)\n x, y = tr.map(app.current_pos)[:2]\n c, r = int(x), int(y)\n deltas = np.array(points) - np.array((r, c))\n sq_dists = np.sum(deltas * deltas, axis=1)\n del points[np.argmin(sq_dists)]\n update_drawing()\n\n if event.key.name == 'S':\n df = pd.DataFrame(points, columns=['X', 'Y'])\n df.to_csv(output_fpath, index=False)\n\n # t1 = scene.visuals.Text('Text in root scene (24 pt)', parent=image, color='red', pos=(100,100))\n # t1.font_size = 24\n # Set 2D camera (the camera will scale to the contents in the scene)\n view.camera = scene.PanZoomCamera(aspect=1)\n view.camera.set_range()\n view.camera.flip = (False, True, False)\n\n update_drawing()\n\n app.run()\n\n\nif __name__ == '__main__':\n main()\n" ]

[ [ "pandas.read_csv", "pandas.DataFrame", "numpy.argmin", "numpy.array", "numpy.sum" ] ]

TeaPoly/Conformer-Athena

[ "9919de269ca3074c20f55d72ca8fc975aca8cf7d" ]

[ "athena/layers/commons.py" ]

[ "# coding=utf-8\n# Copyright (C) 2019 ATHENA AUTHORS; Xiangang Li\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n# pylint: disable=too-few-public-methods, invalid-name\n# pylint: disable=no-self-use, missing-function-docstring\n\"\"\"Utils for common layers.\"\"\"\n\nimport tensorflow as tf\nfrom athena.layers.functional import make_positional_encoding, collapse4d, gelu, glu\nfrom athena.layers.functional import splice\nfrom athena.utils.misc import gated_linear_layer\n\n\nclass PositionalEncoding(tf.keras.layers.Layer):\n \"\"\"positional encoding can be used in transformer\"\"\"\n\n def __init__(self, d_model, max_position=800, scale=False):\n super().__init__()\n self.d_model = d_model\n self.scale = scale\n self.pos_encoding = make_positional_encoding(max_position, d_model)\n\n def call(self, x):\n \"\"\" call function \"\"\"\n seq_len = tf.shape(x)[1]\n if self.scale:\n x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n x += self.pos_encoding[:, :seq_len, :]\n return x\n\n\nclass RelPositionalEncoding(PositionalEncoding):\n \"\"\"Relative positional encoding can be used in conformer\"\"\"\n\n def __init__(self, d_model, max_position=800):\n super().__init__(d_model, max_position)\n\n def call(self, x):\n \"\"\" call function \"\"\"\n seq_len = tf.shape(x)[1]\n return self.pos_encoding[:, :seq_len, :]\n\n\nclass ScaledPositionalEncoding(PositionalEncoding):\n \"\"\"scaled positional encoding,\n reference: https://arxiv.org/pdf/1809.08895.pdf\"\"\"\n def __init__(self, d_model, max_position=800):\n super().__init__(d_model, max_position, scale=False)\n\n def build(self, _):\n self.alpha = self.add_weight(\n name=\"alpha\", initializer=tf.keras.initializers.constant(1)\n )\n\n def call(self, x):\n seq_len = tf.shape(x)[1]\n x += self.alpha * self.pos_encoding[:, :seq_len, :]\n return x\n\n\nclass Collapse4D(tf.keras.layers.Layer):\n \"\"\"collapse4d can be used in cnn-lstm for speech processing\n reshape from [N T D C] -> [N T D*C]\n \"\"\"\n\n def call(self, x):\n return collapse4d(x)\n\n\nclass Gelu(tf.keras.layers.Layer):\n \"\"\"Gaussian Error Linear Unit.\n\n This is a smoother version of the RELU. Original paper: https://arxiv.org/abs/1606.08415\n\n Args:\n x: float Tensor to perform activation.\n Returns:\n x: with the GELU activation applied.\n \"\"\"\n\n def call(self, x):\n return gelu(x)\n\n\nclass TdnnLayer(tf.keras.layers.Layer):\n \"\"\"An implementation of Tdnn Layer\n Args:\n context: a int of left and right context, or a list of context indexes, e.g. (-2, 0, 2).\n output_dim: the dim of the linear transform\n \"\"\"\n\n def __init__(self, context, output_dim, use_bias=False, **kwargs):\n super().__init__(**kwargs)\n\n if hasattr(context, \"__iter__\"):\n self.context_size = len(context)\n self.context_list = context\n else:\n self.context_size = context * 2 + 1\n self.context_list = range(-context, context + 1)\n\n self.output_dim = output_dim\n self.linear = tf.keras.layers.Dense(output_dim, use_bias=use_bias)\n\n def call(self, x, training=None, mask=None):\n x = splice(x, self.context_list)\n x = self.linear(x, training=training, mask=mask)\n return x\n\nclass GroupNormalization(tf.keras.layers.Layer):\n def __init__(\n self,\n groups: int = 2,\n axis: int = -1,\n epsilon: float = 1e-3,\n center: bool = True,\n scale: bool = True,\n beta_initializer = \"zeros\",\n gamma_initializer = \"ones\",\n beta_regularizer = None,\n gamma_regularizer = None,\n beta_constraint = None,\n gamma_constraint = None,\n **kwargs\n ):\n super().__init__(**kwargs)\n self.supports_masking = True\n self.groups = groups\n self.axis = axis\n self.epsilon = epsilon\n self.center = center\n self.scale = scale\n self.beta_initializer = tf.keras.initializers.get(beta_initializer)\n self.gamma_initializer = tf.keras.initializers.get(gamma_initializer)\n self.beta_regularizer = tf.keras.regularizers.get(beta_regularizer)\n self.gamma_regularizer = tf.keras.regularizers.get(gamma_regularizer)\n self.beta_constraint = tf.keras.constraints.get(beta_constraint)\n self.gamma_constraint = tf.keras.constraints.get(gamma_constraint)\n self._check_axis()\n\n def build(self, input_shape):\n\n self._check_if_input_shape_is_none(input_shape)\n self._set_number_of_groups_for_instance_norm(input_shape)\n self._check_size_of_dimensions(input_shape)\n self._create_input_spec(input_shape)\n\n self._add_gamma_weight(input_shape)\n self._add_beta_weight(input_shape)\n self.built = True\n super().build(input_shape)\n\n def call(self, inputs):\n\n input_shape = tf.keras.backend.int_shape(inputs)\n tensor_input_shape = tf.shape(inputs)\n\n reshaped_inputs, group_shape = self._reshape_into_groups(\n inputs, input_shape, tensor_input_shape\n )\n\n normalized_inputs = self._apply_normalization(reshaped_inputs, input_shape)\n\n outputs = tf.reshape(normalized_inputs, tensor_input_shape)\n\n return outputs\n\n def get_config(self):\n config = {\n \"groups\": self.groups,\n \"axis\": self.axis,\n \"epsilon\": self.epsilon,\n \"center\": self.center,\n \"scale\": self.scale,\n \"beta_initializer\": tf.keras.initializers.serialize(self.beta_initializer),\n \"gamma_initializer\": tf.keras.initializers.serialize(\n self.gamma_initializer\n ),\n \"beta_regularizer\": tf.keras.regularizers.serialize(self.beta_regularizer),\n \"gamma_regularizer\": tf.keras.regularizers.serialize(\n self.gamma_regularizer\n ),\n \"beta_constraint\": tf.keras.constraints.serialize(self.beta_constraint),\n \"gamma_constraint\": tf.keras.constraints.serialize(self.gamma_constraint),\n }\n base_config = super().get_config()\n return {**base_config, **config}\n\n def compute_output_shape(self, input_shape):\n return input_shape\n\n def _reshape_into_groups(self, inputs, input_shape, tensor_input_shape):\n\n group_shape = [tensor_input_shape[i] for i in range(len(input_shape))]\n group_shape[self.axis] = input_shape[self.axis] // self.groups\n group_shape.insert(self.axis, self.groups)\n group_shape = tf.stack(group_shape)\n reshaped_inputs = tf.reshape(inputs, group_shape)\n return reshaped_inputs, group_shape\n\n def _apply_normalization(self, reshaped_inputs, input_shape):\n\n group_shape = tf.keras.backend.int_shape(reshaped_inputs)\n group_reduction_axes = list(range(1, len(group_shape)))\n axis = -2 if self.axis == -1 else self.axis - 1\n group_reduction_axes.pop(axis)\n\n mean, variance = tf.nn.moments(\n reshaped_inputs, group_reduction_axes, keepdims=True\n )\n\n gamma, beta = self._get_reshaped_weights(input_shape)\n normalized_inputs = tf.nn.batch_normalization(\n reshaped_inputs,\n mean=mean,\n variance=variance,\n scale=gamma,\n offset=beta,\n variance_epsilon=self.epsilon,\n )\n return normalized_inputs\n\n def _get_reshaped_weights(self, input_shape):\n broadcast_shape = self._create_broadcast_shape(input_shape)\n gamma = None\n beta = None\n if self.scale:\n gamma = tf.reshape(self.gamma, broadcast_shape)\n\n if self.center:\n beta = tf.reshape(self.beta, broadcast_shape)\n return gamma, beta\n\n def _check_if_input_shape_is_none(self, input_shape):\n dim = input_shape[self.axis]\n if dim is None:\n raise ValueError(\n \"Axis \" + str(self.axis) + \" of \"\n \"input tensor should have a defined dimension \"\n \"but the layer received an input with shape \" + str(input_shape) + \".\"\n )\n\n def _set_number_of_groups_for_instance_norm(self, input_shape):\n dim = input_shape[self.axis]\n\n if self.groups == -1:\n self.groups = dim\n\n def _check_size_of_dimensions(self, input_shape):\n\n dim = input_shape[self.axis]\n if dim < self.groups:\n raise ValueError(\n \"Number of groups (\" + str(self.groups) + \") cannot be \"\n \"more than the number of channels (\" + str(dim) + \").\"\n )\n\n if dim % self.groups != 0:\n raise ValueError(\n \"Number of groups (\" + str(self.groups) + \") must be a \"\n \"multiple of the number of channels (\" + str(dim) + \").\"\n )\n\n def _check_axis(self):\n\n if self.axis == 0:\n raise ValueError(\n \"You are trying to normalize your batch axis. Do you want to \"\n \"use tf.layer.batch_normalization instead\"\n )\n\n def _create_input_spec(self, input_shape):\n\n dim = input_shape[self.axis]\n self.input_spec = tf.keras.layers.InputSpec(\n ndim=len(input_shape), axes={self.axis: dim}\n )\n\n def _add_gamma_weight(self, input_shape):\n\n dim = input_shape[self.axis]\n shape = (dim,)\n\n if self.scale:\n self.gamma = self.add_weight(\n shape=shape,\n name=\"gamma\",\n initializer=self.gamma_initializer,\n regularizer=self.gamma_regularizer,\n constraint=self.gamma_constraint,\n )\n else:\n self.gamma = None\n\n def _add_beta_weight(self, input_shape):\n\n dim = input_shape[self.axis]\n shape = (dim,)\n\n if self.center:\n self.beta = self.add_weight(\n shape=shape,\n name=\"beta\",\n initializer=self.beta_initializer,\n regularizer=self.beta_regularizer,\n constraint=self.beta_constraint,\n )\n else:\n self.beta = None\n\n def _create_broadcast_shape(self, input_shape):\n broadcast_shape = [1] * len(input_shape)\n broadcast_shape[self.axis] = input_shape[self.axis] // self.groups\n broadcast_shape.insert(self.axis, self.groups)\n return broadcast_shape\n\n\nclass InstanceNormalization(GroupNormalization):\n \"\"\"Instance normalization layer.\n References\n - [Instance Normalization: The Missing Ingredient for Fast Stylization]\n (https://arxiv.org/abs/1607.08022)\n \"\"\"\n\n def __init__(self, **kwargs):\n\n kwargs[\"groups\"] = -1\n super().__init__(**kwargs)\n\n\nclass DownSampleBlock(tf.keras.layers.Layer):\n \"\"\"conv2d downsample block for stargan, instance norm is used because batch size is 1\n \"\"\"\n def __init__(self, filters, kernel_size, strides):\n super(DownSampleBlock, self).__init__()\n\n self.conv1 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.conv2 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n self.norm2 = InstanceNormalization(epsilon=1e-8)\n\n def call(self, x):\n h1 = self.conv1(x)\n h1_norm = self.norm1(h1)\n h1_gates = self.conv2(x)\n h1_gates_norm = self.norm2(h1_gates)\n h1_glu = gated_linear_layer(inputs=h1_norm, gates=h1_gates_norm)\n return h1_glu\n\n\nclass UpSampleBlock(tf.keras.layers.Layer):\n \"\"\"conv2d upsample block for stargan, instance norm is used because batch size is 1\n \"\"\"\n def __init__(self, filters, kernel_size, strides):\n super(UpSampleBlock, self).__init__()\n self.conv1 = tf.keras.layers.Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.conv2 = tf.keras.layers.Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=strides,\n padding=\"same\")\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n self.norm2 = InstanceNormalization(epsilon=1e-8)\n\n def call(self, x):\n h1 = self.conv1(x)\n h1_norm = self.norm1(h1)\n h1_gates = self.conv2(x)\n h1_gates_norm = self.norm2(h1_gates)\n h1_glu = gated_linear_layer(inputs=h1_norm, gates=h1_gates_norm)\n return h1_glu\n\nclass ConditionalInstanceNormalisation(tf.keras.layers.Layer):\n \"\"\"CIN Block.\"\"\"\n def __init__(self, in_channel):\n super(ConditionalInstanceNormalisation, self).__init__()\n\n self.dim_in = in_channel\n self.gamma = tf.keras.layers.Dense(in_channel)\n self.beta = tf.keras.layers.Dense(in_channel)\n\n def call(self, x, c):\n u = tf.math.reduce_mean(x, axis=1, keepdims=True)\n var = tf.math.reduce_mean((x - u) * (x - u), axis=1, keepdims=True)\n std = tf.math.sqrt(var + 1e-8)\n\n gamma = self.gamma(c)\n gamma = tf.reshape(gamma, [-1, 1, self.dim_in])\n beta = self.beta(c)\n beta = tf.reshape(beta, [-1, 1, self.dim_in])\n\n h = (x - u) / std\n h = h * gamma + beta\n\n return h\n\n\nclass ResidualBlock(tf.keras.layers.Layer):\n \"\"\"Residual Block with instance normalization.\"\"\"\n\n def __init__(self, out_channel):\n super(ResidualBlock, self).__init__()\n self.conv_1 = tf.keras.layers.Conv1D(filters=out_channel, kernel_size=3, strides=1, padding=\"same\", use_bias=False)\n self.cin_1 = ConditionalInstanceNormalisation(out_channel)\n\n def call(self, x, c):\n x = self.conv_1(x)\n x = self.cin_1(x, c)\n x = gated_linear_layer(inputs=x, gates=x)\n return x\n\n\nclass Down2d_init(tf.keras.layers.Layer):\n def __init__(self, filters , kernel_size, stride):\n super(Down2d_init, self).__init__()\n self.c1 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=stride, padding=\"same\")\n\n def call(self, x):\n x1 = self.c1(x)\n x1 = gated_linear_layer(inputs=x1, gates=x1)\n return x1\n\nclass Down2d(tf.keras.layers.Layer):\n def __init__(self, filters , kernel_size, stride):\n super(Down2d, self).__init__()\n self.c1 = tf.keras.layers.Conv2D(filters=filters, kernel_size=kernel_size, strides=stride, padding=\"same\")\n\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n def call(self, x):\n x1 = self.c1(x)\n x1 = self.norm1(x1)\n x1 = gated_linear_layer(inputs=x1, gates=x1)\n return x1\n\n\nclass Up2d(tf.keras.layers.Layer):\n \"\"\"docstring for Up2d.\"\"\"\n\n def __init__(self, filters, kernel_size, stride):\n super(Up2d, self).__init__()\n self.c1 = tf.keras.layers.Conv2DTranspose(filters=filters, kernel_size=kernel_size, strides=stride, padding=\"same\")\n self.norm1 = InstanceNormalization(epsilon=1e-8)\n\n def call(self, x):\n x1 = self.c1(x)\n x1 = self.norm1(x1)\n x1 = gated_linear_layer(inputs=x1, gates=x1)\n\n return x1\n\nclass ZoneOutCell(tf.keras.layers.LSTMCell):\n \"\"\"Wrapper for LSTM cell to create ZoneOut Cell\n\n inspired by:\n https://github.com/teganmaharaj/zoneout/blob/master/zoneout_tensorflow.py\n Published by one of 'https://arxiv.org/pdf/1606.01305.pdf' paper writers.\n \"\"\"\n\n def __init__(self, zoneout_rate=0., **kwargs):\n super().__init__(**kwargs)\n self.zoneout_rate = zoneout_rate\n self.drop_layer = tf.keras.layers.Dropout(self.zoneout_rate)\n\n def call(self, inputs, states, training=False):\n \"\"\"Runs vanilla LSTM Cell and applies zoneout.\n \"\"\"\n # Apply vanilla LSTM\n outputs, new_states = super().call(inputs, states, training=training)\n if self.zoneout_rate == 0:\n return outputs, new_states\n # Apply zoneout\n h = (1 - self.zoneout_rate) * \\\n self.drop_layer(new_states[0] - states[0], training=training) + \\\n states[0]\n c = (1 - self.zoneout_rate) * \\\n self.drop_layer(new_states[1] - states[1], training=training) + \\\n states[1]\n return outputs, [h, c]\n\n def get_config(self):\n config = super().get_config()\n config['zoneout_rate'] = self.zoneout_rate\n return config\n\n\nSUPPORTED_RNNS = {\n \"lstm\": tf.keras.layers.LSTMCell,\n \"gru\": tf.keras.layers.GRUCell,\n \"cudnnlstm\": tf.keras.layers.LSTMCell,\n \"cudnngru\": tf.keras.layers.GRUCell\n}\n\n\nACTIVATIONS = {\n \"relu\": tf.nn.relu,\n \"relu6\": tf.nn.relu6,\n \"elu\": tf.nn.elu,\n \"selu\": tf.nn.selu,\n \"gelu\": gelu,\n \"glu\": glu,\n 'swish': tf.nn.swish,\n \"leaky_relu\": tf.nn.leaky_relu,\n \"sigmoid\": tf.nn.sigmoid,\n \"softplus\": tf.nn.softplus,\n \"softsign\": tf.nn.softsign,\n \"tanh\": tf.nn.tanh,\n}\n" ]

[ [ "tensorflow.keras.constraints.serialize", "tensorflow.stack", "tensorflow.keras.layers.Conv2DTranspose", "tensorflow.cast", "tensorflow.keras.regularizers.serialize", "tensorflow.keras.backend.int_shape", "tensorflow.nn.moments", "tensorflow.keras.layers.Conv2D", "tensorflow.keras.initializers.constant", "tensorflow.keras.initializers.get", "tensorflow.nn.batch_normalization", "tensorflow.shape", "tensorflow.keras.layers.Dense", "tensorflow.keras.initializers.serialize", "tensorflow.math.sqrt", "tensorflow.keras.constraints.get", "tensorflow.keras.layers.Conv1D", "tensorflow.keras.regularizers.get", "tensorflow.reshape", "tensorflow.math.reduce_mean", "tensorflow.keras.layers.Dropout" ] ]

chenyanghungry/person-reid-lib

[ "783e66c9bfedf582e2cf935b9f5be960b543ac3c", "783e66c9bfedf582e2cf935b9f5be960b543ac3c" ]

[ "lib/datamanager/transforms.py", "lib/dataset/dukemtmcreid.py" ]

[ "from torchvision.transforms import ToPILImage, Resize, RandomHorizontalFlip, ToTensor, Normalize, RandomCrop\nimport torchvision.transforms.functional as F\nfrom PIL import Image, ImageOps\nimport numpy as np\nimport random\nimport numbers\nimport torch\nimport math\n\n\n__all__ = ['GroupToTensor',\n 'GroupResize',\n 'GroupRandomHorizontalFlip',\n 'GroupRandomCrop',\n 'GroupToTensor',\n 'GroupNormalize',\n 'StackTensor',\n 'GroupToPILImage',\n 'GroupRandom2DTranslation',\n 'GroupRandomErasing']\n\n\nclass ImageData(object):\n def __init__(self, img, x=None, y=None):\n self.img = img\n self.x = x\n self.y = y\n\n\ndef _group_process(images, func, params):\n if isinstance(images, (tuple, list)):\n return [_group_process(img, func, params) for img in images]\n else:\n return func(images, params)\n\n\nclass GroupOperation(object):\n def _instance_process(self, images, params):\n raise NotImplementedError\n\n def _get_params(self, images):\n return None\n\n def __call__(self, images):\n params = self._get_params(images)\n return _group_process(images, self._instance_process, params)\n\n\nclass GroupToPILImage(GroupOperation, ToPILImage):\n def __init__(self, mode=None, use_flow=False):\n super(GroupToPILImage, self).__init__(mode)\n self.use_flow = use_flow\n\n def _instance_process(self, pic_list, params):\n if isinstance(pic_list, np.ndarray):\n if pic_list.ndim == 3:\n return self.to_pil_image(pic_list)\n elif pic_list.ndim == 4:\n return [self.to_pil_image(pic_i) for pic_i in range(pic_list.shape[0])]\n else:\n raise TypeError\n raise TypeError\n\n def to_pil_image(self, pic):\n if pic.shape[2] == 3:\n return ImageData(F.to_pil_image(pic, self.mode))\n elif pic.shape[2] == 1:\n return ImageData(F.to_pil_image(pic))\n elif pic.shape[2] == 5:\n if self.use_flow:\n pic_rgb = F.to_pil_image(pic[..., :3], self.mode)\n pic_x = F.to_pil_image(pic[..., 3:4])\n pic_y = F.to_pil_image(pic[..., 4:5])\n return ImageData(pic_rgb, pic_x, pic_y)\n else:\n return ImageData(F.to_pil_image(pic[..., :3], self.mode))\n else:\n raise ValueError\n\n\nclass GroupResize(GroupOperation, Resize):\n def _instance_process(self, img, params):\n img.img = F.resize(img.img, self.size, self.interpolation)\n if img.x is not None:\n img.x = F.resize(img.x, self.size, self.interpolation)\n if img.y is not None:\n img.y = F.resize(img.y, self.size, self.interpolation)\n\n return img\n\n\nclass GroupRandomHorizontalFlip(GroupOperation, RandomHorizontalFlip):\n def _get_params(self, images):\n if random.random() < self.p:\n return True\n else:\n return False\n\n def _instance_process(self, img, flip_flag):\n \"\"\"\n Args:\n img (PIL Image): Image to be flipped.\n Returns:\n PIL Image: Randomly flipped image.\n \"\"\"\n if flip_flag:\n img.img = F.hflip(img.img)\n if img.x is not None:\n img.x = ImageOps.invert(img.x)\n return img\n\n\nclass GroupRandomCrop(GroupOperation):\n def __init__(self, size, padding=None, pad_if_needed=False, fill=0, padding_mode='constant'):\n if isinstance(size, numbers.Number):\n self.size = (int(size), int(size))\n else:\n self.size = size\n self.padding = padding\n self.pad_if_needed = pad_if_needed\n self.fill = fill\n self.padding_mode = padding_mode\n\n @staticmethod\n def get_params(img, output_size):\n \"\"\"Get parameters for ``crop`` for a random crop.\n Args:\n img (PIL Image): Image to be cropped.\n output_size (tuple): Expected output size of the crop.\n Returns:\n tuple: params (i, j, h, w) to be passed to ``crop`` for random crop.\n \"\"\"\n w, h = img.size\n th, tw = output_size\n if w == tw and h == th:\n return 0, 0, h, w\n\n i = random.randint(0, h - th)\n j = random.randint(0, w - tw)\n return i, j, th, tw\n\n def pad_func(self, img, params):\n if self.padding is not None:\n img.img = F.pad(img.img, self.padding, self.fill, self.padding_mode)\n if img.x is not None:\n img.x = F.pad(img.x, self.padding, self.fill, self.padding_mode)\n if img.y is not None:\n img.y = F.pad(img.y, self.padding, self.fill, self.padding_mode)\n\n if self.pad_if_needed and img.img.size[0] < self.size[1]:\n img.img = F.pad(img.img, (self.size[1] - img.img.size[0], 0), self.fill, self.padding_mode)\n if img.x is not None:\n img.x = F.pad(img.x, (self.size[1] - img.img.size[0], 0), self.fill, self.padding_mode)\n if img.y is not None:\n img.y = F.pad(img.y, (self.size[1] - img.img.size[0], 0), self.fill, self.padding_mode)\n\n if self.pad_if_needed and img.img.size[1] < self.size[0]:\n img.img = F.pad(img.img, (0, self.size[0] - img.img.size[1]), self.fill, self.padding_mode)\n if img.x is not None:\n img.x = F.pad(img.x, (0, self.size[0] - img.img.size[1]), self.fill, self.padding_mode)\n if img.y is not None:\n img.y = F.pad(img.y, (0, self.size[0] - img.img.size[1]), self.fill, self.padding_mode)\n\n return img\n\n def _get_params(self, images):\n \"\"\"\n Args:\n img (PIL Image) list: Image to be cropped.\n Returns:\n PIL Image list: Cropped image.\n \"\"\"\n while isinstance(images, (tuple, list)):\n images = images[0]\n img = images.img\n\n if self.padding is not None:\n img = F.pad(img, self.padding, self.fill, self.padding_mode)\n\n # pad the width if needed\n if self.pad_if_needed and img.size[0] < self.size[1]:\n img = F.pad(img, (self.size[1] - img.size[0], 0), self.fill, self.padding_mode)\n # pad the height if needed\n if self.pad_if_needed and img.size[1] < self.size[0]:\n img = F.pad(img, (0, self.size[0] - img.size[1]), self.fill, self.padding_mode)\n\n return self.get_params(img, self.size)\n\n def _instance_process(self, images, params):\n i, j, h, w = params\n img = _group_process(images, self.pad_func, None)\n img.img = F.crop(img.img, i, j, h, w)\n\n if img.x is not None:\n img.x = F.crop(img.x, i, j, h, w)\n if img.y is not None:\n img.y = F.crop(img.y, i, j, h, w)\n\n return img\n\n def __repr__(self):\n return self.__class__.__name__ + '(size={0}, padding={1})'.format(self.size, self.padding)\n\n\nclass GroupToTensor(GroupOperation, ToTensor):\n def _instance_process(self, img, params):\n img.img = F.to_tensor(img.img)\n if img.x is not None:\n img.x = F.to_tensor(img.x)\n if img.y is not None:\n img.y = F.to_tensor(img.y)\n\n return img\n\n\nclass GroupNormalize(GroupOperation, Normalize):\n def _instance_process(self, image, params):\n image.img = F.normalize(image.img, self.mean[:3], self.std[:3])\n if image.x is not None:\n image.x = F.normalize(image.x, self.mean[3:4], self.std[3:4])\n if image.y is not None:\n image.y = F.normalize(image.y, self.mean[3:4], self.std[3:4])\n return image\n\n\nclass GroupRandom2DTranslation(GroupOperation):\n \"\"\"\n With a probability, first increase image size to (1 + 1/8), and then perform random crop.\n Args:\n - height (int): target height.\n - width (int): target width.\n - p (float): probability of performing this transformation. Default: 0.5.\n \"\"\"\n\n def __init__(self, height, width, p=0.5, interpolation=Image.BILINEAR):\n self.height = height\n self.width = width\n self.p = p\n self.interpolation = interpolation\n\n def _get_params(self, images):\n if random.uniform(0, 1) > self.p:\n return None\n else:\n new_width, new_height = int(round(self.width * 1.125)), int(round(self.height * 1.125))\n x_maxrange = new_width - self.width\n y_maxrange = new_height - self.height\n x1 = int(round(random.uniform(0, x_maxrange)))\n y1 = int(round(random.uniform(0, y_maxrange)))\n return new_width, new_height, x1, y1\n\n def _instance_process(self, img, params):\n if params is None:\n img.img = img.img.resize((self.width, self.height), self.interpolation)\n\n if img.x is not None:\n img.x = img.x.resize((self.width, self.height), self.interpolation)\n if img.y is not None:\n img.y = img.y.resize((self.width, self.height), self.interpolation)\n\n else:\n new_width, new_height, x1, y1 = params\n img.img = img.img.resize((new_width, new_height), self.interpolation)\n img.img = img.img.crop((x1, y1, x1 + self.width, y1 + self.height))\n\n if img.x is not None:\n img.x = img.x.resize((new_width, new_height), self.interpolation)\n img.x = img.x.crop((x1, y1, x1 + self.width, y1 + self.height))\n\n if img.y is not None:\n img.y = img.y.resize((new_width, new_height), self.interpolation)\n img.y = img.y.crop((x1, y1, x1 + self.width, y1 + self.height))\n\n return img\n\n def __repr__(self):\n return self.__class__.__name__ + '()'\n\n\nclass GroupRandomErasing(GroupOperation):\n \"\"\" Randomly selects a rectangle region in an image and erases its pixels.\n 'Random Erasing Data Augmentation' by Zhong et al.\n See https://arxiv.org/pdf/1708.04896.pdf\n Args:\n probability: The probability that the Random Erasing operation will be performed.\n sl: Minimum proportion of erased area against input image.\n sh: Maximum proportion of erased area against input image.\n r1: Minimum aspect ratio of erased area.\n mean: Erasing value.\n \"\"\"\n\n def __init__(self, probability=0.5, sl=0.02, sh=0.4, r1=0.3, mean=[0.4914, 0.4822, 0.4465]):\n self.probability = probability\n self.mean = mean\n self.sl = sl\n self.sh = sh\n self.r1 = r1\n\n def _instance_process(self, img, params):\n\n if random.uniform(0, 1) > self.probability:\n return img\n\n for attempt in range(100):\n area = img.img.size()[1] * img.img.size()[2]\n\n target_area = random.uniform(self.sl, self.sh) * area\n aspect_ratio = random.uniform(self.r1, 1 / self.r1)\n\n h = int(round(math.sqrt(target_area * aspect_ratio)))\n w = int(round(math.sqrt(target_area / aspect_ratio)))\n\n if w < img.img.size()[2] and h < img.img.size()[1]:\n x1 = random.randint(0, img.img.size()[1] - h)\n y1 = random.randint(0, img.img.size()[2] - w)\n if img.img.size()[0] == 3:\n img.img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n img.img[1, x1:x1 + h, y1:y1 + w] = self.mean[1]\n img.img[2, x1:x1 + h, y1:y1 + w] = self.mean[2]\n else:\n img.img[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n if img.x is not None:\n img.x[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n if img.y is not None:\n img.y[0, x1:x1 + h, y1:y1 + w] = self.mean[0]\n\n return img\n\n def __repr__(self):\n return self.__class__.__name__ + '()'\n\n\nclass StackTensor(object):\n def __call__(self, tensor_list):\n if isinstance(tensor_list, (tuple, list)):\n rgb_tensor = []\n flow_tensor = []\n for tensor_i in tensor_list:\n rgb_tensor.append(tensor_i.img)\n if tensor_i.x is not None and tensor_i.y is not None:\n flow_tensor.append(torch.cat([tensor_i.x, tensor_i.y], dim=0))\n if len(tensor_list) > 1:\n rgb_tensor = torch.stack(rgb_tensor)\n\n if len(flow_tensor) > 1:\n flow_tensor = torch.stack(flow_tensor)\n return rgb_tensor, flow_tensor\n\n return rgb_tensor\n else:\n if len(flow_tensor) > 0:\n return rgb_tensor[0], flow_tensor[0]\n return rgb_tensor[0]\n raise TypeError\n\n def __repr__(self):\n return self.__class__.__name__ + '()'\n\n\nclass ToSpaceBGR(object):\n\n def __init__(self, is_bgr=True):\n self.is_bgr = is_bgr\n\n def __call__(self, tensor):\n if self.is_bgr:\n new_tensor = tensor.clone()\n new_tensor[0] = tensor[2]\n new_tensor[2] = tensor[0]\n tensor = new_tensor\n return tensor\n\n\nclass ToRange255(object):\n\n def __init__(self, is_255=True):\n self.is_255 = is_255\n\n def __call__(self, tensor):\n if self.is_255:\n tensor.mul_(255)\n return tensor", "from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n\nimport numpy as np\nimport glob\nimport re\nimport os.path as osp\nfrom .datasetbase import DataSetBase\nfrom lib.utils.util import unpack_file, remove_folder\n\n\n__all__ = ['DukeMTMCreID']\n\n\nclass DukeMTMCreID(DataSetBase):\n def __init__(self, root_dir, rawfiles_dir, split_id, npr=None, logger=None):\n super().__init__('DukeMTMCreID', split_id, 'h5', root_dir, logger)\n self.zipfiles_dir = rawfiles_dir / 'DukeMTMC-reID.zip'\n\n self.raw_data_folder = self.store_dir / 'DukeMTMC-reID'\n self.train_dir = self.raw_data_folder / 'bounding_box_train'\n self.query_dir = self.raw_data_folder / 'query'\n self.gallery_dir = self.raw_data_folder / 'bounding_box_test'\n\n self.resize_hw = (256, 128)\n self.init()\n\n def check_raw_file(self):\n assert self.zipfiles_dir.exists()\n if not self.raw_data_folder.exists():\n unpack_file(self.zipfiles_dir, self.store_dir, self.logger)\n if (self.store_dir / '__MACOSX').exists():\n remove_folder(self.store_dir / '__MACOSX')\n\n assert self.train_dir.exists()\n assert self.query_dir.exists()\n assert self.gallery_dir.exists()\n\n def _get_dict(self):\n img_list = []\n train_images, train_img_dir = self._process_dir(self.train_dir, 0)\n img_list = img_list + train_img_dir\n probe_images, probe_img_dir = self._process_dir(self.query_dir, len(img_list))\n img_list = img_list + probe_img_dir\n gallery_images, gallery_img_dir = self._process_dir(self.gallery_dir, len(img_list))\n img_list = img_list + gallery_img_dir\n\n train_id = np.unique(train_images[:, 0])\n probe_id = np.unique(probe_images[:, 0])\n gallery_id = np.unique(gallery_images[:, 0])\n assert np.intersect1d(train_id, probe_id).size == 0\n assert np.intersect1d(probe_id, gallery_id).size == probe_id.size\n assert gallery_images[-1, 3] == len(img_list)\n\n data_dict = {}\n data_dict['dir'] = img_list\n\n data_split = {}\n data_split['train'] = train_images\n data_split['probe'] = probe_images\n data_split['gallery'] = gallery_images\n data_split['info'] = 'DukeMTMC-reID dataset. Split ID {:2d}.'.format(0)\n\n data_dict['split'] = [data_split]\n data_dict['info'] = 'DukeMTMCreID Dataset. One Split'\n\n return data_dict\n\n def _process_dir(self, dir_path, begin_id):\n img_paths = glob.glob(osp.join(dir_path, '*.jpg'))\n pattern = re.compile(r'([-\\d]+)_c(\\d)')\n\n dataset = []\n img_dir_list = []\n idx = begin_id\n\n for img_path in img_paths:\n pid, camid = map(int, pattern.search(img_path).groups())\n assert 1 <= camid <= 8\n camid -= 1 # index starts from 0\n img_dir_list.append(img_path)\n dataset.append((pid, camid, idx, idx + 1, 1))\n idx += 1\n\n return np.asarray(dataset, dtype=np.int64), img_dir_list\n" ]

[ [ "torch.stack", "torch.cat" ], [ "numpy.asarray", "numpy.intersect1d", "numpy.unique" ] ]

myepes2/MiSiCgui

[ "a2e76568cf32d00813760e5793d606faf7049701" ]

[ "models/MiSiDC04082020.py" ]

[ "\nfrom tensorflow.keras.models import load_model\nfrom tensorflow.keras.utils import get_file\n\nimport numpy as np\n\nfrom skimage.transform import resize,rescale\nfrom skimage.feature import shape_index\nfrom skimage.util import random_noise\nfrom skimage.io import imread,imsave\n\nimport matplotlib.pyplot as plt\n\nfrom MiSiCgui.utils import *\n#from utils_gui import *\n\nclass SegModel():\n def __init__(self):\n self.size = 256\n self.scalesvals = [1,1.5,2.0]\n #self.model = load_model(model_name)\n model_path = get_file(\n 'MiSiDC04082020',\n 'https://github.com/pswapnesh/Models/raw/master/MiSiDC04082020.h5', cache_dir='./cache')\n self.model = load_model(model_path,compile=False)\n \n def preprocess(self,im):\n n = len(self.scalesvals)\n sh = np.zeros((im.shape[0],im.shape[1],n))\n \n if np.max(im) ==0:\n return sh\n pw = 15\n im = np.pad(im,pw,'reflect')\n sh = np.zeros((im.shape[0],im.shape[1],n)) \n for i in range(n):\n sh[:,:,i] = shape_index(im,self.scalesvals[i])\n \n return sh[pw:-pw,pw:-pw,:]\n \n def segment(self,im,invert = False):\n im = normalize2max(im) \n pw = 16\n if invert:\n im = 1.0-im\n im = np.pad(im,pw,'reflect')\n sh = self.preprocess(im)\n\n tiles,params = extract_tiles(sh,size = self.size,exclude=12)\n\n yp = self.model.predict(tiles)\n\n return stitch_tiles(yp,params)[pw:-pw,pw:-pw,:]" ]

[ [ "tensorflow.keras.models.load_model", "numpy.pad", "numpy.max", "tensorflow.keras.utils.get_file", "numpy.zeros" ] ]

jan-pavlovsky/Deep-Learning-Tasks

[ "220764d350ae1bbe8e50250b44a5f9e0b3abefe4" ]

[ "09/morpho_dataset.py" ]

[ "import os\nimport sys\nimport urllib.request\nimport zipfile\n\nimport numpy as np\n\n# Loads a morphological dataset in a vertical format.\n# - The data consists of three Datasets\n# - train\n# - dev\n# - test\n# - Each dataset is composed of factors (FORMS, LEMMAS, TAGS), each an\n# object containing the following fields:\n# - word_strings: Strings of the original words.\n# - word_ids: Word ids of the original words (uses <unk> and <pad>).\n# - words_map: String -> word_id map.\n# - words: Word_id -> string list.\n# - alphabet_map: Character -> char_id map.\n# - alphabet: Char_id -> character list.\n# - charseq_ids: Character_sequence ids of the original words.\n# - charseqs_map: String -> character_sequence_id map.\n# - charseqs: Character_sequence_id -> [characters], where character is an index\n# to the dataset alphabet.\nclass MorphoDataset:\n _URL = \"https://ufal.mff.cuni.cz/~straka/courses/npfl114/1819/datasets/\"\n\n class Factor:\n PAD = 0\n UNK = 1\n BOW = 2\n EOW = 3\n\n def __init__(self, characters, train=None):\n self.words_map = train.words_map if train else {\"<pad>\": self.PAD, \"<unk>\": self.UNK}\n self.words = train.words if train else [\"<pad>\", \"<unk>\"]\n self.word_ids = []\n self.word_strings = []\n self.characters = characters\n if characters:\n self.alphabet_map = train.alphabet_map if train else {\n \"<pad>\": self.PAD, \"<unk>\": self.UNK, \"<bow>\": self.BOW, \"<eow>\": self.EOW}\n self.alphabet = train.alphabet if train else [\"<pad>\", \"<unk>\", \"<bow>\", \"<eow>\"]\n self.charseqs_map = {\"<pad>\": self.PAD, \"<unk>\": self.UNK}\n self.charseqs = [[self.PAD], [self.UNK]]\n self.charseq_ids = []\n\n class FactorBatch:\n def __init__(self, word_ids, charseq_ids=None, charseqs=None):\n self.word_ids = word_ids\n self.charseq_ids = charseq_ids\n self.charseqs = charseqs\n\n class Dataset:\n FORMS = 0\n LEMMAS = 1\n TAGS = 2\n FACTORS = 3\n\n def __init__(self, data_file, train=None, shuffle_batches=True, add_bow_eow=False, max_sentences=None, seed=42):\n # Create factors\n self._data = []\n for f in range(self.FACTORS):\n self._data.append(MorphoDataset.Factor(f in [self.FORMS, self.LEMMAS], train._data[f] if train else None))\n\n in_sentence = False\n for line in data_file:\n line = line.decode(\"utf-8\").rstrip(\"\\r\\n\")\n if line:\n columns = line.split(\"\\t\")\n for f in range(self.FACTORS):\n factor = self._data[f]\n if not in_sentence:\n if len(factor.word_ids): factor.word_ids[-1] = np.array(factor.word_ids[-1], np.int32)\n factor.word_ids.append([])\n factor.word_strings.append([])\n if factor.characters: factor.charseq_ids.append([])\n\n word = columns[f]\n factor.word_strings[-1].append(word)\n\n # Character-level information\n if factor.characters:\n if word not in factor.charseqs_map:\n factor.charseqs_map[word] = len(factor.charseqs)\n factor.charseqs.append([])\n if add_bow_eow:\n factor.charseqs[-1].append(MorphoDataset.Factor.BOW)\n for c in word:\n if c not in factor.alphabet_map:\n if train:\n c = \"<unk>\"\n else:\n factor.alphabet_map[c] = len(factor.alphabet)\n factor.alphabet.append(c)\n factor.charseqs[-1].append(factor.alphabet_map[c])\n if add_bow_eow:\n factor.charseqs[-1].append(MorphoDataset.Factor.EOW)\n factor.charseq_ids[-1].append(factor.charseqs_map[word])\n\n # Word-level information\n if word not in factor.words_map:\n if train:\n word = \"<unk>\"\n else:\n factor.words_map[word] = len(factor.words)\n factor.words.append(word)\n factor.word_ids[-1].append(factor.words_map[word])\n\n in_sentence = True\n else:\n in_sentence = False\n if max_sentences is not None and len(self._data[self.FORMS].word_ids) >= max_sentences:\n break\n\n self._size = len(self._data[self.FORMS].word_ids)\n self._shuffler = np.random.RandomState(seed) if shuffle_batches else None\n\n @property\n def data(self):\n return self._data\n\n def size(self):\n return self._size\n\n def batches(self, size=None):\n permutation = self._shuffler.permutation(self._size) if self._shuffler else np.arange(self._size)\n while len(permutation):\n batch_size = min(size or np.inf, len(permutation))\n batch_perm = permutation[:batch_size]\n permutation = permutation[batch_size:]\n\n batch = []\n max_sentence_len = max(len(self._data[self.FORMS].word_ids[i]) for i in batch_perm)\n\n # Word-level data\n for factor in self._data:\n batch.append(MorphoDataset.FactorBatch(np.zeros([batch_size, max_sentence_len], np.int32)))\n for i in range(batch_size):\n batch[-1].word_ids[i, :len(factor.word_ids[batch_perm[i]])] = factor.word_ids[batch_perm[i]]\n\n # Character-level data\n for f, factor in enumerate(self._data):\n if not factor.characters: continue\n\n batch[f].charseq_ids = np.zeros([batch_size, max_sentence_len], np.int32)\n charseqs_map = {\"<pad>\": factor.PAD}\n charseqs = [factor.charseqs[factor.PAD]]\n for i in range(batch_size):\n for j, charseq_id in enumerate(factor.charseq_ids[batch_perm[i]]):\n if charseq_id not in charseqs_map:\n charseqs_map[charseq_id] = len(charseqs)\n charseqs.append(factor.charseqs[charseq_id])\n batch[f].charseq_ids[i, j] = charseqs_map[charseq_id]\n\n max_charseq_len = max(len(charseq) for charseq in charseqs)\n batch[f].charseqs = np.zeros([len(charseqs), max_charseq_len], np.int32)\n for i in range(len(charseqs)):\n batch[f].charseqs[i, :len(charseqs[i])] = charseqs[i]\n\n yield batch\n\n\n def __init__(self, dataset, add_bow_eow=False, max_sentences=None):\n path = \"{}.zip\".format(dataset)\n if not os.path.exists(path):\n print(\"Downloading dataset {}...\".format(dataset), file=sys.stderr)\n urllib.request.urlretrieve(\"{}/{}\".format(self._URL, path), filename=path)\n\n with zipfile.ZipFile(path, \"r\") as zip_file:\n for dataset in [\"train\", \"dev\", \"test\"]:\n with zip_file.open(\"{}_{}.txt\".format(os.path.splitext(path)[0], dataset), \"r\") as dataset_file:\n setattr(self, dataset, self.Dataset(dataset_file,\n train=self.train if dataset != \"train\" else None,\n shuffle_batches=dataset == \"train\",\n add_bow_eow=add_bow_eow,\n max_sentences=max_sentences))\n" ]

[ [ "numpy.arange", "numpy.array", "numpy.random.RandomState", "numpy.zeros" ] ]

Henriksen-Lab/Simple_DAQ

[ "3bd313df4c80340eb367081400cb6d75ba132623" ]

[ "pico_vna_adapt/PicoVNA108.py" ]

[ "#!/usr/bin/python\n# -*- coding: utf-8 -*-\n#\n# author: Shilling Du, revised from https://github.com/picotech/picosdk-picovna-python-examples\n# Feb 22, 2022\n\nimport win32com.client\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nclass Smith():\n def __init__(self,real,imag,logmag,phase,freq):\n self.real = np.array(real)\n self.imag = np.array(imag)\n self.log_mag = np.array(logmag)\n self.phase_rad = np.array(phase)\n self.freqs = np.array(freq)\n\ndef get_picoVNA_smith(port='S21',f_min=0.3,f_max=8500,number_of_points=1001,power=0,bandwidth=1000,Average=1):\n\n picoVNA = win32com.client.gencache.EnsureDispatch(\"PicoControl3.PicoVNA_3_2\")\n try:\n findVNA = picoVNA.FND()\n ans=picoVNA.LoadCal(r'C:\\Users\\ICET\\Documents\\Pico Technology\\PicoVNA3\\FacCal.cal')\n freq_step = np.ceil((f_max-f_min)/number_of_points*1E5)/1E5\n picoVNA.SetFreqPlan(f_min,freq_step,number_of_points,power,bandwidth)\n picoVNA.SetEnhance('Aver',Average)\n\n picoVNA.Measure('ALL');\n\n raw_logmag = picoVNA.GetData(port,\"logmag\",0)\n splitdata_logmag = raw_logmag.split(',')\n freq = np.float64(np.array(splitdata_logmag))[: : 2]\n logmag = np.float64(np.array(splitdata_logmag))[1 : : 2]\n\n raw_real = picoVNA.GetData(port, \"real\", 0)\n splitdata_real = raw_real.split(',')\n real = np.float64(np.array(splitdata_real))[1 : : 2]\n\n raw_imag = picoVNA.GetData(port, \"imag\", 0)\n splitdata_imag = raw_imag.split(',')\n imag = np.float64(np.array(splitdata_imag))[1:: 2]\n\n raw_phase = picoVNA.GetData(port, \"phase\", 0)\n splitdata_phase = raw_phase.split(',')\n phase = np.float64(np.array(splitdata_phase))[1:: 2]\n\n data = Smith(real,imag,logmag,phase,freq)\n return data\n finally:\n picoVNA.CloseVNA()\n\n\n'''\ndata = get_picoVNA_smith()\n\nplt.plot(data.freqs, data.log_mag)\nplt.ylabel(\"S21 LogMag\")\nplt.xlabel(\"Frequency\")\nplt.show()\n\n'''\n" ]

[ [ "numpy.ceil", "numpy.array" ] ]

bene1337/OpenFermion

[ "6187085f2a7707012b68370b625acaeed547e62b" ]

[ "src/openfermion/transforms/repconversions/conversions.py" ]

[ "# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport numpy\n\nfrom openfermion.config import EQ_TOLERANCE\nfrom openfermion.ops.operators import FermionOperator\nfrom openfermion.ops.representations import (DiagonalCoulombHamiltonian,\n InteractionOperator,\n InteractionOperatorError)\nfrom openfermion.transforms.opconversions import (check_no_sympy,\n normal_ordered)\nfrom openfermion.ops.representations.quadratic_hamiltonian import (\n QuadraticHamiltonian, QuadraticHamiltonianError)\n\nfrom openfermion.chem import MolecularData\n\n# for breaking cyclic imports\nfrom openfermion.utils import operator_utils as op_utils\n\n\ndef get_quadratic_hamiltonian(fermion_operator,\n chemical_potential=0.,\n n_qubits=None,\n ignore_incompatible_terms=False):\n r\"\"\"Convert a quadratic fermionic operator to QuadraticHamiltonian.\n\n Args:\n fermion_operator(FermionOperator): The operator to convert.\n chemical_potential(float): A chemical potential to include in\n the returned operator\n n_qubits(int): Optionally specify the total number of qubits in the\n system\n ignore_incompatible_terms(bool): This flag determines the behavior\n of this method when it encounters terms that are not quadratic\n that is, terms that are not of the form a^\\dagger_p a_q.\n If set to True, this method will simply ignore those terms.\n If False, then this method will raise an error if it encounters\n such a term. The default setting is False.\n\n Returns:\n quadratic_hamiltonian: An instance of the QuadraticHamiltonian class.\n\n Raises:\n TypeError: Input must be a FermionOperator.\n TypeError: FermionOperator does not map to QuadraticHamiltonian.\n\n Warning:\n Even assuming that each creation or annihilation operator appears\n at most a constant number of times in the original operator, the\n runtime of this method is exponential in the number of qubits.\n \"\"\"\n if not isinstance(fermion_operator, FermionOperator):\n raise TypeError('Input must be a FermionOperator.')\n\n check_no_sympy(fermion_operator)\n\n if n_qubits is None:\n n_qubits = op_utils.count_qubits(fermion_operator)\n if n_qubits < op_utils.count_qubits(fermion_operator):\n raise ValueError('Invalid number of qubits specified.')\n\n # Normal order the terms and initialize.\n fermion_operator = normal_ordered(fermion_operator)\n constant = 0.\n combined_hermitian_part = numpy.zeros((n_qubits, n_qubits), complex)\n antisymmetric_part = numpy.zeros((n_qubits, n_qubits), complex)\n\n # Loop through terms and assign to matrix.\n for term in fermion_operator.terms:\n coefficient = fermion_operator.terms[term]\n # Ignore this term if the coefficient is zero\n if abs(coefficient) < EQ_TOLERANCE:\n # not testable because normal_ordered kills\n # fermion terms lower than EQ_TOLERANCE\n continue # pragma: no cover\n\n if len(term) == 0:\n # Constant term\n constant = coefficient\n elif len(term) == 2:\n ladder_type = [operator[1] for operator in term]\n p, q = [operator[0] for operator in term]\n\n if ladder_type == [1, 0]:\n combined_hermitian_part[p, q] = coefficient\n elif ladder_type == [1, 1]:\n # Need to check that the corresponding [0, 0] term is present\n conjugate_term = ((p, 0), (q, 0))\n if conjugate_term not in fermion_operator.terms:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n else:\n matching_coefficient = -fermion_operator.terms[\n conjugate_term].conjugate()\n discrepancy = abs(coefficient - matching_coefficient)\n if discrepancy > EQ_TOLERANCE:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n antisymmetric_part[p, q] += .5 * coefficient\n antisymmetric_part[q, p] -= .5 * coefficient\n else:\n # ladder_type == [0, 0]\n # Need to check that the corresponding [1, 1] term is present\n conjugate_term = ((p, 1), (q, 1))\n if conjugate_term not in fermion_operator.terms:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n else:\n matching_coefficient = -fermion_operator.terms[\n conjugate_term].conjugate()\n discrepancy = abs(coefficient - matching_coefficient)\n if discrepancy > EQ_TOLERANCE:\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n antisymmetric_part[p, q] -= .5 * coefficient.conjugate()\n antisymmetric_part[q, p] += .5 * coefficient.conjugate()\n elif not ignore_incompatible_terms:\n # Operator contains non-quadratic terms\n raise QuadraticHamiltonianError('FermionOperator does not map '\n 'to QuadraticHamiltonian '\n '(contains non-quadratic terms).')\n\n # Compute Hermitian part\n hermitian_part = (combined_hermitian_part +\n chemical_potential * numpy.eye(n_qubits))\n\n # Check that the operator is Hermitian\n if not op_utils.is_hermitian(hermitian_part):\n raise QuadraticHamiltonianError(\n 'FermionOperator does not map '\n 'to QuadraticHamiltonian (not Hermitian).')\n\n # Form QuadraticHamiltonian and return.\n discrepancy = numpy.max(numpy.abs(antisymmetric_part))\n if discrepancy < EQ_TOLERANCE:\n # Hamiltonian conserves particle number\n quadratic_hamiltonian = QuadraticHamiltonian(\n hermitian_part,\n constant=constant,\n chemical_potential=chemical_potential)\n else:\n # Hamiltonian does not conserve particle number\n quadratic_hamiltonian = QuadraticHamiltonian(hermitian_part,\n antisymmetric_part,\n constant,\n chemical_potential)\n\n return quadratic_hamiltonian\n\n\ndef get_diagonal_coulomb_hamiltonian(fermion_operator,\n n_qubits=None,\n ignore_incompatible_terms=False):\n r\"\"\"Convert a FermionOperator to a DiagonalCoulombHamiltonian.\n\n Args:\n fermion_operator(FermionOperator): The operator to convert.\n n_qubits(int): Optionally specify the total number of qubits in the\n system\n ignore_incompatible_terms(bool): This flag determines the behavior\n of this method when it encounters terms that are not represented\n by the DiagonalCoulombHamiltonian class, namely, terms that are\n not quadratic and not quartic of the form\n a^\\dagger_p a_p a^\\dagger_q a_q. If set to True, this method will\n simply ignore those terms. If False, then this method will raise\n an error if it encounters such a term. The default setting is False.\n \"\"\"\n if not isinstance(fermion_operator, FermionOperator):\n raise TypeError('Input must be a FermionOperator.')\n\n check_no_sympy(fermion_operator)\n\n if n_qubits is None:\n n_qubits = op_utils.count_qubits(fermion_operator)\n if n_qubits < op_utils.count_qubits(fermion_operator):\n raise ValueError('Invalid number of qubits specified.')\n\n fermion_operator = normal_ordered(fermion_operator)\n constant = 0.\n one_body = numpy.zeros((n_qubits, n_qubits), complex)\n two_body = numpy.zeros((n_qubits, n_qubits), float)\n\n for term, coefficient in fermion_operator.terms.items():\n # Ignore this term if the coefficient is zero\n if abs(coefficient) < EQ_TOLERANCE:\n # not testable because normal_ordered kills\n # fermion terms lower than EQ_TOLERANCE\n continue # pragma: no cover\n\n if len(term) == 0:\n constant = coefficient\n else:\n actions = [operator[1] for operator in term]\n if actions == [1, 0]:\n p, q = [operator[0] for operator in term]\n one_body[p, q] = coefficient\n elif actions == [1, 1, 0, 0]:\n p, q, r, s = [operator[0] for operator in term]\n if p == r and q == s:\n if abs(numpy.imag(coefficient)) > EQ_TOLERANCE:\n raise ValueError(\n 'FermionOperator does not map to '\n 'DiagonalCoulombHamiltonian (not Hermitian).')\n coefficient = numpy.real(coefficient)\n two_body[p, q] = -.5 * coefficient\n two_body[q, p] = -.5 * coefficient\n elif not ignore_incompatible_terms:\n raise ValueError('FermionOperator does not map to '\n 'DiagonalCoulombHamiltonian '\n '(contains terms with indices '\n '{}).'.format((p, q, r, s)))\n elif not ignore_incompatible_terms:\n raise ValueError('FermionOperator does not map to '\n 'DiagonalCoulombHamiltonian (contains terms '\n 'with action {}.'.format(tuple(actions)))\n\n # Check that the operator is Hermitian\n if not op_utils.is_hermitian(one_body):\n raise ValueError(\n 'FermionOperator does not map to DiagonalCoulombHamiltonian '\n '(not Hermitian).')\n\n return DiagonalCoulombHamiltonian(one_body, two_body, constant)\n\n\ndef get_interaction_operator(fermion_operator, n_qubits=None):\n r\"\"\"Convert a 2-body fermionic operator to InteractionOperator.\n\n This function should only be called on fermionic operators which\n consist of only a_p^\\dagger a_q and a_p^\\dagger a_q^\\dagger a_r a_s\n terms. The one-body terms are stored in a matrix, one_body[p, q], and\n the two-body terms are stored in a tensor, two_body[p, q, r, s].\n\n Returns:\n interaction_operator: An instance of the InteractionOperator class.\n\n Raises:\n TypeError: Input must be a FermionOperator.\n TypeError: FermionOperator does not map to InteractionOperator.\n\n Warning:\n Even assuming that each creation or annihilation operator appears\n at most a constant number of times in the original operator, the\n runtime of this method is exponential in the number of qubits.\n \"\"\"\n if not isinstance(fermion_operator, FermionOperator):\n raise TypeError('Input must be a FermionOperator.')\n\n check_no_sympy(fermion_operator)\n\n if n_qubits is None:\n n_qubits = op_utils.count_qubits(fermion_operator)\n if n_qubits < op_utils.count_qubits(fermion_operator):\n raise ValueError('Invalid number of qubits specified.')\n\n # Normal order the terms and initialize.\n fermion_operator = normal_ordered(fermion_operator)\n constant = 0.\n one_body = numpy.zeros((n_qubits, n_qubits), complex)\n two_body = numpy.zeros((n_qubits, n_qubits, n_qubits, n_qubits), complex)\n\n # Loop through terms and assign to matrix.\n for term in fermion_operator.terms:\n coefficient = fermion_operator.terms[term]\n # Ignore this term if the coefficient is zero\n if abs(coefficient) < EQ_TOLERANCE:\n # not testable because normal_ordered kills\n # fermion terms lower than EQ_TOLERANCE\n continue # pragma: no cover\n\n # Handle constant shift.\n if len(term) == 0:\n constant = coefficient\n\n elif len(term) == 2:\n # Handle one-body terms.\n if [operator[1] for operator in term] == [1, 0]:\n p, q = [operator[0] for operator in term]\n one_body[p, q] = coefficient\n else:\n raise InteractionOperatorError('FermionOperator does not map '\n 'to InteractionOperator.')\n\n elif len(term) == 4:\n # Handle two-body terms.\n if [operator[1] for operator in term] == [1, 1, 0, 0]:\n p, q, r, s = [operator[0] for operator in term]\n two_body[p, q, r, s] = coefficient\n else:\n raise InteractionOperatorError('FermionOperator does not map '\n 'to InteractionOperator.')\n\n else:\n # Handle non-molecular Hamiltonian.\n raise InteractionOperatorError('FermionOperator does not map '\n 'to InteractionOperator.')\n\n # Form InteractionOperator and return.\n interaction_operator = InteractionOperator(constant, one_body, two_body)\n return interaction_operator\n\n\ndef get_molecular_data(interaction_operator,\n geometry=None,\n basis=None,\n multiplicity=None,\n n_electrons=None,\n reduce_spin=True,\n data_directory=None):\n \"\"\"Output a MolecularData object generated from an InteractionOperator\n\n Args:\n interaction_operator(InteractionOperator): two-body interaction\n operator defining the \"molecular interaction\" to be simulated.\n geometry(string or list of atoms):\n basis(string): String denoting the basis set used to discretize the\n system.\n multiplicity(int): Spin multiplicity desired in the system.\n n_electrons(int): Number of electrons in the system\n reduce_spin(bool): True if one wishes to perform spin reduction on\n integrals that are given in interaction operator. Assumes\n spatial (x) spin structure generically.\n\n Returns:\n molecule(MolecularData):\n Instance that captures the\n interaction_operator converted into the format that would come\n from an electronic structure package adorned with some meta-data\n that may be useful.\n \"\"\"\n\n n_spin_orbitals = interaction_operator.n_qubits\n\n # Introduce bare molecular operator to fill\n molecule = MolecularData(geometry=geometry,\n basis=basis,\n multiplicity=multiplicity,\n data_directory=data_directory)\n\n molecule.nuclear_repulsion = interaction_operator.constant\n\n # Remove spin from integrals and put into molecular operator\n if reduce_spin:\n reduction_indices = list(range(0, n_spin_orbitals, 2))\n else:\n reduction_indices = list(range(n_spin_orbitals))\n\n molecule.n_orbitals = len(reduction_indices)\n\n molecule.one_body_integrals = interaction_operator.one_body_tensor[\n numpy.ix_(reduction_indices, reduction_indices)]\n molecule.two_body_integrals = interaction_operator.two_body_tensor[\n numpy.ix_(reduction_indices, reduction_indices, reduction_indices,\n reduction_indices)]\n\n # Fill in other metadata\n molecule.overlap_integrals = numpy.eye(molecule.n_orbitals)\n molecule.n_qubits = n_spin_orbitals\n molecule.n_electrons = n_electrons\n molecule.multiplicity = multiplicity\n\n return molecule\n" ]

[ [ "numpy.ix_", "numpy.imag", "numpy.abs", "numpy.eye", "numpy.real", "numpy.zeros" ] ]

thangth1102/Wikidata2Text

[ "722b528451e92b3072bf57260fdb8f0962a89929" ]

[ "autoencoders.py" ]

[ "from cluster_losses import *\r\nfrom cluster_metrics import *\r\nfrom corpus_estimation import *\r\nfrom cluster_methods import *\r\n\r\nfrom sklearn.model_selection import train_test_split\r\n\r\nimport keras\r\nfrom keras.layers import Input, Dense\r\nfrom keras.models import Model\r\nfrom keras.callbacks import TensorBoard\r\nfrom keras.callbacks import EarlyStopping\r\n\r\nimport matplotlib.pyplot as plt\r\n\r\nfrom sklearn.preprocessing import MinMaxScaler\r\n\r\ndef add_noise(x_train, x_test, noise_factor):\r\n x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.5, scale=0.5, size=x_train.shape) \r\n x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.5, scale=0.5, size=x_test.shape) \r\n\r\n x_train_noisy = np.clip(x_train_noisy, 0., 10.)\r\n x_test_noisy = np.clip(x_test_noisy, 0., 10.)\r\n\r\n print('x_test_noisy: ', x_test_noisy)\r\n return x_train_noisy, x_test_noisy\r\n\r\ndef calculate_total_loss(network_loss, cluster_loss, loss_coefficient):\r\n return network_loss*loss_coefficient + (1-loss_coefficient)*cluster_loss\r\n\r\ndef train_autoencoder(input_dim, encoding_dim, x_train, x_test, x_all, y_train, y_test, y_all, epochs, n_clusters, batch_size=1,\r\n centroids=[], loss_coefficient=0.5, cluster_loss_type='euclidean', network_loss='mean_squared_error',\r\n optimizer='sgd', exit_type='total_val', min_delta=0.001, denoising=False, noise_factor=0.5):\r\n\r\n \"\"\"\r\n x_all = x_true\r\n y_all = y_true\r\n \"\"\"\r\n # denoising autoencoder\r\n x_train_noisy, x_test_noisy = [], []\r\n if (denoising == True):\r\n x_train_noisy, x_test_noisy = add_noise(x_train, x_test, noise_factor)\r\n \r\n input_data = Input(shape=(input_dim,)) # input_dim = 32\r\n\r\n encoded = Dense(encoding_dim)(input_data) \r\n \r\n # set up more hidden layers here\r\n decoded = Dense(input_dim)(encoded) # \"decoded\" is the lossy reconstruction of the input\r\n \r\n autoencoder = Model(input_data, decoded) # this model maps an input to its reconstruction\r\n\r\n encoder = Model(input_data, encoded) # this model maps an input to its encoded representation\r\n encoded_input = Input(shape=(encoding_dim,)) # create a placeholder for an encoded (2-dimensional) input\r\n \r\n decoder_layer = autoencoder.layers[-1] # retrieve the last layer of the autoencoder model\r\n decoder = Model(encoded_input, decoder_layer(encoded_input)) # create the decoder model\r\n\r\n hidden_layer = autoencoder.layers[0] # get hidden layer values\r\n hidden_layer_decoder = Model(encoded_input, hidden_layer(encoded_input))\r\n\r\n autoencoder.compile(loss=network_loss, optimizer=optimizer)\r\n\r\n total_loss_list = [] # total lost\r\n total_val_loss_list = [] # total validation lost\r\n \r\n hidden_layer_data = []\r\n hidden_layer_data_list = []\r\n decoded_data = []\r\n \r\n centroids = []\r\n cluster_loss = 0\r\n \r\n history_list = []\r\n idx = []\r\n for ep in range(epochs):\r\n\r\n print('..................................................')\r\n print('epoch: \\t', ep)\r\n\r\n if (denoising == True):\r\n history = autoencoder.fit(x_train_noisy, x_train,\r\n batch_size=batch_size, epochs=1,\r\n shuffle=True,\r\n validation_data=(x_test_noisy, x_test),\r\n verbose=0)\r\n else:\r\n history = autoencoder.fit(x_train, x_train,\r\n batch_size=batch_size, epochs=1,\r\n shuffle=True,\r\n validation_data=(x_test, x_test),\r\n verbose=0)\r\n #callbacks=[TensorBoard(log_dir='/tmp/autoencoder')])\r\n\r\n history_list.append(history) # add trained values to history in every epoch\r\n\r\n encoded_data = encoder.predict(x_all) # get all data\r\n #print('encoded_data: ', encoded_data)\r\n \r\n decoded_data = decoder.predict(encoded_data) \r\n #print('decoded_data: ', decoded_data)\r\n \r\n hidden_layer_data = hidden_layer_decoder.predict(encoded_data)\r\n #print('hidden_layer_data: ', hidden_layer_data)\r\n hidden_layer_data_list.append(hidden_layer_data)\r\n\r\n # calculate loss\r\n network_loss = autoencoder.history.history['loss'][0]\r\n network_val_loss = autoencoder.history.history['val_loss'][0]\r\n\r\n print('network_loss, network_val_loss: ', network_loss, network_val_loss)\r\n\r\n centroids = []\r\n for x, y in zip(hidden_layer_data, y_all):\r\n if (y == 0): # true labels\r\n centroids.append(x.tolist())\r\n #print('centroids: ', centroids, len(centroids))\r\n\r\n cluster_sum_loss, cluster_mean_loss = 0, 0\r\n\r\n if (cluster_loss_type == 'kmeans'):\r\n cluster_sum_loss, cluster_mean_loss, centroids, idx = kmeans_loss(hidden_layer_data, n_clusters)\r\n elif (cluster_loss_type == 'euclidean'):\r\n # need to have centroids\r\n cluster_sum_loss, cluster_mean_loss = euclidean_distance_mean_loss(hidden_layer_data, centroids)\r\n elif(cluster_loss_type == 'rmse'):\r\n # need to have centroids\r\n cluster_sum_loss, cluster_mean_loss = rmse_loss(hidden_layer_data, centroids)\r\n else:\r\n # similar to kmeans but need to have centroids\r\n cluster_sum_loss, cluster_mean_loss = mse_loss(hidden_layer_data, centroids)\r\n print('cluster_sum_loss, cluster_mean_loss: ', cluster_sum_loss, cluster_mean_loss)\r\n \r\n total_loss = calculate_total_loss(network_loss, cluster_mean_loss, loss_coefficient)\r\n total_loss_list.append(total_loss)\r\n\r\n total_val_loss = calculate_total_loss(network_val_loss, cluster_mean_loss, loss_coefficient)\r\n total_val_loss_list.append(total_val_loss)\r\n\r\n print('total loss, total validation loss: ', total_loss, total_val_loss)\r\n\r\n #if (ep <= 5): continue\r\n\r\n # break condition\r\n\r\n if (exit_type == 'total'):\r\n condition = exit_condition(total_loss_list, min_delta)\r\n if (condition != -1):\r\n if (condition == 0):\r\n return history_list[:-1], total_loss_list[:-1], total_val_loss_list[:-1], hidden_layer_data_list[-2]\r\n break\r\n elif (exit_type == 'total_val'):\r\n condition = exit_condition(total_val_loss_list, min_delta)\r\n if (condition != -1):\r\n if (condition == 0):\r\n return history_list[:-1], total_loss_list[:-1], total_val_loss_list[:-1], hidden_layer_data_list[-2]\r\n break\r\n \r\n return history_list, total_loss_list, total_val_loss_list, hidden_layer_data\r\n\r\n\r\ndef show_loss_plot(history_list, total_loss_list, total_val_loss_list):\r\n plt.plot([h.history['loss'] for h in history_list])\r\n plt.plot([h.history['val_loss'] for h in history_list])\r\n plt.plot(total_loss_list)\r\n plt.plot(total_val_loss_list)\r\n plt.title('Model loss')\r\n plt.ylabel('Loss')\r\n plt.xlabel('Epoch')\r\n plt.legend(['Train', 'Test', 'Total_train', 'Total_test'], loc='upper left')\r\n plt.show()\r\n \r\n\r\ndef exit_condition(loss_list, min_delta):\r\n\r\n # len(lost_list)\r\n count = 0\r\n if (len(loss_list) < 2): return -1\r\n else:\r\n if (len(loss_list) <= 5): return -1\r\n elif (loss_list[-2] - loss_list[-1] < 0):\r\n return 0\r\n elif (loss_list[-2] - loss_list[-1] <= min_delta):\r\n return 1\r\n return -1\r\n" ]

[ [ "matplotlib.pyplot.legend", "matplotlib.pyplot.title", "matplotlib.pyplot.plot", "matplotlib.pyplot.xlabel", "matplotlib.pyplot.show", "matplotlib.pyplot.ylabel" ] ]

yarenty/ludwig

[ "d77aaf8da39f04a353a3a08fb699ae8a96ffea3a" ]

[ "ludwig/data/preprocessing.py" ]

[ "#! /usr/bin/env python\n# Copyright (c) 2019 Uber Technologies, Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\nimport logging\nfrom abc import ABC, abstractmethod\nfrom typing import Any, Dict, List, Tuple\n\nimport numpy as np\nimport pandas as pd\n\nfrom ludwig.backend import Backend, LOCAL_BACKEND\nfrom ludwig.constants import (\n BACKFILL,\n BFILL,\n BINARY,\n CHECKSUM,\n COLUMN,\n DROP_ROW,\n FFILL,\n FILL_WITH_CONST,\n FILL_WITH_FALSE,\n FILL_WITH_MEAN,\n FILL_WITH_MODE,\n FULL,\n NAME,\n NUMBER,\n PAD,\n PREPROCESSING,\n PROC_COLUMN,\n SPLIT,\n SRC,\n TEST,\n TEXT,\n TRAINING,\n TYPE,\n VALIDATION,\n)\nfrom ludwig.data.concatenate_datasets import concatenate_df, concatenate_files\nfrom ludwig.data.dataset.base import Dataset\nfrom ludwig.encoders.registry import get_encoder_cls\nfrom ludwig.features.feature_registries import base_type_registry\nfrom ludwig.features.feature_utils import compute_feature_hash\nfrom ludwig.utils import data_utils, strings_utils\nfrom ludwig.utils.data_utils import (\n CACHEABLE_FORMATS,\n CSV_FORMATS,\n DATA_TRAIN_HDF5_FP,\n DATAFRAME_FORMATS,\n DICT_FORMATS,\n EXCEL_FORMATS,\n FEATHER_FORMATS,\n figure_data_format,\n FWF_FORMATS,\n get_split_path,\n HDF5_FORMATS,\n HTML_FORMATS,\n JSON_FORMATS,\n JSONL_FORMATS,\n ORC_FORMATS,\n override_in_memory_flag,\n PARQUET_FORMATS,\n PICKLE_FORMATS,\n read_csv,\n read_excel,\n read_feather,\n read_fwf,\n read_html,\n read_json,\n read_jsonl,\n read_orc,\n read_parquet,\n read_pickle,\n read_sas,\n read_spss,\n read_stata,\n read_tsv,\n SAS_FORMATS,\n save_array,\n split_dataset_ttv,\n SPSS_FORMATS,\n STATA_FORMATS,\n TSV_FORMATS,\n)\nfrom ludwig.utils.defaults import default_preprocessing_parameters, default_random_seed\nfrom ludwig.utils.fs_utils import file_lock, path_exists\nfrom ludwig.utils.misc_utils import get_from_registry, merge_dict, resolve_pointers, set_random_seed\nfrom ludwig.utils.type_utils import Column\nfrom ludwig.utils.types import DataFrame\n\nlogger = logging.getLogger(__name__)\n\n\nclass DataFormatPreprocessor(ABC):\n @staticmethod\n @abstractmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n pass\n\n @staticmethod\n @abstractmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n pass\n\n @staticmethod\n @abstractmethod\n def prepare_processed_data(\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n ):\n pass\n\n\nclass DictPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n num_overrides = override_in_memory_flag(features, True)\n if num_overrides > 0:\n logger.warning(\"Using in_memory = False is not supported \" \"with {} data format.\".format(\"dict\"))\n\n df_engine = backend.df_engine\n if dataset is not None:\n dataset = df_engine.from_pandas(pd.DataFrame(dataset))\n if training_set is not None:\n training_set = df_engine.from_pandas(pd.DataFrame(training_set))\n if validation_set is not None:\n validation_set = df_engine.from_pandas(pd.DataFrame(validation_set))\n if test_set is not None:\n test_set = df_engine.from_pandas(pd.DataFrame(test_set))\n\n return _preprocess_df_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n training_set_metadata=training_set_metadata,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset, training_set_metadata = build_dataset(\n pd.DataFrame(dataset),\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass DataFramePreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n num_overrides = override_in_memory_flag(features, True)\n if num_overrides > 0:\n logger.warning(\"Using in_memory = False is not supported \" \"with {} data format.\".format(\"dataframe\"))\n\n if isinstance(dataset, pd.DataFrame):\n dataset = backend.df_engine.from_pandas(dataset)\n\n return _preprocess_df_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n training_set_metadata=training_set_metadata,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n if isinstance(dataset, pd.DataFrame):\n dataset = backend.df_engine.from_pandas(dataset)\n\n dataset, training_set_metadata = build_dataset(\n dataset,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass CSVPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_csv,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_csv(dataset, df_lib=backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass TSVPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_tsv,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_tsv(dataset, df_lib=backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass JSONPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_json,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_json(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass JSONLPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_jsonl,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_jsonl(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass ExcelPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_excel,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_excel(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass ParquetPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_parquet,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_parquet(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n @staticmethod\n def prepare_processed_data(\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n ):\n test_set = test_set if test_set and path_exists(test_set) else None\n validation_set = validation_set if validation_set and path_exists(validation_set) else None\n return training_set, test_set, validation_set, training_set_metadata\n\n\nclass PicklePreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_pickle,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_pickle(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass FatherPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_feather,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_feather(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass FWFPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_fwf,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_fwf(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass HTMLPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_html,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_html(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass ORCPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_orc,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_orc(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass SASPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_sas,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_sas(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass SPSSPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_spss,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_spss(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass StataPreprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return _preprocess_file_for_training(\n config,\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n read_fn=read_stata,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n dataset_df = read_stata(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n dataset, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n callbacks=callbacks,\n mode=\"prediction\",\n )\n return dataset, training_set_metadata, None\n\n\nclass HDF5Preprocessor(DataFormatPreprocessor):\n @staticmethod\n def preprocess_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n ):\n return HDF5Preprocessor.prepare_processed_data(\n features,\n dataset,\n training_set,\n validation_set,\n test_set,\n training_set_metadata,\n skip_save_processed_input,\n preprocessing_params,\n backend,\n random_seed,\n )\n\n @staticmethod\n def preprocess_for_prediction(dataset, features, preprocessing_params, training_set_metadata, backend, callbacks):\n hdf5_fp = dataset\n dataset = load_hdf5(dataset, features, split_data=False, shuffle_training=False)\n return dataset, training_set_metadata, hdf5_fp\n\n @staticmethod\n def prepare_processed_data(\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n ):\n if dataset is None and training_set is None:\n raise ValueError(\"One of `dataset` or `training_set` must be not None\")\n not_none_set = dataset if dataset is not None else training_set\n\n if not training_set_metadata:\n raise ValueError(\"When providing HDF5 data, \" \"training_set_metadata must not be None.\")\n\n logger.info(\"Using full hdf5 and json\")\n\n if DATA_TRAIN_HDF5_FP not in training_set_metadata:\n logger.warning(\n \"data_train_hdf5_fp not present in training_set_metadata. \"\n \"Adding it with the current HDF5 file path {}\".format(not_none_set)\n )\n training_set_metadata[DATA_TRAIN_HDF5_FP] = not_none_set\n\n elif training_set_metadata[DATA_TRAIN_HDF5_FP] != not_none_set:\n logger.warning(\n \"data_train_hdf5_fp in training_set_metadata is {}, \"\n \"different from the current HDF5 file path {}. \"\n \"Replacing it\".format(training_set_metadata[DATA_TRAIN_HDF5_FP], not_none_set)\n )\n training_set_metadata[DATA_TRAIN_HDF5_FP] = not_none_set\n\n if dataset is not None:\n training_set, test_set, validation_set = load_hdf5(dataset, features, shuffle_training=True)\n\n elif training_set is not None:\n kwargs = dict(features=features, split_data=False)\n training_set = load_hdf5(training_set, shuffle_training=True, **kwargs)\n\n if validation_set is not None:\n validation_set = load_hdf5(validation_set, shuffle_training=False, **kwargs)\n\n if test_set is not None:\n test_set = load_hdf5(test_set, shuffle_training=False, **kwargs)\n\n return training_set, test_set, validation_set, training_set_metadata\n\n\ndata_format_preprocessor_registry = {\n **{fmt: DictPreprocessor for fmt in DICT_FORMATS},\n **{fmt: DataFramePreprocessor for fmt in DATAFRAME_FORMATS},\n **{fmt: CSVPreprocessor for fmt in CSV_FORMATS},\n **{fmt: TSVPreprocessor for fmt in TSV_FORMATS},\n **{fmt: JSONPreprocessor for fmt in JSON_FORMATS},\n **{fmt: JSONLPreprocessor for fmt in JSONL_FORMATS},\n **{fmt: ExcelPreprocessor for fmt in EXCEL_FORMATS},\n **{fmt: ParquetPreprocessor for fmt in PARQUET_FORMATS},\n **{fmt: PicklePreprocessor for fmt in PICKLE_FORMATS},\n **{fmt: FWFPreprocessor for fmt in FWF_FORMATS},\n **{fmt: FatherPreprocessor for fmt in FEATHER_FORMATS},\n **{fmt: HTMLPreprocessor for fmt in HTML_FORMATS},\n **{fmt: ORCPreprocessor for fmt in ORC_FORMATS},\n **{fmt: SASPreprocessor for fmt in SAS_FORMATS},\n **{fmt: SPSSPreprocessor for fmt in SPSS_FORMATS},\n **{fmt: StataPreprocessor for fmt in STATA_FORMATS},\n **{fmt: HDF5Preprocessor for fmt in HDF5_FORMATS},\n}\n\n\ndef build_dataset(\n dataset_df,\n features,\n global_preprocessing_parameters,\n metadata=None,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n skip_save_processed_input=False,\n callbacks=None,\n mode=None,\n):\n df_engine = backend.df_engine\n dataset_df = df_engine.parallelize(dataset_df)\n\n # If persisting DataFrames in memory is enabled, we want to do this after\n # each batch of parallel ops in order to avoid redundant computation\n dataset_df = backend.df_engine.persist(dataset_df)\n\n global_preprocessing_parameters = merge_dict(default_preprocessing_parameters, global_preprocessing_parameters)\n\n # Get all the unique preprocessing features to compute\n feature_configs = []\n feature_hashes = set()\n for feature in features:\n if PROC_COLUMN not in feature:\n feature[PROC_COLUMN] = compute_feature_hash(feature)\n if feature[PROC_COLUMN] not in feature_hashes:\n feature_configs.append(feature)\n feature_hashes.add(feature[PROC_COLUMN])\n\n logger.debug(\"cast columns\")\n dataset_cols = cast_columns(dataset_df, feature_configs, backend)\n\n for callback in callbacks or []:\n callback.on_build_metadata_start(dataset_df, mode)\n\n logger.debug(\"build metadata\")\n metadata = build_metadata(metadata, dataset_cols, feature_configs, global_preprocessing_parameters, backend)\n\n for callback in callbacks or []:\n callback.on_build_metadata_end(dataset_df, mode)\n\n for callback in callbacks or []:\n callback.on_build_data_start(dataset_df, mode)\n\n logger.debug(\"build data\")\n proc_cols = build_data(dataset_cols, feature_configs, metadata, backend, skip_save_processed_input)\n\n for callback in callbacks or []:\n callback.on_build_data_end(dataset_df, mode)\n\n logger.debug(\"get split\")\n split = get_split(\n dataset_df,\n force_split=global_preprocessing_parameters[\"force_split\"],\n split_probabilities=global_preprocessing_parameters[\"split_probabilities\"],\n stratify=global_preprocessing_parameters[\"stratify\"],\n backend=backend,\n random_seed=random_seed,\n )\n\n if split is not None:\n proc_cols[SPLIT] = split\n\n # TODO ray: this is needed because ray 1.7 doesn't support Dask to RayDataset\n # conversion with Tensor columns. Can remove for 1.8.\n if backend.df_engine.partitioned:\n for feature in features:\n name = feature[NAME]\n proc_column = feature[PROC_COLUMN]\n reshape = metadata[name].get(\"reshape\")\n if reshape is not None:\n proc_cols[proc_column] = backend.df_engine.map_objects(proc_cols[proc_column], lambda x: x.reshape(-1))\n\n dataset = backend.df_engine.df_like(dataset_df, proc_cols)\n\n # At this point, there should be no missing values left in the dataframe, unless\n # the DROP_ROW preprocessing option was selected, in which case we need to drop those\n # rows.\n dataset = dataset.dropna()\n\n return dataset, metadata\n\n\ndef cast_columns(dataset_df, features, backend) -> Dict[str, DataFrame]:\n \"\"\"Copies each column of the dataset to a dataframe, with potential type casting.\"\"\"\n dataset_cols = {}\n for feature in features:\n # todo figure out if additional parameters are needed\n # for the cast_column function\n try:\n dataset_cols[feature[COLUMN]] = get_from_registry(feature[TYPE], base_type_registry).cast_column(\n dataset_df[feature[COLUMN]], backend\n )\n except KeyError as e:\n raise KeyError(\n f\"Feature name {e} specified in the config was not found in dataset with columns: \"\n + f\"{list(dataset_df.columns)}\"\n )\n\n return dataset_cols\n\n\ndef merge_preprocessing(\n feature_config: Dict[str, Any], global_preprocessing_parameters: Dict[str, Any]\n) -> Dict[str, Any]:\n if PREPROCESSING not in feature_config:\n return global_preprocessing_parameters[feature_config[TYPE]]\n\n return merge_dict(global_preprocessing_parameters[feature_config[TYPE]], feature_config[PREPROCESSING])\n\n\ndef build_metadata(\n metadata: Dict[str, Any],\n dataset_cols: Dict[str, Column],\n feature_configs: List[Dict[str, Any]],\n global_preprocessing_parameters: Dict[str, Any],\n backend: Backend,\n) -> Dict[str, Any]:\n for feature_config in feature_configs:\n if feature_config[NAME] in metadata:\n continue\n\n preprocessing_parameters = merge_preprocessing(feature_config, global_preprocessing_parameters)\n\n # deal with encoders that have fixed preprocessing\n if \"encoder\" in feature_config:\n encoder_class = get_encoder_cls(feature_config[TYPE], feature_config[\"encoder\"])\n if hasattr(encoder_class, \"fixed_preprocessing_parameters\"):\n encoder_fpp = encoder_class.fixed_preprocessing_parameters\n\n preprocessing_parameters = merge_dict(\n preprocessing_parameters, resolve_pointers(encoder_fpp, feature_config, \"feature.\")\n )\n\n fill_value = precompute_fill_value(dataset_cols, feature_config, preprocessing_parameters, backend)\n\n if fill_value is not None:\n preprocessing_parameters = {\"computed_fill_value\": fill_value, **preprocessing_parameters}\n\n handle_missing_values(dataset_cols, feature_config, preprocessing_parameters)\n\n column = dataset_cols[feature_config[COLUMN]]\n if column.dtype == object:\n column = column.astype(str)\n\n metadata[feature_config[NAME]] = get_from_registry(feature_config[TYPE], base_type_registry).get_feature_meta(\n column, preprocessing_parameters, backend\n )\n\n metadata[feature_config[NAME]][PREPROCESSING] = preprocessing_parameters\n\n return metadata\n\n\ndef build_data(\n input_cols: DataFrame,\n feature_configs: List[Dict],\n training_set_metadata: Dict,\n backend: Backend,\n skip_save_processed_input: bool,\n) -> Dict[str, DataFrame]:\n \"\"\"Preprocesses the input dataframe columns, handles missing values, and potentially adds metadata to\n training_set_metadata.\n\n Args:\n input_cols: Input dataframe to be processed.\n feature_configs: List of feature configs.\n training_set_metadata: Training set metadata. Additional fields may be added.\n backend: Backend for data processing.\n skip_save_processed_input: (bool) Whether to skip saving the processed input.\n\n Returns:\n Dictionary of (feature name) -> (processed data).\n \"\"\"\n proc_cols = {}\n for feature_config in feature_configs:\n preprocessing_parameters = training_set_metadata[feature_config[NAME]][PREPROCESSING]\n handle_missing_values(input_cols, feature_config, preprocessing_parameters)\n get_from_registry(feature_config[TYPE], base_type_registry).add_feature_data(\n feature_config,\n input_cols,\n proc_cols,\n training_set_metadata,\n preprocessing_parameters,\n backend,\n skip_save_processed_input,\n )\n\n return proc_cols\n\n\ndef balance_data(dataset_df: DataFrame, output_features: List[Dict], preprocessing_parameters: Dict, backend: Backend):\n \"\"\"The purpose of this function is to balance the training dataset using either over-sampling or under-\n sampling.\n\n Args:\n dataset_df: Input dataframe to be over-sampled or under-sampled.\n output_features: List of feature configs.\n preprocessing_parameters: Dictionary of the global preprocessing parameters.\n backend: Backend for data processing.\n\n Returns: An over-sampled or under-sampled training dataset.\n \"\"\"\n\n if len(output_features) != 1:\n raise ValueError(\"Class balancing is only available for datasets with a single output feature\")\n if output_features[0][TYPE] != BINARY:\n raise ValueError(\"Class balancing is only supported for binary output types\")\n\n target = output_features[0][PROC_COLUMN]\n\n if backend.df_engine.partitioned:\n majority_class = backend.df_engine.compute(dataset_df[target].value_counts()).idxmax()\n minority_class = backend.df_engine.compute(dataset_df[target].value_counts()).idxmin()\n else:\n majority_class = dataset_df[target].value_counts().idxmax()\n minority_class = dataset_df[target].value_counts().idxmin()\n majority_df = dataset_df[dataset_df[target] == majority_class]\n minority_df = dataset_df[dataset_df[target] == minority_class]\n\n if preprocessing_parameters[\"oversample_minority\"] and preprocessing_parameters[\"undersample_majority\"]:\n raise ValueError(\n \"Cannot balance data if both oversampling an undersampling are specified in the config. \"\n \"Must specify only one method\"\n )\n\n if preprocessing_parameters[\"oversample_minority\"]:\n sample_fraction = (len(majority_df) * preprocessing_parameters[\"oversample_minority\"]) / len(minority_df)\n minority_df = minority_df.sample(frac=sample_fraction, replace=True)\n elif preprocessing_parameters[\"undersample_majority\"]:\n sample_fraction = int(len(minority_df) / preprocessing_parameters[\"undersample_majority\"]) / len(majority_df)\n majority_df = majority_df.sample(frac=sample_fraction, replace=False)\n\n balanced_df = backend.df_engine.concat([minority_df, majority_df])\n\n return balanced_df\n\n\ndef precompute_fill_value(dataset_cols, feature, preprocessing_parameters, backend):\n missing_value_strategy = preprocessing_parameters[\"missing_value_strategy\"]\n if missing_value_strategy == FILL_WITH_CONST:\n return preprocessing_parameters[\"fill_value\"]\n elif missing_value_strategy == FILL_WITH_MODE:\n return dataset_cols[feature[COLUMN]].value_counts().index[0]\n elif missing_value_strategy == FILL_WITH_MEAN:\n if feature[TYPE] != NUMBER:\n raise ValueError(\n f\"Filling missing values with mean is supported \"\n f\"only for numerical types, not for type {feature[TYPE]}.\",\n )\n return backend.df_engine.compute(dataset_cols[feature[COLUMN]].mean())\n elif missing_value_strategy == FILL_WITH_FALSE:\n distinct_values = backend.df_engine.compute(\n dataset_cols[feature[COLUMN]].drop_duplicates().dropna()\n ).values.tolist()\n if len(distinct_values) > 2:\n raise ValueError(\n f\"Missing value strategy `fill_with_false` \"\n f\"for column {feature[COLUMN]} expects 2 distinct values, \"\n f\"found: {distinct_values}\"\n )\n\n # Determine the False label.\n # Distinct values are sorted in reverse to mirror the selection of the default fallback_true_label (in\n # binary_feature.get_feature_meta) for binary columns with unconventional boolean values, \"human\"/\"bot\".\n for v in sorted(distinct_values, reverse=True):\n fallback_true_label = preprocessing_parameters.get(\"fallback_true_label\", \"true\")\n if strings_utils.str2bool(v, fallback_true_label) is False:\n return v\n raise ValueError(\n f\"Unable to determine False value for column {feature[COLUMN]} with distinct values: {distinct_values}.\"\n )\n # Otherwise, we cannot precompute the fill value for this dataset\n return None\n\n\ndef handle_missing_values(dataset_cols, feature, preprocessing_parameters):\n missing_value_strategy = preprocessing_parameters[\"missing_value_strategy\"]\n\n # Check for the precomputed fill value in the metadata\n computed_fill_value = preprocessing_parameters.get(\"computed_fill_value\")\n\n if computed_fill_value is not None:\n dataset_cols[feature[COLUMN]] = dataset_cols[feature[COLUMN]].fillna(\n computed_fill_value,\n )\n elif missing_value_strategy in [BACKFILL, BFILL, PAD, FFILL]:\n dataset_cols[feature[COLUMN]] = dataset_cols[feature[COLUMN]].fillna(\n method=missing_value_strategy,\n )\n elif missing_value_strategy == DROP_ROW:\n # Here we only drop from this series, but after preprocessing we'll do a second\n # round of dropping NA values from the entire output dataframe, which will\n # result in the removal of the rows.\n dataset_cols[feature[COLUMN]] = dataset_cols[feature[COLUMN]].dropna()\n else:\n raise ValueError(\"Invalid missing value strategy\")\n\n\ndef get_split(\n dataset_df,\n force_split=False,\n split_probabilities=(0.7, 0.1, 0.2),\n stratify=None,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n):\n if SPLIT in dataset_df and not force_split:\n split = dataset_df[SPLIT]\n else:\n set_random_seed(random_seed)\n if stratify is None or stratify not in dataset_df:\n if backend.df_engine.partitioned:\n # This approach is very inefficient for partitioned backends, which\n # can split by partition\n return None\n\n split = (\n dataset_df.index.to_series()\n .map(lambda x: np.random.choice(3, 1, p=split_probabilities))\n .astype(np.int8)\n )\n else:\n split = np.zeros(len(dataset_df))\n for val in dataset_df[stratify].unique():\n # TODO dask: find a way to better parallelize this operation\n idx_list = dataset_df.index[dataset_df[stratify] == val].tolist()\n array_lib = backend.df_engine.array_lib\n val_list = array_lib.random.choice(\n 3,\n len(idx_list),\n p=split_probabilities,\n ).astype(np.int8)\n split[idx_list] = val_list\n return split\n\n\ndef load_hdf5(hdf5_file_path, features, split_data=True, shuffle_training=False):\n # TODO dask: this needs to work with DataFrames\n logger.info(f\"Loading data from: {hdf5_file_path}\")\n\n def shuffle(df):\n return df.sample(frac=1).reset_index(drop=True)\n\n dataset = data_utils.load_hdf5(hdf5_file_path)\n if not split_data:\n if shuffle_training:\n dataset = shuffle(dataset)\n return dataset\n\n training_set, test_set, validation_set = split_dataset_ttv(dataset, SPLIT)\n\n if shuffle_training:\n training_set = shuffle(training_set)\n\n return training_set, test_set, validation_set\n\n\ndef load_metadata(metadata_file_path):\n logger.info(f\"Loading metadata from: {metadata_file_path}\")\n return data_utils.load_json(metadata_file_path)\n\n\ndef preprocess_for_training(\n config,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n data_format=None,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n) -> Tuple[Dataset, Dataset, Dataset, Dict[str, Any]]:\n \"\"\"Returns training, val and test datasets with training set metadata.\"\"\"\n\n # sanity check to make sure some data source is provided\n if dataset is None and training_set is None:\n raise ValueError(\"No training data is provided!\")\n\n # determine data format if not provided or auto\n if not data_format or data_format == \"auto\":\n data_format = figure_data_format(dataset, training_set, validation_set, test_set)\n\n try:\n lock_path = backend.cache.get_cache_directory(dataset)\n except (TypeError, ValueError):\n lock_path = None\n with file_lock(lock_path, lock_file=\".lock_preprocessing\"):\n # if training_set_metadata is a string, assume it's a path to load the json\n training_set_metadata = training_set_metadata or {}\n if training_set_metadata and isinstance(training_set_metadata, str):\n training_set_metadata = load_metadata(training_set_metadata)\n\n # setup\n features = config[\"input_features\"] + config[\"output_features\"]\n\n # in case data_format is one of the cacheable formats,\n # check if there's a cached hdf5 file with the same name,\n # and in case move on with the hdf5 branch.\n cached = False\n cache = backend.cache.get_dataset_cache(config, dataset, training_set, test_set, validation_set)\n if data_format in CACHEABLE_FORMATS:\n cache_results = cache.get()\n if cache_results is not None:\n valid, *cache_values = cache_results\n if valid:\n logger.info(\n \"Found cached dataset and meta.json with the same filename \"\n \"of the dataset, using them instead\"\n )\n training_set_metadata, training_set, test_set, validation_set = cache_values\n config[\"data_hdf5_fp\"] = training_set\n data_format = backend.cache.data_format\n cached = True\n dataset = None\n else:\n logger.info(\n \"Found cached dataset and meta.json with the same filename \"\n \"of the dataset, but checksum don't match, \"\n \"if saving of processed input is not skipped \"\n \"they will be overridden\"\n )\n cache.delete()\n\n training_set_metadata[CHECKSUM] = cache.checksum\n data_format_processor = get_from_registry(data_format, data_format_preprocessor_registry)\n\n if cached or data_format == \"hdf5\":\n # Always interpret hdf5 files as preprocessed, even if missing from the cache\n processed = data_format_processor.prepare_processed_data(\n features,\n dataset=dataset,\n training_set=training_set,\n validation_set=validation_set,\n test_set=test_set,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n )\n training_set, test_set, validation_set, training_set_metadata = processed\n else:\n processed = data_format_processor.preprocess_for_training(\n config,\n features,\n dataset=dataset,\n training_set=training_set,\n validation_set=validation_set,\n test_set=test_set,\n training_set_metadata=training_set_metadata,\n skip_save_processed_input=skip_save_processed_input,\n preprocessing_params=preprocessing_params,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n )\n training_set, test_set, validation_set, training_set_metadata = processed\n replace_text_feature_level(features, [training_set, validation_set, test_set])\n processed = (training_set, test_set, validation_set, training_set_metadata)\n\n # cache the dataset\n if backend.cache.can_cache(skip_save_processed_input):\n logger.debug(\"cache processed data\")\n processed = cache.put(*processed)\n training_set, test_set, validation_set, training_set_metadata = processed\n\n logger.debug(\"create training dataset\")\n training_dataset = backend.dataset_manager.create(training_set, config, training_set_metadata)\n\n validation_dataset = None\n if validation_set is not None:\n logger.debug(\"create validation dataset\")\n validation_dataset = backend.dataset_manager.create(validation_set, config, training_set_metadata)\n\n test_dataset = None\n if test_set is not None:\n logger.debug(\"create test dataset\")\n test_dataset = backend.dataset_manager.create(test_set, config, training_set_metadata)\n\n return (training_dataset, validation_dataset, test_dataset, training_set_metadata)\n\n\ndef _preprocess_file_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n read_fn=read_csv,\n skip_save_processed_input=False,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n):\n \"\"\"Method to pre-process csv data.\n\n :param features: list of all features (input + output)\n :param dataset: path to the data\n :param training_set: training data\n :param validation_set: validation data\n :param test_set: test data\n :param training_set_metadata: train set metadata\n :param skip_save_processed_input: if False, the pre-processed data is saved\n as .hdf5 files in the same location as the csv files with the same names.\n :param preprocessing_params: preprocessing parameters\n :param random_seed: random seed\n :return: training, test, validation datasets, training metadata\n \"\"\"\n if dataset:\n # Use data and ignore _train, _validation and _test.\n # Also ignore data and train set metadata needs preprocessing\n logger.info(\"Using full raw dataset, no hdf5 and json file \" \"with the same name have been found\")\n logger.info(\"Building dataset (it may take a while)\")\n\n dataset_df = read_fn(dataset, backend.df_engine.df_lib)\n training_set_metadata[SRC] = dataset\n\n data, training_set_metadata = build_dataset(\n dataset_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n random_seed=random_seed,\n skip_save_processed_input=skip_save_processed_input,\n callbacks=callbacks,\n mode=\"training\",\n )\n\n # TODO(travis): implement saving split for Ray\n if backend.is_coordinator() and not skip_save_processed_input and SPLIT in data.columns:\n # save split values for use by visualization routines\n split_fp = get_split_path(dataset)\n save_array(split_fp, data[SPLIT])\n\n elif training_set:\n # use data_train (including _validation and _test if they are present)\n # and ignore data and train set metadata\n # needs preprocessing\n logger.info(\"Using training raw csv, no hdf5 and json \" \"file with the same name have been found\")\n logger.info(\"Building dataset (it may take a while)\")\n\n concatenated_df = concatenate_files(training_set, validation_set, test_set, read_fn, backend)\n training_set_metadata[SRC] = training_set\n\n data, training_set_metadata = build_dataset(\n concatenated_df,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n backend=backend,\n random_seed=random_seed,\n callbacks=callbacks,\n mode=\"training\",\n )\n\n else:\n raise ValueError(\"either data or data_train have to be not None\")\n\n logger.info(\"Building dataset: DONE\")\n\n data = backend.df_engine.persist(data)\n if SPLIT in data.columns:\n logger.debug(\"split on split column\")\n training_data, test_data, validation_data = split_dataset_ttv(data, SPLIT)\n else:\n logger.debug(\"split randomly by partition\")\n training_data, test_data, validation_data = data.random_split(preprocessing_params[\"split_probabilities\"])\n\n if preprocessing_params[\"oversample_minority\"] or preprocessing_params[\"undersample_majority\"]:\n training_data = balance_data(training_data, config[\"output_features\"], preprocessing_params, backend)\n\n return training_data, test_data, validation_data, training_set_metadata\n\n\ndef _preprocess_df_for_training(\n config,\n features,\n dataset=None,\n training_set=None,\n validation_set=None,\n test_set=None,\n training_set_metadata=None,\n preprocessing_params=default_preprocessing_parameters,\n backend=LOCAL_BACKEND,\n random_seed=default_random_seed,\n callbacks=None,\n):\n \"\"\"Method to pre-process dataframes.\n\n This doesn't have the option to save the processed data as hdf5 as we don't expect users to do this as the data can\n be processed in memory\n \"\"\"\n if dataset is not None:\n # needs preprocessing\n logger.info(\"Using full dataframe\")\n elif training_set is not None:\n # needs preprocessing\n logger.info(\"Using training dataframe\")\n dataset = concatenate_df(training_set, validation_set, test_set, backend)\n logger.info(\"Building dataset (it may take a while)\")\n\n dataset, training_set_metadata = build_dataset(\n dataset,\n features,\n preprocessing_params,\n metadata=training_set_metadata,\n random_seed=random_seed,\n backend=backend,\n callbacks=callbacks,\n mode=\"training\",\n )\n\n logger.info(\"Building dataset: DONE\")\n\n dataset = backend.df_engine.persist(dataset)\n if SPLIT in dataset.columns:\n logger.debug(\"split on split column\")\n training_set, test_set, validation_set = split_dataset_ttv(dataset, SPLIT)\n else:\n logger.debug(\"split randomly by partition\")\n training_set, test_set, validation_set = dataset.random_split(preprocessing_params[\"split_probabilities\"])\n\n if preprocessing_params[\"oversample_minority\"] or preprocessing_params[\"undersample_majority\"]:\n training_set = balance_data(training_set, config[\"output_features\"], preprocessing_params, backend)\n\n return training_set, test_set, validation_set, training_set_metadata\n\n\ndef preprocess_for_prediction(\n config,\n dataset,\n training_set_metadata=None,\n data_format=None,\n split=FULL,\n include_outputs=True,\n backend=LOCAL_BACKEND,\n callbacks=None,\n):\n \"\"\"Preprocesses the dataset to parse it into a format that is usable by the Ludwig core.\n\n :param model_path: The input data that is joined with the model\n hyperparameter file to create the config file\n :param data_csv: The CSV input data file\n :param data_hdf5: The hdf5 data file if there is no csv data file\n :param training_set_metadata: Train set metadata for the input features\n :param split: the split of dataset to return\n :returns: Dataset, Train set metadata\n \"\"\"\n # Sanity Check to make sure some data source is provided\n if dataset is None:\n raise ValueError(\"No training data is provided!\")\n\n if isinstance(dataset, Dataset):\n return dataset, training_set_metadata\n\n # determine data format if not provided or auto\n if not data_format or data_format == \"auto\":\n data_format = figure_data_format(dataset)\n\n # manage the in_memory parameter\n if data_format not in HDF5_FORMATS:\n num_overrides = override_in_memory_flag(config[\"input_features\"], True)\n if num_overrides > 0:\n logger.warning(\"Using in_memory = False is not supported \" \"with {} data format.\".format(data_format))\n\n preprocessing_params = merge_dict(default_preprocessing_parameters, config[PREPROCESSING])\n\n # if training_set_metadata is a string, assume it's a path to load the json\n if training_set_metadata and isinstance(training_set_metadata, str):\n training_set_metadata = load_metadata(training_set_metadata)\n\n # setup\n output_features = []\n if include_outputs:\n output_features += config[\"output_features\"]\n features = config[\"input_features\"] + output_features\n\n # Check the cache for an already preprocessed dataset. This only\n # applies to scenarios where the user wishes to predict on a split\n # of the full dataset, where we preprocess the whole dataset together\n # during training. If the user wishes to predict on the full dataset,\n # it is assumed they are predicting on unseen data. This is done\n # because the cached data is stored in its split form, and would be\n # expensive to recombine, requiring further caching.\n cached = False\n cache = backend.cache.get_dataset_cache(config, dataset)\n training_set = test_set = validation_set = None\n if data_format in CACHEABLE_FORMATS and split != FULL:\n cache_results = cache.get()\n if cache_results is not None:\n valid, *cache_values = cache_results\n if valid:\n logger.info(\n \"Found cached dataset and meta.json with the same filename \" \"of the input file, using them instead\"\n )\n training_set_metadata, training_set, test_set, validation_set = cache_values\n config[\"data_hdf5_fp\"] = training_set\n data_format = backend.cache.data_format\n cached = True\n\n data_format_processor = get_from_registry(data_format, data_format_preprocessor_registry)\n\n if cached:\n processed = data_format_processor.prepare_processed_data(\n features,\n dataset=dataset,\n training_set=training_set,\n validation_set=validation_set,\n test_set=test_set,\n training_set_metadata=training_set_metadata,\n preprocessing_params=preprocessing_params,\n backend=backend,\n )\n training_set, test_set, validation_set, training_set_metadata = processed\n else:\n processed = data_format_processor.preprocess_for_prediction(\n dataset, features, preprocessing_params, training_set_metadata, backend, callbacks\n )\n dataset, training_set_metadata, new_hdf5_fp = processed\n training_set_metadata = training_set_metadata.copy()\n\n if new_hdf5_fp:\n training_set_metadata[DATA_TRAIN_HDF5_FP] = new_hdf5_fp\n\n replace_text_feature_level(features, [dataset])\n\n if split != FULL:\n training_set, test_set, validation_set = split_dataset_ttv(dataset, SPLIT)\n\n if split == TRAINING:\n dataset = training_set\n elif split == VALIDATION:\n dataset = validation_set\n elif split == TEST:\n dataset = test_set\n\n config = {\n **config,\n \"output_features\": output_features,\n }\n\n dataset = backend.dataset_manager.create(\n dataset,\n config,\n training_set_metadata,\n )\n\n return dataset, training_set_metadata\n\n\ndef replace_text_feature_level(features, datasets):\n for feature in features:\n if feature[TYPE] == TEXT:\n for dataset in datasets:\n if dataset is not None:\n dataset[feature[PROC_COLUMN]] = dataset[\"{}_{}\".format(feature[PROC_COLUMN], feature[\"level\"])]\n for level in (\"word\", \"char\"):\n name_level = f\"{feature[PROC_COLUMN]}_{level}\"\n if name_level in dataset:\n del dataset[name_level]\n" ]

[ [ "pandas.DataFrame", "numpy.random.choice" ] ]

utiasSTARS/pyslam

[ "5c0de9eaed4ebc7687b6d43079481c9a9336145b" ]

[ "examples/stereo_ba.py" ]

[ "import numpy as np\n\nfrom liegroups import SE3\n\nfrom pyslam.sensors import StereoCamera\nfrom pyslam.residuals import ReprojectionResidual\nfrom pyslam.problem import Options, Problem\nfrom pyslam.utils import invsqrt\n\n# Reproducibility\nnp.random.seed(42)\n\n# Landmarks (world frame is first camera frame)\npts_w_GT = [\n np.array([0., -1., 10.]),\n np.array([1., 1., 5.]),\n np.array([-1., 1., 15.])\n]\n\n# Trajectory\nT_cam_w_GT = [\n SE3.identity(),\n SE3.exp(0.1 * np.ones(6)),\n SE3.exp(0.2 * np.ones(6)),\n SE3.exp(0.3 * np.ones(6))\n]\n\n# Camera\ncamera = StereoCamera(640, 480, 1000, 1000, 0.25, 1280, 960)\n\n# Observations\nobs_var = [1, 1, 2] # [u,v,d]\nobs_stiffness = invsqrt(np.diagflat(obs_var))\n\nobs = [[camera.project(T.dot(p))\n for p in pts_w_GT] for T in T_cam_w_GT]\n\n# Optimize\noptions = Options()\noptions.allow_nondecreasing_steps = True\noptions.max_nondecreasing_steps = 3\n\nproblem = Problem(options)\nfor i, this_pose_obs in enumerate(obs):\n for j, o in enumerate(this_pose_obs):\n residual = ReprojectionResidual(camera, o, obs_stiffness)\n problem.add_residual_block(\n residual, ['T_cam{}_w'.format(i), 'pt{}_w'.format(j)])\n\nparams_true = {}\nparams_init = {}\n\nfor i, pt in enumerate(pts_w_GT):\n pid = 'pt{}_w'.format(i)\n params_true.update({pid: pt})\n params_init.update({pid: camera.triangulate(\n obs[0][i] + 10. * np.random.rand(3))})\n\nfor i, pose in enumerate(T_cam_w_GT):\n pid = 'T_cam{}_w'.format(i)\n params_true.update({pid: pose})\n params_init.update({pid: SE3.identity()})\n\nproblem.initialize_params(params_init)\nproblem.set_parameters_constant('T_cam0_w')\n\n# import ipdb\n# ipdb.set_trace()\nparams_final = problem.solve()\nprint(problem.summary(format='full'))\n\n# Compute errors\nprint(\"Initial Error:\")\nfor key in params_true.keys():\n p_est = params_init[key]\n p_true = params_true[key]\n\n if isinstance(p_est, SE3):\n err = SE3.log(p_est.inv().dot(p_true))\n else:\n err = p_est - p_true\n\n print('{}: {}'.format(key, err))\n\nprint()\n\nprint(\"Final Error:\")\nfor key in params_true.keys():\n p_est = params_final[key]\n p_true = params_true[key]\n\n if isinstance(p_est, SE3):\n err = SE3.log(p_est.inv().dot(p_true))\n else:\n err = p_est - p_true\n\n print('{}: {}'.format(key, err))\n" ]

[ [ "numpy.random.seed", "numpy.diagflat", "numpy.ones", "numpy.random.rand", "numpy.array" ] ]

wangvei/pydefect

[ "e909796c429e16982cefe549d16881039bce89e7" ]

[ "pydefect/cli/main_functions.py" ]

[ "# -*- coding: utf-8 -*-\n\nimport os\nfrom copy import deepcopy\nfrom glob import glob\nfrom pathlib import Path\nfrom typing import Optional\n\nimport numpy as np\n\nfrom pydefect.analysis.defect import Defect\nfrom pydefect.analysis.defect_carrier_concentration import DefectConcentration\nfrom pydefect.analysis.defect_eigenvalues import DefectEigenvalue\nfrom pydefect.analysis.defect_energies import DefectEnergies\nfrom pydefect.analysis.defect_structure import (\n DefectStructure, defect_structure_matcher)\nfrom pydefect.core.complex_defects import ComplexDefects\nfrom pydefect.core.defect_entry import DefectEntry\nfrom pydefect.core.error_classes import StructureError\nfrom pydefect.core.interstitial_site import interstitials_from_charge_density\nfrom pydefect.input_maker.add_interstitials import add_interstitials\nfrom pydefect.core.supercell_calc_results import SupercellCalcResults\nfrom pydefect.core.unitcell_calc_results import UnitcellCalcResults\nfrom pydefect.corrections.corrections import ManualCorrection\nfrom pydefect.corrections.efnv_corrections import ExtendedFnvCorrection, Ewald\nfrom pydefect.corrections.vertical_transition_energy_correction import (\n VerticalTransitionEnergyCorrection)\nfrom pydefect.input_maker.defect_initial_setting import (\n dopant_info, DefectInitialSetting)\nfrom pydefect.input_maker.supercell_maker import Supercell, Supercells\nfrom pydefect.util.logger import get_logger\nfrom pydefect.cli.main_tools import (\n generate_objects_from_json_files)\n\nfrom pymatgen import Structure, Spin\n\nfrom vise.input_set.input_set import ViseInputSet\nfrom vise.cli.main_function import vasp_settings_from_args\nfrom vise.chempotdiag.chem_pot_diag import ChemPotDiag\n\n\nlogger = get_logger(__name__)\n\n\ndef unitcell_calc_results(args):\n if args.print:\n print(UnitcellCalcResults.load_json(filename=args.json_file))\n return\n\n try:\n dft_results = UnitcellCalcResults.load_json(filename=args.json_file)\n except IOError:\n dft_results = UnitcellCalcResults()\n\n if args.band_edge_dir:\n try:\n dft_results.set_band_edge_from_vasp(args.band_edge_dir,\n vasprun_name=args.vasprun,\n outcar_name=args.outcar)\n except IOError:\n raise FileNotFoundError(f\"{args.band_edge_dir} is not appropriate.\")\n\n if args.static_diele:\n dft_results.static_dielectric_tensor = args.static_diele\n elif args.static_diele_dir:\n try:\n dft_results.set_static_dielectric_tensor_from_vasp(\n args.static_diele_dir, outcar_name=args.outcar)\n except IOError:\n raise FileNotFoundError(\n args.static_diele_dir, \"is not appropriate.\")\n except AttributeError as e:\n logger.error(str(e))\n\n if args.ionic_diele:\n dft_results.ionic_dielectric_tensor = args.ionic_diele\n elif args.ionic_diele_dir:\n try:\n dft_results.set_ionic_dielectric_tensor_from_vasp(\n args.ionic_diele_dir, outcar_name=args.outcar)\n except IOError:\n raise FileNotFoundError(args.ionic_diele_dir, \"not appropriate.\")\n\n if args.total_dos_dir:\n try:\n dft_results.set_total_dos_and_volume_from_vasp(\n args.total_dos_dir, vasprun_name=args.vasprun)\n except IOError:\n raise FileNotFoundError(args.total_dos_dir, \"not appropriate.\")\n\n dft_results.to_json_file(args.json_file)\n print(UnitcellCalcResults.load_json(filename=args.json_file))\n\n\ndef initial_setting(args):\n if args.print_dopant:\n print(dopant_info(args.print_dopant))\n return\n\n structure = Structure.from_file(args.poscar)\n\n kwargs = {\"dopants\": args.dopants,\n \"is_antisite\": args.antisite,\n \"en_diff\": args.en_diff,\n \"included\": args.included,\n \"excluded\": args.excluded,\n \"displacement_distance\": args.displacement_distance,\n \"symprec\": args.symprec,\n \"angle_tolerance\": args.angle_tolerance,\n \"interstitial_sites\": args.interstitials,\n \"complex_defect_names\": args.complex_defect_names}\n\n if args.matrix:\n supercell = Supercell(structure=structure,\n trans_mat=args.matrix,\n check_unitcell=True,\n symprec=args.symprec,\n angle_tolerance=args.angle_tolerance)\n supercell.to(poscar=\"DPOSCAR\", uposcar=\"UPOSCAR\")\n\n defect_setting = \\\n DefectInitialSetting.from_basic_settings(\n structure=supercell.structure,\n transformation_matrix=supercell.trans_mat.tolist(),\n cell_multiplicity=supercell.multiplicity, **kwargs)\n defect_setting.to()\n return\n\n supercells = Supercells(structure=structure,\n conventional_base=args.conventional_base,\n max_num_atoms=args.max_num_atoms,\n min_num_atoms=args.min_num_atoms,\n criterion=args.isotropy_criterion,\n rhombohedral_angle=args.rhombohedral_angle,\n symprec=args.symprec,\n angle_tolerance=args.angle_tolerance)\n\n if not supercells.supercells:\n logger.critical(\"Any supercell does not satisfy the criterion.\")\n return False\n\n unitcell = supercells.unitcell\n if unitcell != structure:\n logger.warning(\n \"Unitcell is different from input structure. See UPOSCAR.\")\n else:\n logger.info(\"Input structure is the primitive cell.\")\n\n supercells.to_uposcar(uposcar=\"UPOSCAR\")\n\n if not args.supercell_set:\n if args.most_isotropic:\n supercell = supercells.most_isotropic_supercell\n else:\n supercell = supercells.smallest_supercell\n\n supercell.to(\"DPOSCAR\")\n defect_setting = DefectInitialSetting.from_basic_settings(\n structure=supercell.structure,\n transformation_matrix=supercell.trans_mat.tolist(),\n cell_multiplicity=supercell.multiplicity,\n **kwargs)\n defect_setting.to()\n\n else:\n logger.info(f\"Number of supercells: {len(supercells.supercells)}\")\n\n for supercell in supercells.supercells:\n # Suffix \"c\" means conventional cell, while \"p\" primitive cell.\n prefix = \"c\" if supercells.conventional_base else \"p\"\n isotropy, _ = supercell.isotropy\n if np.count_nonzero(supercell.trans_mat) == 3:\n mat = \"x\".join(\n [str(supercell.trans_mat[i][i]) for i in range(3)])\n name = f\"{prefix + mat}_{supercell.num_atoms}_{isotropy}\"\n else:\n name = f\"{prefix}_{supercell.num_atoms}_{isotropy}\"\n\n os.mkdir(name)\n p = Path(name)\n supercell.to(poscar=p / \"DPOSCAR\")\n defect_setting = \\\n DefectInitialSetting.from_basic_settings(\n structure=supercell.structure,\n transformation_matrix=supercell.trans_mat.tolist(),\n cell_multiplicity=supercell.multiplicity, **kwargs)\n defect_setting.to(p / \"defect.in\")\n\n\ndef interstitial(args):\n\n if args.chgcar:\n interstitials_from_charge_density(\n chgcar_filename=args.chgcar,\n interstitial_symprec=args.interstitial_symprec,\n angle_tolerance=args.angle_tolerance)\n else:\n add_interstitials(coords_in_unitcell=args.interstitial_coords,\n uposcar=args.uposcar,\n interstitials_yaml=args.yaml,\n vicinage_radius=args.radius,\n defect_symprec=args.defect_symprec,\n angle_tolerance=args.angle_tolerance)\n\n\ndef complex_defects(args):\n try:\n complex_defects_obj = ComplexDefects.from_files(args.dposcar, args.yaml)\n except FileNotFoundError:\n structure = Structure.from_file(args.dposcar)\n complex_defects_obj = ComplexDefects(structure=structure)\n\n if (args.inserted_elements and not args.inserted_coords) or \\\n (not args.inserted_elements and args.inserted_coords):\n raise ValueError(f\"For interstitial sites, both elements and \"\n f\"fractional coordinates need to be entered.\")\n elif args.inserted_elements and args.inserted_coords and \\\n len(args.inserted_elements) * 3 != len(args.inserted_coords):\n raise ValueError(f\"The numbers of inserted elements \"\n f\"{args.inserted_elements} and coords \"\n f\"{args.inserted_coords} are inconsistent.\")\n\n inserted_elements = args.inserted_elements or []\n inserted_coords = args.inserted_coords or []\n inserted_atoms = []\n for i, e in enumerate(inserted_elements):\n coords = [inserted_coords[3 * i + j] for j in range(3)]\n inserted_atoms.append({\"element\": e, \"coords\": coords})\n\n # defect_initial_setting = \\\n # DefectInitialSetting.from_defect_in(poscar=args.dposcar,\n # defect_in_file=args.defect_in)\n\n complex_defects_obj.add_defect(\n removed_atom_indices=args.removed_atom_indices,\n inserted_atoms=inserted_atoms,\n name=args.name,\n extreme_charge_state=args.extreme_charge_state,\n annotation=args.annotation,\n symprec=args.defect_symprec,\n angle_tolerance=args.angle_tolerance)\n\n complex_defects_obj.site_set_to_yaml_file(yaml_filename=args.yaml)\n\n\ndef make_dir(dirname: str,\n vis: ViseInputSet,\n force_overwrite: bool,\n defect_entry_obj: Optional[DefectEntry],\n add_neighbor: bool = True) -> None:\n \"\"\"Helper function\"\"\"\n dirname = Path(dirname)\n if force_overwrite and dirname.exists():\n logger.critical(f\"{dirname} is being removed.\")\n dirname.rmdir()\n\n if dirname.exists():\n logger.warning(f\"{dirname} already exists, so nothing is done.\")\n else:\n logger.info(f\"{dirname} is being constructed.\")\n dirname.mkdir()\n vis.write_input(dirname)\n vis.to_json_file(Path(dirname) / \"vise.json\")\n\n if defect_entry_obj is None:\n return\n\n defect_entry_obj.to_json_file(dirname / \"defect_entry.json\")\n\n if add_neighbor and defect_entry_obj.neighboring_sites:\n poscar_name = dirname / \"POSCAR\"\n with open(poscar_name, \"r\") as f:\n lines = f.readlines()\n for index, line in enumerate(lines.copy()):\n if index - 8 in defect_entry_obj.neighboring_sites:\n lines[index] = line.strip() + \" Neighbor\\n\"\n\n with open(poscar_name, \"w\") as f:\n for line in lines:\n f.write(line)\n\n\ndef defect_vasp_set(args):\n\n user_incar_settings, vis_kwargs = vasp_settings_from_args(args)\n user_incar_settings[\"LWAVE\"] = args.wavecar\n vis_kwargs.update(\n {\"xc\": args.xc,\n \"task\": \"defect\",\n \"kpt_density\": args.kpt_density,\n \"kpt_mode\": \"manual_set\",\n \"only_even\": False,\n \"sort_structure\": False,\n \"standardize_structure\": False,\n })\n\n defect_initial_setting = DefectInitialSetting.from_defect_in(\n poscar=args.dposcar, defect_in_file=args.defect_in)\n\n defect_initial_setting.make_defect_set(\n keywords=args.keywords, specified_defects=args.specified_defects)\n\n if not args.specified_defects:\n perfect_incar_setting = deepcopy(user_incar_settings)\n vise_set = ViseInputSet.make_input(\n structure=defect_initial_setting.structure,\n user_incar_settings=perfect_incar_setting,\n **vis_kwargs)\n\n make_dir(\"perfect\", vise_set, args.force_overwrite, None)\n\n # set ISPIN = 2 if \"ISPIN\" is not explicitly set.\n if args.spin_polarize and not hasattr(user_incar_settings, \"ISPIN\"):\n user_incar_settings[\"ISPIN\"] = 2\n\n for de in defect_initial_setting.defect_entries:\n defect_name = \"_\".join([de.name, str(de.charge)])\n vise_set = ViseInputSet.make_input(\n structure=de.perturbed_initial_structure,\n charge=de.charge,\n user_incar_settings=user_incar_settings,\n **vis_kwargs)\n make_dir(defect_name, vise_set, args.force_overwrite, de)\n\n\ndef vertical_transition_input_maker(args):\n if abs(args.additional_charge) != 1:\n raise ValueError(f\"{args.additional_charge} is invalid.\")\n\n initial_dirname = Path(args.initial_dir_name)\n de_filename = initial_dirname / \"defect_entry.json\"\n de = DefectEntry.load_json(de_filename)\n src_filename = initial_dirname / \"dft_results.json\"\n src = SupercellCalcResults.load_json(src_filename)\n\n new_charge = de.charge + args.additional_charge\n vis = ViseInputSet.from_prev_calc(\n initial_dirname,\n user_incar_settings={\"NSW\": 0},\n parse_calc_results=False,\n contcar_filename=args.contcar,\n charge=new_charge)\n\n de.charge += args.additional_charge\n de.initial_structure = src.final_structure\n de.perturbed_initial_structure = src.final_structure\n de.initial_site_symmetry = src.site_symmetry\n # FIX MAGNETIZATION?\n new_dirname = initial_dirname / f\"add_charge_{args.additional_charge}\"\n make_dir(str(new_dirname), vis, force_overwrite=False, defect_entry_obj=de,\n add_neighbor=False)\n new_de_filename = new_dirname / \"defect_entry.json\"\n de.to_json_file(new_de_filename)\n\n\ndef defect_entry(args):\n if args.print:\n print(DefectEntry.load_json(args.json))\n elif args.make_defect_entry:\n defect_structure = Structure.from_file(args.defect_poscar)\n perfect_structure = Structure.from_file(args.perfect_poscar)\n\n defect_entry_from_yaml = DefectEntry.from_defect_structure(\n defect_structure=defect_structure,\n perfect_structure=perfect_structure,\n displacement_distance=args.displacement_distance,\n defect_name=args.defect_name)\n\n defect_entry_from_yaml.to_json_file(args.json)\n else:\n logger.critical(\"Set make_defect_entry or print option.\")\n\n\ndef supercell_calc_results(args):\n\n if args.print:\n print(SupercellCalcResults.load_json(args.json))\n return\n\n if args.defect_center:\n if len(args.defect_center) != 1 and len(args.defect_center) != 3:\n raise ValueError(\"Length of the defect center is neither 1 or 3\")\n results = SupercellCalcResults.load_json(args.json)\n results.defect_center = args.defect_center\n results.to_json_file(filename=args.json)\n return\n\n if args.dir_all:\n dirs = glob('*[0-9]/')\n dirs.insert(0, \"perfect/\")\n else:\n dirs = args.dirs\n\n for d in dirs:\n if os.path.isdir(d):\n logger.info(f\"Parsing data in {d} ...\")\n\n if d in [\"perfect\", \"perfect/\"]:\n try:\n dft_results = SupercellCalcResults.from_vasp_files(\n directory_path=d,\n vasprun=args.vasprun,\n contcar=args.contcar,\n procar=args.procar,\n outcar=args.outcar)\n except IOError:\n raise IOError(\"Parsing data in perfect failed.\")\n else:\n try:\n de = DefectEntry.load_json(Path(d) / args.defect_entry_name)\n dft_results = SupercellCalcResults.from_vasp_files(\n directory_path=d,\n vasprun=args.vasprun,\n contcar=args.contcar,\n outcar=args.outcar,\n procar=args.procar,\n cutoff=args.cutoff,\n defect_entry=de,\n defect_symprec=args.defect_symprec,\n angle_tolerance=args.angle_tolerance)\n except IOError as e:\n logger.warning(f\"Parsing data in {d} failed.\")\n logger.warning(e)\n continue\n\n dft_results.to_json_file(filename=Path(d) / \"dft_results.json\")\n else:\n logger.warning(f\"{d} does not exist, so nothing is done.\")\n\n\ndef efnv_correction(args):\n if args.print:\n print(ExtendedFnvCorrection.load_json(args.json_file))\n return\n\n dirs = glob('*[0-9]/') if args.dir_all else args.dirs\n\n if args.plot_potential:\n for directory in dirs:\n d = Path(directory)\n c = ExtendedFnvCorrection.load_json(d / \"correction.json\")\n c.plot_potential(d / \"potential.pdf\", args.y_range)\n return\n\n if args.nocorr:\n for directory in dirs:\n c = ManualCorrection(manual_correction_energy=args.manual)\n c.to_json_file(Path(directory) / \"correction.json\")\n return\n\n try:\n ucr = UnitcellCalcResults.load_json(args.unitcell_json)\n dielectric_tensor = ucr.total_dielectric_tensor\n except IOError:\n raise FileNotFoundError(\"JSON for the unitcell info is not found.\")\n\n try:\n perfect_dft_data = SupercellCalcResults.load_json(args.perfect_json)\n except IOError:\n raise FileNotFoundError(\"JSON for the perfect supercell is not found.\")\n\n # Ewald parameter related\n if not Path(args.ewald_json).is_file():\n logger.info(\"optimizing ewald...\")\n ewald = Ewald.from_optimization(\n structure=perfect_dft_data.final_structure,\n dielectric_tensor=dielectric_tensor,\n initial_ewald_param=args.ewald_initial_param,\n convergence=args.ewald_convergence,\n prod_cutoff_fwhm=args.ewald_accuracy)\n ewald.to_json_file(args.ewald_json)\n\n for directory in dirs:\n d = Path(directory)\n json_to_make = d / \"correction.json\"\n\n if json_to_make.exists() and not args.force_overwrite:\n logger.warning(f\"{json_to_make} already exists, so nothing done.\")\n continue\n\n logger.info(f\"correcting {directory} ...\")\n entry = DefectEntry.load_json(d / \"defect_entry.json\")\n try:\n defect_dft_data = \\\n SupercellCalcResults.load_json(d / \"dft_results.json\")\n except IOError:\n logger.warning(f\"dft_results.json in {directory} does not exist.\")\n continue\n\n c = ExtendedFnvCorrection. \\\n compute_correction(defect_entry=entry,\n defect_dft=defect_dft_data,\n perfect_dft=perfect_dft_data,\n dielectric_tensor=dielectric_tensor,\n defect_center=args.defect_center,\n ewald=args.ewald_json)\n\n c.plot_potential(d / \"potential.pdf\", args.y_range)\n c.to_json_file(d / \"correction.json\")\n\n\ndef vertical_transition_energy(args):\n\n initial_dir = Path(args.initial_dir)\n initial_calc_results = \\\n SupercellCalcResults.load_json(initial_dir / \"dft_results.json\")\n final_dir = Path(args.dir)\n final_calc_results = \\\n SupercellCalcResults.load_json(final_dir / \"dft_results.json\")\n unitcell = UnitcellCalcResults.load_json(args.unitcell_json)\n\n if args.print:\n vtec = VerticalTransitionEnergyCorrection.load_json(args.json)\n vtec.plot_potential()\n print(vtec)\n if vtec.additional_charge == 1:\n cbm = unitcell.band_edge[1]\n print(f\"CBM position (eV): {cbm}\")\n band_edge_related_energy = cbm\n\n else:\n vbm = unitcell.band_edge[0]\n print(f\"VBM position (eV): {vbm}\")\n band_edge_related_energy = -vbm\n\n vte_wo_corr = (final_calc_results.total_energy\n - initial_calc_results.total_energy\n + band_edge_related_energy)\n vte = vte_wo_corr + vtec.correction_energy\n print(f\"Vertical transition energy w/o correction (eV): {vte_wo_corr}\")\n print(f\"Vertical transition energy w/ correction (eV): {vte}\")\n return\n\n dielectric_tensor = unitcell.total_dielectric_tensor\n static_dielectric_tensor = unitcell.static_dielectric_tensor\n\n initial_efnv = \\\n ExtendedFnvCorrection.load_json(initial_dir / \"correction.json\")\n initial_calc_results = \\\n SupercellCalcResults.load_json(initial_dir / \"dft_results.json\")\n\n final_defect_entry = DefectEntry.load_json(final_dir / \"defect_entry.json\")\n\n c = VerticalTransitionEnergyCorrection.from_files(dielectric_tensor,\n static_dielectric_tensor,\n initial_efnv,\n initial_calc_results,\n final_defect_entry,\n final_calc_results)\n c.to_json_file(args.json)\n print(c)\n\n\ndef defects(args):\n\n if args.band_edge:\n if args.band_edge[0] == \"up\":\n spin = Spin.up\n elif args.band_edge[0] == \"down\":\n spin = Spin.down\n else:\n raise ValueError(\"band edge is inadequate (e.g. -be up no_in_gap).\")\n state = args.band_edge[1]\n defect = Defect.load_json(args.json)\n defect.set_band_edge_state(spin=spin, state=state)\n defect.to_json_file(args.json)\n return True\n\n try:\n perfect = SupercellCalcResults.load_json(args.perfect)\n except FileNotFoundError:\n print(f\"{args.perfect} not found.\")\n raise\n\n defects_dirs = args.defect_dirs or glob('*[0-9]/')\n for d in defects_dirs:\n filename = os.path.join(d, args.json)\n if args.diagnose:\n print(d.rjust(12), end=\" \")\n try:\n print(Defect.load_json(filename).diagnose)\n except FileNotFoundError:\n logger.warning(\"No supercell results file.\")\n except Exception as e:\n logger.warning(f\"An error {e} is caught.\")\n continue\n\n logger.info(f\"parsing directory {d}...\")\n files = [args.defect_entry, args.dft_results, args.correction]\n classes = [DefectEntry, SupercellCalcResults, ExtendedFnvCorrection]\n input_objects = generate_objects_from_json_files(d, files, classes,\n raise_error=False)\n if input_objects:\n try:\n defect = Defect.from_objects(defect_entry=input_objects[0],\n dft_results=input_objects[1],\n perfect_dft_results=perfect,\n correction=input_objects[2])\n defect.to_json_file(filename)\n except StructureError:\n logger.warning(f\"defect.json is not generated in {d}.\")\n\n else:\n logger.warning(f\"Generating {filename} failed.\")\n continue\n\n\ndef plot_energy(args):\n\n if args.reload_defects:\n os.remove(args.energies)\n\n try:\n defect_energies = DefectEnergies.load_json(args.energies)\n except FileNotFoundError:\n unitcell = UnitcellCalcResults.load_json(args.unitcell)\n perfect = SupercellCalcResults.load_json(args.perfect)\n\n defects_dirs = args.defect_dirs or glob('*[0-9]/')\n\n defect_list = []\n for d in defects_dirs:\n filename = Path(d) / 'defect.json'\n logger.info(f\"parsing directory {filename}...\")\n try:\n defect_list.append(Defect.load_json(filename))\n except FileNotFoundError:\n logger.warning(f\"Parsing {filename} failed.\")\n continue\n\n chem_pot = ChemPotDiag.load_json(args.chem_pot_json)\n\n # First construct DefectEnergies class object.\n defect_energies = \\\n DefectEnergies.from_objects(unitcell=unitcell,\n perfect=perfect,\n defects=defect_list,\n chem_pot=chem_pot,\n chem_pot_label=args.chem_pot_label,\n filtering_words=args.filtering,\n system=args.name)\n\n if args.print:\n print(defect_energies)\n return\n\n defect_energies.to_json_file(filename=args.energies)\n\n # if args.concentration:\n # defect_concentration = \\\n # DefectConcentration.from_defect_energies(\n # energies=energies,\n # temperature=args.temperature[0],\n # unitcell=unitcell,\n # num_sites_filename=args.num_site_file)\n\n # # if len(args.temperature) == 2:\n # defect_concentration = \\\n # DefectConcentration.from_defect_energies(\n # energies=energies,\n # temperature=args.temperature[1],\n # unitcell=unitcell,\n # num_sites_filename=args.num_site_file,\n # previous_concentration=defect_concentration)\n # else:\n# defect_concentration = None\n\n # plt = defect_energies.plot_energy(filtering_words=args.filtering,\n # x_range=args.x_range,\n # y_range=args.y_range,\n # show_transition_levels=args.show_tl,\n # show_all_energies=args.show_all)\n plt = defect_energies.plot_energy(\n x_range=args.x_range,\n y_range=args.y_range,\n show_transition_levels=args.show_transition_level,\n show_all_energies=args.show_all)\n\n if args.save_file:\n plt.savefig(args.save_file, format=\"pdf\", transparent=True)\n else:\n plt.show()\n\n\ndef parse_eigenvalues(args):\n unitcell = UnitcellCalcResults.load_json(args.unitcell)\n\n # TODO: Modify here to run w/o correction\n logger.info(f\"parsing directory {args.defect_dir}...\")\n defect = Defect.load_json(Path(args.defect_dir) / \"defect.json\")\n\n defect_eigenvalues = DefectEigenvalue.from_files(unitcell=unitcell,\n defect=defect)\n\n defect_eigenvalues.plot(y_range=args.y_range,\n title=args.title,\n filename=args.save_file)\n\n\ndef vasp_parchg_set(args):\n user_incar_settings = {\"LPARD\": True,\n \"LSEPB\": True,\n \"KPAR\": 1,\n \"IBAND\": args.band_indices}\n\n if args.kpoint_indices:\n user_incar_settings[\"KPUSE\"] = args.kpoint_indices\n\n vasp_set = ViseInputSet.from_prev_calc(\n dirname=args.read_dir,\n parse_calc_results=False,\n parse_incar=True,\n sort_structure=False,\n standardize_structure=False,\n files_to_transfer={\"WAVECAR\": \"L\"},\n user_incar_settings=user_incar_settings,\n contcar_filename=args.contcar)\n\n vasp_set.write_input(args.write_dir)\n\n\ndef local_structure(args):\n defects_dirs = args.defect_dirs or glob('*[0-9]/')\n\n d_list = []\n for d in defects_dirs:\n filename = Path(d) / \"defect.json\"\n logger.info(f\"parsing directory {d}...\")\n try:\n defect = Defect.load_json(filename)\n d_list.append(defect)\n except FileNotFoundError:\n logger.warning(f\"Parsing {filename} failed.\")\n print(\"\")\n print(\"\")\n continue\n\n defect_structure = DefectStructure.from_defect(defect)\n print(\"-\" * 82)\n print(defect_structure.show_displacements(all_atoms=args.show_all))\n print(\"\")\n print(\"\")\n\n if args.compare_structure:\n print(\"-\" * 82)\n print(defect_structure_matcher(d_list, args.site_tolerance))\n print(\"\")\n\n\ndef concentration(args):\n defect_energies = DefectEnergies.load_json(args.energies).defect_energies\n unitcell = UnitcellCalcResults.load_json(args.unitcell)\n\n defect_concentration = DefectConcentration.from_calc_results(\n defect_energies=defect_energies,\n unitcell=unitcell,\n round_magnetization=args.frac_mag_to_one)\n\n defect_concentration.calc_equilibrium_concentration(\n temperature=args.temperature, verbose=args.verbose)\n\n defect_concentration.calc_quenched_equilibrium_concentration(\n temperature=args.quenched_temperature,\n verbose=args.verbose)\n\n print(defect_concentration)\n defect_concentration.calc_concentrations(args.temperature)\n plt = defect_concentration.plot_carrier_concentrations()\n plt.show()\n\n" ]

[ [ "numpy.count_nonzero" ] ]

priikone/colour

[ "e9c8834178c14dd6d8d0d874191aada18929c211" ]

[ "colour/algebra/common.py" ]

[ "# -*- coding: utf-8 -*-\n\"\"\"\nCommon Utilities\n================\n\nDefines common algebra utilities objects that don't fall in any specific\ncategory.\n\"\"\"\n\nimport functools\nimport numpy as np\n\nfrom colour.utilities import as_float_array, as_float, tsplit\n\n__author__ = 'Colour Developers'\n__copyright__ = 'Copyright (C) 2013-2021 - Colour Developers'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Colour Developers'\n__email__ = '[email protected]'\n__status__ = 'Production'\n\n__all__ = [\n 'is_spow_enabled', 'set_spow_enable', 'spow_enable', 'spow',\n 'smoothstep_function', 'normalise_maximum', 'vector_dot', 'matrix_dot',\n 'linear_conversion', 'linstep_function', 'is_identity'\n]\n\n_SPOW_ENABLED = True\n\"\"\"\nGlobal variable storing the current *Colour* safe / symmetrical power function\nenabled state.\n\n_SPOW_ENABLED : bool\n\"\"\"\n\n\ndef is_spow_enabled():\n \"\"\"\n Returns whether *Colour* safe / symmetrical power function is enabled.\n\n Returns\n -------\n bool\n Whether *Colour* safe / symmetrical power function is enabled.\n\n Examples\n --------\n >>> with spow_enable(False):\n ... is_spow_enabled()\n False\n >>> with spow_enable(True):\n ... is_spow_enabled()\n True\n \"\"\"\n\n return _SPOW_ENABLED\n\n\ndef set_spow_enable(enable):\n \"\"\"\n Sets *Colour* safe / symmetrical power function enabled state.\n\n Parameters\n ----------\n enable : bool\n Whether to enable *Colour* safe / symmetrical power function.\n\n Examples\n --------\n >>> with spow_enable(is_spow_enabled()):\n ... print(is_spow_enabled())\n ... set_spow_enable(False)\n ... print(is_spow_enabled())\n True\n False\n \"\"\"\n\n global _SPOW_ENABLED\n\n _SPOW_ENABLED = enable\n\n\nclass spow_enable:\n \"\"\"\n A context manager and decorator temporarily setting *Colour* safe /\n symmetrical power function enabled state.\n\n Parameters\n ----------\n enable : bool\n Whether to enable or disable *Colour* safe / symmetrical power\n function.\n \"\"\"\n\n def __init__(self, enable):\n self._enable = enable\n self._previous_state = is_spow_enabled()\n\n def __enter__(self):\n \"\"\"\n Called upon entering the context manager and decorator.\n \"\"\"\n\n set_spow_enable(self._enable)\n\n return self\n\n def __exit__(self, *args):\n \"\"\"\n Called upon exiting the context manager and decorator.\n \"\"\"\n\n set_spow_enable(self._previous_state)\n\n def __call__(self, function):\n \"\"\"\n Calls the wrapped definition.\n \"\"\"\n\n @functools.wraps(function)\n def wrapper(*args, **kwargs):\n with self:\n return function(*args, **kwargs)\n\n return wrapper\n\n\ndef spow(a, p):\n \"\"\"\n Raises given array :math:`a` to the power :math:`p` as follows:\n :math:`sign(a) * |a|^p`.\n\n This definition avoids NaNs generation when array :math:`a` is negative and\n the power :math:`p` is fractional. This behaviour can be enabled or\n disabled with the :func:`colour.algebra.set_spow_enable` definition or with\n the :func:`spow_enable` context manager.\n\n Parameters\n ----------------\n a : numeric or array_like\n Array :math:`a`.\n p : numeric or array_like\n Power :math:`p`.\n\n Returns\n -------\n numeric or ndarray\n Array :math:`a` safely raised to the power :math:`p`.\n\n Examples\n --------\n >>> np.power(-2, 0.15)\n nan\n >>> spow(-2, 0.15) # doctest: +ELLIPSIS\n -1.1095694...\n >>> spow(0, 0)\n 0.0\n \"\"\"\n\n if not _SPOW_ENABLED:\n return np.power(a, p)\n\n a = np.atleast_1d(a)\n p = as_float_array(p)\n\n a_p = np.sign(a) * np.abs(a) ** p\n\n a_p[np.isnan(a_p)] = 0\n\n return as_float(a_p)\n\n\ndef normalise_maximum(a, axis=None, factor=1, clip=True):\n \"\"\"\n Normalises given *array_like* :math:`a` variable values by :math:`a`\n variable maximum value and optionally clip them between.\n\n Parameters\n ----------\n a : array_like\n :math:`a` variable to normalise.\n axis : numeric, optional\n Normalization axis.\n factor : numeric, optional\n Normalization factor.\n clip : bool, optional\n Clip values to domain [0, 'factor'].\n\n Returns\n -------\n ndarray\n Maximum normalised :math:`a` variable.\n\n Examples\n --------\n >>> a = np.array([0.48222001, 0.31654775, 0.22070353])\n >>> normalise_maximum(a) # doctest: +ELLIPSIS\n array([ 1. , 0.6564384..., 0.4576822...])\n \"\"\"\n\n a = as_float_array(a)\n\n maximum = np.max(a, axis=axis)\n a = a * (1 / maximum[..., np.newaxis]) * factor\n\n return np.clip(a, 0, factor) if clip else a\n\n\ndef vector_dot(m, v):\n \"\"\"\n Convenient wrapper around :func:`np.einsum` with the following subscripts:\n *'...ij,...j->...i'*.\n\n It performs the dot product of two arrays where *m* parameter is expected\n to be an array of 3x3 matrices and parameter *v* an array of vectors.\n\n Parameters\n ----------\n m : array_like\n Array of 3x3 matrices.\n v : array_like\n Array of vectors.\n\n Returns\n -------\n ndarray\n\n Examples\n --------\n >>> m = np.array(\n ... [[0.7328, 0.4296, -0.1624],\n ... [-0.7036, 1.6975, 0.0061],\n ... [0.0030, 0.0136, 0.9834]]\n ... )\n >>> m = np.reshape(np.tile(m, (6, 1)), (6, 3, 3))\n >>> v = np.array([0.20654008, 0.12197225, 0.05136952])\n >>> v = np.tile(v, (6, 1))\n >>> vector_dot(m, v) # doctest: +ELLIPSIS\n array([[ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...],\n [ 0.1954094..., 0.0620396..., 0.0527952...]])\n \"\"\"\n\n m = as_float_array(m)\n v = as_float_array(v)\n\n return np.einsum('...ij,...j->...i', m, v)\n\n\ndef matrix_dot(a, b):\n \"\"\"\n Convenient wrapper around :func:`np.einsum` with the following subscripts:\n *'...ij,...jk->...ik'*.\n\n It performs the dot product of two arrays where *a* parameter is expected\n to be an array of 3x3 matrices and parameter *b* another array of of 3x3\n matrices.\n\n Parameters\n ----------\n a : array_like\n Array of 3x3 matrices.\n b : array_like\n Array of 3x3 matrices.\n dtype : object\n Type to use for conversion, default to the type defined by the\n :attr:`colour.constant.DEFAULT_FLOAT_DTYPE` attribute.\n\n Returns\n -------\n ndarray\n\n Examples\n --------\n >>> a = np.array(\n ... [[0.7328, 0.4296, -0.1624],\n ... [-0.7036, 1.6975, 0.0061],\n ... [0.0030, 0.0136, 0.9834]]\n ... )\n >>> a = np.reshape(np.tile(a, (6, 1)), (6, 3, 3))\n >>> b = a\n >>> matrix_dot(a, b) # doctest: +ELLIPSIS\n array([[[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]],\n <BLANKLINE>\n [[ 0.2342420..., 1.0418482..., -0.2760903...],\n [-1.7099407..., 2.5793226..., 0.1306181...],\n [-0.0044203..., 0.0377490..., 0.9666713...]]])\n \"\"\"\n\n a = as_float_array(a)\n b = as_float_array(b)\n\n return np.einsum('...ij,...jk->...ik', a, b)\n\n\ndef linear_conversion(a, old_range, new_range):\n \"\"\"\n Performs a simple linear conversion of given array between the old and new\n ranges.\n\n Parameters\n ----------\n a : array_like\n Array to perform the linear conversion onto.\n old_range : array_like\n Old range.\n new_range : array_like\n New range.\n\n Returns\n -------\n ndarray\n Linear conversion result.\n\n Examples\n --------\n >>> a = np.linspace(0, 1, 10)\n >>> linear_conversion(a, np.array([0, 1]), np.array([1, 10]))\n array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])\n \"\"\"\n\n a = as_float_array(a)\n\n in_min, in_max = tsplit(old_range)\n out_min, out_max = tsplit(new_range)\n\n return ((a - in_min) / (in_max - in_min)) * (out_max - out_min) + out_min\n\n\ndef linstep_function(x, a=0, b=1, clip=False):\n \"\"\"\n Performs a simple linear interpolation between given array :math:`a` and\n array :math:`b` using :math:`x` array.\n\n Parameters\n ----------\n x : array_like\n Array :math:`x` value to use to interpolate between array :math:`a` and\n array :math:`b`.\n a : array_like\n Array :math:`a`, the start of the range in which to interpolate.\n b : array_like\n Array :math:`b`, the end of the range in which to interpolate.\n clip : bool, optional\n Whether to clip the output values to range [a, b].\n\n Returns\n -------\n ndarray\n Linear interpolation result.\n\n Examples\n --------\n >>> a = 0\n >>> b = 2\n >>> linstep_function(0.5, a, b)\n 1.0\n \"\"\"\n\n x = as_float_array(x)\n a = as_float_array(a)\n b = as_float_array(b)\n\n y = (1 - x) * a + x * b\n\n return np.clip(y, a, b) if clip else y\n\n\nlerp = linstep_function\n\n\ndef smoothstep_function(x, a=0, b=1, clip=False):\n \"\"\"\n Evaluates the *smoothstep* sigmoid-like function on array :math:`x`.\n\n Parameters\n ----------\n x : numeric or array_like\n Array :math:`x`.\n a : numeric, optional\n Low input domain limit, i.e. the left edge.\n b : numeric, optional\n High input domain limit, i.e. the right edge.\n clip : bool, optional\n Whether to scale, bias and clip input values to domain [0, 1].\n\n Returns\n -------\n array_like\n Array :math:`x` after *smoothstep* sigmoid-like function evaluation.\n\n Examples\n --------\n >>> x = np.linspace(-2, 2, 5)\n >>> smoothstep_function(x, -2, 2, clip=True)\n array([ 0. , 0.15625, 0.5 , 0.84375, 1. ])\n \"\"\"\n\n x = as_float_array(x)\n\n i = np.clip((x - a) / (b - a), 0, 1) if clip else x\n\n return (i ** 2) * (3 - 2 * i)\n\n\nsmooth = smoothstep_function\n\n\ndef is_identity(a, n=3):\n \"\"\"\n Returns if :math:`a` array is an identity matrix.\n\n Parameters\n ----------\n a : array_like, (N)\n Variable :math:`a` to test.\n n : int, optional\n Matrix dimension.\n\n Returns\n -------\n bool\n Is identity matrix.\n\n Examples\n --------\n >>> is_identity(np.array([1, 0, 0, 0, 1, 0, 0, 0, 1]).reshape(3, 3))\n True\n >>> is_identity(np.array([1, 2, 0, 0, 1, 0, 0, 0, 1]).reshape(3, 3))\n False\n \"\"\"\n\n return np.array_equal(np.identity(n), a)\n" ]

[ [ "numpy.abs", "numpy.einsum", "numpy.power", "numpy.clip", "numpy.isnan", "numpy.atleast_1d", "numpy.max", "numpy.sign", "numpy.identity" ] ]

ztanml/ptpqp

[ "1438a919174b041fb5f36c30bc6825c3748d9a11" ]

[ "MELD/script.py" ]

[ "# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu Apr 14 20:24:06 2016\n\n@author: zhaoshiwen\n\"\"\"\n\nimport numpy as np\n\nimport MELD as MELD\nreload(MELD)\n\n\nn = 1000\nY = np.loadtxt('../data/CTp20Yn' + str(n) + '.txt')\n(p,n) = Y.shape\n\nYt = np.array([0]*p) \n# the type of the variables\n# 0: categorical\n# 1: non-categorical with non-restrictive mean\n# 2: non-categorical with positive mean\n\n\nk = 3 # the number of components\nS = 100 # maximum number of iterations\n\n\n# --------------------------------\n# --------------------------------\n# Parameter estimation using second moment matrices\n\n# create an object of MELD class\nmyMELD = MELD.MELD(Y,Yt,k)\n\n# calculate second moment matrices\nmyMELD.calM2()\nmyMELD.calM2_bar()\n\n# ------------- first stage\n# initialize weight matrices to identity\nmyMELD.initializeWeight_M2()\n\n# start to perform first stage estimation\nResult = myMELD.estimatePhiGrad_M2(S)\n\n# ------------- second stage\n# recalculate weight matrix\nmyMELD.updateWeight_M2()\n\n# start to perform second stage estimation\nResults = myMELD.estimatePhiGrad_M2(S,step = 0.1)\n\n# --------------------------------\n# --------------------------------\n# Parameter estimation using second moment matrices\n\n# create an object of MELD class\nmyMELD = MELD.MELD(Y,Yt,k)\n\n# calculate third moment tensors\nmyMELD.calM3()\nmyMELD.calM3_bar()\n\n# ------------ first stage\n# initialize weight matrices to identity\nmyMELD.initializeWeight_M3()\n\n# start to perform first stage estimation\nResult = myMELD.estimatePhiGrad_M2M3(S)\n\n# ------------ second stage\n# recalculate weight matrix\nmyMELD.updateWeight_M2()\nmyMELD.updateWeight_M3()\n\n# start to performo second stage estimation\nResults = myMELD.estimatePhiGrad_M2M3(S,step = 0.1)\n" ]

[ [ "numpy.array" ] ]

CosimoRulli/VMRProject_K_D

[ "3dc3f7276b7c9ad67404b2b10de4fc42dbffcaf8" ]

[ "lib/model/faster_rcnn/alexnet_caffe.py" ]

[ "import torch\nimport torch.nn as nn\n\n\nclass AlexNet_caffe(nn.Module):\n\n def __init__(self, num_classes=1000):\n super(AlexNet_caffe, self).__init__()\n self.features = nn.Sequential(\n nn.Conv2d(3, 96, kernel_size=11, stride=4),\n nn.ReLU(),\n nn.LocalResponseNorm(size=5, alpha=0.0001, beta=0.75, k=1),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n nn.Conv2d(96, 256, kernel_size=5, padding=2, groups=2),\n nn.ReLU(inplace=True),\n nn.LocalResponseNorm(size=5, alpha=0.0001, beta=0.75, k=1),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n nn.Conv2d(256, 384, kernel_size=3, padding=1),\n nn.ReLU(),\n nn.Conv2d(384, 384, kernel_size=3, padding=1, groups=2),\n nn.ReLU(),\n nn.Conv2d(384, 256, kernel_size=3, padding=1, groups=2),\n nn.ReLU(),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n )\n self.classifier = nn.Sequential(\n nn.Linear(256 * 6 * 6, 4096),\n nn.ReLU(),\n nn.Dropout(),\n nn.Linear(4096, 4096),\n nn.ReLU(),\n nn.Dropout(),\n nn.Linear(4096, num_classes),\n )\n\n def forward(self, x):\n x = self.features(x)\n x = x.view(x.size(0), 256 * 6 * 6)\n x = self.classifier(x)\n return x\n\n\ndef alexnet(pretrained=False, **kwargs):\n r\"\"\"AlexNet model architecture from the\n `\"One weird trick...\" <https://arxiv.org/abs/1404.5997>`_ paper.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n \"\"\"\n model = AlexNet_caffe(**kwargs)\n return model\n" ]

[ [ "torch.nn.Dropout", "torch.nn.LocalResponseNorm", "torch.nn.Conv2d", "torch.nn.MaxPool2d", "torch.nn.Linear", "torch.nn.ReLU" ] ]

felipeescallon/lux

[ "1dbbcb9967f0e7413675626ce080c1059e214e74" ]

[ "lux/executor/PandasExecutor.py" ]

[ "# Copyright 2019-2020 The Lux Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport pandas as pd\nfrom lux.vis.VisList import VisList\nfrom lux.vis.Vis import Vis\nfrom lux.core.frame import LuxDataFrame\nfrom lux.executor.Executor import Executor\nfrom lux.utils import utils\nfrom lux.utils.date_utils import is_datetime_series\nfrom lux.utils.utils import check_import_lux_widget, check_if_id_like, is_numeric_nan_column\nimport warnings\nimport lux\n\n\nclass PandasExecutor(Executor):\n \"\"\"\n Given a Vis objects with complete specifications, fetch and process data using Pandas dataframe operations.\n \"\"\"\n\n def __init__(self):\n self.name = \"PandasExecutor\"\n warnings.formatwarning = lux.warning_format\n\n def __repr__(self):\n return f\"<PandasExecutor>\"\n\n @staticmethod\n def execute_sampling(ldf: LuxDataFrame):\n # General Sampling for entire dataframe\n SAMPLE_FLAG = lux.config.sampling\n SAMPLE_START = lux.config.sampling_start\n SAMPLE_CAP = lux.config.sampling_cap\n SAMPLE_FRAC = 0.75\n\n if SAMPLE_FLAG and len(ldf) > SAMPLE_CAP:\n if ldf._sampled is None: # memoize unfiltered sample df\n ldf._sampled = ldf.sample(n=SAMPLE_CAP, random_state=1)\n ldf._message.add_unique(\n f\"Large dataframe detected: Lux is only visualizing a random sample capped at {SAMPLE_CAP} rows.\",\n priority=99,\n )\n elif SAMPLE_FLAG and len(ldf) > SAMPLE_START:\n if ldf._sampled is None: # memoize unfiltered sample df\n ldf._sampled = ldf.sample(frac=SAMPLE_FRAC, random_state=1)\n ldf._message.add_unique(\n f\"Large dataframe detected: Lux is only visualizing a random sample of {len(ldf._sampled)} rows.\",\n priority=99,\n )\n else:\n ldf._sampled = ldf\n\n @staticmethod\n def execute(vislist: VisList, ldf: LuxDataFrame):\n \"\"\"\n Given a VisList, fetch the data required to render the vis.\n 1) Apply filters\n 2) Retrieve relevant attribute\n 3) Perform vis-related processing (aggregation, binning)\n 4) return a DataFrame with relevant results\n\n Parameters\n ----------\n vislist: list[lux.Vis]\n vis list that contains lux.Vis objects for visualization.\n ldf : lux.core.frame\n LuxDataFrame with specified intent.\n\n Returns\n -------\n None\n \"\"\"\n PandasExecutor.execute_sampling(ldf)\n for vis in vislist:\n # The vis data starts off being original or sampled dataframe\n vis._vis_data = ldf._sampled\n filter_executed = PandasExecutor.execute_filter(vis)\n # Select relevant data based on attribute information\n attributes = set([])\n for clause in vis._inferred_intent:\n if clause.attribute != \"Record\":\n attributes.add(clause.attribute)\n # TODO: Add some type of cap size on Nrows ?\n vis._vis_data = vis.data[list(attributes)]\n\n if vis.mark == \"bar\" or vis.mark == \"line\" or vis.mark == \"geographical\":\n PandasExecutor.execute_aggregate(vis, isFiltered=filter_executed)\n elif vis.mark == \"histogram\":\n PandasExecutor.execute_binning(ldf, vis)\n elif vis.mark == \"scatter\":\n HBIN_START = 5000\n if lux.config.heatmap and len(ldf) > HBIN_START:\n vis._postbin = True\n ldf._message.add_unique(\n f\"Large scatterplots detected: Lux is automatically binning scatterplots to heatmaps.\",\n priority=98,\n )\n # vis._mark = \"heatmap\"\n # PandasExecutor.execute_2D_binning(vis) # Lazy Evaluation (Early pruning based on interestingness)\n vis.data.clear_intent() # Ensure that intent is not propogated to the vis data\n\n @staticmethod\n def execute_aggregate(vis: Vis, isFiltered=True):\n \"\"\"\n Aggregate data points on an axis for bar or line charts\n\n Parameters\n ----------\n vis: lux.Vis\n lux.Vis object that represents a visualization\n ldf : lux.core.frame\n LuxDataFrame with specified intent.\n\n Returns\n -------\n None\n \"\"\"\n import numpy as np\n\n x_attr = vis.get_attr_by_channel(\"x\")[0]\n y_attr = vis.get_attr_by_channel(\"y\")[0]\n has_color = False\n groupby_attr = \"\"\n measure_attr = \"\"\n attr_unique_vals = []\n if x_attr.aggregation is None or y_attr.aggregation is None:\n return\n if y_attr.aggregation != \"\":\n groupby_attr = x_attr\n measure_attr = y_attr\n agg_func = y_attr.aggregation\n if x_attr.aggregation != \"\":\n groupby_attr = y_attr\n measure_attr = x_attr\n agg_func = x_attr.aggregation\n if groupby_attr.attribute in vis.data.unique_values.keys():\n attr_unique_vals = vis.data.unique_values.get(groupby_attr.attribute)\n # checks if color is specified in the Vis\n if len(vis.get_attr_by_channel(\"color\")) == 1:\n color_attr = vis.get_attr_by_channel(\"color\")[0]\n color_attr_vals = vis.data.unique_values[color_attr.attribute]\n color_cardinality = len(color_attr_vals)\n # NOTE: might want to have a check somewhere to not use categorical variables with greater than some number of categories as a Color variable----------------\n has_color = True\n else:\n color_cardinality = 1\n if measure_attr != \"\":\n if measure_attr.attribute == \"Record\":\n # need to get the index name so that we can rename the index column to \"Record\"\n # if there is no index, default to \"index\"\n index_name = vis.data.index.name\n if index_name == None:\n index_name = \"index\"\n\n vis._vis_data = vis.data.reset_index()\n # if color is specified, need to group by groupby_attr and color_attr\n\n if has_color:\n vis._vis_data = (\n vis.data.groupby(\n [groupby_attr.attribute, color_attr.attribute], dropna=False, history=False\n )\n .count()\n .reset_index()\n .rename(columns={index_name: \"Record\"})\n )\n vis._vis_data = vis.data[[groupby_attr.attribute, color_attr.attribute, \"Record\"]]\n else:\n vis._vis_data = (\n vis.data.groupby(groupby_attr.attribute, dropna=False, history=False)\n .count()\n .reset_index()\n .rename(columns={index_name: \"Record\"})\n )\n vis._vis_data = vis.data[[groupby_attr.attribute, \"Record\"]]\n else:\n # if color is specified, need to group by groupby_attr and color_attr\n if has_color:\n groupby_result = vis.data.groupby(\n [groupby_attr.attribute, color_attr.attribute], dropna=False, history=False\n )\n else:\n groupby_result = vis.data.groupby(\n groupby_attr.attribute, dropna=False, history=False\n )\n groupby_result = groupby_result.agg(agg_func)\n intermediate = groupby_result.reset_index()\n vis._vis_data = intermediate.__finalize__(vis.data)\n result_vals = list(vis.data[groupby_attr.attribute])\n # create existing group by attribute combinations if color is specified\n # this is needed to check what combinations of group_by_attr and color_attr values have a non-zero number of elements in them\n if has_color:\n res_color_combi_vals = []\n result_color_vals = list(vis.data[color_attr.attribute])\n for i in range(0, len(result_vals)):\n res_color_combi_vals.append([result_vals[i], result_color_vals[i]])\n # For filtered aggregation that have missing groupby-attribute values, set these aggregated value as 0, since no datapoints\n if isFiltered or has_color and attr_unique_vals:\n N_unique_vals = len(attr_unique_vals)\n if len(result_vals) != N_unique_vals * color_cardinality:\n columns = vis.data.columns\n if has_color:\n df = pd.DataFrame(\n {\n columns[0]: attr_unique_vals * color_cardinality,\n columns[1]: pd.Series(color_attr_vals).repeat(N_unique_vals),\n }\n )\n vis._vis_data = vis.data.merge(\n df,\n on=[columns[0], columns[1]],\n how=\"right\",\n suffixes=[\"\", \"_right\"],\n )\n for col in columns[2:]:\n vis.data[col] = vis.data[col].fillna(0) # Triggers __setitem__\n assert len(list(vis.data[groupby_attr.attribute])) == N_unique_vals * len(\n color_attr_vals\n ), f\"Aggregated data missing values compared to original range of values of `{groupby_attr.attribute, color_attr.attribute}`.\"\n\n # Keep only the three relevant columns not the *_right columns resulting from merge\n vis._vis_data = vis.data.iloc[:, :3]\n\n else:\n df = pd.DataFrame({columns[0]: attr_unique_vals})\n\n vis._vis_data = vis.data.merge(\n df, on=columns[0], how=\"right\", suffixes=[\"\", \"_right\"]\n )\n\n for col in columns[1:]:\n vis.data[col] = vis.data[col].fillna(0)\n assert (\n len(list(vis.data[groupby_attr.attribute])) == N_unique_vals\n ), f\"Aggregated data missing values compared to original range of values of `{groupby_attr.attribute}`.\"\n\n vis._vis_data = vis._vis_data.dropna(subset=[measure_attr.attribute])\n try:\n vis._vis_data = vis._vis_data.sort_values(by=groupby_attr.attribute, ascending=True)\n except TypeError:\n warnings.warn(\n f\"\\nLux detects that the attribute '{groupby_attr.attribute}' maybe contain mixed type.\"\n + f\"\\nTo visualize this attribute, you may want to convert the '{groupby_attr.attribute}' into a uniform type as follows:\"\n + f\"\\n\\tdf['{groupby_attr.attribute}'] = df['{groupby_attr.attribute}'].astype(str)\"\n )\n vis._vis_data[groupby_attr.attribute] = vis._vis_data[groupby_attr.attribute].astype(str)\n vis._vis_data = vis._vis_data.sort_values(by=groupby_attr.attribute, ascending=True)\n vis._vis_data = vis._vis_data.reset_index()\n vis._vis_data = vis._vis_data.drop(columns=\"index\")\n\n @staticmethod\n def execute_binning(ldf, vis: Vis):\n \"\"\"\n Binning of data points for generating histograms\n\n Parameters\n ----------\n vis: lux.Vis\n lux.Vis object that represents a visualization\n ldf : lux.core.frame\n LuxDataFrame with specified intent.\n\n Returns\n -------\n None\n \"\"\"\n import numpy as np\n\n bin_attribute = list(filter(lambda x: x.bin_size != 0, vis._inferred_intent))[0]\n bin_attr = bin_attribute.attribute\n series = vis.data[bin_attr]\n\n if series.hasnans:\n ldf._message.add_unique(\n f\"The column <code>{bin_attr}</code> contains missing values, not shown in the displayed histogram.\",\n priority=100,\n )\n series = series.dropna()\n if pd.api.types.is_object_dtype(series):\n series = series.astype(\"float\", errors=\"ignore\")\n\n counts, bin_edges = np.histogram(series, bins=bin_attribute.bin_size)\n # bin_edges of size N+1, so need to compute bin_start as the bin location\n bin_start = bin_edges[0:-1]\n binned_result = np.array([bin_start, counts]).T\n vis._vis_data = pd.DataFrame(binned_result, columns=[bin_attr, \"Number of Records\"])\n\n @staticmethod\n def execute_filter(vis: Vis):\n assert (\n vis.data is not None\n ), \"execute_filter assumes input vis.data is populated (if not, populate with LuxDataFrame values)\"\n filters = utils.get_filter_specs(vis._inferred_intent)\n\n if filters:\n # TODO: Need to handle OR logic\n for filter in filters:\n vis._vis_data = PandasExecutor.apply_filter(\n vis.data, filter.attribute, filter.filter_op, filter.value\n )\n return True\n else:\n return False\n\n @staticmethod\n def apply_filter(df: pd.DataFrame, attribute: str, op: str, val: object) -> pd.DataFrame:\n \"\"\"\n Helper function for applying filter to a dataframe\n\n Parameters\n ----------\n df : pandas.DataFrame\n Dataframe to filter on\n attribute : str\n Filter attribute\n op : str\n Filter operation, '=', '<', '>', '<=', '>=', '!='\n val : object\n Filter value\n\n Returns\n -------\n df: pandas.DataFrame\n Dataframe resulting from the filter operation\n \"\"\"\n # Handling NaN filter values\n if utils.like_nan(val):\n if op != \"=\" and op != \"!=\":\n warnings.warn(\"Filter on NaN must be used with equality operations (i.e., `=` or `!=`)\")\n else:\n if op == \"=\":\n return df[df[attribute].isna()]\n elif op == \"!=\":\n return df[~df[attribute].isna()]\n # Applying filter in regular, non-NaN cases\n if op == \"=\":\n return df[df[attribute] == val]\n elif op == \"<\":\n return df[df[attribute] < val]\n elif op == \">\":\n return df[df[attribute] > val]\n elif op == \"<=\":\n return df[df[attribute] <= val]\n elif op == \">=\":\n return df[df[attribute] >= val]\n elif op == \"!=\":\n return df[df[attribute] != val]\n return df\n\n @staticmethod\n def execute_2D_binning(vis: Vis):\n pd.reset_option(\"mode.chained_assignment\")\n with pd.option_context(\"mode.chained_assignment\", None):\n x_attr = vis.get_attr_by_channel(\"x\")[0].attribute\n y_attr = vis.get_attr_by_channel(\"y\")[0].attribute\n\n vis._vis_data[\"xBin\"] = pd.cut(vis._vis_data[x_attr], bins=lux.config.heatmap_bin_size)\n vis._vis_data[\"yBin\"] = pd.cut(vis._vis_data[y_attr], bins=lux.config.heatmap_bin_size)\n\n color_attr = vis.get_attr_by_channel(\"color\")\n if len(color_attr) > 0:\n color_attr = color_attr[0]\n groups = vis._vis_data.groupby([\"xBin\", \"yBin\"], history=False)[color_attr.attribute]\n if color_attr.data_type == \"nominal\":\n # Compute mode and count. Mode aggregates each cell by taking the majority vote for the category variable. In cases where there is ties across categories, pick the first item (.iat[0])\n result = groups.agg(\n [\n (\"count\", \"count\"),\n (color_attr.attribute, lambda x: pd.Series.mode(x).iat[0]),\n ]\n ).reset_index()\n elif color_attr.data_type == \"quantitative\" or color_attr.data_type == \"temporal\":\n # Compute the average of all values in the bin\n result = groups.agg(\n [(\"count\", \"count\"), (color_attr.attribute, \"mean\")]\n ).reset_index()\n result = result.dropna()\n else:\n groups = vis._vis_data.groupby([\"xBin\", \"yBin\"], history=False)[x_attr]\n result = groups.count().reset_index(name=x_attr)\n result = result.rename(columns={x_attr: \"count\"})\n result = result[result[\"count\"] != 0]\n\n # convert type to facilitate weighted correlation interestingess calculation\n result[\"xBinStart\"] = result[\"xBin\"].apply(lambda x: x.left).astype(\"float\")\n result[\"xBinEnd\"] = result[\"xBin\"].apply(lambda x: x.right)\n\n result[\"yBinStart\"] = result[\"yBin\"].apply(lambda x: x.left).astype(\"float\")\n result[\"yBinEnd\"] = result[\"yBin\"].apply(lambda x: x.right)\n\n vis._vis_data = result.drop(columns=[\"xBin\", \"yBin\"])\n\n #######################################################\n ############ Metadata: data type, model #############\n #######################################################\n def compute_dataset_metadata(self, ldf: LuxDataFrame):\n ldf._data_type = {}\n self.compute_data_type(ldf)\n\n def compute_data_type(self, ldf: LuxDataFrame):\n from pandas.api.types import is_datetime64_any_dtype as is_datetime\n\n for attr in list(ldf.columns):\n if attr in ldf._type_override:\n ldf._data_type[attr] = ldf._type_override[attr]\n else:\n temporal_var_list = [\"month\", \"year\", \"day\", \"date\", \"time\", \"weekday\"]\n if is_datetime(ldf[attr]):\n ldf._data_type[attr] = \"temporal\"\n elif self._is_datetime_string(ldf[attr]):\n ldf._data_type[attr] = \"temporal\"\n elif isinstance(attr, pd._libs.tslibs.timestamps.Timestamp):\n ldf._data_type[attr] = \"temporal\"\n elif str(attr).lower() in temporal_var_list:\n ldf._data_type[attr] = \"temporal\"\n elif self._is_datetime_number(ldf[attr]):\n ldf._data_type[attr] = \"temporal\"\n elif self._is_geographical_attribute(ldf[attr]):\n ldf._data_type[attr] = \"geographical\"\n elif pd.api.types.is_float_dtype(ldf.dtypes[attr]):\n\n if ldf.cardinality[attr] != len(ldf) and (ldf.cardinality[attr] < 20):\n ldf._data_type[attr] = \"nominal\"\n else:\n ldf._data_type[attr] = \"quantitative\"\n elif pd.api.types.is_integer_dtype(ldf.dtypes[attr]):\n # See if integer value is quantitative or nominal by checking if the ratio of cardinality/data size is less than 0.4 and if there are less than 10 unique values\n if ldf.pre_aggregated:\n if ldf.cardinality[attr] == len(ldf):\n ldf._data_type[attr] = \"nominal\"\n if ldf.cardinality[attr] / len(ldf) < 0.4 and ldf.cardinality[attr] < 20:\n ldf._data_type[attr] = \"nominal\"\n else:\n ldf._data_type[attr] = \"quantitative\"\n if check_if_id_like(ldf, attr):\n ldf._data_type[attr] = \"id\"\n # Eliminate this clause because a single NaN value can cause the dtype to be object\n elif pd.api.types.is_string_dtype(ldf.dtypes[attr]):\n # Check first if it's castable to float after removing NaN\n is_numeric_nan, series = is_numeric_nan_column(ldf[attr])\n if is_numeric_nan:\n # int columns gets coerced into floats if contain NaN\n ldf._data_type[attr] = \"quantitative\"\n # min max was not computed since object type, so recompute here\n ldf._min_max[attr] = (\n series.min(),\n series.max(),\n )\n elif check_if_id_like(ldf, attr):\n ldf._data_type[attr] = \"id\"\n else:\n ldf._data_type[attr] = \"nominal\"\n # check if attribute is any type of datetime dtype\n elif is_datetime_series(ldf.dtypes[attr]):\n ldf._data_type[attr] = \"temporal\"\n else:\n ldf._data_type[attr] = \"nominal\"\n if not pd.api.types.is_integer_dtype(ldf.index) and ldf.index.name:\n ldf._data_type[ldf.index.name] = \"nominal\"\n\n non_datetime_attrs = []\n for attr in ldf.columns:\n if ldf._data_type[attr] == \"temporal\" and not is_datetime(ldf[attr]):\n non_datetime_attrs.append(attr)\n warn_msg = \"\"\n if len(non_datetime_attrs) == 1:\n warn_msg += f\"\\nLux detects that the attribute '{non_datetime_attrs[0]}' may be temporal.\\n\"\n elif len(non_datetime_attrs) > 1:\n warn_msg += f\"\\nLux detects that attributes {non_datetime_attrs} may be temporal.\\n\"\n if len(non_datetime_attrs) > 0:\n warn_msg += \"To display visualizations for these attributes accurately, please convert temporal attributes to Pandas Datetime objects using the pd.to_datetime function and provide a 'format' parameter to specify the datetime format of the attribute.\\nFor example, you can convert a year-only attribute (e.g., 1998, 1971, 1982) to Datetime type by specifying the `format` as '%Y'.\\n\\nHere is a starter template that you can use for converting the temporal fields:\\n\"\n for attr in non_datetime_attrs:\n warn_msg += f\"\\tdf['{attr}'] = pd.to_datetime(df['{attr}'], format='<replace-with-datetime-format>')\\n\"\n warn_msg += \"\\nSee more at: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.to_datetime.html\"\n warn_msg += f\"\\nIf {attr} is not a temporal attribute, please use override Lux's automatically detected type:\"\n warn_msg += f\"\\n\\tdf.set_data_type({{'{attr}':'quantitative'}})\"\n warnings.warn(warn_msg, stacklevel=2)\n\n @staticmethod\n def _is_datetime_string(series):\n if series.dtype == object:\n not_numeric = False\n try:\n pd.to_numeric(series)\n except Exception as e:\n not_numeric = True\n\n datetime_col = None\n if not_numeric:\n try:\n datetime_col = pd.to_datetime(series)\n except Exception as e:\n return False\n if datetime_col is not None:\n return True\n return False\n\n @staticmethod\n def _is_geographical_attribute(series):\n # run detection algorithm\n name = str(series.name).lower()\n return utils.like_geo(name)\n\n @staticmethod\n def _is_datetime_number(series):\n is_int_dtype = pd.api.types.is_integer_dtype(series.dtype)\n if is_int_dtype:\n try:\n temp = series.astype(str)\n pd.to_datetime(temp)\n return True\n except Exception:\n return False\n return False\n\n def compute_stats(self, ldf: LuxDataFrame):\n # precompute statistics\n ldf.unique_values = {}\n ldf._min_max = {}\n ldf.cardinality = {}\n ldf._length = len(ldf)\n\n for attribute in ldf.columns:\n\n if isinstance(attribute, pd._libs.tslibs.timestamps.Timestamp):\n # If timestamp, make the dictionary keys the _repr_ (e.g., TimeStamp('2020-04-05 00.000')--> '2020-04-05')\n attribute_repr = str(attribute._date_repr)\n else:\n attribute_repr = attribute\n\n ldf.unique_values[attribute_repr] = list(ldf[attribute].unique())\n ldf.cardinality[attribute_repr] = len(ldf.unique_values[attribute_repr])\n\n if pd.api.types.is_float_dtype(ldf.dtypes[attribute]) or pd.api.types.is_integer_dtype(\n ldf.dtypes[attribute]\n ):\n ldf._min_max[attribute_repr] = (\n ldf[attribute].min(),\n ldf[attribute].max(),\n )\n\n if not pd.api.types.is_integer_dtype(ldf.index):\n index_column_name = ldf.index.name\n ldf.unique_values[index_column_name] = list(ldf.index)\n ldf.cardinality[index_column_name] = len(ldf.index)\n" ]

[ [ "pandas.reset_option", "pandas.to_numeric", "pandas.api.types.is_object_dtype", "pandas.to_datetime", "pandas.api.types.is_float_dtype", "pandas.Series", "pandas.api.types.is_datetime64_any_dtype", "pandas.option_context", "pandas.DataFrame", "pandas.Series.mode", "pandas.cut", "pandas.api.types.is_integer_dtype", "pandas.api.types.is_string_dtype", "numpy.array", "numpy.histogram" ] ]

Anomaly-Detection-Research/arma-arima

[ "c5e025641aca41f6b47f9df01573ef956fb8d5df" ]

[ "python_scripts/ARIMA.py" ]

[ "import warnings\nimport itertools\nimport pandas\nimport math\nimport sys\nimport numpy as np\nfrom plotly.offline import download_plotlyjs, init_notebook_mode, plot\n# init_notebook_mode(connected=True)\n\n# dataframe = pandas.read_csv('./data/realTraffic/speed_6005.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/speed_7578.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/speed_t4013.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/TravelTime_387.csv')\n# dataframe = pandas.read_csv('./data/realTraffic/TravelTime_451.csv')\ndataframe = pandas.read_csv('../data/international-airline-passengers.csv')\ntime = dataframe[list(dataframe)[0]]\nvalues = dataframe[list(dataframe)[1]]\ntraining_ratio = 0.5\nvalidation_ratio = 0.5\n\n# Deviding the data set to training, validation, testing parts\ntraining_end = int(math.floor(len(values)*training_ratio))\ntraining_set_values = np.array(values[0:training_end])\ntraining_set_time = np.array(time[0:training_end])\n\nvalidation_start = training_end + 1\nvalidation_end = validation_start + int(math.floor(len(values)*(1-training_ratio)*validation_ratio))\nvalidation_set_values = np.array(values[validation_start:validation_end])\nvalidation_set_time = np.array(time[validation_start:validation_end])\n\ntesting_start = validation_end + 1\ntesting_end = len(values)\ntesting_set_values = np.array(values[testing_start:testing_end])\ntesting_set_time = np.array(time[testing_start:testing_end])\n\nclass ARIMA:\n def __init__(self, p,d,q):\n self.p = p\n self.d = d\n self.q = q\n \n # Setters\n def set_p(self,p):\n self.p=p \n \n def set_d(self,d):\n self.d=d\n \n def set_q(self,q):\n self.q=q\n \n def set_training_data_time(self, time):\n self.training_data_time = time\n \n def set_validation_data_time(self, time):\n self.validation_data_time = time\n \n def set_testing_data_time(self, time):\n self.testing_data_time = time\n \n def set_validation_data_set(self,data):\n self.validation_data_set = data\n \n def set_testing_data_set(self,data):\n self.testing_data_set = data\n \n def set_training_data_set(self,data):\n self.training_data = data\n data.shape = (max(data.shape),1)\n data = self.get_differance(data, self.d)\n self.Z = data - np.mean(data)\n self.Z.shape = (len(data),1)\n \n # Model\n def shock(self,mean,std):\n if std != std:\n return np.random.normal(mean, 0.001, 1)\n return np.random.normal(mean, std, 1)\n# return 0\n \n def get_differance(self,data_set,d):\n if d == 0:\n return data_set\n else:\n differance = np.zeros(len(data_set)-1)\n for i in range(0,len(data_set)-1):\n differance[i] = data_set[i]-data_set[i+1]\n return self.get_differance(differance,d-1)\n \n def plot_differance(self,data_set,d):\n differance = self.get_differance(data_set,d)\n x = np.arange(len(data_set))\n trace = {\"x\": x,\n \"y\": differance,\n \"mode\": 'lines',\n \"name\": 'value'}\n traces = [trace]\n layout = dict(title = \"Differance with d = \"+str(d),\n xaxis = dict(title = 'X'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n return differance\n \n def calculate_AR_normal_matrix_x_row(self,data,t,mean,std):\n row = np.zeros((1,self.p+1))\n j = 0\n for i in range(t-self.p,t):\n if i < 0:\n row[0][j] = 0\n else:\n row[0][j] = data[i]\n j+=1\n row[0][-1] = self.shock(mean,std)\n return row\n \n def calculate_AR_weights(self):\n self.training_data.shape = (max(self.training_data.shape),1)\n differance = self.get_differance(self.training_data, self.d)\n normal_matrix = np.zeros((len(differance),self.p+1))\n mean = np.mean(self.Z)\n std = np.std(self.Z, ddof=1)\n for i in range(0,len(differance)):\n normal_matrix[i] = self.calculate_AR_normal_matrix_x_row(self.Z,i,mean,std)\n \n normal_matrix_tanspose = normal_matrix.transpose()\n self.AR_weights = np.dot(np.dot(np.linalg.pinv(np.dot(normal_matrix_tanspose,normal_matrix)),normal_matrix_tanspose),self.Z)\n\n \n def get_AR_prediction(self,data_set):\n self.calculate_AR_weights()\n self.AR_prediction = np.zeros((np.max(data_set.shape),1))\n mean = np.mean(data_set)\n std = np.std(data_set, ddof=1)\n Z = np.array(data_set)\n Z.shape = (np.max(Z.shape),1)\n Z = Z - mean\n for i in range(0,np.max(Z.shape)):\n self.AR_prediction[i] = np.dot(self.calculate_AR_normal_matrix_x_row(Z, i, mean, std), self.AR_weights)\n \n self.AR_prediction = self.AR_prediction.transpose()[0] + mean\n return self.AR_prediction\n \n def get_previous_q_values(self,data,t):\n previous_q = np.zeros(self.q)\n j = 0\n for i in range(t-self.q,t):\n if i < 0:\n previous_q[j] = 0\n else:\n previous_q[j] = data[i]\n j+=1\n return previous_q\n \n def get_MA_prediction(self,data_set):\n self.MA_prediction = np.zeros(np.max(data_set.shape))\n Z = np.array(data_set)\n Z.shape = (np.max(Z.shape),1)\n for i in range(0,np.max(Z.shape)):\n self.MA_prediction[i] = np.average(self.get_previous_q_values(Z, i))\n \n return self.MA_prediction\n \n def calculate_AR_MA_normal_matrix_x_row(self,t):\n row = np.zeros((1,2))\n row[0][0] = self.MA_prediction[t]\n row[0][1] = self.AR_prediction[t]\n return row\n \n def calculate_AR_MA_weights(self):\n self.training_data.shape = (max(self.training_data.shape),1)\n differance = self.get_differance(self.training_data, self.d)\n self.get_MA_prediction(differance)\n self.get_AR_prediction(differance)\n normal_matrix = np.zeros((len(differance),2))\n \n for i in range(0,len(differance)):\n normal_matrix[i] = self.calculate_AR_MA_normal_matrix_x_row(i)\n \n normal_matrix_tanspose = normal_matrix.transpose()\n self.weights = np.dot(np.dot(np.linalg.pinv(np.dot(normal_matrix_tanspose,normal_matrix)),normal_matrix_tanspose),differance)\n \n# print(self.weights)\n# #normalizing weigts\n# total = self.weights[0] + self.weights[1]\n# self.weights[0] = self.weights[0]/total\n# self.weights[1] = self.weights[1]/total\n# print(self.weights)\n \n def get_prediction(self, data_set):\n data_set.shape = (max(data_set.shape),1)\n differance = self.get_differance(data_set,self.d)\n self.calculate_AR_MA_weights()\n self.get_MA_prediction(differance)\n self.get_AR_prediction(differance)\n Z = np.array(differance)\n Z.shape = (np.max(Z.shape),1)\n self.prediction = np.zeros((np.max(Z.shape),1))\n for i in range(0,np.max(Z.shape)):\n self.prediction[i] = np.dot(self.calculate_AR_MA_normal_matrix_x_row(i), self.weights)\n \n self.prediction = self.prediction.transpose()[0]\n return self.prediction\n \n # Diagnostics and identification messures\n def mse(self,values,pridicted):\n error = 0.0\n for i in range(0,len(values)):\n error += (values[i] - pridicted[i])**2\n return error/len(values)\n \n def get_mse(self, data, prediction):\n return self.mse(data,prediction)\n \n def plot_autocorrelation(self, data_set, lag):\n autocorrelations = np.zeros(lag)\n autocorrelations_x = np.arange(lag)\n autocorrelations[0] = 1.0\n for i in range(1,lag):\n autocorrelations[i] = np.corrcoef(data_set[i:],data_set[:-i])[0,1]\n \n trace = {\"x\": autocorrelations_x,\n \"y\": autocorrelations,\n 'type': 'bar',\n \"name\": 'Autocorrelation', \n }\n \n traces = [trace]\n layout = dict(title = \"Autocorrelation\",\n xaxis = dict(title = 'Lag'),\n yaxis = dict(title = 'Autocorrelation')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n def plot_partial_autocorrelation(self, data_set, lag):\n pac = np.zeros(lag)\n pac_x = np.arange(lag)\n \n residualts = data_set\n slope, intercept = np.polyfit(data_set,residualts,1)\n estimate = intercept + slope*data_set\n residualts = residualts - estimate\n pac[0] = 1\n for i in range(1,lag):\n pac[i] = np.corrcoef(data_set[:-i],residualts[i:])[0,1]\n \n slope, intercept = np.polyfit(data_set[:-i],residualts[i:],1)\n estimate = intercept + slope*data_set[:-i]\n \n residualts[i:] = residualts[i:] - estimate\n \n trace = {\"x\": pac_x,\n \"y\": pac,\n 'type': 'bar',\n \"name\": 'Partial Autocorrelation', \n }\n\n traces = [trace]\n layout = dict(title = \"Partial Autocorrelation\",\n xaxis = dict(title = 'Lag'),\n yaxis = dict(title = 'Partial Autocorrelation')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n def plot_residuals(self, data_set, prediction):\n x = np.arange(len(data_set))\n residual = data_set - prediction\n mean = np.ones(len(data_set))*np.mean(residual)\n \n trace = {\"x\": x,\n \"y\": residual,\n \"mode\": 'markers',\n \"name\": 'Residual'}\n\n trace_mean = {\"x\": x,\n \"y\": mean,\n \"mode\": 'lines',\n \"name\": 'Mean'}\n traces = [trace,trace_mean]\n layout = dict(title = \"Residual\",\n xaxis = dict(title = 'X'),\n yaxis = dict(title = 'Residual')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n print(\"Standard Deviation of Residuals : \" + str(np.std(residual, ddof=1)))\n print(\"Mean of Residuals : \" + str(np.mean(residual)))\n\n \n \n def plot_data(self, data_set, time):\n mean = np.mean(data_set)\n means = np.ones(len(data_set))*mean\n trace_value = {\"x\": time,\n \"y\": data_set,\n \"mode\": 'lines',\n \"name\": 'value'}\n\n trace_mean = {\"x\": time,\n \"y\": means,\n \"mode\": 'lines',\n \"name\": 'mean'}\n traces = [trace_value,trace_mean]\n layout = dict(title = \"Values with mean\",\n xaxis = dict(title = 'Time'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n normalized_data = data_set - mean\n trace_value = {\"x\": time,\n \"y\": normalized_data,\n \"mode\": 'lines',\n \"name\": 'value'}\n traces = [trace_value]\n layout = dict(title = \"After removing mean\",\n xaxis = dict(title = 'Time'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n \n \n def print_stats(self,data,prediction):\n print(\"Mean Square Error : \" + str(self.mse(data,prediction)))\n print(\"Mean of real values : \" + str(np.mean(data)))\n print(\"Standard Deviation of real values : \" + str(np.std(data, ddof=1)))\n print(\"Mean of predicted values : \" + str(np.mean(prediction)))\n print(\"Standard Deviation of predicted values : \" + str(np.std(prediction, ddof=1)))\n print(\"Number of data points : \" + str(len(data)))\n \n def plot_result(self, time, data, prediction):\n data.shape = (1,np.max(data.shape))\n data = data[0]\n data = self.get_differance(data, self.d)\n trace_real = {\"x\": time,\n \"y\": data,\n \"mode\": 'lines',\n \"name\": 'Real value'}\n trace_predicted = {\"x\": time,\n \"y\": prediction,\n \"mode\": 'lines',\n \"name\": 'Predicted value'}\n traces = [trace_real,trace_predicted]\n layout = dict(title = \"Training Data Set with ARIMA(\"+str(self.p)+\",\"+str(self.d)+\",\"+str(self.q)+\")\",\n xaxis = dict(title = 'Time'),\n yaxis = dict(title = 'Value')\n )\n fig = dict(data=traces, layout=layout)\n plot(fig)\n self.print_stats(data,prediction)\n self.plot_residuals(data,prediction)\n\n\narima_model = ARIMA(2,1,2)\narima_model.plot_differance(training_set_values,0)\ndifferance = arima_model.plot_differance(training_set_values,1)\n\narima_model.plot_autocorrelation(differance, 30)\narima_model.plot_partial_autocorrelation(differance, 30)\n\narma_model = ARIMA(2,1,4)\narma_model.set_training_data_set(training_set_values)\narma_model.set_training_data_time(training_set_time)\n\narma_model.set_testing_data_set(testing_set_values)\narma_model.set_testing_data_time(testing_set_time)\n\narma_model.set_validation_data_set(validation_set_values)\narma_model.set_validation_data_time(validation_set_time)\n\n# prediction = arma_model.get_prediction(arma_model.testing_data_set)\n# prediction = arma_model.get_prediction(arma_model.validation_data_set)\nprediction = arma_model.get_prediction(arma_model.training_data)\n\n\n# arma_model.plot_result(arma_model.testing_data_time, arma_model.testing_data_set, prediction)\n# arma_model.plot_result(arma_model.validation_data_time, arma_model.validation_data_set, prediction)\narma_model.plot_result(arma_model.training_data_time, arma_model.training_data, prediction)" ]

[ [ "numpy.dot", "numpy.polyfit", "pandas.read_csv", "numpy.arange", "numpy.max", "numpy.random.normal", "numpy.std", "numpy.mean", "numpy.corrcoef", "numpy.array", "numpy.zeros" ] ]

LilYuuu/transformers

[ "795c9d2de2ec9e3844dc4c2cdf2e0bc9251597f7" ]

[ "src/transformers/data/processors/glue.py" ]

[ "# coding=utf-8\n# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.\n# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\" GLUE processors and helpers \"\"\"\n\nimport logging\nimport os\nimport json\n\nfrom ...file_utils import is_tf_available\nfrom .utils import DataProcessor, InputExample, InputFeatures\n\n\nif is_tf_available():\n import tensorflow as tf\n\nlogger = logging.getLogger(__name__)\n\n\ndef glue_convert_examples_to_features(\n examples,\n tokenizer,\n max_length=512,\n task=None,\n label_list=None,\n output_mode=None,\n pad_on_left=False,\n pad_token=0,\n pad_token_segment_id=0,\n mask_padding_with_zero=True,\n):\n \"\"\"\n Loads a data file into a list of ``InputFeatures``\n\n Args:\n examples: List of ``InputExamples`` or ``tf.data.Dataset`` containing the examples.\n tokenizer: Instance of a tokenizer that will tokenize the examples\n max_length: Maximum example length\n task: GLUE task\n label_list: List of labels. Can be obtained from the processor using the ``processor.get_labels()`` method\n output_mode: String indicating the output mode. Either ``regression`` or ``classification``\n pad_on_left: If set to ``True``, the examples will be padded on the left rather than on the right (default)\n pad_token: Padding token\n pad_token_segment_id: The segment ID for the padding token (It is usually 0, but can vary such as for XLNet where it is 4)\n mask_padding_with_zero: If set to ``True``, the attention mask will be filled by ``1`` for actual values\n and by ``0`` for padded values. If set to ``False``, inverts it (``1`` for padded values, ``0`` for\n actual values)\n\n Returns:\n If the ``examples`` input is a ``tf.data.Dataset``, will return a ``tf.data.Dataset``\n containing the task-specific features. If the input is a list of ``InputExamples``, will return\n a list of task-specific ``InputFeatures`` which can be fed to the model.\n\n \"\"\"\n is_tf_dataset = False\n if is_tf_available() and isinstance(examples, tf.data.Dataset):\n is_tf_dataset = True\n\n if task is not None:\n processor = glue_processors[task]()\n if label_list is None:\n label_list = processor.get_labels()\n logger.info(\"Using label list %s for task %s\" % (label_list, task))\n if output_mode is None:\n output_mode = glue_output_modes[task]\n logger.info(\"Using output mode %s for task %s\" % (output_mode, task))\n\n label_map = {label: i for i, label in enumerate(label_list)}\n\n features = []\n for (ex_index, example) in enumerate(examples):\n len_examples = 0\n if is_tf_dataset:\n example = processor.get_example_from_tensor_dict(example)\n example = processor.tfds_map(example)\n len_examples = tf.data.experimental.cardinality(examples)\n else:\n len_examples = len(examples)\n if ex_index % 10000 == 0:\n logger.info(\"Writing example %d/%d\" % (ex_index, len_examples))\n\n inputs = tokenizer.encode_plus(example.text_a, example.text_b, add_special_tokens=True, max_length=max_length,)\n input_ids, token_type_ids = inputs[\"input_ids\"], inputs[\"token_type_ids\"]\n\n # The mask has 1 for real tokens and 0 for padding tokens. Only real\n # tokens are attended to.\n attention_mask = [1 if mask_padding_with_zero else 0] * len(input_ids)\n\n # Zero-pad up to the sequence length.\n padding_length = max_length - len(input_ids)\n if pad_on_left:\n input_ids = ([pad_token] * padding_length) + input_ids\n attention_mask = ([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask\n token_type_ids = ([pad_token_segment_id] * padding_length) + token_type_ids\n else:\n input_ids = input_ids + ([pad_token] * padding_length)\n attention_mask = attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)\n token_type_ids = token_type_ids + ([pad_token_segment_id] * padding_length)\n\n assert len(input_ids) == max_length, \"Error with input length {} vs {}\".format(len(input_ids), max_length)\n assert len(attention_mask) == max_length, \"Error with input length {} vs {}\".format(\n len(attention_mask), max_length\n )\n assert len(token_type_ids) == max_length, \"Error with input length {} vs {}\".format(\n len(token_type_ids), max_length\n )\n\n if output_mode == \"classification\":\n label = label_map[example.label]\n elif output_mode == \"regression\":\n label = float(example.label)\n else:\n raise KeyError(output_mode)\n\n if ex_index < 5:\n logger.info(\"*** Example ***\")\n logger.info(\"guid: %s\" % (example.guid))\n logger.info(\"input_ids: %s\" % \" \".join([str(x) for x in input_ids]))\n logger.info(\"attention_mask: %s\" % \" \".join([str(x) for x in attention_mask]))\n logger.info(\"token_type_ids: %s\" % \" \".join([str(x) for x in token_type_ids]))\n logger.info(\"label: %s (id = %d)\" % (example.label, label))\n\n features.append(\n InputFeatures(\n input_ids=input_ids, attention_mask=attention_mask, token_type_ids=token_type_ids, label=label\n )\n )\n\n if is_tf_available() and is_tf_dataset:\n\n def gen():\n for ex in features:\n yield (\n {\n \"input_ids\": ex.input_ids,\n \"attention_mask\": ex.attention_mask,\n \"token_type_ids\": ex.token_type_ids,\n },\n ex.label,\n )\n\n return tf.data.Dataset.from_generator(\n gen,\n ({\"input_ids\": tf.int32, \"attention_mask\": tf.int32, \"token_type_ids\": tf.int32}, tf.int64),\n (\n {\n \"input_ids\": tf.TensorShape([None]),\n \"attention_mask\": tf.TensorShape([None]),\n \"token_type_ids\": tf.TensorShape([None]),\n },\n tf.TensorShape([]),\n ),\n )\n\n return features\n\n'''HW4: New code added here'''\n\nclass BoolqProcessor(DataProcessor):\n \"\"\"Processor for the BoolQ data set.\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"passage\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"question\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n logger.info(\"LOOKING AT {}\".format(os.path.join(data_dir, \"train.jsonl\")))\n# with open(os.path.join(data_dir, \"train.jsonl\"), \"r\", encoding=\"utf-8-sig\") as f:\n# with open(os.path.join(data_dir, \"val.jsonl\"), \"r\") as f:\n# lines = json.loads(json.dumps([f.read()]))\n with open(os.path.join(data_dir, \"train.jsonl\"), \"r\") as f:\n lines = f.read().splitlines()\n data = []\n for line in lines:\n data.append(json.loads(line))\n return self._create_examples(data, \"train\")\n\n def get_val_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n# with open(os.path.join(data_dir, \"val.jsonl\"), \"r\", encoding=\"utf-8-sig\") as f:\n# with open(os.path.join(data_dir, \"val.jsonl\"), \"r\") as f:\n# lines = json.loads(json.dumps([f.read()]))\n with open(os.path.join(data_dir, \"val.jsonl\"), \"r\") as f:\n lines = f.read().splitlines()\n data = []\n for line in lines:\n data.append(json.loads(line))\n return self._create_examples(data, \"val\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [True, False]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[\"question\"]\n text_b = line[\"passage\"]\n label = line[\"label\"]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass MrpcProcessor(DataProcessor):\n \"\"\"Processor for the MRPC data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n logger.info(\"LOOKING AT {}\".format(os.path.join(data_dir, \"train.tsv\")))\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n text_b = line[4]\n label = line[0]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass MnliProcessor(DataProcessor):\n \"\"\"Processor for the MultiNLI data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"premise\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"hypothesis\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev_matched.tsv\")), \"dev_matched\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"contradiction\", \"entailment\", \"neutral\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[8]\n text_b = line[9]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass MnliMismatchedProcessor(MnliProcessor):\n \"\"\"Processor for the MultiNLI Mismatched data set (GLUE version).\"\"\"\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev_mismatched.tsv\")), \"dev_matched\")\n\n\nclass ColaProcessor(DataProcessor):\n \"\"\"Processor for the CoLA data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence\"].numpy().decode(\"utf-8\"),\n None,\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[3]\n label = line[1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples\n\n\nclass Sst2Processor(DataProcessor):\n \"\"\"Processor for the SST-2 data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence\"].numpy().decode(\"utf-8\"),\n None,\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, i)\n text_a = line[0]\n label = line[1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=None, label=label))\n return examples\n\n\nclass StsbProcessor(DataProcessor):\n \"\"\"Processor for the STS-B data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [None]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[7]\n text_b = line[8]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass QqpProcessor(DataProcessor):\n \"\"\"Processor for the QQP data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"question1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"question2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n try:\n text_a = line[3]\n text_b = line[4]\n label = line[5]\n except IndexError:\n continue\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass QnliProcessor(DataProcessor):\n \"\"\"Processor for the QNLI data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"question\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev_matched\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"entailment\", \"not_entailment\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass RteProcessor(DataProcessor):\n \"\"\"Processor for the RTE data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"entailment\", \"not_entailment\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nclass WnliProcessor(DataProcessor):\n \"\"\"Processor for the WNLI data set (GLUE version).\"\"\"\n\n def get_example_from_tensor_dict(self, tensor_dict):\n \"\"\"See base class.\"\"\"\n return InputExample(\n tensor_dict[\"idx\"].numpy(),\n tensor_dict[\"sentence1\"].numpy().decode(\"utf-8\"),\n tensor_dict[\"sentence2\"].numpy().decode(\"utf-8\"),\n str(tensor_dict[\"label\"].numpy()),\n )\n\n def get_train_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"train.tsv\")), \"train\")\n\n def get_dev_examples(self, data_dir):\n \"\"\"See base class.\"\"\"\n return self._create_examples(self._read_tsv(os.path.join(data_dir, \"dev.tsv\")), \"dev\")\n\n def get_labels(self):\n \"\"\"See base class.\"\"\"\n return [\"0\", \"1\"]\n\n def _create_examples(self, lines, set_type):\n \"\"\"Creates examples for the training and dev sets.\"\"\"\n examples = []\n for (i, line) in enumerate(lines):\n if i == 0:\n continue\n guid = \"%s-%s\" % (set_type, line[0])\n text_a = line[1]\n text_b = line[2]\n label = line[-1]\n examples.append(InputExample(guid=guid, text_a=text_a, text_b=text_b, label=label))\n return examples\n\n\nglue_tasks_num_labels = {\n \"cola\": 2,\n \"mnli\": 3,\n \"mrpc\": 2,\n \"sst-2\": 2,\n \"sts-b\": 1,\n \"qqp\": 2,\n \"qnli\": 2,\n \"rte\": 2,\n \"wnli\": 2,\n \"boolq\": 2,\n}\n\nglue_processors = {\n \"cola\": ColaProcessor,\n \"mnli\": MnliProcessor,\n \"mnli-mm\": MnliMismatchedProcessor,\n \"mrpc\": MrpcProcessor,\n \"sst-2\": Sst2Processor,\n \"sts-b\": StsbProcessor,\n \"qqp\": QqpProcessor,\n \"qnli\": QnliProcessor,\n \"rte\": RteProcessor,\n \"wnli\": WnliProcessor,\n \"boolq\": BoolqProcessor,\n}\n\nglue_output_modes = {\n \"cola\": \"classification\",\n \"mnli\": \"classification\",\n \"mnli-mm\": \"classification\",\n \"mrpc\": \"classification\",\n \"sst-2\": \"classification\",\n \"sts-b\": \"regression\",\n \"qqp\": \"classification\",\n \"qnli\": \"classification\",\n \"rte\": \"classification\",\n \"wnli\": \"classification\",\n \"boolq\": \"classification\",\n}\n" ]

[ [ "tensorflow.TensorShape", "tensorflow.data.experimental.cardinality" ] ]

vdorobantu/lyapy

[ "485e8490ef77f2286a804b2bd506cc3f46b74c6d" ]

[ "lyapy/systems/system.py" ]

[ "\"\"\"Base class for dynamical systems of the form x_dot = f(t, x).\"\"\"\n\nfrom scipy.integrate import solve_ivp\n\nclass System:\n \"\"\"Base class for dynamical systems of the form x_dot = f(t, x).\n\n Override dx.\n\n Let n be number of states.\n \"\"\"\n\n def dx(self, t, x):\n \"\"\"Evaluate state derivative at a time and state.\n\n Outputs a numpy array (n,).\n\n Inputs:\n Time, t: float\n State, x: numpy array (n,)\n \"\"\"\n\n pass\n\n def simulate(self, x_0, t_eval, rtol=1e-6, atol=1e-6):\n \"\"\"Simulate closed-loop system using Runge-Kutta 4,5.\n\n Solution is evaluated at N time steps. Outputs times and corresponding\n solutions as numpy array (N,) * numpy array (N, n).\n\n Inputs:\n Initial condition, x_0: numpy array (n,)\n Solution times, t_eval: numpy array (N,)\n RK45 relative tolerance, rtol: float\n RK45 absolute tolerance, atol: float\n \"\"\"\n\n t_span = [t_eval[0], t_eval[-1]]\n sol = solve_ivp(self.dx, t_span, x_0, t_eval=t_eval, rtol=rtol, atol=atol)\n return sol.t, sol.y.T\n" ]

[ [ "scipy.integrate.solve_ivp" ] ]

gorogoroyasu/captum

[ "e4e27c537e86deca6ed841432be2f11459d6795a" ]

[ "tests/attr/neuron/test_neuron_gradient.py" ]

[ "#!/usr/bin/env python3\n\nimport unittest\n\nimport torch\nfrom captum.attr._core.saliency import Saliency\nfrom captum.attr._core.neuron.neuron_gradient import NeuronGradient\nfrom captum.attr._utils.gradient import _forward_layer_eval\n\nfrom ..helpers.basic_models import (\n BasicModel_ConvNet,\n BasicModel_MultiLayer,\n BasicModel_MultiLayer_MultiInput,\n)\nfrom ..helpers.utils import assertArraysAlmostEqual, BaseTest\n\n\nclass Test(BaseTest):\n def test_simple_gradient_input_linear2(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 100.0, 0.0]], requires_grad=True)\n self._gradient_input_test_assert(net, net.linear2, inp, (0,), [4.0, 4.0, 4.0])\n\n def test_simple_gradient_input_linear1(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 100.0, 0.0]])\n self._gradient_input_test_assert(net, net.linear1, inp, (0,), [1.0, 1.0, 1.0])\n\n def test_simple_gradient_input_relu_inplace(self):\n net = BasicModel_MultiLayer(inplace=True)\n inp = torch.tensor([[0.0, 5.0, 4.0]])\n self._gradient_input_test_assert(\n net, net.relu, inp, (0,), [1.0, 1.0, 1.0], attribute_to_neuron_input=True\n )\n\n def test_simple_gradient_input_linear1_inplace(self):\n net = BasicModel_MultiLayer(inplace=True)\n inp = torch.tensor([[0.0, 5.0, 4.0]])\n self._gradient_input_test_assert(net, net.linear1, inp, (0,), [1.0, 1.0, 1.0])\n\n def test_simple_gradient_input_relu(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 5.0, 4.0]], requires_grad=True)\n self._gradient_input_test_assert(net, net.relu, inp, 0, [0.0, 0.0, 0.0])\n\n def test_simple_gradient_input_relu2(self):\n net = BasicModel_MultiLayer()\n inp = torch.tensor([[0.0, 5.0, 4.0]])\n self._gradient_input_test_assert(net, net.relu, inp, 1, [1.0, 1.0, 1.0])\n\n def test_simple_gradient_multi_input_linear2(self):\n net = BasicModel_MultiLayer_MultiInput()\n inp1 = torch.tensor([[0.0, 100.0, 0.0]])\n inp2 = torch.tensor([[0.0, 100.0, 0.0]])\n inp3 = torch.tensor([[0.0, 100.0, 0.0]])\n self._gradient_input_test_assert(\n net,\n net.model.linear2,\n (inp1, inp2, inp3),\n (0,),\n ([12.0, 12.0, 12.0], [12.0, 12.0, 12.0], [12.0, 12.0, 12.0]),\n (3,),\n )\n\n def test_simple_gradient_multi_input_linear1(self):\n net = BasicModel_MultiLayer_MultiInput()\n inp1 = torch.tensor([[0.0, 100.0, 0.0]])\n inp2 = torch.tensor([[0.0, 100.0, 0.0]])\n inp3 = torch.tensor([[0.0, 100.0, 0.0]])\n self._gradient_input_test_assert(\n net,\n net.model.linear1,\n (inp1, inp2),\n (0,),\n ([5.0, 5.0, 5.0], [5.0, 5.0, 5.0]),\n (inp3, 5),\n )\n\n def test_matching_output_gradient(self):\n net = BasicModel_ConvNet()\n inp = torch.randn(2, 1, 10, 10, requires_grad=True)\n self._gradient_matching_test_assert(net, net.softmax, inp)\n\n def test_matching_intermediate_gradient(self):\n net = BasicModel_ConvNet()\n inp = torch.randn(3, 1, 10, 10)\n self._gradient_matching_test_assert(net, net.relu2, inp)\n\n def _gradient_input_test_assert(\n self,\n model,\n target_layer,\n test_input,\n test_neuron,\n expected_input_gradient,\n additional_input=None,\n attribute_to_neuron_input=False,\n ):\n grad = NeuronGradient(model, target_layer)\n attributions = grad.attribute(\n test_input,\n test_neuron,\n additional_forward_args=additional_input,\n attribute_to_neuron_input=attribute_to_neuron_input,\n )\n if isinstance(expected_input_gradient, tuple):\n for i in range(len(expected_input_gradient)):\n assertArraysAlmostEqual(\n attributions[i].squeeze(0).tolist(),\n expected_input_gradient[i],\n delta=0.1,\n )\n else:\n assertArraysAlmostEqual(\n attributions.squeeze(0).tolist(), expected_input_gradient, delta=0.1\n )\n\n def _gradient_matching_test_assert(self, model, output_layer, test_input):\n out = _forward_layer_eval(model, test_input, output_layer)\n gradient_attrib = NeuronGradient(model, output_layer)\n for i in range(out.shape[1]):\n neuron = (i,)\n while len(neuron) < len(out.shape) - 1:\n neuron = neuron + (0,)\n input_attrib = Saliency(\n lambda x: _forward_layer_eval(model, x, output_layer)[\n (slice(None), *neuron)\n ]\n )\n sal_vals = input_attrib.attribute(test_input, abs=False)\n grad_vals = gradient_attrib.attribute(test_input, neuron)\n # Verify matching sizes\n self.assertEqual(grad_vals.shape, sal_vals.shape)\n self.assertEqual(grad_vals.shape, test_input.shape)\n assertArraysAlmostEqual(\n sal_vals.reshape(-1).tolist(),\n grad_vals.reshape(-1).tolist(),\n delta=0.001,\n )\n\n\nif __name__ == \"__main__\":\n unittest.main()\n" ]

[ [ "torch.randn", "torch.tensor" ] ]

GregTheRick/Deep-Learning-for-Fast-Low-Light-Imaging

[ "c2a3f869f9e9a4691900962a0541b41fc17f2f0c" ]

[ "experiment_trainer_flip.py" ]

[ "from __future__ import division\nimport numpy as np\nimport tensorflow as tf\nfrom SIDLoader import SIDLoader\nfrom ModelBuilder import ModelBuilder\nfrom Experiment import Experiment\nimport time,datetime,os,glob\n\npath_prefix = '.'\ncheckpoint_dir = path_prefix+'/chk'\ndataset_dir = path_prefix+'/dataset'\nvalid_freq = 20\nseed = 1337\ntensorboard_dir = path_prefix+'/tensorboard'\n#Set initial seed\nnp.random.seed(seed)\n#Set up experiments\nexpList = []\nexpList.append(Experiment(name='cchen_sony_flip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp},device=\"/device:GPU:0\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='unet_s_sony_flip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp},device=\"/device:GPU:1\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='deep_isp_flip',model_fn={'fn':ModelBuilder.build_deep_isp_exp},device=\"/device:GPU:2\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='cchen_resize_sony_flip',model_fn={'fn':ModelBuilder.build_cchen_sony_exp_resize},device=\"/device:GPU:3\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\nexpList.append(Experiment(name='unet_s_resize_sony_flip',model_fn={'fn':ModelBuilder.build_unet_s_sony_exp_resize},device=\"/device:GPU:4\",tensorboard_dir=tensorboard_dir,checkpoint_dir=checkpoint_dir))\n\n\n#Load flat matrix\ndataset = SIDLoader(dataset_dir, patch_fn=SIDLoader.patch_flip_unprocessed_sony,keep_raw=True,keep_gt=True)\nvalidSet = None\n#Get epoch from first experiment\nepoch = expList[0].epoch\ndataset.writeEpoch = epoch\ndataset.readEpoch = epoch\ndataset.start()\nlearning_rate = 1e-4\ntry:\n #train loop\n for exp in expList:\n exp.begin_train_cycle()\n while(epoch < 300):\n if(epoch >= 149):\n learning_rate = 1e-5\n #Get batch from batchloader\n (x,y,r) = dataset.get_batch()\n #start running training step on each GPU\n for exp in expList:\n exp.train_action(x,y,r,learning_rate)\n #Wait for all to finish\n for exp in expList:\n exp.finish_train_action()\n epoch = dataset.readEpoch\n\n if(dataset.readC == 0): #It is the end of the epoch\n for exp in expList:\n exp.end_of_epoch_train(epoch)\n #Validate\n if(epoch%valid_freq == 0):\n if(validSet == None):\n validSet = SIDLoader(dataset_dir, patch_fn=None,keep_raw=True,keep_gt=True, set_id='valid')\n validSet.start()\n validSet.readEpoch = dataset.readEpoch-1\n validSet.writeEpoch = dataset.readEpoch-1\n vepoch = validSet.readEpoch\n for exp in expList:\n exp.begin_valid_cycle(epoch)\n while(vepoch < epoch):\n (x,y,r) = validSet.get_batch()\n for exp in expList:\n exp.valid_action(x,y,r)\n for exp in expList:\n exp.finish_valid_action()\n vepoch = validSet.readEpoch\n if(validSet.readC == 0):\n #get validation epoch summaries\n for exp in expList:\n exp.end_of_epoch_valid(epoch)\n \nexcept KeyboardInterrupt:\n print('Keyboard interrupt accepted. Shutting down')\nfinally:\n dataset.stop()\n if(validSet is not None):\n validSet.stop()\n for exp in expList:\n exp.finish_train_cycle()\n exp.model['sess'].close()" ]

[ [ "numpy.random.seed" ] ]

gwdgithubnom/monkey-clever

[ "05290c33f7f2cf1de752e68f99464b92c02a9faf" ]

[ "arithmetic4py/src/kmeans/ref/wire3d.py" ]

[ "#http://matplotlib.org/examples/mplot3d/wire3d_demo.html\nfrom mpl_toolkits.mplot3d import axes3d\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nX, Y, Z = axes3d.get_test_data(0.05)\nax.plot_wireframe(X, Y, Z, rstride=10, cstride=10)\n\nplt.show()" ]

[ [ "matplotlib.pyplot.show", "matplotlib.pyplot.figure" ] ]

vvanirudh/deluca

[ "673e66038547db90a7b23335cfe7508728076a4d" ]

[ "tests/utils/test_experiment.py" ]

[ "# Copyright 2020 Google LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"deluca/tests/utils/test_experiment.py\"\"\"\nimport jax\nimport numpy as np\nimport pytest\n\nfrom deluca.utils import Random\nfrom deluca.utils.experiment import experiment\n\nrandom = Random()\n\n\[email protected](\"shape\", [(), (1,), (1, 2), (1, 2, 3)])\[email protected](\"num_args\", [1, 2, 10])\ndef test_experiment(shape, num_args):\n \"\"\"Test normal experiment behavior\"\"\"\n args = [\n (\n jax.random.uniform(random.generate_key(), shape=shape),\n jax.random.uniform(random.generate_key(), shape=shape),\n )\n for _ in range(num_args)\n ]\n\n @experiment(\"a,b\", args)\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n results = dummy.run()\n print(results)\n for i in range(len(results)):\n np.testing.assert_array_almost_equal(results[i], np.sum(args[i], axis=0))\n\n\[email protected](\"times\", [1, 2, 10])\ndef test_experiment_call(times):\n \"\"\"Tests repeated decorator calls\"\"\"\n\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n for _ in range(times):\n dummy = experiment(\"a,b\", [(1, 2)])(dummy)\n dummy._func(1, 2)\n assert isinstance(dummy, experiment)\n\n\ndef test_experiment_duplicated_argname():\n \"\"\"Tests duplicated arguments\"\"\"\n with pytest.raises(ValueError):\n\n @experiment(\"a\", [1])\n @experiment(\"a,b\", [(1, 2)])\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n dummy._func(1, 2)\n dummy._validate()\n\n\ndef test_experiment_missing_argument():\n \"\"\"Test missing arguments\"\"\"\n with pytest.raises(ValueError):\n\n @experiment(\"a\", [1])\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n dummy._func(1, 2)\n dummy._validate()\n\n\ndef test_experiment_unused_arguments():\n \"\"\"Testing unused arguments\"\"\"\n with pytest.raises(ValueError):\n\n @experiment(\"a,b,c\", [(1, 2, 3)])\n def dummy(a, b):\n \"\"\"dummy\"\"\"\n return a + b\n\n dummy._func(1, 2)\n dummy._validate()\n\n\ndef test_experiment_list_args():\n \"\"\"Testing args as list\"\"\"\n\n @experiment([\"a\", \"b\"], [(1, 2)])\n def dummy(a, b):\n \"\"\"dummmy\"\"\"\n return a + b\n\n dummy.run()\n\n\ndef test_experiment_list_atoms():\n \"\"\"Testing atoms\"\"\"\n\n @experiment([\"a\"], [1])\n def dummy(a):\n \"\"\"dummy\"\"\"\n return a\n\n assert 1 == dummy.run()[0]\n" ]

[ [ "numpy.sum" ] ]

sachsanjoy/ezmist

[ "68afd231bd1323b33cd70ceff8a724b87e81cefa" ]

[ "ezmist/simpletable.py" ]

[ "\"\"\" This file implements a Table class\n that is designed to be the basis of any format\n\nRequirements\n------------\n\n* FIT format:\n * astropy:\n provides a replacement to pyfits\n pyfits can still be used instead but astropy is now the default\n\n* HDF5 format:\n * pytables\n\nRuntimeError will be raised when writing to a format associated with missing\npackage.\n\n\n.. code-block::python\n\n >>> t = SimpleTable('path/mytable.csv')\n # get a subset of columns only\n >>> s = t.get('M_* logTe logLo U B V I J K')\n # set some aliases\n >>> t.set_alias('logT', 'logTe')\n >>> t.set_alias('logL', 'logLLo')\n # make a query on one or multiple column\n >>> q = s.selectWhere('logT logL', '(J > 2) & (10 ** logT > 5000)')\n # q is also a table object\n >>> q.Plotter.plot('logT', 'logL', ',')\n # makes a simple plot (see :module:`plotter`)\n >>> s.write('newtable.fits')\n # export the initial subtable to a new file\n\"\"\"\nfrom __future__ import (absolute_import, division, print_function)\n\n__version__ = '3.0'\n__all__ = ['AstroHelpers', 'AstroTable', 'SimpleTable', 'stats']\n\nimport sys\nimport math\nfrom copy import deepcopy\nimport re\nimport itertools\nfrom functools import wraps, partial\nimport numpy as np\nfrom numpy import deg2rad, rad2deg, sin, cos, sqrt, arcsin, arctan2\nfrom numpy.lib import recfunctions\nimport types\n\ntry:\n from astropy.io import fits as pyfits\nexcept ImportError:\n import pyfits\nexcept:\n pyfits = None\n\ntry:\n import tables\nexcept ImportError:\n tables = None\n\ntry:\n import pandas as _pd\nexcept ImportError:\n _pd = None\n\ntry:\n from astropy.table import Table as _astropytable\nexcept ImportError:\n _astropytable = None\n\ntry:\n from .plotter import Plotter\nexcept ImportError:\n Plotter = None\n\n# ==============================================================================\n# Python 3 compatibility behavior\n# ==============================================================================\n# remap some python 2 built-ins on to py3k behavior or equivalent\n# Most of them become generators\nimport operator\n\nPY3 = sys.version_info[0] > 2\n\nif PY3:\n iteritems = operator.methodcaller('items')\n itervalues = operator.methodcaller('values')\n basestring = (str, bytes)\nelse:\n range = xrange\n from itertools import izip as zip\n iteritems = operator.methodcaller('iteritems')\n itervalues = operator.methodcaller('itervalues')\n basestring = (str, unicode)\n\n\n# ==============================================================================\n# Specials -- special functions\n# ==============================================================================\n\ndef pretty_size_print(num_bytes):\n \"\"\"\n Output number of bytes in a human readable format\n\n keywords\n --------\n num_bytes: int\n number of bytes to convert\n\n returns\n -------\n output: str\n string representation of the size with appropriate unit scale\n \"\"\"\n if num_bytes is None:\n return\n\n KiB = 1024\n MiB = KiB * KiB\n GiB = KiB * MiB\n TiB = KiB * GiB\n PiB = KiB * TiB\n EiB = KiB * PiB\n ZiB = KiB * EiB\n YiB = KiB * ZiB\n\n if num_bytes > YiB:\n output = '%.3g YB' % (num_bytes / YiB)\n elif num_bytes > ZiB:\n output = '%.3g ZB' % (num_bytes / ZiB)\n elif num_bytes > EiB:\n output = '%.3g EB' % (num_bytes / EiB)\n elif num_bytes > PiB:\n output = '%.3g PB' % (num_bytes / PiB)\n elif num_bytes > TiB:\n output = '%.3g TB' % (num_bytes / TiB)\n elif num_bytes > GiB:\n output = '%.3g GB' % (num_bytes / GiB)\n elif num_bytes > MiB:\n output = '%.3g MB' % (num_bytes / MiB)\n elif num_bytes > KiB:\n output = '%.3g KB' % (num_bytes / KiB)\n else:\n output = '%.3g Bytes' % (num_bytes)\n\n return output\n\n\ndef _fits_read_header(hdr):\n \"\"\"\n Convert pyfits header into dictionary with relevant values\n\n Parameters\n ----------\n\n hdr: pyftis.Header\n fits unit\n\n Returns\n -------\n header: dict\n header dictionary\n\n alias: dict\n aliases\n\n units: dict\n units\n\n comments: dict\n comments/description of keywords\n \"\"\"\n header = {}\n alias = {}\n units = {}\n comments = {}\n\n # generic cards\n genTerms = ['XTENSION', 'BITPIX', 'NAXIS', 'NAXIS1',\n 'NAXIS2', 'PCOUNT', 'GCOUNT', 'TFIELDS',\n 'EXTNAME']\n fieldTerms = ['TTYPE', 'TFORM', 'TUNIT', 'ALIAS']\n\n # read col comments\n # for k, name, comment in hdr.ascard['TTYPE*']:\n try:\n for card in hdr.cards['TTYPE*']:\n name = card.value\n comments[name] = card.comment\n u = hdr.get(card.keyword.replace('TYPE', 'UNIT'), None)\n if u is not None:\n units[name] = u\n\n # for k, val, _ in hdr.ascard['ALIAS*']:\n for card in hdr.cards['ALIAS*']:\n k = card.keyword\n val = card.value\n al, orig = val.split('=')\n alias[al] = orig\n except: #pyfits stsci\n for card in hdr.ascard['TTYPE*']:\n name = card.value\n comments[name] = card.comment\n u = hdr.get(card.key.replace('TYPE', 'UNIT'), None)\n if u is not None:\n units[name] = u\n\n # for k, val, _ in hdr.ascard['ALIAS*']:\n for card in hdr.ascard['ALIAS*']:\n k = card.key\n val = card.value\n al, orig = val.split('=')\n alias[al] = orig\n\n # other specific keywords: COMMENT, HISTORY\n header_comments = []\n header_history = []\n for k, v in hdr.items():\n if (k not in genTerms) and (k[:5] not in fieldTerms):\n if (k == 'COMMENT'):\n header_comments.append(v)\n elif (k == 'HISTORY'):\n header_history.append(v)\n else:\n header[k] = v\n\n # COMMENT, HISTORY polish\n if len(header_comments) > 0:\n header['COMMENT'] = '\\n'.join(header_comments)\n if len(header_history) > 0:\n header['HISTORY'] = '\\n'.join(header_history)\n\n if 'EXTNAME' in hdr:\n header['NAME'] = hdr['EXTNAME']\n\n return header, alias, units, comments\n\n\ndef _fits_generate_header(tab):\n \"\"\" Generate the corresponding fits Header that contains all necessary info\n\n Parameters\n ----------\n\n tab: SimpleTable instance\n table\n\n Returns\n -------\n hdr: pyfits.Header\n header instance\n \"\"\"\n # get column cards\n\n cards = []\n\n # names units and comments\n for e, k in enumerate(tab.keys()):\n cards.append(('TTYPE{0:d}'.format(e + 1), k, tab._desc.get(k, '')))\n u = tab._units.get(k, '')\n if u not in ['', 'None', None]:\n cards.append(('TUNIT{0:d}'.format(e + 1), tab._units.get(k, ''),\n 'unit of {0:s}'.format(k)))\n\n # add aliases\n for e, v in enumerate(tab._aliases.items()):\n cards.append( ('ALIAS{0:d}'.format(e + 1), '='.join(v), '') )\n\n if tab.header['NAME'] not in ['', 'None', None, 'No Name']:\n cards.append(('EXTNAME', tab.header['NAME'], ''))\n\n hdr = pyfits.Header(cards)\n\n for k, v in tab.header.items():\n if (v not in ['', 'None', None]) & (k != 'NAME'):\n if (k != 'COMMENT') & (k != 'HISTORY'):\n hdr.update(k, v)\n else:\n txt = v.split('\\n')\n for j in txt:\n if k == 'COMMENT':\n hdr.add_comment(j)\n elif k == 'HISTORY':\n hdr.add_history(j)\n return hdr\n\n\ndef _fits_writeto(filename, data, header=None, output_verify='exception',\n clobber=False, checksum=False):\n \"\"\"\n Create a new FITS file using the supplied data/header.\n Patched version of pyfits to correctly include provided header\n\n Parameters\n ----------\n filename : file path, file object, or file like object\n File to write to. If opened, must be opened in a writeable binary\n mode such as 'wb' or 'ab+'.\n\n data : array, record array, or groups data object\n data to write to the new file\n\n header : `Header` object, optional\n the header associated with ``data``. If `None`, a header\n of the appropriate type is created for the supplied data. This\n argument is optional.\n\n output_verify : str\n Output verification option. Must be one of ``\"fix\"``, ``\"silentfix\"``,\n ``\"ignore\"``, ``\"warn\"``, or ``\"exception\"``. May also be any\n combination of ``\"fix\"`` or ``\"silentfix\"`` with ``\"+ignore\"``,\n ``+warn``, or ``+exception\" (e.g. ``\"fix+warn\"``). See :ref:`verify`\n for more info.\n\n clobber : bool, optional\n If `True`, and if filename already exists, it will overwrite\n the file. Default is `False`.\n\n checksum : bool, optional\n If `True`, adds both ``DATASUM`` and ``CHECKSUM`` cards to the\n headers of all HDU's written to the file\n \"\"\"\n\n hdu = pyfits.convenience._makehdu(data, header)\n hdu.header.update(header.cards)\n if hdu.is_image and not isinstance(hdu, pyfits.PrimaryHDU):\n hdu = pyfits.PrimaryHDU(data, header=header)\n hdu.writeto(filename, clobber=clobber, output_verify=output_verify,\n checksum=checksum)\n\n\ndef _fits_append(filename, data, header=None, checksum=False, verify=True,\n **kwargs):\n \"\"\"\n Append the header/data to FITS file if filename exists, create if not.\n\n If only ``data`` is supplied, a minimal header is created.\n Patched version of pyfits to correctly include provided header\n\n Parameters\n ----------\n filename : file path, file object, or file like object\n File to write to. If opened, must be opened for update (rb+) unless it\n is a new file, then it must be opened for append (ab+). A file or\n `~gzip.GzipFile` object opened for update will be closed after return.\n\n data : array, table, or group data object\n the new data used for appending\n\n header : `Header` object, optional\n The header associated with ``data``. If `None`, an appropriate header\n will be created for the data object supplied.\n\n checksum : bool, optional\n When `True` adds both ``DATASUM`` and ``CHECKSUM`` cards to the header\n of the HDU when written to the file.\n\n verify : bool, optional\n When `True`, the existing FITS file will be read in to verify it for\n correctness before appending. When `False`, content is simply appended\n to the end of the file. Setting ``verify`` to `False` can be much\n faster.\n\n kwargs\n Any additional keyword arguments to be passed to\n `astropy.io.fits.open`.\n \"\"\"\n\n name, closed, noexist_or_empty = pyfits.convenience._stat_filename_or_fileobj(filename)\n\n if noexist_or_empty:\n #\n # The input file or file like object either doesn't exits or is\n # empty. Use the writeto convenience function to write the\n # output to the empty object.\n #\n _fits_writeto(filename, data, header, checksum=checksum, **kwargs)\n else:\n hdu = pyfits.convenience._makehdu(data, header)\n hdu.header.update(header.cards)\n\n if isinstance(hdu, pyfits.PrimaryHDU):\n hdu = pyfits.ImageHDU(data, header)\n\n if verify or not closed:\n f = pyfits.convenience.fitsopen(filename, mode='append')\n f.append(hdu)\n\n # Set a flag in the HDU so that only this HDU gets a checksum when\n # writing the file.\n hdu._output_checksum = checksum\n f.close(closed=closed)\n else:\n f = pyfits.convenience._File(filename, mode='append')\n hdu._output_checksum = checksum\n hdu._writeto(f)\n f.close()\n\n\ndef _ascii_read_header(fname, comments='#', delimiter=None, commentedHeader=True,\n *args, **kwargs):\n \"\"\"\n Read ASCII/CSV header\n\n Parameters\n ----------\n fname: str or stream\n File, filename, or generator to read.\n Note that generators should return byte strings for Python 3k.\n\n comments: str, optional\n The character used to indicate the start of a comment;\n default: '#'.\n\n delimiter: str, optional\n The string used to separate values. By default, this is any\n whitespace.\n\n commentedHeader: bool, optional\n if set, the last line of the header is expected to be the column titles\n\n Returns\n -------\n nlines: int\n number of lines from the header\n\n header: dict\n header dictionary\n\n alias: dict\n aliases\n\n units: dict\n units\n\n comments: dict\n comments/description of keywords\n\n names: sequence\n sequence or str, first data line after header, expected to be the column\n names.\n \"\"\"\n if hasattr(fname, 'read'):\n stream = fname\n else:\n stream = open(fname, 'r')\n\n header = {}\n alias = {}\n units = {}\n desc = {}\n\n def parseStrNone(v):\n \"\"\" robust parse \"\"\"\n _v = v.split()\n if (len(_v) == 0):\n return None\n else:\n _v = ' '.join(_v)\n if (_v.lower()) == 'none' or (_v.lower() == 'null'):\n return None\n else:\n return _v\n\n done = False\n oldline = None\n lasthdr = None\n nlines = 0\n header.setdefault('COMMENT', '')\n header.setdefault('HISTORY', '')\n while done is False:\n line = stream.readline()[:-1] # getting rid of '\\n'\n nlines += 1\n if (line[0] == comments): # header part\n if (len(line) > 2):\n if line[1] == comments: # column meta data\n # column meta is expected to start with ##\n k = line[2:].split('\\t')\n colname = k[0].strip()\n colunit = None\n colcomm = None\n if len(k) > 1:\n colunit = parseStrNone(k[1])\n if len(k) > 2:\n colcomm = parseStrNone(k[2])\n\n if colunit is not None:\n units[colname] = colunit\n if colcomm is not None:\n desc[colname] = colcomm\n else:\n # header is expected as \"# key \\t value\"\n k = line[1:].split('\\t')\n if len(k) > 1:\n key = k[0].strip() # remove trainling spaces\n val = ' '.join(k[1:]).strip()\n\n if key in ('', None, 'None', 'NONE', 'COMMENT'):\n header['COMMENT'] = header['COMMENT'] + '\\n' + val\n if key in ('HISTORY', ):\n header['HISTORY'] = header['HISTORY'] + '\\n' + val\n elif 'alias' in key.lower():\n # take care of aliases\n al, orig = val.split('=')\n alias[al] = orig\n else:\n header[key] = val\n lasthdr = key\n else:\n header['COMMENT'] = header['COMMENT'] + '\\n' + line[1:]\n else:\n done = True\n if commentedHeader and (oldline is not None):\n names = oldline.split(delimiter)\n nlines -= 1\n if lasthdr == names[0]:\n header.pop(lasthdr)\n else:\n names = line.split(delimiter)\n oldline = line[1:]\n\n if not hasattr(fname, 'read'):\n stream.close()\n else:\n stream.seek(stream.tell() - len(line))\n nlines = 0 # make sure the value is set to the current position\n\n return nlines, header, units, desc, alias, names\n\n\ndef _hdf5_write_data(filename, data, tablename=None, mode='w', append=False,\n header={}, units={}, comments={}, aliases={}, **kwargs):\n \"\"\" Write table into HDF format\n\n Parameters\n ----------\n filename : file path, or tables.File instance\n File to write to. If opened, must be opened and writable (mode='w' or 'a')\n\n data: recarray\n data to write to the new file\n\n tablename: str\n path of the node including table's name\n\n mode: str\n in ('w', 'a') mode to open the file\n\n append: bool\n if set, tends to append data to an existing table\n\n header: dict\n table header\n\n units: dict\n dictionary of units\n\n alias: dict\n aliases\n\n comments: dict\n comments/description of keywords\n\n .. note::\n other keywords are forwarded to :func:`tables.open_file`\n \"\"\"\n\n if hasattr(filename, 'read'):\n raise Exception(\"HDF backend does not implement stream\")\n\n if append is True:\n mode = 'a'\n silent = kwargs.pop('silent', False)\n\n if isinstance(filename, tables.File):\n if (filename.mode != mode) & (mode != 'r'):\n raise tables.FileModeError('The file is already opened in a different mode')\n hd5 = filename\n else:\n hd5 = tables.open_file(filename, mode=mode)\n\n # check table name and path\n tablename = tablename or header.get('NAME', None)\n if tablename in ('', None, 'Noname', 'None'):\n tablename = '/data'\n\n w = tablename.split('/')\n where = '/'.join(w[:-1])\n name = w[-1]\n if where in ('', None):\n where = '/'\n if where[0] != '/':\n where = '/' + where\n\n if append:\n try:\n t = hd5.get_node(where + name)\n t.append(data.astype(t.description._v_dtype))\n t.flush()\n except tables.NoSuchNodeError:\n if not silent:\n print((\"Warning: Table {0} does not exists. \\n A new table will be created\").format(where + name))\n append = False\n\n if not append:\n t = hd5.createTable(where, name, data, **kwargs)\n\n # update header\n for k, v in header.items():\n if (k == 'FILTERS') & (float(t.attrs['VERSION']) >= 2.0):\n t.attrs[k.lower()] = v\n else:\n t.attrs[k] = v\n if 'TITLE' not in header:\n t.attrs['TITLE'] = name\n\n # add column descriptions and units\n for e, colname in enumerate(data.dtype.names):\n _u = units.get(colname, None)\n _d = comments.get(colname, None)\n if _u is not None:\n t.attrs['FIELD_{0:d}_UNIT'] = _u\n if _d is not None:\n t.attrs['FIELD_{0:d}_DESC'] = _d\n\n # add aliases\n for i, (k, v) in enumerate(aliases.items()):\n t.attrs['ALIAS{0:d}'.format(i)] = '{0:s}={1:s}'.format(k, v)\n\n t.flush()\n\n if not isinstance(filename, tables.File):\n hd5.flush()\n hd5.close()\n\n\ndef _hdf5_read_data(filename, tablename=None, silent=False, *args, **kwargs):\n \"\"\" Generate the corresponding ascii Header that contains all necessary info\n\n Parameters\n ----------\n filename: str\n file to read from\n\n tablename: str\n node containing the table\n\n silent: bool\n skip verbose messages\n\n Returns\n -------\n hdr: str\n string that will be be written at the beginning of the file\n \"\"\"\n source = tables.open_file(filename, *args, **kwargs)\n\n if tablename is None:\n node = source.listNodes('/')[0]\n tablename = node.name\n else:\n if tablename[0] != '/':\n node = source.get_node('/' + tablename)\n else:\n node = source.get_node(tablename)\n if not silent:\n print(\"\\tLoading table: {0}\".format(tablename))\n\n hdr = {}\n aliases = {}\n\n # read header\n exclude = ['NROWS', 'VERSION', 'CLASS', 'EXTNAME', 'TITLE']\n for k in node.attrs._v_attrnames:\n if (k not in exclude):\n if (k[:5] != 'FIELD') & (k[:5] != 'ALIAS'):\n hdr[k] = node.attrs[k]\n elif k[:5] == 'ALIAS':\n c0, c1 = node.attrs[k].split('=')\n aliases[c0] = c1\n\n empty_name = ['', 'None', 'Noname', None]\n if node.attrs['TITLE'] not in empty_name:\n hdr['NAME'] = node.attrs['TITLE']\n else:\n hdr['NAME'] = '{0:s}/{1:s}'.format(filename, node.name)\n\n # read column meta\n units = {}\n desc = {}\n\n for (k, colname) in enumerate(node.colnames):\n _u = getattr(node.attrs, 'FIELD_{0:d}_UNIT'.format(k), None)\n _d = getattr(node.attrs, 'FIELD_{0:d}_DESC'.format(k), None)\n if _u is not None:\n units[colname] = _u\n if _d is not None:\n desc[colname] = _d\n\n data = node[:]\n\n source.close()\n\n return hdr, aliases, units, desc, data\n\n\ndef _ascii_generate_header(tab, comments='#', delimiter=' ',\n commentedHeader=True):\n \"\"\" Generate the corresponding ascii Header that contains all necessary info\n\n Parameters\n ----------\n\n tab: SimpleTable instance\n table\n\n comments: str\n string to prepend header lines\n\n delimiter: str, optional\n The string used to separate values. By default, this is any\n whitespace.\n\n commentedHeader: bool, optional\n if set, the last line of the header is expected to be the column titles\n\n Returns\n -------\n hdr: str\n string that will be be written at the beginning of the file\n \"\"\"\n hdr = []\n\n if comments is None:\n comments = ''\n\n # table header\n length = max(map(len, tab.header.keys()))\n fmt = '{{0:s}} {{1:{0:d}s}}\\t{{2:s}}'.format(length)\n for k, v in tab.header.items():\n for vk in v.split('\\n'):\n if len(vk) > 0:\n hdr.append(fmt.format(comments, k.upper(), vk.strip()))\n\n # column metadata\n hdr.append(comments) # add empty line\n length = max(map(len, tab.keys()))\n fmt = '{{0:s}}{{0:s}} {{1:{0:d}s}}\\t{{2:s}}\\t{{3:s}}'.format(length)\n for colname in tab.keys():\n unit = tab._units.get(colname, 'None')\n desc = tab._desc.get(colname, 'None')\n hdr.append(fmt.format(comments, colname, unit, desc))\n\n # aliases\n if len(tab._aliases) > 0:\n hdr.append(comments) # add empty line\n for k, v in tab._aliases.items():\n hdr.append('{0:s} alias\\t{1:s}={2:s}'.format(comments, k, v))\n\n # column names\n hdr.append(comments)\n if commentedHeader:\n hdr.append('{0:s} {1:s}'.format(comments, delimiter.join(tab.keys())))\n else:\n hdr.append('{0:s}'.format(delimiter.join(tab.keys())))\n\n return '\\n'.join(hdr)\n\n\ndef _latex_writeto(filename, tab, comments='%'):\n \"\"\" Write the data into a latex table format\n\n Parameters\n ----------\n filename: str\n file or unit to write into\n\n tab: SimpleTable instance\n table\n\n comments: str\n string to prepend header lines\n\n delimiter: str, optional\n The string used to separate values. By default, this is any\n whitespace.\n\n commentedHeader: bool, optional\n if set, the last line of the header is expected to be the column titles\n \"\"\"\n txt = \"\\\\begin{table}\\n\\\\begin{center}\\n\"\n\n # add caption\n tabname = tab.header.get('NAME', None)\n if tabname not in ['', None, 'None']:\n txt += \"\\\\caption{{{0:s}}}\\n\".format(tabname)\n\n # tabular\n txt += '\\\\begin{{tabular}}{{{0:s}}}\\n'.format('c' * tab.ncols)\n txt += tab.pprint(delim=' & ', fields='MAG*', headerChar='', endline='\\\\\\\\\\n', all=True, ret=True)\n txt += '\\\\end{tabular}\\n'\n\n # end table\n txt += \"\\\\end{center}\\n\"\n\n # add notes if any\n if len(tab._desc) > 0:\n txt += '\\% notes \\n\\\\begin{scriptsize}\\n'\n for e, (k, v) in enumerate(tab._desc.items()):\n if v not in (None, 'None', 'none', ''):\n txt += '{0:d} {1:s}: {2:s} \\\\\\\\\\n'.format(e, k, v)\n txt += '\\\\end{scriptsize}\\n'\n txt += \"\\\\end{table}\\n\"\n if hasattr(filename, 'write'):\n filename.write(txt)\n else:\n with open(filename, 'w') as unit:\n unit.write(txt)\n\n\ndef _convert_dict_to_structured_ndarray(data):\n \"\"\"convert_dict_to_structured_ndarray\n\n Parameters\n ----------\n\n data: dictionary like object\n data structure which provides iteritems and itervalues\n\n returns\n -------\n tab: structured ndarray\n structured numpy array\n \"\"\"\n newdtype = []\n try:\n for key, dk in iteritems(data):\n _dk = np.asarray(dk)\n dtype = _dk.dtype\n # unknown type is converted to text\n if dtype.type == np.object_:\n if len(data) == 0:\n longest = 0\n else:\n longest = len(max(_dk, key=len))\n _dk = _dk.astype('|%iS' % longest)\n if _dk.ndim > 1:\n newdtype.append((str(key), _dk.dtype, (_dk.shape[1],)))\n else:\n newdtype.append((str(key), _dk.dtype))\n tab = np.rec.fromarrays(itervalues(data), dtype=newdtype)\n except AttributeError: # not a dict\n # hope it's a tuple ((key, value),) pairs.\n from itertools import tee\n d1, d2 = tee(data)\n for key, dk in d1:\n _dk = np.asarray(dk)\n dtype = _dk.dtype\n # unknown type is converted to text\n if dtype.type == np.object_:\n if len(data) == 0:\n longest = 0\n else:\n longest = len(max(_dk, key=len))\n _dk = _dk.astype('|%iS' % longest)\n if _dk.ndim > 1:\n newdtype.append((str(key), _dk.dtype, (_dk.shape[1],)))\n else:\n newdtype.append((str(key), _dk.dtype))\n tab = np.rec.fromarrays((dk for (_, dk) in d2), dtype=newdtype)\n\n return tab\n\n\ndef __indent__(rows, header=None, units=None, headerChar='-',\n delim=' | ', endline='\\n', **kwargs):\n \"\"\"Indents a table by column.\n\n Parameters\n ----------\n rows: sequences of rows\n one sequence per row.\n\n header: sequence of str\n row consists of the columns' names\n\n units: sequence of str\n Sequence of units\n\n headerChar: char\n Character to be used for the row separator line\n\n delim: char\n The column delimiter.\n\n returns\n -------\n txt: str\n string represation of rows\n \"\"\"\n length_data = list(map(max, zip(*[list(map(len, k)) for k in rows])))\n length = length_data[:]\n\n if (header is not None):\n length_header = list(map(len, header))\n length = list(map(max, zip(length_data, length_header)))\n\n if (units is not None):\n length_units = list(map(len, units))\n length = list(map(max, zip(length_data, length_units)))\n\n if headerChar not in (None, '', ' '):\n rowSeparator = headerChar * (sum(length) + len(delim) * (len(length) - 1)) + endline\n else:\n rowSeparator = ''\n\n # make the format\n fmt = ['{{{0:d}:{1:d}s}}'.format(k, l) for (k, l) in enumerate(length)]\n fmt = delim.join(fmt) + endline\n # write the string\n txt = rowSeparator\n if header is not None:\n txt += fmt.format(*header) # + endline\n txt += rowSeparator\n if units is not None:\n txt += fmt.format(*units) # + endline\n txt += rowSeparator\n for r in rows:\n txt += fmt.format(*r) # + endline\n txt += rowSeparator\n return txt\n\n\ndef pprint_rec_entry(data, num=0, keys=None):\n \"\"\" print one line with key and values properly to be readable\n\n Parameters\n ----------\n data: recarray\n data to extract entry from\n\n num: int, slice\n indice selection\n\n keys: sequence or str\n if str, can be a regular expression\n if sequence, the sequence of keys to print\n \"\"\"\n if (keys is None) or (keys == '*'):\n _keys = data.dtype.names\n elif type(keys) in basestring:\n _keys = [k for k in data.dtype.names if (re.match(keys, k) is not None)]\n else:\n _keys = keys\n\n length = max(map(len, _keys))\n fmt = '{{0:{0:d}s}}: {{1}}'.format(length)\n data = data[num]\n\n for k in _keys:\n print(fmt.format(k, data[k]))\n\n\ndef pprint_rec_array(data, idx=None, fields=None, ret=False, all=False,\n headerChar='-', delim=' | ', endline='\\n' ):\n \"\"\" Pretty print the table content\n you can select the table parts to display using idx to\n select the rows and fields to only display some columns\n (ret is only for insternal use)\n\n Parameters\n ----------\n data: array\n array to show\n\n idx: sequence, slide\n sub selection to print\n\n fields: str, sequence\n if str can be a regular expression, and/or list of fields separated\n by spaces or commas\n\n ret: bool\n if set return the string representation instead of printing the result\n\n all: bool\n if set, force to show all rows\n\n headerChar: char\n Character to be used for the row separator line\n\n delim: char\n The column delimiter.\n \"\"\"\n if (fields is None) or (fields == '*'):\n _keys = data.dtype.names\n elif type(fields) in basestring:\n if ',' in fields:\n _fields = fields.split(',')\n elif ' ' in fields:\n _fields = fields.split()\n else:\n _fields = [fields]\n lbls = data.dtype.names\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (re.match(_fk, k) is not None)]\n else:\n lbls = data.dtype.names\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (re.match(_fk, k) is not None)]\n\n nfields = len(_keys)\n nrows = len(data)\n fields = list(_keys)\n\n if idx is None:\n if (nrows < 10) or (all is True):\n rows = [ [ str(data[k][rk]) for k in _keys ] for rk in range(nrows)]\n else:\n _idx = range(6)\n rows = [ [ str(data[k][rk]) for k in _keys ] for rk in range(5) ]\n if nfields > 1:\n rows += [ ['...' for k in range(nfields) ] ]\n else:\n rows += [ ['...' for k in range(nfields) ] ]\n rows += [ [ str(data[k][rk]) for k in fields ] for rk in range(-5, 0)]\n elif isinstance(idx, slice):\n _idx = range(idx.start, idx.stop, idx.step or 1)\n rows = [ [ str(data[k][rk]) for k in fields ] for rk in _idx]\n else:\n rows = [ [ str(data[k][rk]) for k in fields ] for rk in idx]\n\n out = __indent__(rows, header=_keys, units=None, delim=delim,\n headerChar=headerChar, endline=endline)\n if ret is True:\n return out\n else:\n print(out)\n\n\ndef elementwise(func):\n \"\"\"\n Quick and dirty elementwise function decorator it provides a quick way\n to apply a function either on one element or a sequence of elements\n \"\"\"\n @wraps(func)\n def wrapper(it, **kwargs):\n if hasattr(it, '__iter__') & (type(it) not in basestring):\n _f = partial(func, **kwargs)\n return map(_f, it)\n else:\n return func(it, **kwargs)\n return wrapper\n\n\nclass AstroHelpers(object):\n \"\"\" Helpers related to astronomy data \"\"\"\n\n @staticmethod\n @elementwise\n def hms2deg(_str, delim=':'):\n \"\"\" Convert hex coordinates into degrees\n\n Parameters\n ----------\n str: string or sequence\n string to convert\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n deg: float\n angle in degrees\n \"\"\"\n if _str[0] == '-':\n neg = -1\n _str = _str[1:]\n else:\n neg = 1\n _str = _str.split(delim)\n return neg * ((((float(_str[-1]) / 60. +\n float(_str[1])) / 60. +\n float(_str[0])) / 24. * 360.))\n\n @staticmethod\n @elementwise\n def deg2dms(val, delim=':'):\n \"\"\" Convert degrees into hex coordinates\n\n Parameters\n ----------\n deg: float\n angle in degrees\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n str: string or sequence\n string to convert\n \"\"\"\n if val < 0:\n sign = -1\n else:\n sign = 1\n d = int( sign * val )\n m = int( (sign * val - d) * 60. )\n s = (( sign * val - d) * 60. - m) * 60.\n return '{0}{1}{2}{3}{4}'.format( sign * d, delim, m, delim, s)\n\n @staticmethod\n @elementwise\n def deg2hms(val, delim=':'):\n \"\"\" Convert degrees into hex coordinates\n\n Parameters\n ----------\n deg: float\n angle in degrees\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n str: string or sequence\n string to convert\n \"\"\"\n if val < 0:\n sign = -1\n else:\n sign = 1\n h = int( sign * val / 45. * 3.) # * 24 / 360\n m = int( (sign * val / 45. * 3. - h) * 60. )\n s = (( sign * val / 45. * 3. - h) * 60. - m) * 60.\n return '{0}{1}{2}{3}{4}'.format( sign * h, delim, m, delim, s)\n\n @staticmethod\n @elementwise\n def dms2deg(_str, delim=':'):\n \"\"\" Convert hex coordinates into degrees\n\n Parameters\n ----------\n str: string or sequence\n string to convert\n\n delimiter: str\n character delimiting the fields\n\n Returns\n -------\n deg: float\n angle in degrees\n \"\"\"\n if _str[0] == '-':\n neg = -1\n _str = _str[1:]\n else:\n neg = 1\n _str = _str.split(delim)\n return (neg * ((float(_str[-1]) / 60. + float(_str[1])) / 60. + float(_str[0])))\n\n @staticmethod\n @elementwise\n def euler(ai_in, bi_in, select, b1950=False, dtype='f8'):\n \"\"\"\n Transform between Galactic, celestial, and ecliptic coordinates.\n Celestial coordinates (RA, Dec) should be given in equinox J2000\n unless the b1950 is True.\n\n +-------+--------------+------------+----------+----------+-----------+\n |select | From | To | select | From | To |\n +-------+--------------+------------+----------+----------+-----------+\n |1 |RA-Dec (2000) | Galactic | 4 | Ecliptic | RA-Dec |\n +-------+--------------+------------+----------+----------+-----------+\n |2 |Galactic | RA-DEC | 5 | Ecliptic | Galactic |\n +-------+--------------+------------+----------+----------+-----------+\n |3 |RA-Dec | Ecliptic | 6 | Galactic | Ecliptic |\n +-------+--------------+------------+----------+----------+-----------+\n\n Parameters\n ----------\n\n long_in: float, or sequence\n Input Longitude in DEGREES, scalar or vector.\n\n lat_in: float, or sequence\n Latitude in DEGREES\n\n select: int\n Integer from 1 to 6 specifying type of coordinate transformation.\n\n b1950: bool\n set equinox set to 1950\n\n\n Returns\n -------\n long_out: float, seq\n Output Longitude in DEGREES\n\n lat_out: float, seq\n Output Latitude in DEGREES\n\n\n .. note::\n\n Written W. Landsman, February 1987\n Adapted from Fortran by Daryl Yentis NRL\n Converted to IDL V5.0 W. Landsman September 1997\n Made J2000 the default, added /FK4 keyword W. Landsman December 1998\n Add option to specify SELECT as a keyword W. Landsman March 2003\n Converted from IDL to numerical Python: Erin Sheldon, NYU, 2008-07-02\n \"\"\"\n\n # Make a copy as an array. ndmin=1 to avoid messed up scalar arrays\n ai = np.array(ai_in, ndmin=1, copy=True, dtype=dtype)\n bi = np.array(bi_in, ndmin=1, copy=True, dtype=dtype)\n\n PI = math.pi\n # HALFPI = PI / 2.0\n D2R = PI / 180.0\n R2D = 1.0 / D2R\n\n twopi = 2.0 * PI\n fourpi = 4.0 * PI\n\n # J2000 coordinate conversions are based on the following constants\n # (see the Hipparcos explanatory supplement).\n # eps = 23.4392911111d Obliquity of the ecliptic\n # alphaG = 192.85948d Right Ascension of Galactic North Pole\n # deltaG = 27.12825d Declination of Galactic North Pole\n # lomega = 32.93192d Galactic longitude of celestial equator\n # alphaE = 180.02322d Ecliptic longitude of Galactic North Pole\n # deltaE = 29.811438523d Ecliptic latitude of Galactic North Pole\n # Eomega = 6.3839743d Galactic longitude of ecliptic equator\n # Parameters for all the different conversions\n if b1950:\n # equinox = '(B1950)'\n psi = np.array([ 0.57595865315, 4.9261918136,\n 0.00000000000, 0.0000000000,\n 0.11129056012, 4.7005372834], dtype=dtype)\n stheta = np.array([ 0.88781538514, -0.88781538514,\n 0.39788119938, -0.39788119938,\n 0.86766174755, -0.86766174755], dtype=dtype)\n ctheta = np.array([ 0.46019978478, 0.46019978478,\n 0.91743694670, 0.91743694670,\n 0.49715499774, 0.49715499774], dtype=dtype)\n phi = np.array([ 4.9261918136, 0.57595865315,\n 0.0000000000, 0.00000000000,\n 4.7005372834, 0.11129056012], dtype=dtype)\n else:\n # equinox = '(J2000)'\n psi = np.array([ 0.57477043300, 4.9368292465,\n 0.00000000000, 0.0000000000,\n 0.11142137093, 4.71279419371], dtype=dtype)\n stheta = np.array([ 0.88998808748, -0.88998808748,\n 0.39777715593, -0.39777715593,\n 0.86766622025, -0.86766622025], dtype=dtype)\n ctheta = np.array([ 0.45598377618, 0.45598377618,\n 0.91748206207, 0.91748206207,\n 0.49714719172, 0.49714719172], dtype=dtype)\n phi = np.array([ 4.9368292465, 0.57477043300,\n 0.0000000000, 0.00000000000,\n 4.71279419371, 0.11142137093], dtype=dtype)\n\n # zero offset\n i = select - 1\n a = ai * D2R - phi[i]\n\n b = bi * D2R\n sb = sin(b)\n cb = cos(b)\n cbsa = cb * sin(a)\n b = -stheta[i] * cbsa + ctheta[i] * sb\n w, = np.where(b > 1.0)\n if w.size > 0:\n b[w] = 1.0\n bo = arcsin(b) * R2D\n a = arctan2( ctheta[i] * cbsa + stheta[i] * sb, cb * cos(a) )\n ao = ( (a + psi[i] + fourpi) % twopi) * R2D\n return ao, bo\n\n @staticmethod\n def sphdist(ra1, dec1, ra2, dec2):\n \"\"\"measures the spherical distance between 2 points\n\n Parameters\n ----------\n ra1: float or sequence\n first right ascensions in degrees\n\n dec1: float or sequence\n first declination in degrees\n ra2: float or sequence\n second right ascensions in degrees\n dec2: float or sequence\n first declination in degrees\n\n Returns\n -------\n Outputs: float or sequence\n returns a distance in degrees\n \"\"\"\n dec1_r = deg2rad(dec1)\n dec2_r = deg2rad(dec2)\n return 2. * rad2deg(arcsin(sqrt((sin((dec1_r - dec2_r) / 2)) ** 2 +\n cos(dec1_r) * cos(dec2_r) * (\n sin((deg2rad(ra1 - ra2)) / 2)) **\n 2)))\n\n @staticmethod\n def conesearch(ra0, dec0, ra, dec, r, outtype=0):\n \"\"\" Perform a cone search on a table\n\n Parameters\n ----------\n ra0: ndarray[ndim=1, dtype=float]\n column name to use as RA source in degrees\n\n dec0: ndarray[ndim=1, dtype=float]\n column name to use as DEC source in degrees\n\n ra: float\n ra to look for (in degree)\n\n dec: float\n ra to look for (in degree)\n\n r: float\n distance in degrees\n\n outtype: int\n type of outputs\n 0 -- minimal, indices of matching coordinates\n 1 -- indices and distances of matching coordinates\n 2 -- full, boolean filter and distances\n\n Returns\n -------\n t: tuple\n if outtype is 0:\n only return indices from ra0, dec0\n elif outtype is 1:\n return indices from ra0, dec0 and distances\n elif outtype is 2:\n return conditional vector and distance to all ra0, dec0\n \"\"\"\n @elementwise\n def getDist( pk ):\n \"\"\" get spherical distance between 2 points \"\"\"\n return AstroHelpers.sphdist(pk[0], pk[1], ra, dec)\n\n dist = np.array(list(getDist(zip(ra0, dec0))))\n v = (dist <= r)\n\n if outtype == 0:\n return np.ravel(np.where(v))\n elif outtype == 1:\n return np.ravel(np.where(v)), dist[v]\n else:\n return v, dist\n\n\n# ==============================================================================\n# SimpleTable -- provides table manipulations with limited storage formats\n# ==============================================================================\nclass SimpleTable(object):\n \"\"\" Table class that is designed to be the basis of any format wrapping\n around numpy recarrays\n\n Attributes\n ----------\n\n fname: str or object\n if str, the file to read from. This may be limited to the format\n currently handled automatically. If the format is not correctly handled,\n you can try by providing an object.__\n\n if object with a structure like dict, ndarray, or recarray-like\n the data will be encapsulated into a Table\n\n caseless: bool\n if set, column names will be caseless during operations\n\n aliases: dict\n set of column aliases (can be defined later :func:`set_alias`)\n\n units: dict\n set of column units (can be defined later :func:`set_unit`)\n\n desc: dict\n set of column description or comments (can be defined later :func:`set_comment`)\n\n header: dict\n key, value pair corresponding to the attributes of the table\n \"\"\"\n\n def __init__(self, fname, *args, **kwargs):\n\n dtype = kwargs.pop('dtype', None)\n dtype = kwargs.pop('format', dtype)\n self.caseless = kwargs.get('caseless', False)\n self._aliases = kwargs.get('aliases', {})\n self._units = kwargs.get('units', {})\n self._desc = kwargs.get('desc', {})\n\n if (isinstance(fname, (dict, tuple, list, types.GeneratorType))) or (dtype in [dict, 'dict']):\n try:\n self.header = fname.pop('header', {})\n except (AttributeError, TypeError):\n self.header = kwargs.pop('header', {})\n self.data = _convert_dict_to_structured_ndarray(fname)\n elif (type(fname) in basestring) or (dtype is not None):\n if (type(fname) in basestring):\n extension = fname.split('.')[-1]\n else:\n extension = None\n if (extension == 'csv') or dtype == 'csv':\n kwargs.setdefault('delimiter', ',')\n commentedHeader = kwargs.pop('commentedHeader', False)\n n, header, units, comments, aliases, names = _ascii_read_header(fname, commentedHeader=commentedHeader, **kwargs)\n if 'names' in kwargs:\n n -= 1\n kwargs.setdefault('names', names)\n if _pd is not None: # pandas is faster\n kwargs.setdefault('comment', '#')\n kwargs.setdefault('skiprows', n)\n self.data = _pd.read_csv(fname, *args, **kwargs).to_records()\n else:\n kwargs.setdefault('skip_header', n)\n kwargs.setdefault('comments', '#')\n self.data = np.recfromcsv(fname, *args, **kwargs)\n self.header = header\n self._units.update(**units)\n self._desc.update(**comments)\n self._aliases.update(**aliases)\n kwargs.setdefault('names', True)\n elif (extension in ('tsv', 'dat', 'txt')) or (dtype in ('tsv', 'dat', 'txt')):\n commentedHeader = kwargs.pop('commentedHeader', True)\n n, header, units, comments, aliases, names = _ascii_read_header(fname, commentedHeader=commentedHeader, **kwargs)\n kwargs.setdefault('names', names)\n if _pd is not None: # pandas is faster\n kwargs.setdefault('delimiter', '\\s+')\n kwargs.setdefault('comment', '#')\n self.data = _pd.read_csv(fname, *args, **kwargs).to_records()\n else:\n kwargs.setdefault('delimiter', None)\n kwargs.setdefault('comments', '#')\n kwargs.setdefault('skip_header', n)\n self.data = np.recfromtxt(fname, *args, **kwargs)\n self.header = header\n self._units.update(**units)\n self._desc.update(**comments)\n self._aliases.update(**aliases)\n elif (extension == 'fits') or dtype == 'fits':\n if pyfits is None:\n raise RuntimeError('Cannot read this format, Astropy or pyfits not found')\n if ('extname' not in kwargs) and ('ext' not in kwargs) and (len(args) == 0):\n args = (1, )\n self.data = np.array(pyfits.getdata(fname, *args, **kwargs))\n header, aliases, units, comments = _fits_read_header(pyfits.getheader(fname, *args, **kwargs))\n self.header = header\n self._desc.update(**comments)\n self._units.update(**units)\n self._aliases.update(**aliases)\n elif (extension in ('hdf5', 'hd5', 'hdf')) or (dtype in ('hdf5', 'hd5', 'hdf')):\n if tables is None:\n raise RuntimeError('Cannot read this format, pytables not found')\n hdr, aliases, units, desc, data = _hdf5_read_data(fname, *args, **kwargs)\n self.data = data\n self.header = hdr\n self._units.update(**units)\n self._desc.update(**desc)\n self._aliases.update(**aliases)\n elif (extension in ('vot', 'votable')) or (dtype in ('vot', 'votable')):\n # Votable case\n if _astropytable is None:\n raise RuntimeError('Cannot read this votable format, astropy not found')\n data = _astropytable.read(fname, format='votable', *args, **kwargs)\n units = [(k, data[k].unit.name) for k in data.keys()]\n desc = [(k, data[k].description) for k in data.keys()]\n self.data = data.as_array()\n self.header = {}\n self._units.update(units)\n self._desc.update(desc)\n else:\n raise Exception('Format {0:s} not handled'.format(extension))\n elif type(fname) == np.ndarray:\n self.data = fname\n self.header = {}\n elif type(fname) == pyfits.FITS_rec:\n self.data = np.array(fname)\n self.header = {}\n elif isinstance(fname, SimpleTable):\n cp = kwargs.pop('copy', True)\n if cp:\n self.data = deepcopy(fname.data)\n self.header = deepcopy(fname.header)\n self._aliases = deepcopy(fname._aliases)\n self._units = deepcopy(fname._units)\n self._desc = deepcopy(fname._desc)\n else:\n self.data = fname.data\n self.header = fname.header\n self._aliases = fname._aliases\n self._units = fname._units\n self._desc = fname._desc\n elif hasattr(fname, 'dtype'):\n self.data = np.array(fname)\n self.header = {}\n else:\n raise Exception('Type {0!s:s} not handled'.format(type(fname)))\n if 'NAME' not in self.header:\n if type(fname) not in basestring:\n self.header['NAME'] = 'No Name'\n else:\n self.header['NAME'] = fname\n\n def pprint_entry(self, num, keys=None):\n \"\"\" print one line with key and values properly to be readable\n\n Parameters\n ----------\n num: int, slice\n indice selection\n\n keys: sequence or str\n if str, can be a regular expression\n if sequence, the sequence of keys to print\n \"\"\"\n if (keys is None) or (keys == '*'):\n _keys = self.keys()\n elif type(keys) in basestring:\n _keys = [k for k in (self.keys() + tuple(self._aliases.keys()))\n if (re.match(keys, k) is not None)]\n else:\n _keys = keys\n\n length = max(map(len, _keys))\n fmt = '{{0:{0:d}s}}: {{1}}'.format(length)\n data = self[num]\n\n for k in _keys:\n print(fmt.format(k, data[self.resolve_alias(k)]))\n\n def pprint(self, idx=None, fields=None, ret=False, all=False,\n full_match=False, headerChar='-', delim=' | ', endline='\\n',\n **kwargs):\n \"\"\" Pretty print the table content\n you can select the table parts to display using idx to\n select the rows and fields to only display some columns\n (ret is only for insternal use)\n\n Parameters\n ----------\n\n idx: sequence, slide\n sub selection to print\n\n fields: str, sequence\n if str can be a regular expression, and/or list of fields separated\n by spaces or commas\n\n ret: bool\n if set return the string representation instead of printing the result\n\n all: bool\n if set, force to show all rows\n\n headerChar: char\n Character to be used for the row separator line\n\n delim: char\n The column delimiter.\n \"\"\"\n if full_match is True:\n fn = re.fullmatch\n else:\n fn = re.match\n\n if (fields is None) or (fields == '*'):\n _keys = self.keys()\n elif type(fields) in basestring:\n if ',' in fields:\n _fields = fields.split(',')\n elif ' ' in fields:\n _fields = fields.split()\n else:\n _fields = [fields]\n lbls = self.keys() + tuple(self._aliases.keys())\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (fn(_fk, k) is not None)]\n else:\n lbls = self.keys() + tuple(self._aliases.keys())\n _keys = []\n for _fk in _fields:\n _keys += [k for k in lbls if (fn(_fk, k) is not None)]\n\n nfields = len(_keys)\n\n fields = list(map( self.resolve_alias, _keys ))\n\n if idx is None:\n if (self.nrows < 10) or all:\n rows = [ [ str(self[k][rk]) for k in _keys ] for rk in range(self.nrows)]\n else:\n _idx = range(6)\n rows = [ [ str(self[k][rk]) for k in _keys ] for rk in range(5) ]\n if nfields > 1:\n rows += [ ['...' for k in range(nfields) ] ]\n else:\n rows += [ ['...' for k in range(nfields) ] ]\n rows += [ [ str(self[k][rk]) for k in fields ] for rk in range(-5, 0)]\n elif isinstance(idx, slice):\n _idx = range(idx.start, idx.stop, idx.step or 1)\n rows = [ [ str(self[k][rk]) for k in fields ] for rk in _idx]\n else:\n rows = [ [ str(self[k][rk]) for k in fields ] for rk in idx]\n\n if len(self._units) == 0:\n units = None\n else:\n units = [ '(' + str( self._units.get(k, None) or '') + ')' for k in fields ]\n\n out = __indent__(rows, header=_keys, units=units, delim=delim,\n headerChar=headerChar, endline=endline)\n if ret is True:\n return out\n else:\n print(out)\n\n def write(self, fname, **kwargs):\n \"\"\" write table into file\n\n Parameters\n ----------\n fname: str\n filename to export the table into\n\n .. note::\n additional keywords are forwarded to the corresponding libraries\n :func:`pyfits.writeto` or :func:`pyfits.append`\n :func:`np.savetxt`\n \"\"\"\n extension = kwargs.pop('extension', None)\n if extension is None:\n extension = fname.split('.')[-1]\n if (extension == 'csv'):\n comments = kwargs.pop('comments', '#')\n delimiter = kwargs.pop('delimiter', ',')\n commentedHeader = kwargs.pop('commentedHeader', False)\n hdr = _ascii_generate_header(self, comments=comments, delimiter=delimiter,\n commentedHeader=commentedHeader)\n header = kwargs.pop('header', hdr)\n np.savetxt(fname, self.data, delimiter=delimiter, header=header,\n comments='', **kwargs)\n elif (extension in ['txt', 'dat']):\n comments = kwargs.pop('comments', '#')\n delimiter = kwargs.pop('delimiter', ' ')\n commentedHeader = kwargs.pop('commentedHeader', True)\n hdr = _ascii_generate_header(self, comments=comments, delimiter=delimiter,\n commentedHeader=commentedHeader)\n header = kwargs.pop('header', hdr)\n np.savetxt(fname, self.data, delimiter=delimiter, header=header,\n comments='', **kwargs)\n elif (extension == 'fits'):\n hdr0 = kwargs.pop('header', None)\n append = kwargs.pop('append', False)\n hdr = _fits_generate_header(self)\n if hdr0 is not None:\n hdr.update(**hdr0)\n if append:\n _fits_append(fname, self.data, hdr, **kwargs)\n else:\n # patched version to correctly include the header\n _fits_writeto(fname, self.data, hdr, **kwargs)\n elif (extension in ('hdf', 'hdf5', 'hd5')):\n _hdf5_write_data(fname, self.data, header=self.header,\n units=self._units, comments=self._desc,\n aliases=self._aliases, **kwargs)\n else:\n raise Exception('Format {0:s} not handled'.format(extension))\n\n def to_records(self, **kwargs):\n \"\"\" Construct a numpy record array from this dataframe \"\"\"\n return self.data\n\n def to_pandas(self, **kwargs):\n \"\"\" Construct a pandas dataframe\n\n Parameters\n ----------\n data : ndarray \n (structured dtype), list of tuples, dict, or DataFrame\n keys: sequence, optional\n ordered subset of columns to export\n index : string, list of fields, array-like\n Field of array to use as the index, alternately a specific set of\n input labels to use\n exclude : sequence, default None\n Columns or fields to exclude\n columns : sequence, default None\n Column names to use. If the passed data do not have names\n associated with them, this argument provides names for the\n columns. Otherwise this argument indicates the order of the columns\n in the result (any names not found in the data will become all-NA\n columns)\n coerce_float : boolean, default False\n Attempt to convert values to non-string, non-numeric objects (like\n decimal.Decimal) to floating point, useful for SQL result sets\n\n Returns\n -------\n df : DataFrame\n \"\"\"\n try:\n from pandas import DataFrame\n keys = kwargs.pop('keys', None)\n return DataFrame.from_dict(self.to_dict(keys=keys), **kwargs)\n except ImportError as error:\n print(\"Pandas import error\")\n raise error\n\n def to_dict(self, keys=None, contiguous=False):\n \"\"\" Construct a dictionary from this dataframe with contiguous arrays\n\n Parameters\n ----------\n keys: sequence, optional\n ordered subset of columns to export\n\n contiguous: boolean\n make sure each value is a contiguous numpy array object\n (C-aligned)\n\n Returns\n -------\n data: dict\n converted data\n \"\"\"\n if keys is None:\n keys = self.keys()\n if contiguous:\n return {k: np.ascontiguousarray(self[k]) for k in keys}\n return {k: self[k] for k in keys}\n\n def to_xarray(self, **kwargs):\n \"\"\" Construct an xarray dataset\n\n Each column will be converted into an independent variable in the\n Dataset. If the dataframe's index is a MultiIndex, it will be expanded\n into a tensor product of one-dimensional indices (filling in missing\n values with NaN). This method will produce a Dataset very similar to\n that on which the 'to_dataframe' method was called, except with\n possibly redundant dimensions (since all dataset variables will have\n the same dimensionality).\n \"\"\"\n try:\n from xarray import Dataset\n return Dataset.from_dataframe(self.to_pandas(**kwargs))\n except ImportError as error:\n print(\"xray import error\")\n raise error\n\n def to_vaex(self, **kwargs):\n \"\"\"\n Create an in memory Vaex dataset\n\n Parameters\n ----------\n name: str\n unique for the dataset\n keys: sequence, optional\n ordered subset of columns to export\n\n Returns\n -------\n df: vaex.DataSetArrays\n vaex dataset\n \"\"\"\n try:\n import vaex\n return vaex.from_arrays(**self.to_dict(contiguous=True, **kwargs))\n except ImportError as error:\n print(\"Vaex import error\")\n raise error\n\n def to_dask(self, **kwargs):\n \"\"\" Construct a Dask DataFrame\n\n This splits an in-memory Pandas dataframe into several parts and constructs\n a dask.dataframe from those parts on which Dask.dataframe can operate in\n parallel.\n\n Note that, despite parallelism, Dask.dataframe may not always be faster\n than Pandas. We recommend that you stay with Pandas for as long as\n possible before switching to Dask.dataframe.\n\n Parameters\n ----------\n keys: sequence, optional\n ordered subset of columns to export\n npartitions : int, optional\n The number of partitions of the index to create. Note that depending on\n the size and index of the dataframe, the output may have fewer\n partitions than requested.\n chunksize : int, optional\n The size of the partitions of the index.\n sort: bool\n Sort input first to obtain cleanly divided partitions or don't sort and\n don't get cleanly divided partitions\n name: string, optional\n An optional keyname for the dataframe. Defaults to hashing the input\n\n Returns\n -------\n dask.DataFrame or dask.Series\n A dask DataFrame/Series partitioned along the index\n \"\"\"\n try:\n from dask import dataframe\n keys = kwargs.pop('keys', None)\n return dataframe.from_pandas(self.to_pandas(keys=keys), **kwargs)\n except ImportError as error:\n print(\"Dask import error\")\n raise error\n\n def to_astropy_table(self, **kwargs):\n \"\"\"\n A class to represent tables of heterogeneous data.\n\n `astropy.table.Table` provides a class for heterogeneous tabular data,\n making use of a `numpy` structured array internally to store the data\n values. A key enhancement provided by the `Table` class is the ability\n to easily modify the structure of the table by adding or removing\n columns, or adding new rows of data. In addition table and column\n metadata are fully supported.\n\n Parameters\n ----------\n masked : bool, optional\n Specify whether the table is masked.\n names : list, optional\n Specify column names\n dtype : list, optional\n Specify column data types\n meta : dict, optional\n Metadata associated with the table.\n copy : bool, optional\n Copy the input data (default=True).\n rows : numpy ndarray, list of lists, optional\n Row-oriented data for table instead of ``data`` argument\n copy_indices : bool, optional\n Copy any indices in the input data (default=True)\n **kwargs : dict, optional\n Additional keyword args when converting table-like object\n\n Returns\n -------\n df: astropy.table.Table\n dataframe\n \"\"\"\n try:\n from astropy.table import Table\n keys = kwargs.pop('keys', None)\n return Table(self.to_records(keys=keys), **kwargs)\n except ImportError as e:\n print(\"Astropy import error\")\n raise e\n\n def _repr_html_(self):\n return self.to_pandas().head()._repr_html_()\n\n def set_alias(self, alias, colname):\n \"\"\"\n Define an alias to a column\n\n Parameters\n ----------\n alias: str\n The new alias of the column\n\n colname: str\n The column being aliased\n \"\"\"\n if (colname not in self.keys()):\n raise KeyError(\"Column {0:s} does not exist\".format(colname))\n self._aliases[alias] = colname\n\n def reverse_alias(self, colname):\n \"\"\"\n Return aliases of a given column.\n\n Given a colname, return a sequence of aliases associated to this column\n Aliases are defined by using .define_alias()\n \"\"\"\n _colname = self.resolve_alias(colname)\n if (_colname not in self.keys()):\n raise KeyError(\"Column {0:s} does not exist\".format(colname))\n\n return tuple([ k for (k, v) in self._aliases.iteritems() if (v == _colname) ])\n\n def resolve_alias(self, colname):\n \"\"\"\n Return the name of an aliased column.\n\n Given an alias, return the column name it aliases. This\n function is a no-op if the alias is a column name itself.\n\n Aliases are defined by using .define_alias()\n \"\"\"\n # User aliases\n if hasattr(colname, '__iter__') & (type(colname) not in basestring):\n return [ self.resolve_alias(k) for k in colname ]\n else:\n if self.caseless is True:\n maps = dict( [ (k.lower(), v) for k, v in self._aliases.items() ] )\n maps.update( (k.lower(), k) for k in self.keys() )\n return maps.get(colname.lower(), colname)\n else:\n return self._aliases.get(colname, colname)\n\n def set_unit(self, colname, unit):\n \"\"\" Set the unit of a column referenced by its name\n\n Parameters\n ----------\n colname: str\n column name or registered alias\n\n unit: str\n unit description\n \"\"\"\n if isinstance(unit, basestring) and isinstance(colname, basestring):\n self._units[self.resolve_alias(colname)] = str(unit)\n else:\n for k, v in zip(colname, unit):\n self._units[self.resolve_alias(k)] = str(v)\n\n def set_comment(self, colname, comment):\n \"\"\" Set the comment of a column referenced by its name\n\n Parameters\n ----------\n colname: str\n column name or registered alias\n\n comment: str\n column description\n \"\"\"\n if isinstance(comment, basestring) and isinstance(colname, basestring):\n self._desc[self.resolve_alias(colname)] = str(comment)\n else:\n for k, v in zip(colname, comment):\n self._desc[self.resolve_alias(k)] = str(v)\n\n def keys(self, regexp=None, full_match=False):\n \"\"\"\n Return the data column names or a subset of it\n\n Parameters\n ----------\n regexp: str\n pattern to filter the keys with\n\n full_match: bool\n if set, use :func:`re.fullmatch` instead of :func:`re.match`\n\n Try to apply the pattern at the start of the string, returning\n a match object, or None if no match was found.\n\n returns\n -------\n seq: sequence\n sequence of keys\n \"\"\"\n if (regexp is None) or (regexp == '*'):\n return self.colnames\n elif type(regexp) in basestring:\n if full_match is True:\n fn = re.fullmatch\n else:\n fn = re.match\n\n if regexp.count(',') > 0:\n _re = regexp.split(',')\n elif regexp.count(' ') > 0:\n _re = regexp.split()\n else:\n _re = [regexp]\n\n lbls = self.colnames + tuple(self._aliases.keys())\n _keys = []\n for _rk in _re:\n _keys += [k for k in lbls if (fn(_rk, k) is not None)]\n\n return _keys\n elif hasattr(regexp, '__iter__'):\n _keys = []\n for k in regexp:\n _keys += self.keys(k)\n return _keys\n else:\n raise ValueError('Unexpected type {0} for regexp'.format(type(regexp)))\n\n @property\n def name(self):\n \"\"\" name of the table given by the Header['NAME'] attribute \"\"\"\n return self.header.get('NAME', None)\n\n @property\n def colnames(self):\n \"\"\" Sequence of column names \"\"\"\n return self.data.dtype.names\n\n @property\n def ncols(self):\n \"\"\" number of columns \"\"\"\n return len(self.colnames)\n\n @property\n def nrows(self):\n \"\"\" number of lines \"\"\"\n return len(self.data)\n\n @property\n def nbytes(self):\n \"\"\" number of bytes of the object \"\"\"\n n = sum(k.nbytes if hasattr(k, 'nbytes') else sys.getsizeof(k)\n for k in self.__dict__.values())\n return n\n\n def __len__(self):\n \"\"\" number of lines \"\"\"\n return self.nrows\n\n @property\n def shape(self):\n \"\"\" shape of the data \"\"\"\n return self.data.shape\n\n @property\n def dtype(self):\n \"\"\" dtype of the data \"\"\"\n return self.data.dtype\n\n @property\n def Plotter(self):\n \"\"\" Plotter instance related to this dataset.\n Requires plotter add-on to work \"\"\"\n if Plotter is None:\n raise AttributeError('the add-on was not found, this property is not available')\n else:\n return Plotter(self, label=self.name)\n\n def __getitem__(self, v):\n return np.asarray(self.data.__getitem__(self.resolve_alias(v)))\n\n def take(self, indices, axis=None, out=None, mode='raise'):\n \"\"\"\n Take elements from an array along an axis.\n\n This function does the same thing as \"fancy\" indexing (indexing arrays\n using arrays); however, it can be easier to use if you need elements\n along a given axis.\n\n Parameters\n ----------\n indices : array_like\n The indices of the values to extract.\n Also allow scalars for indices.\n\n axis : int, optional\n The axis over which to select values. By default, the flattened\n input array is used.\n\n out : ndarray, optional\n If provided, the result will be placed in this array. It should\n be of the appropriate shape and dtype.\n\n mode : {'raise', 'wrap', 'clip'}, optional\n Specifies how out-of-bounds indices will behave.\n\n * 'raise' -- raise an error (default)\n * 'wrap' -- wrap around\n * 'clip' -- clip to the range\n\n 'clip' mode means that all indices that are too large are replaced\n by the index that addresses the last element along that axis. Note\n that this disables indexing with negative numbers.\n\n Returns\n -------\n subarray : ndarray\n The returned array has the same type as `a`.\n \"\"\"\n return self.data.take(indices, axis, out, mode)\n\n def compress(self, condition, axis=None, out=None):\n \"\"\"\n Return selected slices of an array along given axis.\n\n When working along a given axis, a slice along that axis is returned in\n `output` for each index where `condition` evaluates to True. When\n working on a 1-D array, `compress` is equivalent to `extract`.\n\n Parameters\n ----------\n condition : 1-D array of bools\n Array that selects which entries to return. If len(condition)\n is less than the size of `a` along the given axis, then output is\n truncated to the length of the condition array.\n\n axis : int, optional\n Axis along which to take slices. If None (default), work on the\n flattened array.\n\n out : ndarray, optional\n Output array. Its type is preserved and it must be of the right\n shape to hold the output.\n\n Returns\n -------\n compressed_array : ndarray\n A copy of `a` without the slices along axis for which `condition`\n is false.\n \"\"\"\n return self.data.compress(condition, axis, out)\n\n def get(self, v, full_match=False):\n \"\"\" returns a table from columns given as v\n\n this function is equivalent to :func:`__getitem__` but preserve the\n Table format and associated properties (units, description, header)\n\n Parameters\n ----------\n v: str\n pattern to filter the keys with\n\n full_match: bool\n if set, use :func:`re.fullmatch` instead of :func:`re.match`\n\n \"\"\"\n new_keys = self.keys(v)\n t = self.__class__(self[new_keys])\n t.header.update(**self.header)\n t._aliases.update((k, v) for (k, v) in self._aliases.items() if v in new_keys)\n t._units.update((k, v) for (k, v) in self._units.items() if v in new_keys)\n t._desc.update((k, v) for (k, v) in self._desc.items() if v in new_keys)\n return t\n\n def __setitem__(self, k, v):\n if k in self:\n return self.data.__setitem__(self.resolve_alias(k), v)\n else:\n object.__setitem__(self, k, v)\n\n def __getattr__(self, k):\n try:\n return self.data.__getitem__(self.resolve_alias(k))\n except:\n return object.__getattribute__(self, k)\n\n def __iter__(self):\n newtab = self.select('*', [0])\n for d in self.data:\n newtab.data[0] = d\n yield newtab\n # return self.data.__iter__()\n\n def iterkeys(self):\n \"\"\" Iterator over the columns of the table \"\"\"\n for k in self.colnames:\n yield k\n\n def itervalues(self):\n \"\"\" Iterator over the lines of the table \"\"\"\n for l in self.data:\n yield l\n\n def items(self):\n \"\"\" Iterator on the (key, value) pairs \"\"\"\n for k in self.colnames:\n yield k, self[k]\n\n def info(self):\n \"\"\" prints information on the table \"\"\"\n s = \"\\nTable: {name:s}\\n nrows={s.nrows:d}, ncols={s.ncols:d}, mem={size:s}\"\n s = s.format(name=self.header.get('NAME', 'Noname'), s=self,\n size=pretty_size_print(self.nbytes))\n\n s += '\\n\\nHeader:\\n'\n vals = list(self.header.items())\n length = max(map(len, self.header.keys()))\n fmt = '\\t{{0:{0:d}s}} {{1}}\\n'.format(length)\n for k, v in vals:\n s += fmt.format(k, v)\n\n vals = [(k, self._units.get(k, ''), self._desc.get(k, ''))\n for k in self.colnames]\n lengths = [(len(k), len(self._units.get(k, '')), len(self._desc.get(k, '')))\n for k in self.colnames]\n lengths = list(map(max, (zip(*lengths))))\n\n s += '\\nColumns:\\n'\n\n fmt = '\\t{{0:{0:d}s}} {{1:{1:d}s}} {{2:{2:d}s}}\\n'.format(*(k + 1 for k in lengths))\n for k, u, c in vals:\n s += fmt.format(k, u, c)\n\n print(s)\n\n if len(self._aliases) > 0:\n print(\"\\nTable contains alias(es):\")\n for k, v in self._aliases.items():\n print('\\t{0:s} --> {1:s}'.format(k, v))\n\n def __repr__(self):\n s = object.__repr__(self)\n s += \"\\nTable: {name:s}\\n nrows={s.nrows:d}, ncols={s.ncols:d}, mem={size:s}\"\n return s.format(name=self.header.get('NAME', 'Noname'), s=self,\n size=pretty_size_print(self.nbytes))\n\n def __getslice__(self, i, j):\n return self.data.__getslice__(i, j)\n\n def __contains__(self, k):\n if hasattr(k, 'decode'):\n _k = k.decode('utf8')\n else:\n _k = k\n return (_k in self.colnames) or (_k in self._aliases)\n\n def __array__(self):\n return self.data\n\n def __call__(self, *args, **kwargs):\n if (len(args) > 0) or (len(kwargs) > 0):\n return self.evalexpr(*args, **kwargs)\n else:\n return self.info()\n\n def sort(self, keys, copy=False):\n \"\"\"\n Sort the table inplace according to one or more keys. This operates on\n the existing table (and does not return a new table).\n\n Parameters\n ----------\n\n keys: str or seq(str)\n The key(s) to order by\n\n copy: bool\n if set returns a sorted copy instead of working inplace\n \"\"\"\n if not hasattr(keys, '__iter__'):\n keys = [keys]\n\n if copy is False:\n self.data.sort(order=keys)\n else:\n t = self.__class__(self, copy=True)\n t.sort(keys, copy=False)\n return t\n\n def match(self, r2, key):\n \"\"\" Returns the indices at which the tables match\n matching uses 2 columns that are compared in values\n\n Parameters\n ----------\n r2: Table\n second table to use\n\n key: str\n fields used for comparison.\n\n Returns\n -------\n indexes: tuple\n tuple of both indices list where the two columns match.\n \"\"\"\n return np.where( np.equal.outer( self[key], r2[key] ) )\n\n def stack(self, r, *args, **kwargs):\n \"\"\"\n Superposes arrays fields by fields inplace\n\n t.stack(t1, t2, t3, default=None, inplace=True)\n\n Parameters\n ----------\n r: Table\n \"\"\"\n if not hasattr(r, 'data'):\n raise AttributeError('r should be a Table object')\n defaults = kwargs.get('defaults', None)\n inplace = kwargs.get('inplace', False)\n\n data = [self.data, r.data] + [k.data for k in args]\n sdata = recfunctions.stack_arrays(data, defaults, usemask=False,\n asrecarray=True)\n\n if inplace:\n self.data = sdata\n else:\n t = self.__class__(self)\n t.data = sdata\n return t\n\n def join_by(self, r2, key, jointype='inner', r1postfix='1', r2postfix='2',\n defaults=None, asrecarray=False, asTable=True):\n \"\"\"\n Join arrays `r1` and `r2` on key `key`.\n\n The key should be either a string or a sequence of string corresponding\n to the fields used to join the array.\n An exception is raised if the `key` field cannot be found in the two input\n arrays.\n Neither `r1` nor `r2` should have any duplicates along `key`: the presence\n of duplicates will make the output quite unreliable. Note that duplicates\n are not looked for by the algorithm.\n\n Parameters\n ----------\n key: str or seq(str)\n corresponding to the fields used for comparison.\n\n r2: Table\n Table to join with\n\n jointype: str in {'inner', 'outer', 'leftouter'}\n * 'inner' : returns the elements common to both r1 and r2.\n * 'outer' : returns the common elements as well as the elements of r1 not in r2 and the elements of not in r2.\n * 'leftouter' : returns the common elements and the elements of r1 not in r2.\n\n r1postfix: str\n String appended to the names of the fields of r1 that are present in r2\n\n r2postfix: str\n String appended to the names of the fields of r2 that are present in r1\n\n defaults: dict\n Dictionary mapping field names to the corresponding default values.\n\n Returns\n -------\n tab: Table\n joined table\n\n .. note::\n\n * The output is sorted along the key.\n\n * A temporary array is formed by dropping the fields not in the key\n for the two arrays and concatenating the result. This array is\n then sorted, and the common entries selected. The output is\n constructed by filling the fields with the selected entries.\n Matching is not preserved if there are some duplicates...\n \"\"\"\n arr = recfunctions.join_by(key, self.data, r2.data, jointype=jointype,\n r1postfix=r1postfix, r2postfix=r2postfix,\n defaults=defaults, usemask=False,\n asrecarray=True)\n\n return SimpleTable(arr)\n\n @property\n def empty_row(self):\n \"\"\" Return an empty row array respecting the table format \"\"\"\n return np.rec.recarray(shape=(1,), dtype=self.data.dtype)\n\n def add_column(self, name, data, dtype=None, unit=None, description=None):\n \"\"\"\n Add one or multiple columns to the table\n\n Parameters\n ----------\n name: str or sequence(str)\n The name(s) of the column(s) to add\n\n data: ndarray, or sequence of ndarray\n The column data, or sequence of columns\n\n dtype: dtype\n numpy dtype for the data to add\n\n unit: str\n The unit of the values in the column\n\n description: str\n A description of the content of the column\n \"\"\"\n\n _data = np.array(data, dtype=dtype)\n dtype = _data.dtype\n\n # unknown type is converted to text\n if dtype.type == np.object_:\n if len(data) == 0:\n longest = 0\n else:\n longest = len(max(data, key=len))\n _data = np.asarray(data, dtype='|%iS' % longest)\n\n dtype = _data.dtype\n\n if len(self.data.dtype) > 0:\n # existing data in the table\n if type(name) in basestring:\n # _name = name.encode('utf8')\n _name = str(name)\n else:\n # _name = [k.encode('utf8') for k in name]\n _name = [str(k) for k in name]\n\n self.data = recfunctions.append_fields(self.data, _name, _data,\n dtypes=dtype, usemask=False,\n asrecarray=True)\n\n else:\n if _data.ndim > 1:\n newdtype = (str(name), _data.dtype, (_data.shape[1],))\n else:\n newdtype = (str(name), _data.dtype)\n self.data = np.array(_data, dtype=[newdtype])\n\n if unit is not None:\n self.set_unit(name, unit)\n\n if description is not None:\n self.set_comment(name, description)\n\n def append_row(self, iterable):\n \"\"\"\n Append one row in this table.\n\n see also: :func:`stack`\n\n Parameters\n ----------\n iterable: iterable\n line to add\n \"\"\"\n if (len(iterable) != self.ncols):\n raise AttributeError('Expecting as many items as columns')\n r = self.empty_row\n for k, v in enumerate(iterable):\n r[0][k] = v\n self.stack(r)\n\n def remove_columns(self, names):\n \"\"\"\n Remove several columns from the table\n\n Parameters\n ----------\n names: sequence\n A list containing the names of the columns to remove\n \"\"\"\n self.pop_columns(names)\n\n def pop_columns(self, names):\n \"\"\"\n Pop several columns from the table\n\n Parameters\n ----------\n\n names: sequence\n A list containing the names of the columns to remove\n\n Returns\n -------\n\n values: tuple\n list of columns\n \"\"\"\n\n if not hasattr(names, '__iter__') or type(names) in basestring:\n names = [names]\n\n p = [self[k] for k in names]\n\n _names = set([ self.resolve_alias(k) for k in names ])\n self.data = recfunctions.drop_fields(self.data, _names)\n for k in names:\n self._aliases.pop(k, None)\n self._units.pop(k, None)\n self._desc.pop(k, None)\n\n return p\n\n def find_duplicate(self, index_only=False, values_only=False):\n \"\"\"Find duplication in the table entries, return a list of duplicated\n elements Only works at this time is 2 lines are *the same entry* not if\n 2 lines have *the same values*\n \"\"\"\n dup = []\n idd = []\n for i in range(len(self.data)):\n if (self.data[i] in self.data[i + 1:]):\n if (self.data[i] not in dup):\n dup.append(self.data[i])\n idd.append(i)\n if index_only:\n return idd\n elif values_only:\n return dup\n else:\n return zip(idd, dup)\n\n def evalexpr(self, expr, exprvars=None, dtype=float):\n \"\"\" evaluate expression based on the data and external variables\n all np function can be used (log, exp, pi...)\n\n Parameters\n ----------\n expr: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n exprvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n dtype: dtype definition\n dtype of the output array\n\n Returns\n -------\n out : NumPy array\n array of the result\n \"\"\"\n _globals = {}\n for k in ( list(self.colnames) + list(self._aliases.keys()) ):\n if k in expr:\n _globals[k] = self[k]\n\n if exprvars is not None:\n if (not (hasattr(exprvars, 'keys') & hasattr(exprvars, '__getitem__' ))):\n raise AttributeError(\"Expecting a dictionary-like as condvars\")\n for k, v in ( exprvars.items() ):\n _globals[k] = v\n\n # evaluate expression, to obtain the final filter\n r = np.empty( self.nrows, dtype=dtype)\n r[:] = eval(expr, _globals, np.__dict__)\n\n return r\n\n def where(self, condition, condvars=None, *args, **kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n\n Parameters\n ----------\n condition: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n condvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n Returns\n -------\n out: ndarray/ tuple of ndarrays\n result equivalent to :func:`np.where`\n\n \"\"\"\n ind = np.where(self.evalexpr(condition, condvars, dtype=bool ), *args, **kwargs)\n return ind\n\n def select(self, fields, indices=None, **kwargs):\n \"\"\"\n Select only a few fields in the table\n\n Parameters\n ----------\n fields: str or sequence\n fields to keep in the resulting table\n\n indices: sequence or slice\n extract only on these indices\n\n returns\n -------\n tab: SimpleTable instance\n resulting table\n \"\"\"\n _fields = self.keys(fields)\n\n if fields == '*':\n if indices is None:\n return self\n else:\n tab = self.__class__(self[indices])\n for k in self.__dict__.keys():\n if k not in ('data', ):\n setattr(tab, k, deepcopy(self.__dict__[k]))\n return tab\n else:\n d = {}\n for k in _fields:\n _k = self.resolve_alias(k)\n if indices is not None:\n d[k] = self[_k][indices]\n else:\n d[k] = self[_k]\n d['header'] = deepcopy(self.header)\n tab = self.__class__(d)\n for k in self.__dict__.keys():\n if k not in ('data', ):\n setattr(tab, k, deepcopy(self.__dict__[k]))\n return tab\n\n def selectWhere(self, fields, condition, condvars=None, **kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n\n Parameters\n ----------\n fields: str or sequence\n fields to keep in the resulting table\n\n condition: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n condvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n Returns\n -------\n tab: SimpleTable instance\n resulting table\n \"\"\"\n if condition in [True, 'True', None]:\n ind = None\n else:\n ind = self.where(condition, condvars, **kwargs)[0]\n\n tab = self.select(fields, indices=ind)\n\n return tab\n\n def groupby(self, *key):\n \"\"\"\n Create an iterator which returns (key, sub-table) grouped by each value\n of key(value)\n\n Parameters\n ----------\n key: str\n expression or pattern to filter the keys with\n\n Returns\n -------\n key: str or sequence\n group key\n\n tab: SimpleTable instance\n sub-table of the group\n header, aliases and column metadata are preserved (linked to the\n master table).\n \"\"\"\n _key = self.keys(key)\n getter = operator.itemgetter(*_key)\n\n for k, grp in itertools.groupby(self.data, getter):\n t = self.__class__(np.dstack(grp))\n t.header = self.header\n t._aliases = self._aliases\n t._units = self._units\n t._desc = self._desc\n yield (k, t)\n\n def stats(self, fn=None, fields=None, fill=None):\n \"\"\" Make statistics on columns of a table\n\n Parameters\n ----------\n fn: callable or sequence of callables\n functions to apply to each column\n default: (np.mean, np.std, np.nanmin, np.nanmax)\n\n fields: str or sequence\n any key or key expression to subselect columns\n default is all columns\n\n fill: value\n value when not applicable\n default np.nan\n\n returns\n -------\n tab: Table instance\n collection of statistics, one column per function in fn and 1 ligne\n per column in the table\n \"\"\"\n from collections import OrderedDict\n\n if fn is None:\n fn = (stats.mean, stats.std,\n stats.min, stats.max,\n stats.has_nan)\n\n d = OrderedDict()\n d.setdefault('FIELD', [])\n for k in fn:\n d.setdefault(k.__name__, [])\n\n if fields is None:\n fields = self.colnames\n else:\n fields = self.keys(fields)\n\n if fill is None:\n fill = np.nan\n\n for k in fields:\n d['FIELD'].append(k)\n for fnk in fn:\n try:\n val = fnk(self[k])\n except:\n val = fill\n d[fnk.__name__].append(val)\n\n return self.__class__(d, dtype=dict)\n\n # method aliases\n remove_column = remove_columns\n\n # deprecated methods\n addCol = add_column\n addLine = append_row\n setComment = set_comment\n setUnit = set_unit\n delCol = remove_columns\n\n\nclass AstroTable(SimpleTable):\n \"\"\"\n Derived from the Table, this class add implementations of common astro\n tools especially conesearch\n \"\"\"\n def __init__(self, *args, **kwargs):\n super(self.__class__, self).__init__(*args, **kwargs)\n self._ra_name, self._dec_name = self.__autoRADEC__()\n if (len(args) > 0):\n if isinstance(args[0], AstroTable):\n self._ra_name = args[0]._ra_name\n self._dec_name = args[0]._dec_name\n self._ra_name = kwargs.get('ra_name', self._ra_name)\n self._dec_name = kwargs.get('dec_name', self._dec_name)\n\n def __autoRADEC__(self):\n \"\"\" Tries to identify the columns containing RA and DEC coordinates \"\"\"\n if 'ra' in self:\n ra_name = 'ra'\n elif 'RA' in self:\n ra_name = 'RA'\n else:\n ra_name = None\n if 'dec' in self:\n dec_name = 'dec'\n elif 'DEC' in self:\n dec_name = 'DEC'\n else:\n dec_name = None\n return ra_name, dec_name\n\n def set_RA(self, val):\n \"\"\" Set the column that defines RA coordinates \"\"\"\n assert(val in self), 'column name {} not found in the table'.format(val)\n self._ra_name = val\n\n def set_DEC(self, val):\n \"\"\" Set the column that defines DEC coordinates \"\"\"\n assert(val in self), 'column name {} not found in the table'.format(val)\n self._dec_name = val\n\n def get_RA(self, degree=True):\n \"\"\" Returns RA, converted from hexa/sexa into degrees \"\"\"\n if self._ra_name is None:\n return None\n if (not degree) or (self.dtype[self._ra_name].kind != 'S'):\n return self[self._ra_name]\n else:\n if (len(str(self[0][self._ra_name]).split(':')) == 3):\n return np.asarray(AstroHelpers.hms2deg(self[self._ra_name],\n delim=':'))\n elif (len(str(self[0][self._ra_name]).split(' ')) == 3):\n return np.asarray(AstroHelpers.hms2deg(self[self._ra_name],\n delim=' '))\n else:\n raise Exception('RA Format not understood')\n\n def get_DEC(self, degree=True):\n \"\"\" Returns RA, converted from hexa/sexa into degrees \"\"\"\n if self._dec_name is None:\n return None\n if (not degree) or (self.dtype[self._dec_name].kind != 'S'):\n return self[self._dec_name]\n else:\n if (len(str(self[0][self._dec_name]).split(':')) == 3):\n return np.asarray(AstroHelpers.dms2deg(self[self._dec_name],\n delim=':'))\n elif (len(str(self[0][self._dec_name]).split(' ')) == 3):\n return np.asarray(AstroHelpers.dms2deg(self[self._dec_name],\n delim=' '))\n else:\n raise Exception('RA Format not understood')\n\n def info(self):\n s = \"\\nTable: {name:s}\\n nrows={s.nrows:d}, ncols={s.ncols:d}, mem={size:s}\"\n s = s.format(name=self.header.get('NAME', 'Noname'), s=self,\n size=pretty_size_print(self.nbytes))\n\n s += '\\n\\nHeader:\\n'\n vals = list(self.header.items())\n length = max(map(len, self.header.keys()))\n fmt = '\\t{{0:{0:d}s}} {{1}}\\n'.format(length)\n for k, v in vals:\n s += fmt.format(k, v)\n\n vals = [(k, self._units.get(k, ''), self._desc.get(k, ''))\n for k in self.colnames]\n lengths = [(len(k), len(self._units.get(k, '')), len(self._desc.get(k, '')))\n for k in self.colnames]\n lengths = list(map(max, (zip(*lengths))))\n\n if (self._ra_name is not None) & (self._dec_name is not None):\n s += \"\\nPosition coordinate columns: {0}, {1}\\n\".format(self._ra_name,\n self._dec_name)\n\n s += '\\nColumns:\\n'\n\n fmt = '\\t{{0:{0:d}s}} {{1:{1:d}s}} {{2:{2:d}s}}\\n'.format(*(k + 1 for k in lengths))\n for k, u, c in vals:\n s += fmt.format(k, u, c)\n\n print(s)\n\n if len(self._aliases) > 0:\n print(\"\\nTable contains alias(es):\")\n for k, v in self._aliases.items():\n print('\\t{0:s} --> {1:s}'.format(k, v))\n\n def coneSearch(self, ra, dec, r, outtype=0):\n \"\"\" Perform a cone search on a table\n\n Parameters\n ----------\n ra0: ndarray[ndim=1, dtype=float]\n column name to use as RA source in degrees\n\n dec0: ndarray[ndim=1, dtype=float]\n column name to use as DEC source in degrees\n\n ra: float\n ra to look for (in degree)\n\n dec: float\n ra to look for (in degree)\n\n r: float\n distance in degrees\n\n outtype: int\n type of outputs\n 0 -- minimal, indices of matching coordinates\n 1 -- indices and distances of matching coordinates\n 2 -- full, boolean filter and distances\n\n Returns\n -------\n t: tuple\n if outtype is 0:\n only return indices from ra0, dec0\n elif outtype is 1:\n return indices from ra0, dec0 and distances\n elif outtype is 2:\n return conditional vector and distance to all ra0, dec0\n \"\"\"\n if (self._ra_name is None) or (self._dec_name is None):\n raise AttributeError('Coordinate columns not set.')\n\n ra0 = self.get_RA()\n dec0 = self.get_DEC()\n return AstroHelpers.conesearch(ra0, dec0, ra, dec, r, outtype=outtype)\n\n def zoneSearch(self, ramin, ramax, decmin, decmax, outtype=0):\n \"\"\" Perform a zone search on a table, i.e., a rectangular selection\n\n Parameters\n ----------\n ramin: float\n minimal value of RA\n\n ramax: float\n maximal value of RA\n\n decmin: float\n minimal value of DEC\n\n decmax: float\n maximal value of DEC\n\n outtype: int\n type of outputs\n 0 or 1 -- minimal, indices of matching coordinates\n 2 -- full, boolean filter and distances\n\n Returns\n -------\n r: sequence\n indices or conditional sequence of matching values\n \"\"\"\n\n assert( (self._ra_name is not None) & (self._dec_name is not None) ), 'Coordinate columns not set.'\n\n ra0 = self.get_RA()\n dec0 = self.get_DEC()\n ind = (ra0 >= ramin) & (ra0 <= ramax) & (dec0 >= decmin) & (dec0 <= decmax)\n if outtype <= 2:\n return ind\n else:\n return np.where(ind)\n\n def where(self, condition=None, condvars=None, cone=None, zone=None, **kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n\n Parameters\n ----------\n condition: str\n expression to evaluate on the table\n includes mathematical operations and attribute names\n\n condvars: dictionary, optional\n A dictionary that replaces the local operands in current frame.\n\n Returns\n -------\n out: ndarray/ tuple of ndarrays\n result equivalent to :func:`np.where`\n \"\"\"\n if cone is not None:\n if len(cone) != 3:\n raise ValueError('Expecting cone keywords as a triplet (ra, dec, r)')\n if zone is not None:\n if len(zone) != 4:\n raise ValueError('Expecting zone keywords as a tuple of 4 elements (ramin, ramax, decmin, decmax)')\n\n if condition is not None:\n ind = super(self.__class__, self).where(condition, **kwargs)\n if ind is None:\n if (cone is None) & (zone is None):\n return None\n else:\n ind = True\n\n blobs = []\n if (cone is not None) and (zone is not None): # cone + zone\n ra, dec, r = cone\n ind, d = self.coneSearch(ra, dec, r, outtype=2)\n ind = ind & self.zoneSearch(zone[0], zone[1], zone[2], zone[3], outtype=2)\n d = d[ind]\n blobs.append(d)\n elif (cone is not None):\n ra, dec, r = cone\n _ind, d = self.coneSearch(ra, dec, r, outtype=2)\n ind = ind & _ind.astype(bool)\n blobs.append(d[ind])\n elif (zone is not None):\n _ind = self.zoneSearch(zone[0], zone[1], zone[2], zone[3], outtype=1)\n ind = ind & _ind\n\n ind = np.where(ind)[0]\n\n return ind, blobs\n\n def selectWhere(self, fields, condition=None, condvars=None, cone=None, zone=None, **kwargs):\n \"\"\" Read table data fulfilling the given `condition`.\n Only the rows fulfilling the `condition` are included in the result.\n conesearch is also possible through the keyword cone formatted as (ra, dec, r)\n zonesearch is also possible through the keyword zone formatted as (ramin, ramax, decmin, decmax)\n\n Combination of multiple selections is also available.\n \"\"\"\n ind, blobs = self.where(condition, condvars, cone, zone, **kwargs)\n tab = self.select(fields, indices=ind)\n\n if cone is not None:\n tab.add_column('separation', np.squeeze(blobs), unit='degree')\n\n if self._ra_name in tab:\n tab.set_RA(self._ra_name)\n\n if self._dec_name in tab:\n tab.set_DEC(self._dec_name)\n\n return tab\n\n\nclass stats(object):\n @classmethod\n def has_nan(s, v):\n return (True in np.isnan(v))\n\n @classmethod\n def mean(s, v):\n return np.nanmean(v)\n\n @classmethod\n def max(s, v):\n return np.nanmax(v)\n\n @classmethod\n def min(s, v):\n return np.nanmin(v)\n\n @classmethod\n def std(s, v):\n return np.nanstd(v)\n\n @classmethod\n def var(s, v):\n return np.var(v)\n\n @classmethod\n def p16(s, v):\n try:\n return np.nanpercentile(v, 16)\n except AttributeError:\n return np.percentile(v, 16)\n\n @classmethod\n def p84(s, v):\n try:\n return np.nanpercentile(v, 84)\n except AttributeError:\n return np.percentile(v, 84)\n\n @classmethod\n def p50(s, v):\n try:\n return np.nanmedian(v)\n except AttributeError:\n return np.percentile(v, 50)\n\n\n'''\n# =============================================================================\n# Adding some plotting functions\n# =============================================================================\n\ntry:\n import pylab as plt\n\n def plot_function(tab, fn, *args, **kwargs):\n \"\"\" Generate a plotting method of tab from a given function\n\n Parameters\n ----------\n tab: SimpleTable instance\n table instance\n\n fn: str or callable\n if str, will try a function in matplotlib\n if callable, calls the function directly\n\n xname: str\n expecting a column name from the table\n\n yname: str, optional\n if provided, another column to use for the plot\n\n onlywhere: sequence or str, optional\n if provided, selects only data with this condition\n the condition can be a ndarray slice or a string.\n When a string is given, the evaluation calls :func:`SimpleTable.where`\n\n ax: matplotlib.Axes instance\n if provided make sure it uses the axis to do the plots if a mpl\n function is used.\n\n Returns\n -------\n r: object\n anything returned by the called function\n \"\"\"\n if not hasattr(fn, '__call__'):\n ax = kwargs.pop('ax', None)\n if ax is None:\n ax = plt.gca()\n _fn = getattr(ax, fn, None)\n if _fn is None:\n raise AttributeError('function neither callable or found in matplotlib')\n else:\n _fn = fn\n\n onlywhere = kwargs.pop('onlywhere', None)\n if type(onlywhere) in basestring:\n select = tab.where(onlywhere)\n else:\n select = onlywhere\n\n _args = ()\n for a in args:\n if (hasattr(a, '__iter__')):\n try:\n b = tab[a]\n if select is not None:\n b = b.compress(select)\n if (len(b.dtype) > 1):\n b = list((b[k] for k in b.dtype.names))\n _args += (b, )\n except Exception as e:\n print(e)\n _args += (a, )\n else:\n _args += (a, )\n\n return _fn(*_args, **kwargs)\n\n def attached_function(fn, doc=None, errorlevel=0):\n \"\"\" eclare a function as a method to the class table\"\"\"\n\n def _fn(self, *args, **kwargs):\n try:\n return plot_function(self, fn, *args, **kwargs)\n except Exception as e:\n if errorlevel < 1:\n pass\n else:\n raise e\n\n if doc is not None:\n _fn.__doc__ = doc\n\n return _fn\n\n SimpleTable.plot_function = plot_function\n SimpleTable.plot = attached_function('plot', plt.plot.__doc__)\n SimpleTable.hist = attached_function('hist', plt.hist.__doc__)\n SimpleTable.hist2d = attached_function('hist2d', plt.hist2d.__doc__)\n SimpleTable.hexbin = attached_function('hexbin', plt.hexbin.__doc__)\n SimpleTable.scatter = attached_function('scatter', plt.scatter.__doc__)\n\n # newer version of matplotlib\n if hasattr(plt, 'violinplot'):\n SimpleTable.violinplot = attached_function('violinplot', plt.violinplot.__doc__)\n if hasattr(plt, 'boxplot'):\n SimpleTable.boxplot = attached_function('boxplot', plt.boxplot.__doc__)\n\nexcept Exception as e:\n print(e)\n'''\n" ]

[ [ "numpy.nanmax", "numpy.nanmedian", "numpy.asarray", "numpy.squeeze", "numpy.nanmin", "numpy.nanmean", "numpy.var", "numpy.nanstd", "numpy.where", "numpy.equal.outer", "pandas.read_csv", "numpy.arcsin", "numpy.sin", "numpy.lib.recfunctions.drop_fields", "numpy.lib.recfunctions.append_fields", "numpy.recfromtxt", "numpy.rec.recarray", "numpy.isnan", "numpy.ascontiguousarray", "numpy.deg2rad", "numpy.savetxt", "numpy.lib.recfunctions.join_by", "numpy.array", "numpy.nanpercentile", "numpy.lib.recfunctions.stack_arrays", "numpy.rec.fromarrays", "numpy.cos", "numpy.dstack", "numpy.percentile", "numpy.recfromcsv", "numpy.empty" ] ]

cypherix/ssd.pytorch

[ "0529c61bb945973d29a416487046d4aae63360fc" ]

[ "data/__init__.py" ]

[ "from .voc0712 import VOCDetection, VOCAnnotationTransform, VOC_CLASSES, VOC_ROOT\n\nfrom .coco import COCOAnnotationTransform\nfrom .config import *\nimport torch\nimport cv2\nimport numpy as np\n\ndef detection_collate(batch):\n \"\"\"Custom collate fn for dealing with batches of images that have a different\n number of associated object annotations (bounding boxes).\n\n Arguments:\n batch: (tuple) A tuple of tensor images and lists of annotations\n\n Return:\n A tuple containing:\n 1) (tensor) batch of images stacked on their 0 dim\n 2) (list of tensors) annotations for a given image are stacked on\n 0 dim\n \"\"\"\n targets = []\n imgs = []\n for sample in batch:\n imgs.append(sample[0])\n targets.append(torch.FloatTensor(sample[1]))\n return torch.stack(imgs, 0), targets\n\n\ndef base_transform(image, size, mean):\n x = cv2.resize(image, (size, size)).astype(np.float32)\n x -= mean\n x = x.astype(np.float32)\n return x\n\n\nclass BaseTransform:\n def __init__(self, size, mean):\n self.size = size\n self.mean = np.array(mean, dtype=np.float32)\n\n def __call__(self, image, boxes=None, labels=None):\n return base_transform(image, self.size, self.mean), boxes, labels\n" ]

[ [ "torch.stack", "numpy.array", "torch.FloatTensor" ] ]

blzheng/pytorch-YOLOv4

[ "8956c4801c4e1ae4b0c2fadf807a0356f0bfe058" ]

[ "test_inference.py" ]

[ "import torch\nimport argparse\nimport os\nimport random\nimport shutil\nimport time\nimport warnings\nfrom torch import nn\nimport torch.nn.functional as F\nfrom tool.torch_utils import *\nfrom tool.yolo_layer import YoloLayer\nfrom yolo_loss import Yolo_loss\nfrom torch.utils import mkldnn as mkldnn_utils\nfrom models import Yolov4\nfrom dataset import Yolo_dataset\n\nparser = argparse.ArgumentParser(description='PyTorch Yolov4 Training')\nparser.add_argument('-N', '--n_classes', default=80, type=int, metavar='n_classes',\n help='num classes')\nparser.add_argument('-w', '--weightfile', type=str, default='./yolov4.pth',\n help='weight file')\nparser.add_argument('-i', '--imgfile', type=str, default='./data/dog.jpg',\n help='image file')\nparser.add_argument('--height', default=320, type=int, help='height')\nparser.add_argument('--width', default=320, type=int, help='width')\nparser.add_argument('-n', '--namesfile', type=str, help='names file')\nparser.add_argument('-j', '--workers', default=4, type=int, metavar='N',\n help='number of data loading workers (default: 4)')\nparser.add_argument('--ipex', action='store_true', default=False,\n help='use intel pytorch extension')\nparser.add_argument('--int8', action='store_true', default=False,\n help='enable ipex int8 path')\nparser.add_argument('--bf16', action='store_true', default=False,\n help='enable ipex bf16 path')\nparser.add_argument('--jit', action='store_true', default=False,\n help='enable ipex jit fusionpath')\nparser.add_argument('--calibration', action='store_true', default=False,\n help='doing calibration step for int8 path')\nparser.add_argument('--configure-dir', default='configure.json', type=str, metavar='PATH',\n help = 'path to int8 configures, default file name is configure.json')\nparser.add_argument(\"--dummy\", action='store_true',\n help=\"using dummu data to test the performance of inference\")\nparser.add_argument('--warmup', default=30, type=int, metavar='N',\n help='number of warmup iterati ons to run')\nparser.add_argument('-b', '--batch-size', default=64, type=int, metavar='N',\n help='mini-batch size (default: 64), this is the total '\n 'batch size of all GPUs on the current node when '\n 'using Data Parallel or Distributed Data Parallel')\n\ndef fp32_imperative_stock_pytorch(model, images):\n model = model.to(memory_format=torch.channels_last)\n images = images.to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef fp32_jit_stock_pytorch(model, images, args):\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width))\n model = torch.jit.freeze(model)\n images = images.to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef bf16_imperative_stock_pytorch(model, images):\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n with torch.cpu.amp.autocast():\n images = images.to(torch.bfloat16).to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef bf16_jit_stock_pytorch(model, images, args):\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n with torch.no_grad():\n with torch.cpu.amp.autocast():\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width))\n model = torch.jit.freeze(model)\n with torch.cpu.amp.autocast():\n images = images.to(torch.bfloat16).to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef fp32_imperative_stock_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n model = model.to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.float32, level=\"O0\")\n images = images.to(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef fp32_jit_stock_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n model = model.to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.float32, level=\"O0\")\n model = torch.jit.trace(model, torch.rand(args.batch_size, 3, args.height, args.width).to(memory_format=torch.channels_last))\n model = torch.jit.freeze(model)\n images = images.contiguous(memory_format=torch.channels_last)\n output=model(images)\n print(output)\n\ndef bf16_imperative_stock_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.bfloat16, level=\"O0\")\n conf = ipex.AmpConf(torch.bfloat16)\n with ipex.amp.autocast(enabled=True, configure=conf), torch.no_grad():\n output=model(images)\n print(output)\n\ndef bf16_jit_stock_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n with torch.no_grad():\n model = model.to(torch.bfloat16).to(memory_format=torch.channels_last)\n model = ipex.optimize(model, dtype=torch.bfloat16, level=\"O0\")\n conf = ipex.AmpConf(torch.bfloat16)\n images = images.to(torch.bfloat16)\n with ipex.amp.autocast(enabled=True, configure=conf), torch.no_grad():\n model = torch.jit.trace(model, torch.rand(args.batch_size, 3, args.height, args.width).to(memory_format=torch.channels_last))\n model = torch.jit.freeze(model)\n output=model(images)\n print(output)\n\ndef fp32_imperative_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n output=model(images)\n print(output)\n\ndef fp32_jit_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n with torch.no_grad():\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width).to(ipex.DEVICE))\n output=model(images)\n print(output)\n\ndef bf16_imperative_pytorch_ipex(model, images):\n import intel_pytorch_extension as ipex\n ipex.enable_auto_mixed_precision(mixed_dtype = torch.bfloat16)\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n output=model(images)\n print(output)\n\ndef bf16_jit_pytorch_ipex(model, images, args):\n import intel_pytorch_extension as ipex\n ipex.enable_auto_mixed_precision(mixed_dtype = torch.bfloat16)\n model = model.to(ipex.DEVICE)\n images = images.to(ipex.DEVICE)\n with torch.no_grad():\n model = torch.jit.trace(model, torch.randn(args.batch_size, 3, args.height, args.width).to(ipex.DEVICE))\n output=model(images)\n print(output)\n\ndef get_data(args):\n if args.dummy:\n images = torch.randn(args.batch_size, 3, args.height, args.width)\n return images\n else:\n import sys\n import cv2\n img = cv2.imread(args.imgfile)\n sized = cv2.resize(img, (args.width, args.height))\n img = cv2.cvtColor(sized, cv2.COLOR_BGR2RGB)\n if type(img) == np.ndarray and len(img.shape) == 3: # cv2 image\n img = torch.from_numpy(img.transpose(2, 0, 1)).float().div(255.0).unsqueeze(0)\n elif type(img) == np.ndarray and len(img.shape) == 4:\n img = torch.from_numpy(img.transpose(0, 3, 1, 2)).float().div(255.0)\n else:\n print(\"unknow image type\")\n exit(-1)\n img = torch.autograd.Variable(img)\n return img\n\nif __name__ == \"__main__\":\n args = parser.parse_args()\n print(args)\n n_classes = args.n_classes\n weightfile = args.weightfile\n \n model = Yolov4(yolov4conv137weight=None, n_classes=n_classes, inference=True)\n pretrained_dict = torch.load(weightfile, map_location=torch.device('cpu'))\n model.load_state_dict(pretrained_dict)\n img = get_data(args)\n \n model.eval()\n fp32_imperative_stock_pytorch(model, img)\n fp32_jit_stock_pytorch(model, img, args)\n bf16_imperative_stock_pytorch(model, img)\n bf16_jit_stock_pytorch(model, img, args)\n fp32_imperative_stock_pytorch_ipex(model, img)\n fp32_jit_stock_pytorch_ipex(model, img, args)\n bf16_imperative_stock_pytorch_ipex(model, img)\n bf16_jit_stock_pytorch_ipex(model, img, args)\n fp32_imperative_pytorch_ipex(model, img)\n fp32_jit_pytorch_ipex(model, img, args)\n bf16_imperative_pytorch_ipex(model, img)\n bf16_jit_pytorch_ipex(model, img, args)\n\n" ]

[ [ "torch.jit.freeze", "torch.randn", "torch.no_grad", "torch.rand", "torch.device", "torch.cpu.amp.autocast", "torch.autograd.Variable" ] ]

ChristosT/meshio

[ "de0ced0cc19fa40389764514328874dce8afdbec" ]

[ "meshio/medit/_medit.py" ]

[ "\"\"\"\nI/O for Medit's format/Gamma Mesh Format,\nLatest official up-to-date documentation and a reference C implementation at\n<https://github.com/LoicMarechal/libMeshb>\n\"\"\"\nimport logging\nimport struct\nfrom ctypes import c_double, c_float\n\nimport numpy as np\n\nfrom .._common import _pick_first_int_data\nfrom .._exceptions import ReadError\nfrom .._files import open_file\nfrom .._helpers import register\nfrom .._mesh import Mesh\nfrom ._medit_internal import medit_codes\n\n\ndef read(filename):\n with open_file(filename) as f:\n if str(filename)[-1] == \"b\":\n mesh = read_binary_buffer(f)\n else:\n mesh = read_ascii_buffer(f)\n return mesh\n\n\ndef _produce_dtype(string_type, dim, itype, ftype):\n \"\"\"\n convert a medit_code to a dtype appropriate for building a numpy array\n \"\"\"\n res = \"\"\n c = 0\n while c < len(string_type):\n s = string_type[c]\n if s == \"i\":\n res += itype\n elif s == \"r\":\n res += ftype\n elif s == \"d\":\n res += str(dim)\n c += 1\n continue\n else:\n raise ReadError(\"Invalid string type\")\n c += 1\n if c != len(string_type):\n res += \",\"\n return res\n\n\ndef read_binary_buffer(f):\n\n meshio_from_medit = {\n \"GmfVertices\": (\"point\", None),\n \"GmfEdges\": (\"line\", 2),\n \"GmfTriangles\": (\"triangle\", 3),\n \"GmfQuadrilaterals\": (\"quad\", 4),\n \"GmfTetrahedra\": (\"tetra\", 4),\n \"GmfPrisms\": (\"wedge\", 6),\n \"GmfPyramids\": (\"pyramid\", 5),\n \"GmfHexahedra\": (\"hexahedron\", 8),\n }\n\n dim = 0\n points = None\n cells = []\n point_data = {}\n cell_data = {\"medit:ref\": []}\n itype = \"\"\n ftype = \"\"\n postype = \"\"\n # the file version\n keytype = \"i4\"\n\n code = np.fromfile(f, count=1, dtype=keytype).item()\n\n if code != 1 and code != 16777216:\n raise ReadError(\"Invalid code\")\n\n if code == 16777216:\n # swap endianess\n swapped = \">\" if struct.unpack(\"=l\", struct.pack(\"<l\", 1))[0] == 1 else \"<\"\n itype += swapped\n ftype += swapped\n postype += swapped\n keytype = swapped + keytype\n\n version = np.fromfile(f, count=1, dtype=keytype).item()\n\n if version < 1 or version > 4:\n raise ReadError(\"Invalid version\")\n\n if version == 1:\n itype += \"i4\"\n ftype += \"f4\"\n postype += \"i4\"\n elif version == 2:\n itype += \"i4\"\n ftype += \"f8\"\n postype += \"i4\"\n elif version == 3:\n itype += \"i4\"\n ftype += \"f8\"\n postype += \"i8\"\n else:\n itype += \"i8\"\n ftype += \"f8\"\n postype += \"i8\"\n\n field = np.fromfile(f, count=1, dtype=keytype).item()\n\n if field != 3: # = GmfDimension\n raise ReadError(\"Invalid dimension code : \" + str(field) + \" it should be 3\")\n\n np.fromfile(f, count=1, dtype=postype)\n\n dim = np.fromfile(f, count=1, dtype=keytype).item()\n\n if dim != 2 and dim != 3:\n raise ReadError(\"Invalid mesh dimension : \" + str(dim))\n\n while True:\n field = np.fromfile(f, count=1, dtype=keytype)\n\n if field.size == 0:\n msg = \"End-of-file reached before GmfEnd keyword\"\n logging.warning(msg)\n break\n\n field = field.item()\n if field not in medit_codes.keys():\n raise ReadError(\"Unsupported field\")\n\n field_code = medit_codes[field]\n\n if field_code[0] == \"GmfEnd\":\n break\n\n if field_code[0] == \"GmfReserved\":\n continue\n\n np.fromfile(f, count=1, dtype=postype)\n\n nitems = 1\n if field_code[1] == \"i\":\n nitems = np.fromfile(f, count=1, dtype=itype).item()\n\n field_template = field_code[2]\n dtype = np.dtype(_produce_dtype(field_template, dim, itype, ftype))\n out = np.asarray(np.fromfile(f, count=nitems, dtype=dtype))\n if field_code[0] not in meshio_from_medit.keys():\n msg = (\"meshio doesn't know {} type. Skipping.\").format(field_code[0])\n logging.warning(msg)\n continue\n\n elif field_code[0] == \"GmfVertices\":\n points = out[\"f0\"]\n point_data[\"medit:ref\"] = out[\"f1\"]\n else:\n meshio_type, ncols = meshio_from_medit[field_code[0]]\n # transform the structured array to integer array which suffices\n # for the cell connectivity\n out_view = out.view(itype).reshape(nitems, ncols + 1)\n cells.append((meshio_type, out_view[:, :ncols] - 1))\n cell_data[\"medit:ref\"].append(out_view[:, -1])\n\n return Mesh(points, cells, point_data=point_data, cell_data=cell_data)\n\n\ndef read_ascii_buffer(f):\n dim = 0\n cells = []\n point_data = {}\n cell_data = {\"medit:ref\": []}\n\n meshio_from_medit = {\n \"Edges\": (\"line\", 2),\n \"Triangles\": (\"triangle\", 3),\n \"Quadrilaterals\": (\"quad\", 4),\n \"Tetrahedra\": (\"tetra\", 4),\n \"Prisms\": (\"wedge\", 6),\n \"Pyramids\": (\"pyramid\", 5),\n \"Hexahedra\": (\"hexahedron\", 8), # Frey\n \"Hexaedra\": (\"hexahedron\", 8), # Dobrzynski\n }\n points = None\n dtype = None\n\n while True:\n line = f.readline()\n if not line:\n # EOF\n break\n\n line = line.strip()\n if len(line) == 0 or line[0] == \"#\":\n continue\n\n items = line.split()\n\n if not items[0].isalpha():\n raise ReadError()\n\n if items[0] == \"MeshVersionFormatted\":\n version = items[1]\n dtype = {\"1\": c_float, \"2\": c_double}[version]\n elif items[0] == \"Dimension\":\n if len(items) >= 2:\n dim = int(items[1])\n else:\n dim = int(\n int(f.readline())\n ) # e.g. Dimension\\n3, where the number of dimensions is on the next line\n elif items[0] == \"Vertices\":\n if dim <= 0:\n raise ReadError()\n if dtype is None:\n raise ReadError(\"Expected `MeshVersionFormatted` before `Vertices`\")\n num_verts = int(f.readline())\n out = np.fromfile(\n f, count=num_verts * (dim + 1), dtype=dtype, sep=\" \"\n ).reshape(num_verts, dim + 1)\n points = out[:, :dim]\n point_data[\"medit:ref\"] = out[:, dim].astype(int)\n elif items[0] in meshio_from_medit:\n meshio_type, points_per_cell = meshio_from_medit[items[0]]\n # The first value is the number of elements\n num_cells = int(f.readline())\n\n out = np.fromfile(\n f, count=num_cells * (points_per_cell + 1), dtype=int, sep=\" \"\n ).reshape(num_cells, points_per_cell + 1)\n\n # adapt for 0-base\n cells.append((meshio_type, out[:, :points_per_cell] - 1))\n cell_data[\"medit:ref\"].append(out[:, -1])\n elif items[0] == \"Corners\":\n # those are just discarded\n num_corners = int(f.readline())\n np.fromfile(f, count=num_corners, dtype=dtype, sep=\" \")\n elif items[0] == \"Normals\":\n # those are just discarded\n num_normals = int(f.readline())\n np.fromfile(f, count=num_normals * dim, dtype=dtype, sep=\" \").reshape(\n num_normals, dim\n )\n elif items[0] == \"NormalAtVertices\":\n # those are just discarded\n num_normal_at_vertices = int(f.readline())\n np.fromfile(\n f, count=num_normal_at_vertices * 2, dtype=int, sep=\" \"\n ).reshape(num_normal_at_vertices, 2)\n else:\n if items[0] != \"End\":\n raise ReadError(f\"Unknown keyword '{items[0]}'.\")\n\n if points is None:\n raise ReadError(\"Expected `Vertices`\")\n return Mesh(points, cells, point_data=point_data, cell_data=cell_data)\n\n\ndef write(filename, mesh, float_fmt=\".16e\"):\n if str(filename)[-1] == \"b\":\n write_binary_file(filename, mesh)\n else:\n write_ascii_file(filename, mesh, float_fmt)\n\n\ndef write_ascii_file(filename, mesh, float_fmt=\".16e\"):\n with open_file(filename, \"wb\") as fh:\n version = {np.dtype(c_float): 1, np.dtype(c_double): 2}[mesh.points.dtype]\n # N. B.: PEP 461 Adding % formatting to bytes and bytearray\n fh.write(b\"MeshVersionFormatted %d\\n\" % version)\n\n n, d = mesh.points.shape\n\n fh.write(b\"Dimension %d\\n\" % d)\n\n # vertices\n fh.write(b\"\\nVertices\\n\")\n fh.write(f\"{n}\\n\".encode(\"utf-8\"))\n\n # pick out point data\n labels_key, other = _pick_first_int_data(mesh.point_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one point data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n labels = mesh.point_data[labels_key] if labels_key else np.ones(n, dtype=int)\n\n fmt = \" \".join([\"{:\" + float_fmt + \"}\"] * d) + \" {:d}\\n\"\n for x, label in zip(mesh.points, labels):\n fh.write(fmt.format(*x, label).encode(\"utf-8\"))\n\n medit_from_meshio = {\n \"line\": (\"Edges\", 2),\n \"triangle\": (\"Triangles\", 3),\n \"quad\": (\"Quadrilaterals\", 4),\n \"tetra\": (\"Tetrahedra\", 4),\n \"wedge\": (\"Prisms\", 6),\n \"pyramid\": (\"Pyramids\", 5),\n \"hexahedron\": (\"Hexahedra\", 8),\n }\n\n # pick out cell_data\n labels_key, other = _pick_first_int_data(mesh.cell_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one cell data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n\n for k, (cell_type, data) in enumerate(mesh.cells):\n try:\n medit_name, num = medit_from_meshio[cell_type]\n except KeyError:\n msg = (\"MEDIT's mesh format doesn't know {} cells. Skipping.\").format(\n cell_type\n )\n logging.warning(msg)\n continue\n fh.write(b\"\\n\")\n fh.write(f\"{medit_name}\\n\".encode(\"utf-8\"))\n fh.write(f\"{len(data)}\\n\".encode(\"utf-8\"))\n\n # pick out cell data\n labels = (\n mesh.cell_data[labels_key][k]\n if labels_key\n else np.ones(len(data), dtype=data.dtype)\n )\n\n fmt = \" \".join([\"{:d}\"] * (num + 1)) + \"\\n\"\n # adapt 1-base\n for d, label in zip(data + 1, labels):\n fh.write(fmt.format(*d, label).encode(\"utf-8\"))\n\n fh.write(b\"\\nEnd\\n\")\n\n\ndef write_binary_file(f, mesh):\n with open_file(f, \"wb\") as fh:\n\n version = 3\n itype = \"i4\"\n postype = \"i8\"\n ftype = \"f8\"\n # according to manual keywords are always written as i4 independently of\n # the file version\n keytype = \"i4\"\n\n # if we store internally 64bit integers upgrade file version\n has_big_ints = False\n for _, data in mesh.cells:\n if data.dtype.itemsize == 8:\n has_big_ints = True\n break\n\n if has_big_ints:\n itype = \"i8\"\n version = 4\n\n itype_size = np.dtype(itype).itemsize\n ftype_size = np.dtype(ftype).itemsize\n postype_size = np.dtype(postype).itemsize\n keyword_size = np.dtype(keytype).itemsize\n\n code = 1\n field = 3 # GmfDimension\n pos = 4 * keyword_size + postype_size\n\n num_verts, dim = mesh.points.shape\n\n header_type = np.dtype(\",\".join([keytype, keytype, keytype, postype, keytype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = code\n tmp_array[\"f1\"] = version\n tmp_array[\"f2\"] = field\n tmp_array[\"f3\"] = pos\n tmp_array[\"f4\"] = dim\n tmp_array.tofile(fh)\n\n # write points\n field = 4 # GmfVertices\n field_code = medit_codes[field]\n\n pos += num_verts * dim * ftype_size\n pos += num_verts * itype_size\n pos += keyword_size + postype_size + itype_size\n header_type = np.dtype(\",\".join([keytype, postype, itype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = field\n tmp_array[\"f1\"] = pos\n tmp_array[\"f2\"] = num_verts\n tmp_array.tofile(fh)\n\n field_template = field_code[2]\n dtype = np.dtype(_produce_dtype(field_template, dim, itype, ftype))\n\n labels_key, other = _pick_first_int_data(mesh.point_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one point data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n labels = (\n mesh.point_data[labels_key]\n if labels_key\n else np.ones(num_verts, dtype=itype)\n )\n\n tmp_array = np.empty(num_verts, dtype=dtype)\n tmp_array[\"f0\"] = mesh.points\n tmp_array[\"f1\"] = labels\n tmp_array.tofile(fh)\n\n labels_key, other = _pick_first_int_data(mesh.cell_data)\n if labels_key and other:\n logging.warning(\n \"Medit can only write one cell data array. \"\n \"Picking {}, skipping {}.\".format(labels_key, \", \".join(other))\n )\n\n # first component is medit keyword id see _medit_internal.py\n medit_from_meshio = {\n \"line\": 5,\n \"triangle\": 6,\n \"quad\": 7,\n \"tetra\": 8,\n \"wedge\": 9,\n \"pyramid\": 49,\n \"hexahedron\": 10,\n }\n for k, (cell_type, data) in enumerate(mesh.cells):\n try:\n medit_key = medit_from_meshio[cell_type]\n except KeyError:\n msg = (\"MEDIT's mesh format doesn't know {} cells. Skipping.\").format(\n cell_type\n )\n logging.warning(msg)\n continue\n\n num_cells, num_verts = data.shape\n\n pos += num_cells * (num_verts + 1) * itype_size\n pos += keyword_size + postype_size + itype_size\n\n header_type = np.dtype(\",\".join([keytype, postype, itype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = medit_key\n tmp_array[\"f1\"] = pos\n tmp_array[\"f2\"] = num_cells\n tmp_array.tofile(fh)\n\n # pick out cell data\n labels = (\n mesh.cell_data[labels_key][k]\n if labels_key\n else np.ones(len(data), dtype=data.dtype)\n )\n field_template = medit_codes[medit_key][2]\n dtype = np.dtype(_produce_dtype(field_template, dim, itype, ftype))\n\n tmp_array = np.empty(num_cells, dtype=dtype)\n i = 0\n for col_type in dtype.names[:-1]:\n tmp_array[col_type] = data[:, i] + 1\n i += 1\n\n tmp_array[dtype.names[-1]] = labels\n tmp_array.tofile(fh)\n\n pos = 0\n field = 54 # GmfEnd\n header_type = np.dtype(\",\".join([keytype, postype]))\n tmp_array = np.empty(1, dtype=header_type)\n tmp_array[\"f0\"] = field\n tmp_array[\"f1\"] = pos\n tmp_array.tofile(fh)\n\n\nregister(\"medit\", [\".mesh\", \".meshb\"], read, {\"medit\": write})\n" ]

[ [ "numpy.dtype", "numpy.fromfile", "numpy.empty", "numpy.ones" ] ]

mleshen/pytorch

[ "314a578154d9f0981bc08397aaaeaf50d8233730" ]

[ "torch/fx/graph_module.py" ]

[ "import torch\nimport torch.nn as nn\nimport torch.overrides\nfrom torch.nn.modules.module import _addindent\nfrom torch.package import PackageImporter, PackageExporter\nimport linecache\nfrom typing import Type, Dict, List, Any, Union, Optional, Set\nfrom .graph import Graph, _is_from_torch, _custom_builtins, PythonCode\nfrom torch.package import Importer, sys_importer\nimport copy\nimport itertools\nimport sys\nimport traceback\nfrom pathlib import Path\nimport os\nimport warnings\n\n# normal exec loses the source code, however we can patch\n# the linecache module to still recover it.\n# using exec_with_source will add it to our local cache\n# and then tools like TorchScript will be able to get source info.\n_next_id = 0\ndef exec_with_source(src: str, globals: Dict[str, Any]):\n global _next_id\n key = f'<eval_with_key_{_next_id}>'\n _next_id += 1\n _eval_cache[key] = [line + '\\n' for line in src.splitlines()]\n exec(compile(src, key, 'exec'), globals)\n\n# patch linecache so that any code we exec using exec_with_source\n# works with inspect\n_eval_cache : Dict[str, List[str]] = {}\n_orig_getlines = linecache.getlines\ndef patched_getline(*args, **kwargs):\n if args[0] in _eval_cache:\n return _eval_cache[args[0]]\n return _orig_getlines(*args, **kwargs)\nlinecache.getlines = patched_getline\n\n\ndef _forward_from_src(src: str, globals: Dict[str, Any]):\n # avoid mutating the passed in dict\n globals_copy = globals.copy()\n exec_with_source(src, globals_copy)\n forward_fn = globals_copy['forward']\n del globals_copy['forward']\n return forward_fn\n\n\ndef _format_import_statement(name: str, obj: Any, importer: Importer) -> str:\n if name in _custom_builtins:\n return _custom_builtins[name].import_str\n if _is_from_torch(name):\n return 'import torch'\n\n module_name, attr_name = importer.get_name(obj)\n return f'from {module_name} import {attr_name} as {name}'\n\n\ndef _format_import_block(globals: Dict[str, Any], importer: Importer):\n import_strs: Set[str] = set()\n for name, obj in globals.items():\n import_strs.add(_format_import_statement(name, obj, importer))\n return '\\n'.join(import_strs)\n\n\ndef reduce_graph_module(body: Dict[Any, Any], import_block: str) -> torch.nn.Module:\n # BC: attribute name was changed from `code` to `_code` to facilitate\n # making `code` into a property and adding a docstring to it\n fn_src = body.get('_code') or body['code']\n forward = _forward_from_src(import_block + fn_src, {})\n return _deserialize_graph_module(forward, body, None)\n\n\ndef reduce_package_graph_module(importer: PackageImporter,\n body: Dict[Any, Any],\n generated_module_name: str) -> torch.nn.Module:\n forward = importer.import_module(generated_module_name).forward\n return _deserialize_graph_module(forward, body, importer)\n\n\ndef _deserialize_graph_module(forward, body: Dict[Any, Any], importer: Optional[PackageImporter]) -> torch.nn.Module:\n \"\"\"\n Deserialize a GraphModule given the dictionary of the original module,\n using the code to reconstruct the graph. We delete the actual graph before\n saving the dictionary so that changes to the in-memory graph format do not\n get serialized.\n \"\"\"\n # We create a dummy class here because symbolic_trace pulls the forward()\n # function off of the class, rather than the instance\n class CodeOnlyModule(torch.nn.Module):\n def __init__(self, body):\n super().__init__()\n self.__dict__ = body\n\n # Try to retrieve the forward source in a backward-compatible way\n CodeOnlyModule.forward = forward\n\n from .symbolic_trace import Tracer\n\n # we shouldn't trace into any of the submodules, they were not\n # because they were not traced in the original GraphModule\n class KeepModules(Tracer):\n def is_leaf_module(self, _: torch.nn.Module, __: str) -> bool:\n return True\n\n com = CodeOnlyModule(body)\n return GraphModule(com, KeepModules().trace(com))\n\n# copy an attribute value with qualified name 'target' from 'from_module' to 'to_module'\n# This installs empty Modules where none exist yet if they are subpaths of target\ndef _copy_attr(from_module: torch.nn.Module, to_module: torch.nn.Module, target: str):\n *prefix, field = target.split('.')\n for item in prefix:\n f = getattr(from_module, item)\n t = getattr(to_module, item, None)\n if f is t:\n # we have already installed one of its parents\n # (e.g. target = root.linear.weight, but we have already installed root.linear)\n # once we install a parent, we no longer need to copy the children\n # since all the needed properties will already be present\n return\n\n if t is None:\n t = torch.nn.Module()\n setattr(to_module, item, t)\n from_module, to_module = f, t\n\n orig = getattr(from_module, field)\n # If it is a tensor and not a parameter attribute of a module, it should be a named buffer.\n # So, we register it as a named buffer in the target module.\n if isinstance(orig, torch.Tensor) and not isinstance(orig, torch.nn.Parameter):\n to_module.register_buffer(field, orig)\n else:\n setattr(to_module, field, orig)\n\n# Assign attribute 'from_obj' to the qualified name 'target' on 'to_module\n# This installs empty Modules where none exist yet if they are subpaths of target\ndef _assign_attr(from_obj: Any, to_module: torch.nn.Module, target: str):\n *prefix, field = target.split('.')\n for item in prefix:\n t = getattr(to_module, item, None)\n\n if t is None:\n t = torch.nn.Module()\n setattr(to_module, item, t)\n to_module = t\n\n # If it is a tensor and not a parameter attribute of a module, it should be a named buffer.\n # So, we register it as a named buffer in the target module.\n if isinstance(from_obj, torch.Tensor) and not isinstance(from_obj, torch.nn.Parameter):\n to_module.register_buffer(field, from_obj)\n else:\n setattr(to_module, field, from_obj)\n\nclass GraphModule(torch.nn.Module):\n \"\"\"\n GraphModule is an nn.Module generated from an fx.Graph. Graphmodule has a\n ``graph`` attribute, as well as ``code`` and ``forward`` attributes generated\n from that ``graph``.\n\n .. warning::\n\n When ``graph`` is reassigned, ``code`` and ``forward`` will be automatically\n regenerated. However, if you edit the contents of the ``graph`` without reassigning\n the ``graph`` attribute itself, you must call ``recompile()`` to update the generated\n code.\n\n \"\"\"\n def __new__(cls: 'Type[GraphModule]', *args, **kwargs):\n # each instance of a graph module needs its own forward method\n # so create a new singleton class for each instance.\n # it is a subclass of the user-defined class, the only difference\n # is an extra layer to install the forward method\n\n class GraphModuleImpl(cls): # type: ignore[misc, valid-type]\n pass\n return super().__new__(GraphModuleImpl)\n\n def __init__(self,\n root: Union[torch.nn.Module, Dict[str, Any]],\n graph: Graph,\n class_name: str = 'GraphModule'):\n \"\"\"\n Construct a GraphModule.\n\n Args:\n\n root (Union[torch.nn.Module, Dict[str, Any]):\n ``root`` can either be an nn.Module instance or a Dict mapping strings to any attribute type.\n In the case that ``root`` is a Module, any references to Module-based objects (via qualified\n name) in the Graph's Nodes' ``target`` field will be copied over from the respective place\n within ``root``'s Module hierarchy into the GraphModule's module hierarchy.\n In the case that ``root`` is a dict, the qualified name found in a Node's ``target`` will be\n looked up directly in the dict's keys. The object mapped to by the Dict will be copied\n over into the appropriate place within the GraphModule's module hierarchy.\n\n graph (Graph): ``graph`` contains the nodes this GraphModule should use for code generation\n\n class_name (str): ``name`` denotes the name of this GraphModule for debugging purposes. If it's unset, all\n error messages will report as originating from ``GraphModule``. It may be helpful to set this\n to ``root``'s original name or a name that makes sense within the context of your transform.\n\n \"\"\"\n super().__init__()\n self.__class__.__name__ = class_name\n if isinstance(root, torch.nn.Module):\n if hasattr(root, 'training'):\n self.training = root.training\n for node in graph.nodes:\n if node.op in ['get_attr', 'call_module']:\n assert isinstance(node.target, str)\n _copy_attr(root, self, node.target)\n elif isinstance(root, dict):\n targets_to_copy = []\n for node in graph.nodes:\n if node.op in ['get_attr', 'call_module']:\n assert isinstance(node.target, str)\n if node.target not in root:\n raise RuntimeError('Node ' + str(node) + ' referenced target ' + node.target +\n ' but that target was not provided in ``root``!')\n targets_to_copy.append(node.target)\n # Sort targets in ascending order of the # of atoms.\n # This will ensure that less deeply nested attributes are assigned\n # before more deeply nested attributes. For example, foo.bar\n # will be assigned before foo.bar.baz. Otherwise, we might assign\n # the user-provided ``foo.bar`` and wipe out the previously-assigned\n # ``foo.bar.baz``\n targets_to_copy.sort(key=lambda t: t.count('.'))\n for target_to_copy in targets_to_copy:\n _assign_attr(root[target_to_copy], self, target_to_copy)\n else:\n raise RuntimeError('Unsupported type ' + str(root) + ' passed for root!')\n\n self.graph = graph\n\n # TorchScript breaks trying to compile the graph setter because of the\n # continued string literal. Issue here: https://github.com/pytorch/pytorch/issues/44842\n #\n # Shouldn't be an issue since these methods shouldn't be used in TorchScript anyway\n __jit_unused_properties__ = ['graph']\n\n @property\n def graph(self) -> Graph:\n \"\"\"\n Return the ``Graph`` underlying this ``GraphModule``\n \"\"\"\n return self._graph\n\n @graph.setter\n def graph(self, g : Graph) -> None:\n \"\"\"\n Set the underlying ``Graph`` for this ``GraphModule``. This will internally\n recompile the ``GraphModule`` so that the generated ``forward()`` function\n corresponds to ``g``\n \"\"\"\n assert isinstance(g, Graph), f'Expected a Graph instance, but got {type(g)}'\n self._graph = g\n g.owning_module = self\n self.recompile()\n\n def to_folder(self, folder: Union[str, os.PathLike], module_name : str = \"FxModule\"):\n \"\"\"Dumps out module to ``folder`` with ``module_name`` so that it can be\n imported with ``from <folder> import <module_name>``\n\n Args:\n\n folder (Union[str, os.PathLike]): The folder to write the code out to\n\n module_name (str): Top-level name to use for the ``Module`` while\n writing out the code\n \"\"\"\n folder = Path(folder)\n Path(folder).mkdir(exist_ok=True)\n torch.save(self.state_dict(), folder / 'state_dict.pt')\n tab = \" \" * 4\n model_str = f\"\"\"\nimport torch\nfrom torch.nn import *\nclass {module_name}(torch.nn.Module):\n def __init__(self):\n super().__init__()\n\"\"\"\n\n def _gen_model_repr(module_name: str, module: torch.nn.Module) -> Optional[str]:\n safe_reprs = [nn.Linear, nn.Conv1d, nn.Conv2d, nn.Conv3d, nn.BatchNorm1d, nn.BatchNorm2d, nn.BatchNorm3d]\n if type(module) in safe_reprs:\n return f\"{module.__repr__()}\"\n else:\n return None\n\n blobified_modules = []\n for module_name, module in self.named_children():\n module_str = _gen_model_repr(module_name, module)\n if module_str is None:\n module_file = folder / f'{module_name}.pt'\n torch.save(module, module_file)\n blobified_modules.append(module_name)\n module_repr = module.__repr__().replace('\\r', ' ').replace('\\n', ' ')\n module_str = f\"torch.load(r'{module_file}') # {module_repr}\"\n model_str += f\"{tab*2}self.{module_name} = {module_str}\\n\"\n\n for buffer_name, buffer in self._buffers.items():\n model_str += f\"{tab*2}self.register_buffer('{buffer_name}', torch.empty({list(buffer.shape)}))\\n\"\n\n for param_name, param in self._parameters.items():\n model_str += f\"{tab*2}self.{param_name} = torch.nn.Parameter(torch.empty({list(buffer.shape)}))\\n\"\n\n model_str += f\"{tab*2}self.load_state_dict(torch.load(r'{folder}/state_dict.pt'))\\n\"\n model_str += f\"{_addindent(self.code, 4)}\\n\"\n\n module_file = folder / 'module.py'\n module_file.write_text(model_str)\n\n init_file = folder / '__init__.py'\n init_file.write_text('from .module import *')\n\n if len(blobified_modules) > 0:\n warnings.warn(\"Was not able to save the following children modules as reprs -\"\n f\"saved as pickled files instead: {blobified_modules}\")\n\n def add_submodule(self, target: str, m: torch.nn.Module) -> bool:\n \"\"\"\n Adds the given submodule to ``self``.\n\n This installs empty Modules where none exist yet if they are\n subpaths of ``target``.\n\n Args:\n target: The fully-qualified string name of the new submodule\n (See example in ``nn.Module.get_submodule`` for how to\n specify a fully-qualified string.)\n m: The submodule itself; the actual object we want to\n install in the current Module\n\n Return:\n bool: Whether or not the submodule could be inserted. For\n this method to return True, each object in the chain\n denoted by ``target`` must either a) not exist yet,\n or b) reference an ``nn.Module`` (not a parameter or\n other attribute)\n\n \"\"\"\n *prefix, field = target.split('.')\n mod: torch.nn.Module = self\n\n for item in prefix:\n\n submod = getattr(mod, item, None)\n\n if submod is None:\n submod = torch.nn.Module()\n setattr(mod, item, submod)\n\n if not isinstance(submod, torch.nn.Module):\n return False\n\n mod = submod\n\n mod.add_module(field, m)\n return True\n\n def delete_submodule(self, target: str) -> bool:\n \"\"\"\n Deletes the given submodule from ``self``.\n\n The module will not be deleted if ``target`` is not a valid\n target.\n\n Args:\n target: The fully-qualified string name of the new submodule\n (See example in ``nn.Module.get_submodule`` for how to\n specify a fully-qualified string.)\n\n Returns:\n bool: Whether or not the target string referenced a\n submodule we want to delete. A return value of ``False``\n means that the ``target`` was not a valid reference to\n a submodule.\n \"\"\"\n atoms = target.split(\".\")\n path, target_submod = atoms[:-1], atoms[-1]\n mod: torch.nn.Module = self\n\n # Get the parent module\n for item in path:\n\n if not hasattr(mod, item):\n return False\n\n mod = getattr(mod, item)\n\n if not isinstance(mod, torch.nn.Module):\n return False\n\n if not hasattr(mod, target_submod):\n return False\n\n if not isinstance(getattr(mod, target_submod), torch.nn.Module):\n return False\n\n delattr(mod, target_submod)\n return True\n\n def delete_all_unused_submodules(self) -> None:\n \"\"\"\n Deletes all unused submodules from ``self``.\n\n A Module is considered \"used\" if any one of the following is\n true:\n 1. It has children that are used\n 2. Its forward is called directly via a ``call_module`` node\n 3. It has a non-Module attribute that is used from a\n ``get_attr`` node\n\n This method can be called to clean up an ``nn.Module`` without\n manually calling ``delete_submodule`` on each unused submodule.\n \"\"\"\n used: List[str] = []\n\n for node in self.graph.nodes:\n\n if node.op == \"call_module\" or node.op == \"get_attr\":\n\n # A list of strings representing the different parts\n # of the path. For exmaple, `foo.bar.baz` gives us\n # [\"foo\", \"bar\", \"baz\"]\n fullpath = node.target.split(\".\")\n\n # If we're looking at multiple parts of a path, join\n # join them with a dot. Otherwise, return that single\n # element without doing anything to it.\n def join_fn(x: str, y: str) -> str:\n return '.'.join([x, y] if y else [x])\n\n # Progressively collect all the names of intermediate\n # modules. For example, if we have the target\n # `foo.bar.baz`, we'll add `foo`, `foo.bar`, and\n # `foo.bar.baz` to the list.\n for path in itertools.accumulate(fullpath, join_fn):\n used.append(path)\n\n to_delete = [name for name, _ in self.named_modules()\n if name not in used]\n\n for name in to_delete:\n self.delete_submodule(name)\n\n @property\n def code(self) -> str:\n \"\"\"\n Return the Python code generated from the ``Graph`` underlying this\n ``GraphModule``.\n \"\"\"\n if not hasattr(self, '_code'):\n raise RuntimeError('Code has not been generated! Please report a bug to PyTorch')\n return self._code\n\n def recompile(self) -> PythonCode:\n \"\"\"\n Recompile this GraphModule from its ``graph`` attribute. This should be\n called after editing the contained ``graph``, otherwise the generated\n code of this ``GraphModule`` will be out of date.\n \"\"\"\n if self._graph._pytree_info is not None:\n self._in_spec = self._graph._pytree_info.in_spec\n self._out_spec = self._graph._pytree_info.out_spec\n python_code = self._graph.python_code(root_module='self')\n self._code = python_code.src\n\n cls = type(self)\n cls.forward = _forward_from_src(self._code, python_code.globals)\n\n cls_call = cls.__call__\n\n # Previously, if an error occurred when valid\n # symbolically-traced code was run with an invalid input, the\n # user would see the source of the error as coming from\n # `File \"<eval_with_key_N\">`, where N is some number. We use\n # this function to generate a more informative error message. We\n # return the traceback itself, a message explaining that the\n # error occurred in a traced Module's generated forward\n # function, and five lines of context surrounding the faulty\n # line\n def generate_error_message(frame_summary: traceback.FrameSummary) -> str:\n # auxiliary variables (for readability)\n err_lineno = frame_summary.lineno\n err_line_len = len(frame_summary.line)\n all_src_lines = _eval_cache[frame_summary.filename]\n\n # constituent substrings of the error message\n tb_repr = traceback.format_exc()\n custom_msg = (\"Call using an FX-traced Module, \"\n f\"line {err_lineno} of the traced Module's \"\n \"generated forward function:\")\n before_err = \"\".join(all_src_lines[err_lineno - 2 : err_lineno])\n marker = \"~\" * err_line_len + \"~~~ <--- HERE\"\n err_and_after_err = \"\\n\".join(all_src_lines[err_lineno : err_lineno + 2])\n\n # joined message\n return \"\\n\".join([tb_repr, custom_msg, before_err, marker, err_and_after_err])\n\n def wrapped_call(self, *args, **kwargs):\n try:\n return cls_call(self, *args, **kwargs)\n except Exception as e:\n assert e.__traceback__\n topmost_framesummary: traceback.FrameSummary = \\\n traceback.StackSummary.extract(traceback.walk_tb(e.__traceback__))[-1] # type: ignore[arg-type]\n if \"eval_with_key\" in topmost_framesummary.filename:\n print(generate_error_message(topmost_framesummary),\n file=sys.stderr)\n raise e.with_traceback(None)\n\n cls.__call__ = wrapped_call\n\n return python_code\n\n def __reduce_package__(self, exporter: PackageExporter):\n generated_module_name = f'fx-generated._{exporter.get_unique_id()}'\n python_code = self.recompile()\n import_block = _format_import_block(python_code.globals, exporter.importer)\n module_code = import_block + self.code\n exporter.save_source_string(generated_module_name, module_code)\n\n dict_without_graph = self.__dict__.copy()\n del dict_without_graph['_graph']\n return (reduce_package_graph_module, (dict_without_graph, generated_module_name))\n\n def __reduce__(self):\n \"\"\"\n Serialization of GraphModule. We serialize only the generated code, not\n the underlying ``Graph``. This is because ``Graph`` does not have on-disk\n backward-compatibility guarantees, whereas Python source code does.\n On the deserialization side, we symbolically trace through the generated\n code to regenerate the underlying ``Graph``\n \"\"\"\n dict_without_graph = self.__dict__.copy()\n python_code = self.recompile()\n import_block = _format_import_block(python_code.globals, sys_importer)\n del dict_without_graph['_graph']\n return (reduce_graph_module, (dict_without_graph, import_block))\n\n # because __reduce__ is defined for serialization,\n # we need to define deepcopy otherwise it will call __reduce__\n # and cause symbolic tracing to occur every time we try to copy the object\n def __deepcopy__(self, memo):\n fake_mod = torch.nn.Module()\n fake_mod.__dict__ = copy.deepcopy(self.__dict__)\n return GraphModule(fake_mod, self.graph)\n\n def __copy__(self):\n return GraphModule(self, self.graph)\n\n def __str__(self) -> str:\n orig_str = super().__str__()\n return '\\n'.join([orig_str, self._code])\n\n# workarounds for issues in __torch_function__\n\n# WAR for __torch_function__ not handling tensor lists,\n# fix is in https://github.com/pytorch/pytorch/pull/34725\n# orig_cat = torch.cat\n# def patched_cat(*args, **kwargs):\n# tensors = args[0]\n# for t in tensors:\n# if isinstance(t, Proxy):\n# return t.__torch_function__(patched_cat, (), args, kwargs)\n# return orig_cat(*args, **kwargs)\n# patched_cat.__module__ = 'torch'\n# patched_cat.__name__ = 'cat'\n# torch.cat = patched_cat\n" ]

[ [ "torch.nn.Module", "torch.nn.modules.module._addindent", "torch.save" ] ]