feat:add beit,rise xai;display closest imgs with gallery

app.py

@@ -18,6 +18,7 @@ import glob
 from inference_sam import segmentation_sam
 from explanations import explain
 from inference_resnet import get_triplet_model
+from inference_beit import get_triplet_model_beit
 import pathlib
 import tensorflow as tf
 from closest_sample import get_images
@@ -26,6 +27,14 @@ 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')
 
+if not os.path.exists('dataset'):
+  REPO_ID='Serrelab/Fossils'
+  token = os.environ.get('READ_TOKEN')
+  print(f"Read token:{token}")
+  if token is None:
+     print("warning! A read token in env variables is needed for authentication.")
+  snapshot_download(repo_id=REPO_ID, token=token,repo_type='dataset',local_dir='dataset')
+
 def get_model(model_name):
    
         
@@ -45,25 +54,24 @@ def get_model(model_name):
                         backbone_class=tf.keras.applications.ResNet50V2,
                         nb_classes = n_classes,load_weights=False,finer_model=True,backbone_name ='Resnet50v2')
         model.load_weights('model_classification/rock-170.h5')
+    elif model_name == 'Fossils 142':
+        n_classes = 142
+        model = get_triplet_model_beit(input_shape = (384, 384, 3),
+                                  embedding_units = 256,
+                                  embedding_depth = 2,
+                                  n_classes = n_classes)
+        model.load_weights('model_classification/fossil-142.h5')
     else:
         raise ValueError(f"Model name '{model_name}' is not recognized") 
     return model,n_classes
 
-    '''
-    elif model_name == 'Fossils 19':
-        n_classes = 19 or 23?
-        model = get_beit_model(input_shape=(600, 600, 3),
-                               num_labels=n_classes,
-                               load_weights=False, 
-                               )
-        model.load_weights('model_classification/beit-fossils-19.h5')
-    '''
 
 def segment_image(input_image):
     img = segmentation_sam(input_image)
     return img
 
 def classify_image(input_image, model_name):
+    #segmented_image = segment_image(input_image)
     if 'Rock 170' ==model_name:
         from inference_resnet import inference_resnet_finer
         model,n_classes= get_model(model_name)
@@ -74,10 +82,10 @@ def classify_image(input_image, model_name):
         model, n_classes= get_model(model_name)
         result = inference_resnet_finer(input_image,model,size=600,n_classes=n_classes)
         return result 
-    if 'Fossils 19' ==model_name:
-        from inference_beit import inference_dino
+    if 'Fossils 142' ==model_name:
+        from inference_beit import inference_resnet_finer_beit
         model,n_classes = get_model(model_name)
-        result = inference_dino(input_image,model_name)
+        result = inference_resnet_finer_beit(input_image,model,size=384,n_classes=n_classes)
         return result
     return None
 
@@ -92,12 +100,10 @@ def get_embeddings(input_image,model_name):
         model, n_classes= get_model(model_name)
         result = inference_resnet_embedding(input_image,model,size=600,n_classes=n_classes)
         return result 
-    if 'Fossils 19' ==model_name:
-        from inference_beit import inference_dino
+    if 'Fossils 142' ==model_name:
+        from inference_beit import inference_resnet_embedding_beit
         model,n_classes = get_model(model_name)
-        result = inference_dino(input_image,model_name)
-        #TODO
-        #result = inference_beit_embedding
+        result = inference_resnet_embedding_beit(input_image,model,size=384,n_classes=n_classes)
         return result
     return None
     
@@ -110,11 +116,16 @@ def find_closest(input_image,model_name):
 
 def explain_image(input_image,model_name):
     model,n_classes= get_model(model_name)
+    if model_name=='Fossils 142':
+        size = 384
+    else:
+        size = 600
     #saliency, integrated, smoothgrad,
-    rise = explain(model,input_image,n_classes=n_classes)
+    rise,avg = explain(model,input_image,size = size, n_classes=n_classes)
     #original =  saliency + integrated + smoothgrad 
     print('done')
-    return rise
+    rise1,rise2,rise3,rise4,rise5,avg = rise[0],rise[1],rise[2],rise[3],rise[4],avg[0]
+    return rise1,rise2,rise3,rise4,rise5,avg
     
 #minimalist theme
 with gr.Blocks(theme='sudeepshouche/minimalist') as demo:
@@ -126,17 +137,17 @@ with gr.Blocks(theme='sudeepshouche/minimalist') as demo:
                 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')
-                segmented_image=gr.Image(label="Segmented Image", type='numpy')
-                segment_button = gr.Button("Segment Image")
-                #classify_segmented_button = gr.Button("Classify Segmented Image")
+            # with gr.Column():
+            #     #segmented_image = gr.outputs.Image(label="SAM output",type='numpy')
+            #     segmented_image=gr.Image(label="Segmented Image", type='numpy')
+            #     segment_button = gr.Button("Segment Image")
+            #     #classify_segmented_button = gr.Button("Classify Segmented Image")
                 
             with gr.Column():
                 model_name = gr.Dropdown(
-                    ["Mummified 170", "Rock 170","Fossils 19"],
+                    ["Mummified 170", "Rock 170","Fossils 142"],
                     multiselect=False,
-                    value="Rock 170", # default option
+                    value="Fossils 142", # default option
                     label="Model",
                     interactive=True,
                 )
@@ -168,7 +179,12 @@ with gr.Blocks(theme='sudeepshouche/minimalist') as demo:
                 #gradcam = gr.Image(label='integraged gradients')
                 #guided_gradcam = gr.Image(label='gradcam')
                 #guided_backprop = gr.Image(label='guided backprop')
-                rise = gr.Image(label = 'Rise')
+                rise1 = gr.Image(label = 'Rise1')
+                rise2 = gr.Image(label = 'Rise2')
+                rise3 = gr.Image(label = 'Rise3')
+                rise4 = gr.Image(label = 'Rise4')
+                rise5 = gr.Image(label = 'Rise5')
+                avg = gr.Image(label = 'Avg')
             generate_explanations = gr.Button("Generate Explanations")
                 
         # with gr.Accordion('Closest Images'):
@@ -199,9 +215,9 @@ with gr.Blocks(theme='sudeepshouche/minimalist') as demo:
 
             find_closest_btn = gr.Button("Find Closest Images")
             
-        segment_button.click(segment_image, inputs=input_image, outputs=segmented_image)
+        #segment_button.click(segment_image, inputs=input_image, outputs=segmented_image)
         classify_image_button.click(classify_image, inputs=[input_image,model_name], outputs=class_predicted)
-        generate_explanations.click(explain_image, inputs=[input_image,model_name], outputs=[rise]) #saliency,gradcam,guided_gradcam
+        generate_explanations.click(explain_image, inputs=[input_image,model_name], outputs=[rise1,rise2,rise3,rise4,rise5,avg]) #
         #find_closest_btn.click(find_closest, inputs=[input_image,model_name], outputs=[label_closest_image_0,label_closest_image_1,label_closest_image_2,label_closest_image_3,label_closest_image_4,closest_image_0,closest_image_1,closest_image_2,closest_image_3,closest_image_4])
         def update_outputs(input_image,model_name):
             labels, images = find_closest(input_image,model_name)

closest_sample.py

@@ -77,6 +77,7 @@ def get_images(embedding):
             public_path = path.replace('/gpfs/data/tserre/irodri15/Fossils/new_data/leavesdb-v1_1/images/Fossil/General_Fossil/512/full/jpg/', folder_general)
         else:
             print("no match found")
+        print(public_path)
         download_public_image(public_path, local_file_path)
         names = []
         parts = [part for part in public_path.split('/') if part]

env.py

@@ -17,6 +17,7 @@ def config_env():
         ('xplique', None),
         ('segment_anything', None),
         ('panopticapi', None),
+        ('keras_cv_attention_models',None)
     ]
 
     name_to_command = {'segment_anything':'git+https://github.com/facebookresearch/segment-anything.git',

explanations.py

@@ -54,35 +54,46 @@ def explain(model, input_image,size=600, n_classes=171) :
              #IntegratedGradients(class_model, steps=50, batch_size=BATCH_SIZE),
              #SmoothGrad(class_model, nb_samples=50, batch_size=BATCH_SIZE),
              #GradCAM(class_model),
-             Rise(class_model,nb_samples = 50, batch_size = BATCH_SIZE,grid_size=7,
+             Rise(class_model,nb_samples = 50, batch_size = BATCH_SIZE,grid_size=15,
                  preservation_probability=0.5)
              #
-  ]
+    ]
+    explainer = Rise(class_model,nb_samples = 50, batch_size = BATCH_SIZE,grid_size=15,
+                 preservation_probability=0.5)
+  
     cropped,repetitions = _clever_crop(input_image,(size,size))
     size_repetitions = int(size//(repetitions.numpy()+1))
     X = preprocess(cropped,size=size)
-    Y = np.argmax(class_model.predict(np.array([X])))
+    predictions = class_model.predict(np.array([X]))
+    #Y = np.argmax(predictions)
+    top_5_indices = np.argsort(predictions[0])[-5:][::-1]
+    #print(top_5_indices)
     X = np.expand_dims(X, 0)
     explanations = []
-    for e,explainer in enumerate(explainers):
-        print(f'{e}/{len(explainers)}')
-        print('1')
+    for i,Y in enumerate(top_5_indices):
         Y = tf.one_hot([Y], n_classes)
+        print(f'{i}/{len(top_5_indices)}')
         phi = np.abs(explainer(X, Y))[0]
-        print('1')
         if len(phi.shape) == 3:
             phi = np.mean(phi, -1)
-        print('1')
         show(X[0][:,size_repetitions:2*size_repetitions,:])
         show(phi[:,size_repetitions:2*size_repetitions], p=1, alpha=0.4)
-        print('1')
-        plt.savefig(f'phi_{e}.png')
-        print('1')
-        explanations.append(f'phi_{e}.png')
-        print('1')
-        print(type(explanations))
-        print(len(explanations))
-      
-    print('Done')  
+        plt.savefig(f'phi_{i}.png')
+        explanations.append(f'phi_{i}.png')
+    avg=[]
+    for i,Y in enumerate(top_5_indices):
+        Y = tf.one_hot([Y], n_classes)
+        print(f'{i}/{len(top_5_indices)}')
+        phi = np.abs(explainer(X, Y))[0]
+        if len(phi.shape) == 3:
+            phi = np.mean(phi, -1)
+        show(X[0][:,size_repetitions:2*size_repetitions,:])
+    show(phi[:,size_repetitions:2*size_repetitions], p=1, alpha=0.4)
+    plt.savefig(f'phi_6.png')
+    avg.append(f'phi_6.png')
+
+    print('Done')
+    if len(explanations)==1:
+        explanations = explanations[0]
     
-    return explanations
+    return explanations,avg

inference_beit.py

@@ -9,195 +9,109 @@ import os
 import numpy as np
 import keras
 from PIL import Image
-import keras_cv
 from keras_cv_attention_models import beit
 import matplotlib.pyplot as plt
 
-
-#preprocessing
-#TODO
-num_classes = len(class_names)
-AUTO = tf.data.AUTOTUNE
-rand_augment = keras_cv.layers.RandAugment(value_range = (-1, 1), augmentations_per_image = 3, magnitude=0.5)
-
-SIZE = 384
-debug = None
-
-def augmentations(x, crop_size=22, brightness=0.2, contrast=0.2, saturation=0.2, hue=0.2):
-    x = tf.cast(x, tf.float32)
-    x = tf.image.random_crop(x, (tf.shape(x)[0], 100, 100, 3))
-    x = tf.image.random_brightness(x, max_delta=brightness)
-    x = tf.image.random_contrast(x, lower=1.0-contrast, upper=1+contrast)
-    x = tf.image.random_saturation(x, lower=1.0-saturation, upper=1.0+saturation)
-    x = tf.image.random_hue(x, max_delta=hue)
-    x = tf.image.resize(x, (128, 128))
-    x = tf.clip_by_value(x, 0.0, 255.0)
-    x = tf.keras.applications.resnet_v2.preprocess_input(x)
-    return x
-
-
-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 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 resize(img):
-  # default resize function for all pi outputs
-  return tf.image.resize(img, (SIZE, SIZE), 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)
-  mask = tf.reduce_mean(mask, -1)
-
-  img = img * tf.cast(mask > 0.1, 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, tf.float32)
-
-def parse_img(element, split, randaugment,maskaugment=True):
-  #global debug
-  path, class_id = element[0], element[1]
-
-  data = tf.io.read_file(path)
-  img = tf.io.decode_jpeg(data)
-  img = tf.cast(img, tf.uint8)
-  img = normalize(img)
-  shape = tf.shape(img)
-
-  # data_mask = tf.io.read_file(path_mask)
-  # mask = tf.io.decode_jpeg(data_mask)
-
-  class_id = tf.strings.to_number(class_id)
-  class_id = tf.cast(class_id, tf.int32)
-
-  label = tf.one_hot(class_id, num_classes)
-
-  # img = pi(img, mask)
-  img = tf.image.resize_with_pad(img, SIZE, SIZE, method="bicubic", antialias=True)
-
-  return tf.cast(img, tf.float32), tf.cast(label, tf.int32)
-
-SIZE = 384
-wsize=hsize=SIZE
-def resize_images(batch_x, width=224, height=224):
-    return tf.image.resize(batch_x, (width, height))
-
-def load_img(image_path,gray=False):
-    img = tf.io.read_file(image_path)
-    img = tf.image.decode_jpeg(img, channels=3)
-    img = tf.image.convert_image_dtype(img, tf.float32)
-    if gray:
+import tensorflow as tf
+from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
+from typing import Tuple
+#from huggingface_hub import snapshot_download
+from labels import lookup_140
+
+
+def get_triplet_model_beit(input_shape = (600, 600, 3),
+                      embedding_units = 256,
+                      embedding_depth = 2,
+                      n_classes = 19,backbone_name ='Beit'):
+
+    backbone_class = beit.BeitBasePatch16(input_shape=input_shape, pretrained="imagenet21k-ft1k")
+
+    backbone_class = tf.keras.Model(backbone_class.input, backbone_class.layers[-2].output)
+    #features = GlobalAveragePooling2D()(backbone_class.output)
+    embedding_head = backbone_class.output
+
+    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(n_classes)(backbone_class.output)
+
+    model = tf.keras.Model(backbone_class.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)
-    img = tf.image.resize(img,(wsize,hsize))
-    return img
-
-LR = 1e-3
-
-optimizer = tf.keras.optimizers.Adam(LR)
-cce = tf.keras.losses.categorical_crossentropy
-
-model_path = '/content/drive/MyDrive/Gg_Fossils_data_shared_copy/Fossils/models/model-13.h5'
-model = keras.models.load_model(model_path, custom_objects = {'cce': cce})
-
-outputs = model.predict(images)
-
-predictions = tf.math.top_k(outputs[1], k = 5)
-cid = 1
-dataset = np.array(dataset)
-final_predictions = []
-for ele in predictions[1]:
-  if cid in ele:
-    final_predictions.append(cid)
-  else:
-    final_predictions.append(cid+10)
-final_predictions = np.array(final_predictions)
-images2 = images[final_predictions == cid]
-image2_paths = dataset[final_predictions == cid][:,0]
-print(images2.shape)
-
-def get_beit_model(input_shape, num_labels, load_weights=False, ...):
-    pass
-
-def inference_dino(input_image, model_name):
-    pass
 
-def inference_beit_embedding(input_image, model, size=600):
-    pass
+    return img,repeating
+
+def preprocess(img,size=384):
+  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_140[n]
+        results[label] = float(logits[n])
+    return results
+
+def inference_resnet_embedding_beit(x,model,size=576,n_classes=142,n_top=10):
+    cropped = _clever_crop(x,(size,size))[0]
+    prep = preprocess(cropped,size=size)
+    embedding = model.predict(np.array([prep]))[0][0]
+   
+    
+    return embedding 
+
+def inference_resnet_finer_beit(x,model,size=576,n_classes=142,n_top=10):
+    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)

labels.py

@@ -173,3 +173,147 @@ lookup_170 =  {0: 'Anacardiaceae',
 dict_lu ={}
 for i in range(171):
   dict_lu[i] = lookup_170[i]
+
+
+lookup_140 = {0: 'Anacardiaceae',
+ 1: 'Berberidaceae',
+ 2: 'Betulaceae',
+ 3: 'Cupressaceae',
+ 4: 'Dryopteridaceae',
+ 5: 'Fabaceae',
+ 6: 'Fagaceae',
+ 7: 'Juglandaceae',
+ 8: 'Lauraceae',
+ 9: 'Meliaceae',
+ 10: 'Myrtaceae',
+ 11: 'Pinaceae',
+ 12: 'Rhamnaceae',
+ 13: 'Rosaceae',
+ 14: 'Salicaceae',
+ 15: 'Sapindaceae',
+ 16: 'Ulmaceae',
+ 17: 'Viburnaceae',
+ 18: 'Vitaceae',
+ 19: 'Araceae',
+ 20: 'Grossulariaceae',
+ 21: 'Hydrangeaceae',
+ 22: 'Taxaceae',
+ 23: 'Achariaceae',
+ 24: 'Actinidiaceae',
+ 25: 'Altingiaceae',
+ 26: 'Amaranthaceae',
+ 27: 'Annonaceae',
+ 28: 'Apiaceae',
+ 29: 'Apocynaceae',
+ 30: 'Aquifoliaceae',
+ 31: 'Araliaceae',
+ 32: 'Aristolochiaceae',
+ 33: 'Asteraceae',
+ 34: 'Bignoniaceae',
+ 35: 'Boraginaceae',
+ 36: 'Burseraceae',
+ 37: 'Buxaceae',
+ 38: 'Calophyllaceae',
+ 39: 'Calycanthaceae',
+ 40: 'Campanulaceae',
+ 41: 'Canellaceae',
+ 42: 'Cannabaceae',
+ 43: 'Capparaceae',
+ 44: 'Caprifoliaceae',
+ 45: 'Cardiopteridaceae',
+ 46: 'Celastraceae',
+ 47: 'Chloranthaceae',
+ 48: 'Chrysobalanaceae',
+ 49: 'Clusiaceae',
+ 50: 'Combretaceae',
+ 51: 'Connaraceae',
+ 52: 'Coriariaceae',
+ 53: 'Cornaceae',
+ 54: 'Crassulaceae',
+ 55: 'Cucurbitaceae',
+ 56: 'Cunoniaceae',
+ 57: 'Dilleniaceae',
+ 58: 'Dipterocarpaceae',
+ 59: 'Ebenaceae',
+ 60: 'Elaeagnaceae',
+ 61: 'Elaeocarpaceae',
+ 62: 'Ericaceae',
+ 63: 'Escalloniaceae',
+ 64: 'Euphorbiaceae',
+ 65: 'Garryaceae',
+ 66: 'Geraniaceae',
+ 67: 'Gesneriaceae',
+ 68: 'Gnetaceae',
+ 69: 'Hamamelidaceae',
+ 70: 'Humiriaceae',
+ 71: 'Hypericaceae',
+ 72: 'Icacinaceae',
+ 73: 'Iteaceae',
+ 74: 'Ixonanthaceae',
+ 75: 'Lamiaceae',
+ 76: 'Lardizabalaceae',
+ 77: 'Lecythidaceae',
+ 78: 'Linaceae',
+ 79: 'Loganiaceae',
+ 80: 'Loranthaceae',
+ 81: 'Lythraceae',
+ 82: 'Magnoliaceae',
+ 83: 'Malpighiaceae',
+ 84: 'Malvaceae',
+ 85: 'Marantaceae',
+ 86: 'Melastomataceae',
+ 87: 'Menispermaceae',
+ 88: 'Monimiaceae',
+ 89: 'Moraceae',
+ 90: 'Myricaceae',
+ 91: 'Myristicaceae',
+ 92: 'Nothofagaceae',
+ 93: 'Nyctaginaceae',
+ 94: 'Nyssaceae',
+ 95: 'Ochnaceae',
+ 96: 'Olacaceae',
+ 97: 'Oleaceae',
+ 98: 'Onagraceae',
+ 99: 'Opiliaceae',
+ 100: 'Oxalidaceae',
+ 101: 'Paracryphiaceae',
+ 102: 'Passifloraceae',
+ 103: 'Penaeaceae',
+ 104: 'Pentaphylacaceae',
+ 105: 'Phyllanthaceae',
+ 106: 'Phytolaccaceae',
+ 107: 'Piperaceae',
+ 108: 'Pittosporaceae',
+ 109: 'Platanaceae',
+ 110: 'Polemoniaceae',
+ 111: 'Polygalaceae',
+ 112: 'Polygonaceae',
+ 113: 'Primulaceae',
+ 114: 'Proteaceae',
+ 115: 'Ranunculaceae',
+ 116: 'Rhizophoraceae',
+ 117: 'Rubiaceae',
+ 118: 'Rutaceae',
+ 119: 'Sabiaceae',
+ 120: 'Santalaceae',
+ 121: 'Sapotaceae',
+ 122: 'Sarcolaenaceae',
+ 123: 'Saxifragaceae',
+ 124: 'Schisandraceae',
+ 125: 'Scrophulariaceae',
+ 126: 'Simaroubaceae',
+ 127: 'Smilacaceae',
+ 128: 'Solanaceae',
+ 129: 'Staphyleaceae',
+ 130: 'Stemonuraceae',
+ 131: 'Styracaceae',
+ 132: 'Symplocaceae',
+ 133: 'Theaceae',
+ 134: 'Thymelaeaceae',
+ 135: 'Urticaceae',
+ 136: 'Verbenaceae',
+ 137: 'Violaceae',
+ 138: 'Vochysiaceae',
+ 139: 'Winteraceae',
+ 140: 'Zygophyllaceae',
+ 141:'Uncertain'}

update_csv.py

@@ -0,0 +1,10 @@
+# import pandas as pd
+
+# # Load the CSV file into a DataFrame
+# fossils_pd = pd.read_csv('fossils_paths.csv')
+
+# # Replace '. ' with '' (effectively removing it) in the 'file_name' column
+# fossils_pd['file_name'] = fossils_pd['file_name'].str.replace('. ', '', regex=False)
+
+# # Optional: Save the updated DataFrame back to a CSV file if needed
+# fossils_pd.to_csv('fossils_paths.csv', index=False)