trying to use pyt

app.py

@@ -3,12 +3,20 @@ from matplotlib import cm
 import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 import numpy as np
-import onnxruntime as ort
+# import onnxruntime as ort
 from PIL import Image
 from scipy import special
+import sys
+from types import SimpleNamespace
+from transformers import AutoModel
+import torch
 
-# model_path = 'chlab/planet_detection_models/'
-model_path = './models/'
+# sys.path.insert(1, "../")
+# from utils import model_utils, train_utils, data_utils, run_utils
+# from model_utils import jason_regnet_maker, jason_efficientnet_maker
+
+model_path = 'chlab/'
+# model_path = './models/'
 
 # plotting a prameters
 labels = 20
@@ -20,6 +28,24 @@ lw = 3
 ps = 200
 cmap = 'magma'
 
+effnet_61_hparams = {
+    "num_classes": 2,
+    "gamma": 0.032606396652426956,
+    "lr": 0.008692971067922545,
+    "weight_decay": 0.00008348389688708425,
+    "batch_size": 23,
+    "num_channels": 61,
+    "stochastic_depth_prob": 0.003581930052432713,
+    "dropout": 0.027804120950575217,
+    "width_mult": 1.060782511229692,
+    "depth_mult": 0.7752918857163054,
+}
+effnet_61_config = SimpleNamespace(**effnet_61_hparams)
+
+# which layers to look at
+activation_indices = {'efficientnet': [0, 3]}
+
+
 def normalize_array(x: list):
 
     '''Makes array between 0 and 1'''
@@ -28,42 +54,56 @@ def normalize_array(x: list):
     
     return (x - np.min(x)) / np.max(x - np.min(x))
 
-def load_model(model: str, activation: bool=True):
+# def load_model(model: str, activation: bool=True):
     
-    if activation:
-        model += '_w_activation'
+#     if activation:
+#         model += '_w_activation'
     
-    # set options for onnx runtime
-    options = ort.SessionOptions()
-    options.intra_op_num_threads = 1
-    options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-    provider = "CPUExecutionProvider"
+#     # set options for onnx runtime
+#     options = ort.SessionOptions()
+#     options.intra_op_num_threads = 1
+#     options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+#     provider = "CPUExecutionProvider"
     
-    # start session
-    ort_session = ort.InferenceSession(model_path + '%s.onnx' % (model), options, providers=[provider])
-    # ort_session = ORTModel.load_model(model_path + '%s.onnx' % (model))
+#     # start session
+#     ort_session = ort.InferenceSession(model_path + '%s.onnx' % (model), options, providers=[provider])
+#     # ort_session = ORTModel.load_model(model_path + '%s.onnx' % (model))
     
-    return ort_session
+#     return ort_session
 
-def get_activations(intermediate_model, image: list,
-                    layer=None, vmax=2.5, sub_mean=True):
+def get_activations(model, image: list, model_name: str,
+                    layer=None, vmax=2.5, sub_mean=True,
+                    channel: int=0):
     
     '''Gets activations for a given input image'''
     
     # run model
-    input_name = intermediate_model.get_inputs()[0].name
-    outputs = intermediate_model.run(None, {input_name: image})
+    # input_name = intermediate_model.get_inputs()[0].name
+    # outputs = intermediate_model.run(None, {input_name: image})
+    
+    
+    layer_outputs = {}
+    for i in range(len(model.model.features)):
+        image = model.model.features[i](image)
+        layer_outputs[i] = image
+        print(i, layer_outputs[i].shape)
+    output = model.model(image).detach().cpu().numpy()
+    output_1 = activation_indices[model_name].detach().cpu().numpy()
+    output_2 = activation_indices[model_name].detach().cpu().numpy()
     
     # get activations
-    output_1 = outputs[1]
-    output_2 = outputs[2]
+    # output_1 = outputs[1]
+    # output_2 = outputs[2]
     
     # get prediction
-    output = outputs[0][0]
+    # output = outputs[0][0]
     output = special.softmax(output)
     
     # sum over velocity channels
-    in_image = np.sum(image[0, :, :, :], axis=0)
+    if channel == 0:
+        in_image = np.sum(image[0, :, :, :], axis=0)
+    else:
+        image[0, int(channel-1), :, :]
     in_image = normalize_array(in_image)
 
     if layer is None:
@@ -134,7 +174,7 @@ def plot_activations(activation_1: list, activation_2: list, origin='lower'):
     return fig
 
 
-def predict_and_analyze(model_name, num_channels, dim, image):
+def predict_and_analyze(model_name, num_channels, dim, input_channel, image):
     
     '''
     Loads a model with activations, passes through image and shows activations
@@ -153,16 +193,23 @@ def predict_and_analyze(model_name, num_channels, dim, image):
     if len(image.shape) != 4:
         image = image[np.newaxis, :, :, :]
         
+    image = torch.from_numpy(image)
+        
     assert image.shape == (1, num_channels, W, W), "Data is the wrong shape"
     
-    model_name += '_%i' % (num_channels)
+    # pipeline = pipeline(task="image-classification", model=model_path + "%s_%i_.pyt" % (model_name, num_channels))
+    
+    # model_name += '_%i' % (num_channels)
+    
+    model_loading_name =  model_path + "%s_%i_planet_detection" % (model_name, num_channels)
     
     print("Loading model")
-    model = load_model(model_name, activation=True)
+    # model = load_model(model_name, activation=True)
+    model = AutoModel.from_pretrained(model_loading_name)
     print("Model loaded")
     
     print("Looking at activations")
-    output, input_image, activation_1, activation_2 = get_activations(model, image, sub_mean=True)
+    output, input_image, activation_1, activation_2 = get_activations(model, image, model_name, sub_mean=True)
     print("Activations and predictions finished")
     
     if output[0] < output[1]:
@@ -185,13 +232,13 @@ def predict_and_analyze(model_name, num_channels, dim, image):
     input_fig = plot_input(input_image, origin=origin)
     
     # plot mean subtracted activations
-    fig1 = plot_activations(activation_1, activation_2, origin=origin)
+    fig1 = plot_activations(activation_1, activation_2, model_name, origin=origin)
     
     # plot raw activations
-    _, _, activation_1, activation_2 = get_activations(model, image, sub_mean=False)
+    _, _, activation_1, activation_2 = get_activations(model, image, model_name, sub_mean=False)
     activation_1 = normalize_array(activation_1)
     activation_2 = normalize_array(activation_2)
-    fig2 = plot_activations(activation_1, activation_2, origin=origin)
+    fig2 = plot_activations(activation_1, activation_2, model_name, origin=origin)
     
     print("Sending to Hugging Face")
     
@@ -214,6 +261,9 @@ if __name__ == "__main__":
                             value="600",
                             label="Image Dimensions",
                             show_label=True), 
+                gr.Number(value=0.,
+                            label="Input Channel to show (0 = sum over all)",
+                            show_label=True), 
                 gr.File(label="Input Data", show_label=True)],
         outputs=[gr.Textbox(lines=1, label="Prediction", show_label=True), 
                 # gr.Image(label="Input Image", show_label=True), 

requirements.txt

@@ -2,5 +2,5 @@ torch
 numpy
 matplotlib
 scipy
-onnxruntime
-Pillow
+Pillow
+transformers