:initial commit

.gitignore

@@ -0,0 +1,8 @@
+.env
+venv/
+images/
+*.pyc
+*.pyo
+*.pyd
+*.swp
+*.__pycache__

app.py

@@ -0,0 +1,121 @@
+
+import subprocess
+import os  
+if os.getenv('SYSTEM') == 'spaces':
+    subprocess.call('pip install tensorflow==2.9'.split())
+    subprocess.call('pip install keras==2.9'.split())
+    subprocess.call('pip install git+https://github.com/facebookresearch/segment-anything.git')
+    subprocess.call('pip install opencv-python-headless==4.5.5.64'.split())
+    subprocess.call('pip install git+https://github.com/cocodataset/panopticapi.git'.split())
+
+import gradio as gr
+from huggingface_hub import snapshot_download
+import cv2 
+import dotenv 
+dotenv.load_dotenv()
+import numpy as np
+import gradio as gr
+import glob
+from inference_sam import segmentation_sam
+
+import pathlib
+
+if not os.path.exists('images'):
+    REPO_ID='Serrelab/image_examples_gradio'
+    snapshot_download(repo_id=REPO_ID, token=os.environ.get('READ_TOKEN'),repo_type='dataset',local_dir='images')
+
+
+def segment_image(input_image):
+    img = segmentation_sam(input_image)
+    return img
+
+def classify_image(input_image, model_name):
+    if 'Rock 170' ==model_name:
+        from inference_resnet import inference_resnet_finer
+        result = inference_resnet_finer(input_image,model_name,n_classes=171)
+        return result 
+    elif 'Mummified 170' ==model_name:
+        from inference_resnet import inference_resnet_finer
+        result = inference_resnet_finer(input_image,model_name,n_classes=170)
+        return result 
+    if 'Fossils 19' ==model_name:
+        from inference_beit import inference_dino
+        return inference_dino(input_image,model_name)
+    return None
+
+def find_closest(input_image):
+    return None 
+
+
+with gr.Blocks(theme='sudeepshouche/minimalist') as demo:
+    
+    with gr.Tab(" 19 Classes Support"):
+    
+        with gr.Row():
+            with gr.Column():
+                input_image = gr.Image(label="Input")
+                classify_image_button = gr.Button("Classify Image")
+            
+            with gr.Column():
+                segmented_image = gr.outputs.Image(label="SAM output",type='numpy')
+                segment_button = gr.Button("Segment Image")
+                #classify_segmented_button = gr.Button("Classify Segmented Image")
+                
+            with gr.Column():
+                drop_2 = gr.Dropdown(
+                    ["Mummified 170", "Rock 170", "Fossils 19"],
+                    multiselect=False,
+                    value=["Rock 170"],
+                    label="Model",
+                    interactive=True,
+                )
+                class_predicted = gr.Label(label='Class Predicted',num_top_classes=10)
+               
+        with gr.Row():
+           
+            paths = sorted(pathlib.Path('images/').rglob('*.jpg'))
+            samples=[[path.as_posix()] for path in paths  if 'fossils' in  str(path) ][:19]
+            examples_fossils = gr.Examples(samples, inputs=input_image,examples_per_page=10,label='Fossils Examples from the dataset')
+            samples=[[path.as_posix()] for path in paths  if 'leaves' in  str(path) ][:19]
+            examples_leaves = gr.Examples(samples, inputs=input_image,examples_per_page=5,label='Leaves Examples from the dataset')
+            
+        with gr.Accordion("Using Diffuser"):
+            with gr.Column(): 
+                prompt = gr.Textbox(lines=1, label="Prompt")
+                output_image = gr.Image(label="Output")
+                generate_button = gr.Button("Generate Leave")    
+            with gr.Column():
+                class_predicted2 = gr.Label(label='Class Predicted from diffuser')
+                classify_button = gr.Button("Classify Image")
+            
+        
+        with gr.Accordion("Explanations "):
+            gr.Markdown("Computing Explanations from the model")
+            with gr.Row():
+                original_input = gr.Image(label="Original Frame")
+                saliency  = gr.Image(label="saliency")
+                gradcam = gr.Image(label='gradcam')
+                guided_gradcam = gr.Image(label='guided gradcam')
+                guided_backprop = gr.Image(label='guided backprop')
+            generate_explanations = gr.Button("Generate Explanations")
+                
+        with gr.Accordion('Closest Images'):
+            gr.Markdown("Finding the closest images in the dataset")
+            with gr.Row():
+                closest_image_0 = gr.Image(label='Closest Image')
+                closest_image_1 = gr.Image(label='Second Closest Image')
+                closest_image_2 = gr.Image(label='Third Closest Image')
+                closest_image_3 = gr.Image(label='Forth Closest Image')
+                closest_image_4 = gr.Image(label='Fifth Closest Image')
+            find_closest_btn = gr.Button("Find Closest Images")
+            
+        segment_button.click(segment_image, inputs=input_image, outputs=segmented_image)
+        classify_image_button.click(classify_image, inputs=[input_image,drop_2], outputs=class_predicted)
+        #classify_segmented_button.click(classify_image, inputs=[segmented_image,drop_2], outputs=class_predicted)
+        
+        
+   
+demo.launch(debug=True)
+    
+
+

inference_resnet.py

@@ -0,0 +1,167 @@
+import tensorflow as tf
+gpu_devices = tf.config.experimental.list_physical_devices('GPU')
+tf.config.experimental.set_memory_growth(gpu_devices[0], True)
+from keras.applications import resnet
+import tensorflow.keras.layers as L
+import os 
+
+from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
+import matplotlib.pyplot as plt
+from typing import Tuple
+from huggingface_hub import snapshot_download
+from labels import lookup_170
+import numpy as np 
+
+
+REPO_ID='Serrelab/fossil_classification_models'
+snapshot_download(repo_id=REPO_ID, token=os.environ.get('READ_TOKEN'),repo_type='model',local_dir='model_classification')
+
+
+def get_model(base_arch='Nasnet',weights='imagenet',input_shape=(600,600,3),classes=64500):
+
+    if base_arch == 'Nasnet':
+        base_model = tf.keras.applications.NASNetLarge(
+                                     input_shape=input_shape,
+                                    include_top=False,
+                                    weights=weights,
+                                    input_tensor=None,
+                                    pooling=None,
+                                    
+                            )
+    elif base_arch == 'Resnet50v2':
+        base_model = tf.keras.applications.ResNet50V2(weights=weights, 
+                                    include_top=False, 
+                                    pooling='avg',
+                                    input_shape=input_shape)
+    elif base_arch == 'Resnet50v2_finer':
+        base_model = tf.keras.applications.ResNet50V2(weights=weights, 
+                                    include_top=False, 
+                                    pooling='avg',
+                                    input_shape=input_shape)
+        base_model = resnet.stack2(base_model.output, 512, 2, name="conv6")
+        base_model = resnet.stack2(base_model, 512, 2, name="conv7")
+        base_model = tf.keras.Model(base_model.input,base_model)        
+                             
+    model = tf.keras.Sequential([
+        base_model,
+        L.Dense(classes,activation='softmax')
+    ])
+    
+    
+    
+    model.compile(optimizer='adam',
+                  loss='categorical_crossentropy',
+                  )
+    
+    return model
+
+
+def get_triplet_model(input_shape = (600, 600, 3),
+                      embedding_units = 256,
+                      embedding_depth = 2,
+                      backbone_class=tf.keras.applications.ResNet50V2,
+                      nb_classes = 19,load_weights=False,finer_model=False,backbone_name ='Resnet50v2'):
+
+    
+    backbone = backbone_class(input_shape=input_shape, include_top=False)
+    if load_weights:
+        model = get_model(backbone_name,input_shape=input_shape)
+        model.load_weights('/users/irodri15/data/irodri15/Fossils/Models/pretrained-herbarium/Resnet50v2_NO_imagenet_None_best_1600.h5')
+        trw = model.layers[0].get_weights()
+        backbone.set_weights(trw)
+    if finer_model: 
+        base_model = resnet.stack2(backbone.output, 512, 2, name="conv6")
+        base_model = resnet.stack2(base_model, 512, 2, name="conv7")
+        backbone = tf.keras.Model(backbone.input,base_model)  
+
+    features = GlobalAveragePooling2D()(backbone.output)
+
+    embedding_head = features
+    for embed_i in range(embedding_depth):
+        embedding_head = Dense(embedding_units, activation="relu" if embed_i < embedding_depth-1 else "linear")(embedding_head)
+    embedding_head = tf.nn.l2_normalize(embedding_head, -1, epsilon=1e-5)
+
+    logits_head = Dense(nb_classes)(features)
+
+    model = tf.keras.Model(backbone.input, [embedding_head, logits_head])
+    model.compile(loss='cce',metrics=['accuracy'])
+    #model.summary()
+
+    return model
+
+load_size = 600
+crop_size = 600
+def _clever_crop(img: tf.Tensor,
+                 target_size: Tuple[int]=(128,128),
+                 grayscale: bool=False
+                 ) -> tf.Tensor:
+    """[summary]
+    Args:
+        img (tf.Tensor): [description]
+        target_size (Tuple[int], optional): [description]. Defaults to (128,128).
+        grayscale (bool, optional): [description]. Defaults to False.
+    Returns:
+        tf.Tensor: [description]
+    """    
+    maxside = tf.math.maximum(tf.shape(img)[0],tf.shape(img)[1])
+    minside = tf.math.minimum(tf.shape(img)[0],tf.shape(img)[1])
+    new_img = img
+             
+    if tf.math.divide(maxside,minside) > 1.2:
+        repeating = tf.math.floor(tf.math.divide(maxside,minside))  
+        new_img = img
+        if tf.math.equal(tf.shape(img)[1],minside):
+            for _ in range(int(repeating)):
+                new_img = tf.concat((new_img, img), axis=1) 
+
+        if tf.math.equal(tf.shape(img)[0],minside):
+            for _ in range(int(repeating)):
+                new_img = tf.concat((new_img, img), axis=0)
+            new_img = tf.image.rot90(new_img) 
+    else:
+        new_img = img  
+        repeating = 0     
+    img = tf.image.resize(new_img, target_size)
+    if grayscale:
+        img = tf.image.rgb_to_grayscale(img)
+        img = tf.image.grayscale_to_rgb(img)
+        
+    return img,repeating
+
+def preprocess(img,size=600):
+  img = np.array(img, np.float32) / 255.0
+  img = tf.image.resize(img, (size, size))
+  return np.array(img, np.float32)
+
+
+def select_top_n(preds,n=10):
+    top_n = np.argsort(preds)[-n:][::-1]
+    return top_n
+
+
+def parse_results(top_n,logits):
+    results = {}
+    for n in top_n:
+        label = lookup_170[n]
+        results[label] = float(logits[n])
+    return results 
+
+def inference_resnet_finer(x,type_model,size=576,n_classes=170,n_top=10):
+    
+    model = get_triplet_model(input_shape = (size, size, 3),
+                        embedding_units = 256,
+                        embedding_depth = 2,
+                        backbone_class=tf.keras.applications.ResNet50V2,
+                        nb_classes = n_classes,load_weights=False,finer_model=True,backbone_name ='Resnet50v2')
+    if type_model=='Mummified 170':
+        model.load_weights('model_classification/mummified-170.h5')
+    elif type_model=='Rock 170':
+        model.load_weights('model_classification/rock-170.h5')
+    else:
+        return 'Error' 
+    cropped = _clever_crop(x,(size,size))[0]
+    prep = preprocess(cropped,size=size)
+    logits = tf.nn.softmax(model.predict(np.array([prep]))[1][0]).cpu().numpy()
+    top_n = select_top_n(logits,n=n_top)
+    
+    return parse_results(top_n,logits)

inference_sam.py

@@ -0,0 +1,175 @@
+import torch
+torch.cuda.set_per_process_memory_fraction(0.3, device=0)
+import tensorflow as tf
+gpu_devices = tf.config.experimental.list_physical_devices('GPU')
+tf.config.experimental.set_memory_growth(gpu_devices[0], True)
+
+from segment_anything import SamPredictor, sam_model_registry
+import matplotlib.pyplot as plt
+import cv2
+import numpy as np
+from math import ceil
+import os
+from huggingface_hub import snapshot_download
+
+REPO_ID='Serrelab/SAM_Leaves'
+snapshot_download(repo_id=REPO_ID, token=os.environ.get('READ_TOKEN'),repo_type='model',local_dir='model')
+
+sam = sam_model_registry["default"]("model/sam_02-06_dice_mse_0.pth")
+sam.cuda()
+predictor = SamPredictor(sam)
+
+
+from torch.nn import functional as F
+
+
+def pad_gt(x):
+  h, w = x.shape[-2:]
+  padh = sam.image_encoder.img_size - h
+  padw = sam.image_encoder.img_size - w
+  x = F.pad(x, (0, padw, 0, padh))
+  return x
+
+def preprocess(img):
+ 
+  img = np.array(img).astype(np.uint8)
+
+  #assert img.max() > 127.0
+
+  img_preprocess = predictor.transform.apply_image(img)
+  intermediate_shape = img_preprocess.shape
+
+  img_preprocess = torch.as_tensor(img_preprocess).cuda()
+  img_preprocess = img_preprocess.permute(2, 0, 1).contiguous()[None, :, :, :]
+
+  img_preprocess = sam.preprocess(img_preprocess)
+  if len(intermediate_shape) == 3:
+     intermediate_shape = intermediate_shape[:2]
+  elif len(intermediate_shape) == 4:
+     intermediate_shape = intermediate_shape[1:3]
+
+  return img_preprocess, intermediate_shape
+
+
+def normalize(img):
+  img = img - tf.math.reduce_min(img)
+  img = img / tf.math.reduce_max(img)
+  img = img * 2.0 - 1.0
+  return img
+
+def resize(img):
+  # default resize function for all pi outputs
+  return tf.image.resize(img, (SIZE, SIZE), method="bicubic")
+
+def smooth_mask(mask, ds=20):
+  shape = tf.shape(mask)
+  w, h = shape[0], shape[1]
+  return tf.image.resize(tf.image.resize(mask, (ds, ds), method="bicubic"), (w, h), method="bicubic")
+
+def pi(img, mask):
+  img = tf.cast(img, tf.float32)
+
+  shape = tf.shape(img)
+  w, h = tf.cast(shape[0], tf.int64), tf.cast(shape[1], tf.int64)
+  
+  mask = smooth_mask(mask.cpu().numpy().astype(float))
+  mask = tf.reduce_mean(mask, -1)
+
+  img = img * tf.cast(mask > 0.01, tf.float32)[:, :, None]
+
+
+  img_resize = tf.image.resize(img, (SIZE, SIZE), method="bicubic", antialias=True)
+  img_pad = tf.image.resize_with_pad(img, SIZE, SIZE, method="bicubic", antialias=True)
+
+  # building 2 anchors
+  anchors = tf.where(mask > 0.15)
+  anchor_xmin = tf.math.reduce_min(anchors[:, 0])
+  anchor_xmax = tf.math.reduce_max(anchors[:, 0])
+  anchor_ymin = tf.math.reduce_min(anchors[:, 1])
+  anchor_ymax = tf.math.reduce_max(anchors[:, 1])
+
+  if anchor_xmax - anchor_xmin > 50 and anchor_ymax - anchor_ymin > 50:
+
+    img_anchor_1 = resize(img[anchor_xmin:anchor_xmax, anchor_ymin:anchor_ymax])
+
+    delta_x = (anchor_xmax - anchor_xmin) // 4
+    delta_y = (anchor_ymax - anchor_ymin) // 4
+    img_anchor_2 = img[anchor_xmin+delta_x:anchor_xmax-delta_x,
+                      anchor_ymin+delta_y:anchor_ymax-delta_y]
+    img_anchor_2 = resize(img_anchor_2)
+  else:
+    img_anchor_1 = img_resize
+    img_anchor_2 = img_pad
+
+  # building the anchors max
+  anchor_max = tf.where(mask == tf.math.reduce_max(mask))[0]
+  anchor_max_x, anchor_max_y = anchor_max[0], anchor_max[1]
+
+  img_max_zoom1 = img[tf.math.maximum(anchor_max_x-SIZE, 0): tf.math.minimum(anchor_max_x+SIZE, w),
+                      tf.math.maximum(anchor_max_y-SIZE, 0): tf.math.minimum(anchor_max_y+SIZE, h)]
+
+  img_max_zoom1 = resize(img_max_zoom1)
+  img_max_zoom2 = img[anchor_max_x-SIZE//2:anchor_max_x+SIZE//2,
+                      anchor_max_y-SIZE//2:anchor_max_y+SIZE//2]
+  #img_max_zoom2 = img[tf.math.maximum(anchor_max_x-SIZE//2, 0): tf.math.minimum(anchor_max_x+SIZE//2, w),
+  #                    tf.math.maximum(anchor_max_y-SIZE//2, 0): tf.math.minimum(anchor_max_y+SIZE//2, h)]
+  #tf.print(img_max_zoom2.shape)
+  #img_max_zoom2 = resize(img_max_zoom2)
+  return tf.cast([
+      img_resize,
+      #img_pad,
+      img_anchor_1,
+      img_anchor_2,
+      img_max_zoom1,
+      #img_max_zoom2,
+    ], tf.float32)
+  
+def one_step_inference(x):
+  if len(x.shape) == 3:
+    original_size = x.shape[:2]
+  elif len(x.shape) == 4:
+    original_size = x.shape[1:3]
+  
+  x, intermediate_shape = preprocess(x)
+
+  with torch.no_grad():
+    image_embedding = sam.image_encoder(x)
+
+  with torch.no_grad():
+    sparse_embeddings, dense_embeddings = sam.prompt_encoder(points = None, boxes = None,masks = None)
+    low_res_masks, iou_predictions = sam.mask_decoder(
+    image_embeddings=image_embedding,
+    image_pe=sam.prompt_encoder.get_dense_pe(),
+    sparse_prompt_embeddings=sparse_embeddings,
+    dense_prompt_embeddings=dense_embeddings,
+    multimask_output=False,
+    )
+    if len(x.shape) == 3:
+        input_size = tuple(x.shape[:2])
+    elif len(x.shape) == 4:
+        input_size = tuple(x.shape[-2:])
+    
+
+    #upscaled_masks = sam.postprocess_masks(low_res_masks, input_size, original_size).cuda()
+    mask = F.interpolate(low_res_masks, (1024, 1024))[:, :, :intermediate_shape[0], :intermediate_shape[1]]
+    mask = F.interpolate(mask, (original_size[0], original_size[1]))
+
+  return mask 
+
+def segmentation_sam(x,SIZE=384):
+    
+    x = tf.image.resize_with_pad(x, SIZE, SIZE)
+    predicted_mask = one_step_inference(x)
+    fig, ax =  plt.subplots()
+    img = x.cpu().numpy()
+    mask = predicted_mask.cpu().numpy()[0][0]>0.2
+    ax.imshow(img)
+    ax.imshow(mask, cmap='jet', alpha=0.4)
+    plt.savefig('test.png')
+    ax.axis('off')
+    fig.canvas.draw()
+    # Now we can save it to a numpy array.
+    data = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)
+    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+    plt.close()
+    return data 

labels.py

@@ -0,0 +1,175 @@
+lookup_170 =  {0: 'Anacardiaceae',
+ 1: 'Betulaceae',
+ 2: 'Cornaceae',
+ 3: 'Cunoniaceae',
+ 4: 'Euphorbiaceae',
+ 5: 'Fabaceae',
+ 6: 'Fagaceae',
+ 7: 'Juglandaceae',
+ 8: 'Lauraceae',
+ 9: 'Malvaceae',
+ 10: 'Meliaceae',
+ 11: 'Menispermaceae',
+ 12: 'Myrtaceae',
+ 13: 'Proteaceae',
+ 14: 'Rhamnaceae',
+ 15: 'Rosaceae',
+ 16: 'Salicaceae',
+ 17: 'Sapindaceae',
+ 18: 'Ulmaceae',
+ 19: 'Acanthaceae',
+ 20: 'Achariaceae',
+ 21: 'Achatocarpaceae',
+ 22: 'Actinidiaceae',
+ 23: 'Adoxaceae',
+ 24: 'Altingiaceae',
+ 25: 'Amaranthaceae',
+ 26: 'Ancistrocladaceae',
+ 27: 'Anisophylleaceae',
+ 28: 'Annonaceae',
+ 29: 'Apiaceae',
+ 30: 'Apocynaceae',
+ 31: 'Berberidaceae',
+ 32: 'Bignoniaceae',
+ 33: 'Bixaceae',
+ 34: 'Bonnetiaceae',
+ 35: 'Boraginaceae',
+ 36: 'Brunelliaceae',
+ 37: 'Burseraceae',
+ 38: 'Buxaceae',
+ 39: 'Calophyllaceae',
+ 40: 'Calycanthaceae',
+ 41: 'Campanulaceae',
+ 42: 'Canellaceae',
+ 43: 'Cannabaceae',
+ 44: 'Capparaceae',
+ 45: 'Caprifoliaceae',
+ 46: 'Cardiopteridaceae',
+ 47: 'Caricaceae',
+ 48: 'Caryocaraceae',
+ 49: 'Celastraceae',
+ 50: 'Centroplacaceae',
+ 51: 'Cercidiphyllaceae',
+ 52: 'Chloranthaceae',
+ 53: 'Chrysobalanaceae',
+ 54: 'Clethraceae',
+ 55: 'Clusiaceae',
+ 56: 'Combretaceae',
+ 57: 'Connaraceae',
+ 58: 'Coriariaceae',
+ 59: 'Crassulaceae',
+ 60: 'Crossosomataceae',
+ 61: 'Cucurbitaceae',
+ 62: 'Dichapetalaceae',
+ 63: 'Dilleniaceae',
+ 64: 'Dipterocarpaceae',
+ 65: 'Ebenaceae',
+ 66: 'Elaeocarpaceae',
+ 67: 'Ericaceae',
+ 68: 'Erythroxylaceae',
+ 69: 'Escalloniaceae',
+ 70: 'Eucommiaceae',
+ 71: 'Garryaceae',
+ 72: 'Gentianaceae',
+ 73: 'Geraniaceae',
+ 74: 'Gesneriaceae',
+ 75: 'Gnetaceae',
+ 76: 'Grossulariaceae',
+ 77: 'Gunneraceae',
+ 78: 'Hamamelidaceae',
+ 79: 'Hernandiaceae',
+ 80: 'Humiriaceae',
+ 81: 'Hydrangeaceae',
+ 82: 'Hypericaceae',
+ 83: 'Icacinaceae',
+ 84: 'Irvingiaceae',
+ 85: 'Iteaceae',
+ 86: 'Ixonanthaceae',
+ 87: 'Lamiaceae',
+ 88: 'Lardizabalaceae',
+ 89: 'Lecythidaceae',
+ 90: 'Liliaceae',
+ 91: 'Linaceae',
+ 92: 'Loganiaceae',
+ 93: 'Loranthaceae',
+ 94: 'Lythraceae',
+ 95: 'Magnoliaceae',
+ 96: 'Malpighiaceae',
+ 97: 'Marantaceae',
+ 98: 'Marcgraviaceae',
+ 99: 'Melastomataceae',
+ 100: 'Melianthaceae',
+ 101: 'Monimiaceae',
+ 102: 'Moraceae',
+ 103: 'Myricaceae',
+ 104: 'Myristicaceae',
+ 105: 'Nitrariaceae',
+ 106: 'Nothofagaceae',
+ 107: 'Nyctaginaceae',
+ 108: 'Ochnaceae',
+ 109: 'Olacaceae',
+ 110: 'Oleaceae',
+ 111: 'Onagraceae',
+ 112: 'Opiliaceae',
+ 113: 'Orchidaceae',
+ 114: 'Orobanchaceae',
+ 115: 'Oxalidaceae',
+ 116: 'Pandaceae',
+ 117: 'Papaveraceae',
+ 118: 'Paracryphiaceae',
+ 119: 'Passifloraceae',
+ 120: 'Pedaliaceae',
+ 121: 'Penaeaceae',
+ 122: 'Pentaphylacaceae',
+ 123: 'Peridiscaceae',
+ 124: 'Phyllanthaceae',
+ 125: 'Phytolaccaceae',
+ 126: 'Picramniaceae',
+ 127: 'Picrodendraceae',
+ 128: 'Piperaceae',
+ 129: 'Pittosporaceae',
+ 130: 'Platanaceae',
+ 131: 'Polemoniaceae',
+ 132: 'Polygalaceae',
+ 133: 'Polygonaceae',
+ 134: 'Primulaceae',
+ 135: 'Ranunculaceae',
+ 136: 'Rhabdodendraceae',
+ 137: 'Rhizophoraceae',
+ 138: 'Rubiaceae',
+ 139: 'Rutaceae',
+ 140: 'Sabiaceae',
+ 141: 'Santalaceae',
+ 142: 'Sapotaceae',
+ 143: 'Sarcolaenaceae',
+ 144: 'Saxifragaceae',
+ 145: 'Schisandraceae',
+ 146: 'Schoepfiaceae',
+ 147: 'Scrophulariaceae',
+ 148: 'Simaroubaceae',
+ 149: 'Siparunaceae',
+ 150: 'Smilacaceae',
+ 151: 'Solanaceae',
+ 152: 'Sphaerosepalaceae',
+ 153: 'Stachyuraceae',
+ 154: 'Staphyleaceae',
+ 155: 'Stegnospermataceae',
+ 156: 'Stemonuraceae',
+ 157: 'Styracaceae',
+ 158: 'Symplocaceae',
+ 159: 'Theaceae',
+ 160: 'Thymelaeaceae',
+ 161: 'Trigoniaceae',
+ 162: 'Trochodendraceae',
+ 163: 'Urticaceae',
+ 164: 'Verbenaceae',
+ 165: 'Violaceae',
+ 166: 'Vitaceae',
+ 167: 'Vochysiaceae',
+ 168: 'Winteraceae',
+ 169: 'Zygophyllaceae',
+ 170:'Araceae'}
+
+dict_lu ={}
+for i in range(171):
+  dict_lu[i] = lookup_170[i]

pre-requirements.txt

@@ -0,0 +1,6 @@
+numpy==1.22.4
+opencv-python-headless==4.5.5.64
+openmim==0.1.5
+torch==1.11.0
+torchvision==0.12.0
+tensorflow==2.8