Update inference.py

inference.py

@@ -16,98 +16,49 @@ model.to(device)
 
 import json
 
-def token2json(words, labels):
-    result = {}
-    current_entity = None
-    current_text = []
-
-    for word, label in zip(words, labels):
-        if label.startswith("B-"):
-            if current_entity:
-                result[current_entity] = " ".join(current_text).strip()
-                current_text = []
-            current_entity = label[2:].lower()
-            current_text = [word]
-        elif label.startswith("I-"):
-            if current_entity == label[2:].lower():
-                current_text.append(word)
-            else:
-                # Gestione di sequenze I- non precedute da B-
-                if current_entity:
-                    result[current_entity] = " ".join(current_text).strip()
-                current_entity = label[2:].lower()
-                current_text = [word]
-        else:  # Label "O"
-            if current_entity:
-                result[current_entity] = " ".join(current_text).strip()
-                current_entity = None
-                current_text = []
-
-    # Aggiunge l'ultima entità se presente
-    if current_entity:
-        result[current_entity] = " ".join(current_text).strip()
-
-    return json.dumps(result, ensure_ascii=False, indent=2)
-
-
-def prediction(image):
-    
-    boxes, words = OCR(image)
-    encoding = processor(image, words, boxes=boxes, return_offsets_mapping=True, return_tensors="pt", truncation=True)
-    offset_mapping = encoding.pop('offset_mapping')
-
-    for k, v in encoding.items():
-        encoding[k] = v.to(device)
+boxes, words = OCR(image)
+# Preprocessa l'immagine e il testo con il processore di LayoutLMv3
+encoding = processor(image, words=words, boxes=boxes, return_tensors="pt", padding="max_length", truncation=True)
 
+# Esegui l'inferenza con il modello fine-tuned
+with torch.no_grad():
     outputs = model(**encoding)
 
-    predictions = outputs.logits.argmax(-1).squeeze().tolist()
-    token_boxes = encoding.bbox.squeeze().tolist()
-    probabilities = torch.softmax(outputs.logits, dim=-1)
-    confidence_scores = probabilities.max(-1).values.squeeze().tolist()
-
-    inp_ids = encoding.input_ids.squeeze().tolist()
-    inp_words = [tokenizer.decode(i) for i in inp_ids]
-
-    width, height = image.size
-    is_subword = np.array(offset_mapping.squeeze().tolist())[:, 0] != 0
+# Ottieni le etichette previste dal modello
+logits = outputs.logits
+predicted_ids = logits.argmax(-1).squeeze().tolist()
 
-    true_predictions = [id2label[pred] for idx, pred in enumerate(predictions) if not is_subword[idx]]
-    true_boxes = [unnormalize_box(box, width, height) for idx, box in enumerate(token_boxes) if not is_subword[idx]]
-    true_confidence_scores = [confidence_scores[idx] for idx, conf in enumerate(confidence_scores) if not is_subword[idx]]
-    true_words = []
+predictions = outputs.logits.argmax(-1).squeeze().tolist()
+token_boxes = encoding.bbox.squeeze().tolist()
+probabilities = torch.softmax(outputs.logits, dim=-1)
+confidence_scores = probabilities.max(-1).values.squeeze().tolist()
 
-    for id, i in enumerate(inp_words):
-        if not is_subword[id]:
-            true_words.append(i)
-        else:
-            true_words[-1] = true_words[-1]+i
-
-    true_predictions = true_predictions[1:-1]
-    true_boxes = true_boxes[1:-1]
-    true_words = true_words[1:-1]
-    true_confidence_scores = true_confidence_scores[1:-1]
-
-    for i, conf in enumerate(true_confidence_scores):
-        if conf < 0.6 :
-            true_predictions[i] = "O"        
+# Mappa gli ID predetti nelle etichette di classificazione
+labels = processor.tokenizer.convert_ids_to_tokens(predicted_ids)
 
+# Funzione per creare l'output JSON in formato CORD-like
+def create_json_output(words, labels, boxes):
+    output = []
     
-    d = token2json(true_words, true_predictions)
+    for word, label, box in zip(words, labels, boxes):
+        # Considera solo le etichette rilevanti (escludendo "O")
+        if label != "O":
+            output.append({
+                "text": word,
+                "category": label,  # la categoria predetta dal modello (es. "B-PRODUCT", "B-PRICE", "B-TOTAL")
+                "bounding_box": box  # le coordinate di bounding box per la parola
+            })
     
-    """for id, i in enumerate(true_predictions):
-        if i not in d.keys():
-            d[i] = true_words[id]
-        else:
-            d[i] = d[i] + ", " + true_words[id]
-    d = {k: v.strip() for (k, v) in d.items()}
-    d.pop("O")"""
+    # Converti in JSON
+    json_output = json.dumps(output, indent=4)
+    return json_output
 
-    draw = ImageDraw.Draw(image, "RGBA")
-    font = ImageFont.load_default()
+# Crea il JSON usando i risultati ottenuti
+json_result = create_json_output(words, labels, boxes)
 
-    for prediction, box, confidence in zip(true_predictions, true_boxes, true_confidence_scores):
+for prediction, box, confidence in zip(true_predictions, true_boxes, true_confidence_scores):
         draw.rectangle(box)
         draw.text((box[0]+10, box[1]-10), text=prediction+ ", "+ str(confidence), font=font, fill="black", font_size="15")
 
-    return image, d
+return image, json_result
+