Upload 12 files

app.py

@@ -0,0 +1,156 @@
+import gradio as gr
+import joblib
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import json
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+print("Pokrećem aplikaciju...")
+
+# --- Učitavanje SVM pipelinea ---
+print("Učitavam SVM pipeline...")
+svm_pipeline = joblib.load("svm_pipeline.pkl")
+
+# --- Učitavanje riječnika za CNN i GRU ---
+print("Učitavam riječnik...")
+with open("word2idx.json", "r", encoding="utf-8") as f:
+    word2idx = json.load(f)
+
+# --- Definicija CNN modela ---
+class CNNModel(nn.Module):
+    def __init__(self, vocab_size, embed_dim=300, num_classes=3, kernel_sizes=[3,4,5], num_filters=128):
+        super(CNNModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
+        self.convs = nn.ModuleList([
+            nn.Conv2d(1, num_filters, (k, embed_dim)) for k in kernel_sizes
+        ])
+        self.dropout = nn.Dropout(0.5)
+        self.fc = nn.Linear(num_filters * len(kernel_sizes), num_classes)
+
+    def forward(self, x):
+        x = self.embedding(x).unsqueeze(1)
+        convs = [F.relu(conv(x)).squeeze(3) for conv in self.convs]
+        pools = [F.max_pool1d(c, c.size(2)).squeeze(2) for c in convs]
+        x = torch.cat(pools, 1)
+        x = self.dropout(x)
+        return self.fc(x)
+
+# --- Definicija GRU modela ---
+class GRUModel(nn.Module):
+    def __init__(self, vocab_size, embed_dim=300, hidden_dim=256, num_layers=1, num_classes=3):
+        super(GRUModel, self).__init__()
+        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
+        self.gru = nn.GRU(embed_dim, hidden_dim, num_layers=num_layers, batch_first=True)
+        self.fc = nn.Linear(hidden_dim, num_classes)
+
+    def forward(self, x):
+        x = self.embedding(x)
+        _, h_n = self.gru(x)
+        out = self.fc(h_n[-1])
+        return out
+
+# --- Učitavanje CNN i GRU modela ---
+vocab_size = len(word2idx) + 1
+embed_dim = 300
+num_classes = 3
+
+print("Učitavam CNN model...")
+cnn_model = CNNModel(vocab_size, embed_dim, num_classes)
+cnn_model.load_state_dict(torch.load("cnn_model.pt", map_location=torch.device('cpu')))
+cnn_model.eval()
+
+print("Učitavam GRU model...")
+gru_model = GRUModel(vocab_size, embed_dim, hidden_dim=256, num_layers=1, num_classes=num_classes)
+gru_model.load_state_dict(torch.load("gru_model.pt", map_location=torch.device('cpu')))
+gru_model.eval()
+
+# --- Učitavanje BERTić modela i tokenizer ---
+print("Učitavam BERTić model i tokenizer...")
+bert_tokenizer = AutoTokenizer.from_pretrained("my_finetuned_model")
+bert_model = AutoModelForSequenceClassification.from_pretrained("my_finetuned_model")
+bert_model.eval()
+
+# --- Pretvaranje teksta u indekse za CNN i GRU ---
+def text_to_indices(text, max_len=100):
+    tokens = text.lower().split()
+    print(f"Tokeni: {tokens}")
+    indices = [word2idx.get(token, 0) for token in tokens]
+    print(f"Indeksi: {indices}")
+    if len(indices) < max_len:
+        indices += [0] * (max_len - len(indices))
+    else:
+        indices = indices[:max_len]
+    tensor = torch.tensor([indices], dtype=torch.long)
+    print(f"Tensor shape: {tensor.shape}")
+    return tensor
+
+# --- Funkcije za predikciju ---
+
+def predict_svm(text):
+    print(f"Predikcija SVM za tekst: {text}")
+    proba = svm_pipeline.predict_proba([text])[0]
+    pred = svm_pipeline.classes_[proba.argmax()]
+    print(f"SVM predikcija: {pred}, povjerenje: {proba.max():.2f}")
+    return f"{pred} (p={proba.max():.2f})"
+
+def predict_cnn(text):
+    print(f"Predikcija CNN za tekst: {text}")
+    with torch.no_grad():
+        inputs = text_to_indices(text)
+        outputs = cnn_model(inputs)
+        print(f"CNN output: {outputs}")
+        probs = F.softmax(outputs, dim=1)
+        pred = torch.argmax(probs, dim=1).item()
+        confidence = probs[0][pred].item()
+    print(f"CNN predikcija: {pred}, povjerenje: {confidence:.2f}")
+    return f"{pred} (p={confidence:.2f})"
+
+def predict_gru(text):
+    print(f"Predikcija GRU za tekst: {text}")
+    with torch.no_grad():
+        inputs = text_to_indices(text)
+        outputs = gru_model(inputs)
+        print(f"GRU output: {outputs}")
+        probs = F.softmax(outputs, dim=1)
+        pred = torch.argmax(probs, dim=1).item()
+        confidence = probs[0][pred].item()
+    print(f"GRU predikcija: {pred}, povjerenje: {confidence:.2f}")
+    return f"{pred} (p={confidence:.2f})"
+
+def predict_bert(text):
+    print(f"Predikcija BERTić za tekst: {text}")
+    inputs = bert_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+    with torch.no_grad():
+        outputs = bert_model(**inputs)
+        print(f"BERTić output logits: {outputs.logits}")
+        probs = F.softmax(outputs.logits, dim=1)
+        pred = torch.argmax(probs, dim=1).item()
+        confidence = probs[0][pred].item()
+    print(f"BERTić predikcija: {pred}, povjerenje: {confidence:.2f}")
+    return f"{pred} (p={confidence:.2f})"
+
+# --- Gradio sučelje ---
+def predict_all(text):
+    return (
+        predict_svm(text),
+        predict_cnn(text),
+        predict_gru(text),
+        predict_bert(text)
+    )
+
+demo = gr.Interface(
+    fn=predict_all,
+    inputs=gr.Textbox(lines=3, placeholder="Upiši tekst za klasifikaciju..."),
+    outputs=[
+        gr.Textbox(label="SVM (RBF)"),
+        gr.Textbox(label="CNN"),
+        gr.Textbox(label="GRU"),
+        gr.Textbox(label="BERTić")
+    ],
+    title="Demo klasifikacije teksta",
+    description="Predikcije koriste SVM, CNN, GRU i BERTić modele."
+)
+
+if __name__ == "__main__":
+    demo.launch(share=True, debug=True)

cnn_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b26e145bac986a39cff1bc7f39e064f250c0dba7662f9088c8d496f38bbb63b1
+size 13854439

gru_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e574b173307f1d8eb5aeea8ef68d0d8b9e1e660fa00cb09387586281e483348
+size 13721707

my_finetuned_model/config.json

@@ -0,0 +1,36 @@
+{
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "torch_dtype": "float32",
+  "transformers_version": "4.52.4",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

my_finetuned_model/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9f9be5bc9757223ac3e314f7d10c36c0946894585e6c350188dcc4592515234
+size 437961724

my_finetuned_model/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

my_finetuned_model/tokenizer_config.json

@@ -0,0 +1,56 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "unk_token": "[UNK]"
+}

my_finetuned_model/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ee4fb7862129aec04f692f0fed9a34edd7916d9024dd152c28a040631fd81c7c
+size 5649

svm_pipeline.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cce78663d1e601e069e87581f022bb2c4cdc82531ebcfc1b33d2343c40572350
+size 2055480