app.py

# For neural networks
import keras
# For train-test splits
import sklearn.model_selection
# For random calculations
import numpy
# For help with saving and opening things
import os

# Disable eager execution because its bad
from tensorflow.python.framework.ops import disable_eager_execution
disable_eager_execution()

# Start a session for checking calculations and stuff
import tensorflow as tf
sess = tf.compat.v1.Session()

from keras import backend as K
K.set_session(sess)

# Do you want it loud? 
VERBOSE = 1

# This function loads a fuckton of data
def load_data():
    # Open all the files we downloaded at the beginning and take out hte good bits
    curves = numpy.load('data_curves.npz')['curves']
    geometry = numpy.load('data_geometry.npz')['geometry']
    constants = numpy.load('constants.npz')
    S = constants['S']
    N = constants['N']
    D = constants['D']
    F = constants['F']
    G = constants['G']

    # Some of the good bits need additional processining
    new_curves = numpy.zeros((S*N, D * F))
    for i, curveset in enumerate(curves):
        new_curves[i, :] = curveset.T.flatten() / 1000000

    new_geometry = numpy.zeros((S*N, G * G * G))
    for i, geometryset in enumerate(geometry):
        new_geometry[i, :] = geometryset.T.flatten()

    # Return good bits to user
    return curves, geometry, S, N, D, F, G, new_curves, new_geometry
    
import gradio
import pandas

curves, geometry, S, N, D, F, G, new_curves, new_geometry = load_data()

class Network(object):

  def __init__(self, structure, weights):
      # Instantiate variables
      self.curves = curves
      self.new_curves = new_curves
      self.geometry = geometry
      self.new_geometry = new_geometry
      self.S = S
      self.N = N
      self.D = D
      self.F = F
      self.G = G

      # Load network
      with open(structure, 'r') as file:
          self.network = keras.models.model_from_json(file.read())
          self.network.load_weights(weights)

  def analysis(self, idx=None):
      print(idx)

      if idx is None:
          idx = numpy.random.randint(1, self.S * self.N)
      else:
        idx = int(idx)

      # Get the input
      data_input = self.new_geometry[idx:(idx+1), :]
      other_data_input = data_input.reshape((self.G, self.G, self.G), order='F')

      # Get the outputs
      predicted_output = self.network.predict(data_input)
      true_output = self.new_curves[idx].reshape((3, self.F))
      predicted_output = predicted_output.reshape((3, self.F))

      f = numpy.linspace(0.05, 2.0, 64)
      fd = pandas.DataFrame(f).rename(columns={0: "Frequency"})
      df_pred = pandas.DataFrame(predicted_output.transpose()).rename(columns={0: "Surge", 1: "Heave", 2: "Pitch"})
      df_true = pandas.DataFrame(true_output.transpose()).rename(columns={0: "Surge", 1: "Heave", 2: "Pitch"})

      # return idx, other_data_input, true_output, predicted_output
      return pandas.concat([fd, df_pred], axis=1), pandas.concat([fd, df_true], axis=1)

  def synthesis(self, idx=None):
      print(idx)

      if idx is None:
          idx = numpy.random.randint(1, self.S * self.N)
      else:
        idx = int(idx)

      # Get the input
      data_input = self.new_curves[idx:(idx+1), :]
      other_data_input = data_input.reshape((3, self.F))

      # Get the outputs
      predicted_output = self.network.predict(data_input)
      true_output = self.new_geometry[idx].reshape((self.G, self.G, self.G), order='F')
      predicted_output = predicted_output.reshape((self.G, self.G, self.G), order='F')

      # return idx, other_data_input, true_output, predicted_output
      return predicted_output, true_output
      
  
  def synthesis_from_spectrum(self, other_data_input):
      # Get the input
      data_input = other_data_input.reshape((1, 3*self.F))
 
      # Get the outputs
      predicted_output = self.network.predict(data_input)
      predicted_output = predicted_output.reshape((self.G, self.G, self.G), order='F')

      # return idx, other_data_input, true_output, predicted_output
      return predicted_output

  def get_geometry(self, idx=None):

      if idx is None:
          idx = numpy.random.randint(1, self.S * self.N)
      else:
        idx = int(idx)

      idx = int(idx)

      # Get the input
      data_input = self.new_geometry[idx:(idx+1), :]
      other_data_input = data_input.reshape((self.G, self.G, self.G), order='F')

      # return idx, other_data_input, true_output, predicted_output
      return other_data_input


  def get_performance(self, idx=None):

      if idx is None:
          idx = numpy.random.randint(1, self.S * self.N)
      else:
        idx = int(idx)

      idx = int(idx)

      # Get the input
      data_input = self.new_curves[idx:(idx+1), :]
      other_data_input = data_input.reshape((3, self.F))

      f = numpy.linspace(0.05, 2.0, 64)
      fd = pandas.DataFrame(f).rename(columns={0: "Frequency"})
      df_pred = pandas.DataFrame(other_data_input.transpose()).rename(columns={0: "Surge", 1: "Heave", 2: "Pitch"})
      table = pandas.concat([fd, df_pred], axis=1)

      # return idx, other_data_input, true_output, predicted_output
      return table

# forward_net = Network("16forward_structure.json", "16forward_weights.h5")
# inverse_net = Network("16inverse_structure.json", "16inverse_weights.h5")



import plotly.graph_objects as go
import numpy as np


def plotly_fig(values):
    X, Y, Z = np.mgrid[0:1:32j, 0:1:32j, 0:1:32j]
    fig = go.Figure(data=go.Volume(
        x=X.flatten(),
        y=Y.flatten(),
        z=Z.flatten(),
        value=values.flatten(),
        isomin=-0.1,
        isomax=0.8,
        opacity=0.1, # needs to be small to see through all surfaces
        surface_count=21, # needs to be a large number for good volume rendering
        ))
    return fig 

value_net = Network("16forward_structure.json", "16forward_weights.h5")

def performance(index):
    return value_net.get_performance(index)

def geometry(index):
    values = value_net.get_geometry(index)
    return plotly_fig(values)

def simple_analysis(index): 
    forward_net = Network("16forward_structure.json", "16forward_weights.h5")  
    return forward_net.analysis(index)

def simple_synthesis(index):
    inverse_net = Network("16inverse_structure.json", "16inverse_weights.h5")
    pred, true = inverse_net.synthesis(index)
    return plotly_fig(pred), plotly_fig(true)
    
def synthesis_from_spectrum(df):
    inverse_net = Network("16inverse_structure.json", "16inverse_weights.h5")
    pred = inverse_net.synthesis_from_spectrum(df.to_numpy())
    return plotly_fig(pred)
   
    
with gradio.Blocks() as analysis_demo:
    with gradio.Row():
        with gradio.Column():
            num = gradio.Number(42, label="data index")
            btn1 = gradio.Button("Select")    
        with gradio.Column():
            geo = gradio.Plot(label="Geometry")

    with gradio.Row():
        btn2 = gradio.Button("Estimate Spectrum")

    with gradio.Row():
      with gradio.Column():
          pred = gradio.Timeseries(x="Frequency", y=['Surge', 'Heave', 'Pitch'], label="Predicted")

      with gradio.Column():
          true = gradio.Timeseries(x="Frequency", y=['Surge', 'Heave', 'Pitch'], label="True")

    btn1.click(fn=geometry, inputs=[num], outputs=[geo])
    btn2.click(fn=simple_analysis, inputs=[num], outputs=[pred, true])
    
with gradio.Blocks() as synthesis_demo:
    with gradio.Row():
        with gradio.Column():
            num = gradio.Number(42, label="data index")
            btn1 = gradio.Button("Select")    
        with gradio.Column():
            perf = gradio.Timeseries(x="Frequency", y=['Surge', 'Heave', 'Pitch'], label="Performance")

    with gradio.Row():
        btn2 = gradio.Button("Synthesize Geometry")

    with gradio.Row():
      with gradio.Column():
          pred = gradio.Plot(label="Predicted")

      with gradio.Column():
          true = gradio.Plot(label="True")

    btn1.click(fn=performance, inputs=[num], outputs=[perf])
    btn2.click(fn=simple_synthesis, inputs=[num], outputs=[pred, true])
    
    
with gradio.Blocks() as synthesis_demo2:
    with gradio.Row():
        perf = gradio.Timeseries(x="Frequency", y=['Surge', 'Heave', 'Pitch'], label="Performance")

    with gradio.Row():
        btn2 = gradio.Button("Synthesize Geometry")

    with gradio.Row():
        pred = gradio.Plot(label="Predicted")

    btn2.click(fn=synthesis_from_spectrum, inputs=[perf], outputs=[pred])
    
    
with gradio.Blocks() as synthesis_demo3:
    with gradio.Row():
        perf = gradio.DataFrame(headers=['Surge', 'Heave', 'Pitch'], value=numpy.zeros((64, 3)).tolist())

    with gradio.Row():
        btn2 = gradio.Button("Synthesize Geometry")

    with gradio.Row():
        pred = gradio.Plot(label="Predicted")

    btn2.click(fn=synthesis_from_spectrum, inputs=[perf], outputs=[pred])
    
    
with gradio.Blocks() as intro:
    with gradio.Row():
        with gradio.Column():
            title = gradio.Markdown("# Toward the Rapid Design of Engineered Systems Through Deep Neural Networks")
        with gradio.Column():
            title = gradio.Markdown("Christopher McComb\n[Design Research Collective](https://cmudrc.github.io/)\nCarnegie Mellon University")
        with gradio.Column():
            download = gradio.File(value="McComb2019_Chapter_TowardTheRapidDesignOfEngineer.pdf")
    with gradio.Row():
        gradio.Markdown("The design of a system commits a significant portion of the final cost of that system. Many computational approaches have been developed to assist designers in the analysis (e.g., computational fluid dynamics) and synthesis (e.g., topology optimization) of engineered systems. However, many of these approaches are computationally intensive, taking significant time to complete an analysis and even longer to iteratively synthesize a solution. The current work proposes a methodology for rapidly evaluating and synthesizing engineered systems through the use of deep neural networks. The proposed methodology is applied to the analysis and synthesis of offshore structures such as oil platforms. These structures are constructed in a marine environment and are typically designed to achieve specific dynamics in response to a known spectrum of ocean waves. Results show that deep learning can be used to accurately and rapidly synthesize and analyze offshore structures.\n\nThe paper linked to the left provides details about the implementation. This site contains demos of the trained networks.")
    
all_synthesis_demos = gradio.TabbedInterface([synthesis_demo, synthesis_demo2, synthesis_demo3], ["Spectrum from Dataset", "Spectrum from File", "Spectrum from DataFrame"])

all_analysis_demos = gradio.TabbedInterface([analysis_demo], ["Geometry from Data"])

demo = gradio.TabbedInterface([intro, all_analysis_demos, all_synthesis_demos], ["About", "Analysis", "Synthesis"])
demo.launch(debug=True)