Spaces:
Sleeping
Sleeping
| import gradio | |
| import torch.nn as nn | |
| import torch | |
| from torch_geometric.loader import DataLoader | |
| import utils.clean_data as cd | |
| import utils.shape_features as sf | |
| import utils.node_features as nf | |
| import utils.edge_features as ef | |
| # from datetime import datetime | |
| # start_time = datetime.now() | |
| node_model_path = 'utils/emb_model/Node_64.pt' | |
| edge_model_path = 'utils/emb_model/Edge_64.pt' | |
| class InfoGraph(nn.Module): | |
| def __init__(self, hidden_dim, num_gc_layers, alpha=0.5, beta=1., gamma=.1): | |
| super(InfoGraph, self).__init__() | |
| self.alpha = alpha | |
| self.beta = beta | |
| self.gamma = gamma | |
| self.prior = False | |
| self.embedding_dim = mi_units = hidden_dim * num_gc_layers | |
| self.encoder = Encoder(dataset_num_features, hidden_dim, num_gc_layers) | |
| self.local_d = FF(self.embedding_dim) | |
| self.global_d = FF(self.embedding_dim) | |
| # self.local_d = MI1x1ConvNet(self.embedding_dim, mi_units) | |
| # self.global_d = MIFCNet(self.embedding_dim, mi_units) | |
| if self.prior: | |
| self.prior_d = PriorDiscriminator(self.embedding_dim) | |
| self.init_emb() | |
| def init_emb(self): | |
| initrange = -1.5 / self.embedding_dim | |
| for m in self.modules(): | |
| if isinstance(m, nn.Linear): | |
| torch.nn.init.xavier_uniform_(m.weight.data) | |
| if m.bias is not None: | |
| m.bias.data.fill_(0.0) | |
| def forward(self, x, edge_index, batch, num_graphs): | |
| # batch_size = data.num_graphs | |
| if x is None: | |
| x = torch.ones(batch.shape[0]).to(device) | |
| y, M = self.encoder(x, edge_index, batch) | |
| g_enc = self.global_d(y) | |
| l_enc = self.local_d(M) | |
| mode='fd' | |
| measure='JSD' | |
| local_global_loss = local_global_loss_(l_enc, g_enc, edge_index, batch, measure) | |
| if self.prior: | |
| prior = torch.rand_like(y) | |
| term_a = torch.log(self.prior_d(prior)).mean() | |
| term_b = torch.log(1.0 - self.prior_d(y)).mean() | |
| PRIOR = - (term_a + term_b) * self.gamma | |
| else: | |
| PRIOR = 0 | |
| return local_global_loss + PRIOR | |
| def outline_embedding(wkt, wall): | |
| wall_f, wkt_f = cd.read_wall_wkt(wall, wkt) | |
| apa_wall, apa_geo = cd.clean_geometry(wall_f, wkt_f) | |
| apa_geo = apa_geo | |
| apa_line = apa_geo.boundary | |
| apa_wall_O = cd.exterior_wall(apa_line, apa_wall) | |
| apa_coor = cd.geo_coor(apa_geo) | |
| xarr4cv, yarr4cv = apa_geo.exterior.coords.xy | |
| x4cv = xarr4cv.tolist() | |
| y4cv = yarr4cv.tolist() | |
| scale = 100000 | |
| xmin_abs = abs(min(x4cv)) | |
| ymin_abs = abs(min(y4cv)) | |
| p_4_cv = cd.points4cv(x4cv, y4cv, xmin_abs, ymin_abs, scale) | |
| grid_points = cd.gridpoints(apa_geo, 1) | |
| Dir_S_longestedge, Dir_N_longestedge, Dir_W_longestedge, Dir_E_longestedge, Dir_S_max, Dir_N_max, Dir_W_max, Dir_E_max, Facade_length, Facade_ratio = sf.wall_direction_ratio(apa_line, apa_wall) | |
| Perimeter = sf.apartment_perimeter(apa_geo) | |
| Area = sf.apartment_area(apa_geo) | |
| BBox_width_x, BBox_height_y, Aspect_ratio, Extent, ULC_x, ULC_y, LRC_x, LRC_y = sf.boundingbox_features(apa_geo) | |
| Max_diameter = sf.max_diameter(apa_geo) | |
| Fractality = sf.fractality(apa_geo) | |
| Circularity = sf.circularity(apa_geo) | |
| Outer_radius = sf.outer_radius(p_4_cv, xmin_abs, ymin_abs, scale) | |
| Inner_radius = sf.inner_radius(apa_geo, apa_line) | |
| Dist_mean, Dist_sigma, Roundness = sf.roundness_features(apa_line) | |
| Compactness = sf.compactness(apa_geo) | |
| Equivalent_diameter = sf.equivalent_diameter(apa_geo) | |
| Shape_membership_index = sf.shape_membership_index(apa_line) | |
| Convexity, Hull_geo = sf.convexity(p_4_cv, apa_geo, xmin_abs, ymin_abs, scale) | |
| Rectangularity, Rect_phi, Rect_width, Rect_height = sf.rectangle_features(p_4_cv, apa_geo, xmin_abs, ymin_abs, scale) | |
| Squareness = sf.squareness(apa_geo) | |
| Moment_index = sf.moment_index(apa_geo, Convexity, Compactness) | |
| nDetour_index = sf.ndetour_index(apa_geo, Hull_geo) | |
| nCohesion_index = sf.ncohesion_index(apa_geo, grid_points) | |
| nProximity_index, nSpin_index = sf.nproximity_nspin_index(apa_geo, grid_points) | |
| nExchange_index = sf.nexchange_index(apa_geo) | |
| nPerimeter_index = sf.nperimeter_index(apa_geo) | |
| nDepth_index = sf.ndepth_index(apa_geo, apa_line, grid_points) | |
| nGirth_index = sf.ngirth_index(apa_geo, Inner_radius) | |
| nRange_index = sf.nrange_index(apa_geo, Outer_radius) | |
| nTraversal_index = sf.ntraversal_index(apa_geo, apa_line) | |
| shape = [Dir_S_longestedge, Dir_N_longestedge, Dir_W_longestedge, Dir_E_longestedge, Dir_S_max, Dir_N_max, Dir_W_max, Dir_E_max, Facade_length, Facade_ratio, | |
| Perimeter, Area, | |
| BBox_width_x, BBox_height_y, Aspect_ratio, Extent, ULC_x, ULC_y, LRC_x, LRC_y, | |
| Max_diameter, Fractality, Circularity, Outer_radius, Inner_radius, | |
| Dist_mean, Dist_sigma, Roundness, | |
| Compactness, Equivalent_diameter, Shape_membership_index, Convexity, | |
| Rectangularity, Rect_phi, Rect_width, Rect_height, | |
| Squareness, Moment_index, nDetour_index, nCohesion_index, | |
| nProximity_index, nExchange_index, nSpin_index, nPerimeter_index, | |
| nDepth_index, nGirth_index, nRange_index, nTraversal_index] | |
| shape = [float(i) for i in shape] | |
| node_graph = nf.node_graph(apa_coor, apa_geo) | |
| node_model = torch.load(node_model_path) | |
| node_model.eval() | |
| node_dataloader = DataLoader(node_graph, batch_size=1) | |
| node_emb = node_model.encoder.get_embeddings(node_dataloader) | |
| node = node_emb[0].tolist() | |
| edge_graph = ef.edge_graph(apa_line, apa_wall) | |
| edge_model = torch.load(edge_model_path) | |
| edge_model.eval() | |
| edge_dataloader = DataLoader(edge_graph, batch_size=1) | |
| edge_emb = edge_model.encoder.get_embeddings(edge_dataloader) | |
| edge = edge_emb[0].tolist() | |
| json = {"edge": edge, | |
| "shape": shape, | |
| "node": node} | |
| return json | |
| gradio_interface = gradio.Interface(fn=outline_embedding, | |
| inputs = [gradio.Textbox(type="text", label="wkt", placeholder="wkt"), | |
| gradio.Textbox(type="text", label="wall", placeholder="wall")], | |
| outputs = "json", | |
| title="outline embedding") | |
| # end_time = datetime.now() | |
| # print('Duration: {}'.format(end_time - start_time)) | |
| # api_open=True, | |
| gradio_interface.queue(max_size=5, status_update_rate="auto") | |
| gradio_interface.launch(show_error=True, enable_queue=True) | |