sBERT_Text_Similarity

1
—
by
AventIQ-AI
Other
OTHER
New
1 downloads
Early-stage
Try on Hugging FaceAdd to Compare
Edge AI:
Mobile
Laptop
Server
Unknown
Mobile
Laptop
Server
Quick Summary

Sentence-BERT Quantized Model for Text Similarity & Paraphrase Detection This repository hosts a quantized version of the Sentence-BERT (SBERT) model, fine-tun...

Code Examples

Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Usagebashonnx
pip install sentence-transformers onnxruntime transformers
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Threshold to classify as paraphrasepythontransformers
from onnxruntime import InferenceSession
from transformers import AutoTokenizer
import numpy as np

# Load tokenizer and ONNX session
tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
session = InferenceSession("sbert_onnx/model.onnx")

def encode_onnx(session, tokenizer, sentence):
    inputs = tokenizer(sentence, return_tensors="np", padding=True, truncation=True)
    outputs = session.run(None, dict(inputs))
    return outputs[0][0]

# Encode and compute similarity
emb1 = encode_onnx(session, tokenizer, sentence1)
emb2 = encode_onnx(session, tokenizer, sentence2)
score = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print("Quantized Similarity Score:", score)
print("Paraphrase" if score > 0.75 else "Not Paraphrase")
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation
Quantizationtextonnx
.
├── fine-tuned-model/      # Fine-tuned SBERT model directory
├── sbert_onnx/            # Quantized ONNX model directory
├── test_functions.py      # Code for evaluation and testing
├── README.md              # Project documentation

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Try Free API

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Deploy Now

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.