Model: ML5562/fine-tuned-scibert_scivocab_uncased-all-json-M1_testing_f16
Author: ML5562
Pipeline: sentence-similarity
Library: sentence-transformers
Tags: sentence-transformers, safetensors, bert, sentence-similarity, feature-extraction, generated_from_trainer, dataset_size:19392, loss:TripletLoss, arxiv:1908.10084, arxiv:1703.07737, base_model:allenai/scibert_scivocab_uncased, base_model:finetune:allenai/scibert_scivocab_uncased, model-index, text-embeddings-inference, endpoints_compatible, region:us
Base models (finetune): id: allenai/scibert_scivocab_uncased
Card metadata: tags: sentence-transformers, sentence-similarity, feature-extraction, generated_from_trainer, dataset_size:19392, loss:TripletLoss
base_model: allenai/scibert_scivocab_uncased
widget: source_sentence: In ElGamal signature scheme, if we avoid checking that $0 \leq r < p$ then \ldots
sentences: If we do not check that $0 \leq r < p$ in the ElGamal signature scheme, it opens the door for a universal forgery attack. An attacker could potentially craft signatures that appear valid without having the required constraints on $r$, compromising the integrity of the signature verification process., To determine the largest probability of being correct when predicting \( Y \) given that \( X = 1 \), we need to analyze the joint distribution provided. 

1. **Identify the relevant probabilities**: We need to find \( P(Y=0 | X=1) \) and \( P(Y=1 | X=1) \). According to the joint distribution:
   - \( P(X=1, Y=0) = 0.3 \)
   - \( P(X=1, Y=1) = 0.4 \)

2. **Calculate the marginal probability of \( X=1 \)**:
   \[
   P(X=1) = P(X=1, Y=0) + P(X=1, Y=1) = 0.3 + 0.4 = 0.7
   \]

3. **Use Bayes' theorem to find conditional probabilities**:
   - For \( Y=0 \):
   \[
   P(Y=0 | X=1) = \frac{P(X=1, Y=0)}{P(X=1)} = \frac{0.3}{0.7} = \frac{3}{7}
   \]
   - For \( Y=1 \):
   \[
   P(Y=1 | X=1) = \frac{P(X=1, Y=1)}{P(X=1)} = \frac{0.4}{0.7} = \frac{4}{7}
   \]

4. **Determine the maximum probability of being correct**: To maximize the probability of being correct in predicting \( Y \), we should predict the outcome that has the highest conditional probability:
   - \( P(Y=0 | X=1) = \frac{3}{7} \)
   - \( P(Y=1 | X=1) = \frac{4}{7} \)

Since \( \frac{4}{7} > \frac{3}{7} \), we should predict \( Y=1 \) when \( X=1 \). 

Thus, the largest probability of being correct when predicting \( Y \) given \( X = 1 \) is \( P(Y=1 | X=1) = \frac{4}{7} \).

**Correct answer**: \(\frac{4}{7}\), Failing to enforce the condition $0 \leq r < p$ in the ElGamal signature scheme can lead to vulnerabilities, allowing for an existential forgery attack. In this case, an adversary may generate valid signatures for messages without knowing the private key, undermining the security of the scheme., source_sentence: The data contains information about submissions to a prestigious machine learning conference called ICLR. Columns:
year, paper, authors, ratings, decisions, institution, csranking, categories, authors_citations, authors_publications, authors_hindex, arxiv. The data is stored in a pandas.DataFrame format. 

Create 3 new fields in the dataframe corresponding to the median value of the number of citations per author, the number of publications per author, and the h-index per author. So for instance, for the row authors_publications, you will create an additional column, e.g. authors_publications_median, containing the median number of publications per author in each paper.
sentences: To determine $\mathsf{LP}^{C_K}(x,x)$, we analyze the cipher defined by $C(x) = x \oplus K$. This function produces outputs that are uniformly distributed over $\{0,1\}^{64}$ for any fixed key $K$. 

In this case, $C(x)$ will equal $C(x)$ by definition, but to find the probability of two outputs being the same when $x$ remains constant, we need to consider the distribution of $K$. For any given $K$, the output is equal to the input only when $K$ is the zero string, which occurs with a probability of $1/2^{64}$. 

However, considering the uniform distribution across all possible outputs, we find that the probability is $\frac{1}{2}$ that two randomly chosen outputs will match. 

Therefore, the consistent probability that $C(x)$ equals $C(x)$ when evaluating $\mathsf{LP}^{C_K}(x,x)$ is:

Answer: *1*.,  
To create three new fields in the DataFrame corresponding to the median value of the number of citations per author, number of publications per author, and h-index per author, we can follow these steps:

1. **Load the DataFrame**: First, ensure that the DataFrame is properly loaded with all the columns mentioned.

2. **Extract Information**: For each row in the DataFrame, we will extract the relevant information from `authors_citations`, `authors_publications`, and `authors_hindex`, which should be lists or strings that can be converted into lists.

3. **Calculate Medians**:
    - For `authors_citations`, split the string or list and convert it to a numeric format if necessary, then calculate the median.
    - Repeat this for `authors_publications` and `authors_hindex`.

4. **Create New Columns**: Finally, add these median values as new columns in the DataFrame, naming them appropriately such as `authors_citations_median`, `authors_publications_median`, and `authors_hindex_median`.

5. **Final Output**: The DataFrame will now include the three new fields with the required median values.

The correct implementation in Python using pandas would look something like this:
```python
import pandas as pd

# Assuming df is your DataFrame
df['authors_citations_median'] = df['authors_citations'].apply(lambda x: pd.Series(map(int, x.split(','))).median())
df['authors_publications_median'] = df['authors_publications'].apply(lambda x: pd.Series(map(int, x.split(','))).median())
df['authors_hindex_median'] = df['authors_hindex'].apply(lambda x: pd.Series(map(int, x.split(','))).median())
```

,  
To achieve the task of creating three new fields in the DataFrame that represent the median values of the number of citations per author, publications per author, and h-index per author, we need to focus on a few key points.

1. **Understanding Data Structure**: We must first recognize that the existing fields `authors_citations`, `authors_publications`, and `authors_hindex` need to be processed. These fields should ideally contain lists or strings of numerical values that represent various metrics for each author associated with a particular paper.

2. **Data Processing**: The first step in our implementation is to extract the numerical values from these fields. This involves splitting strings into lists of numbers and converting them into a format that can be processed mathematically. For example, if `authors_citations` is a string like "10,15,20", we need to convert it into a list of integers [10, 15, 20].

3. **Calculating the Median**: Once we have the numerical representations of citations, publications, and h-index, we can compute the median. The median is a robust statistical measure that indicates the middle value in a sorted list of numbers. It is particularly useful in this context as it helps to mitigate the effect of outliers, which can skew the mean.

4. **Creating New Columns**: After calculating the median for each of the metrics, we will create new columns in the DataFrame. This is done to maintain the integrity of the original data while also providing additional insights through the median values.

5. **Final Implementation**: The expected output will be a DataFrame that now contains three additional columns: `authors_citations_median`, `authors_publications_median`, and `authors_hindex_median`. These columns will hold the median values of citations, publications, and h-index per author for each paper, respectively.

The implementation in Python using pandas would be as follows:
```python
import pandas as pd

# Assuming df is your DataFrame
df['authors_citations_median'] = df['authors_citations'].apply(lambda x: pd.Series(map(int, x.split(','))).median())
df['authors_publications_median'] = df['authors_publications'].apply(lambda x: pd.Series(map(int, x.split(','))).median())
df['authors_hindex_median'] = df['authors_hindex'].apply(lambda x: pd.Series(map(int, x.split(','))).median())
```

In conclusion, through careful data manipulation and statistical computation, we are able to enhance our DataFrame with valuable insights regarding author contributions to conference papers., source_sentence: When using linear regression, how do you help prevent numerical instabilities? (One or multiple answers)
sentences: To determine all possible taggings of the sentence "a computer process programs accurately" using a Hidden Markov Model (HMM) Part-of-Speech (POS) tagger, we need to analyze the sequence of words and their potential tags based on the provided parameters.

### Step 1: Identify the Words and Possible Tags

The sentence consists of the following words:
1. a
2. computer
3. process
4. programs
5. accurately

The possible tags from the tagset are:
- DET (Determiner)
- N (Noun)
- V (Verb)
- ADV (Adverb)
- ADJ (Adjective)

### Step 2: Tagging Each Word

We will consider the possible tags for each word based on the provided emission probabilities \(P_1\) and transition probabilities \(P_2\). 

1. **Word: "a"**
   - Possible Tag: DET
   - Emission Probability: \(P_1(a \mid \mathrm{DET}) = 0.1\)

2. **Word: "computer"**
   - Possible Tags: N
   - Emission Probability: \(P_1(\text{computer} \mid \mathrm{N}) = 0.1\)

3. **Word: "process"**
   - Possible Tags: N, V
   - Emission Probabilities:
     - \(P_1(\text{process} \mid \mathrm{N}) = 0.095\)
     - \(P_1(\text{process} \mid \mathrm{V}) = 0.005\)

4. **Word: "programs"**
   - Possible Tags: N, V
   - Emission Probabilities:
     - \(P_1(\text{programs} \mid \mathrm{N}) = 0.080\)
     - \(P_1(\text{programs} \mid \mathrm{V}) = 0.020\)

5. **Word: "accurately"**
   - Possible Tag: ADV
   - Emission Probability: \(P_1(\text{accurately} \mid \mathrm{ADV}) = 0.1\)

### Step 3: Constructing Possible Tag Sequences

We will denote the tags as follows:
- T1 = DET
- T2 = N
- T3 = {N, V}
- T4 = {N, V}
- T5 = ADV

Now we can enumerate the possible combinations of tags for the sentence:

1. **Tagging Combinations**:
   - For T3 (process):
     - T3 = N
     - T3 = V
     
   - For T4 (programs):
     - If T3 = N, then T4 can be either N or V.
     - If T3 = V, then T4 can also be either N or V.

Thus, we have the following combinations for T3 and T4:
- If T3 = N:
  - T4 = N → (DET, N, N, N, ADV)
  - T4 = V → (DET, N, N, V, ADV)
  
- If T3 = V:
  - T4 = N → (DET, N, V, N, ADV)
  - T4 = V → (DET, N, V, V, ADV)

### Step 4: Listing All Possible Tag Sequences

From the above analysis, we can summarize the possible tag sequences as follows:

1. **(DET, N, N, N, ADV)**
2. **(DET, N, N, V, ADV)**
3. **(DET, N, V, N, ADV)**
4. **(DET, N, V, V, ADV)**

### Conclusion

The possible taggings of the sentence "a computer process programs accurately" are:
1. DET N N N ADV
2. DET N N V ADV
3. DET N V N ADV
4. DET N V V ADV

These combinations represent all feasible tagging sequences based on the given parameters of the HMM POS tagger., When using linear regression, numerical instabilities can arise from various factors such as multicollinearity among features, inappropriate scaling, or the presence of outliers. Here’s a detailed look at each of the provided options and how they relate to preventing numerical instabilities:

1. **Reduce Learning Rate**: This option is more relevant to gradient-based optimization methods (like gradient descent) rather than linear regression itself. While a lower learning rate can help in convergence and stability during training, it is not a direct method used to prevent numerical instabilities in the linear regression model itself. 

2. **Add a Regularization Term**: Regularization techniques like Lasso (L1) or Ridge (L2) regression can help mitigate issues related to overfitting and high variance, which can indirectly reduce numerical instability. By adding a penalty for large coefficients, regularization can help stabilize the solution and make the optimization problem more well-posed. This is a valid approach for preventing numerical instabilities.

3. **Remove Degenerate Features**: Degenerate features, or highly correlated features (multicollinearity), can lead to inflated variances of the coefficient estimates, making the model unstable and sensitive to small changes in the data. Removing these features can help in achieving a more stable model because it reduces redundancy and improves the numerical performance of the regression.

4. **Add More Features**: This option is generally not a good strategy for preventing numerical instabilities. In fact, adding more features, especially if they are irrelevant or noisy, might exacerbate issues like multicollinearity and lead to further instability. Therefore, this choice is not advisable for addressing numerical stability.

In summary, the two most effective strategies from the options provided for preventing numerical instabilities in linear regression are to **add a regularization term** and to **remove degenerate features**. 

Thus, the succinct answer is:
**Add a regularization term and remove degenerate features.**, To address the question of preventing numerical instabilities in linear regression, let's analyze the provided options step by step:

1. **Reduce learning rate**: While reducing the learning rate can help in optimization algorithms (like gradient descent) to ensure convergence, it does not directly address numerical instabilities inherent in the calculations of linear regression itself.

2. **Add a regularization term**: Regularization techniques, such as Lasso (L1) or Ridge (L2), can help mitigate issues related to overfitting and can also improve numerical stability by constraining the size of the coefficient estimates, particularly in the presence of multicollinearity.

3. **Remove degenerate features**: Degenerate features (or highly correlated features) can lead to multicollinearity, which can cause numerical instability in the computation of the regression coefficients. Therefore, removing such features can help prevent these instabilities.

4. **Add more features**: This option does not help in preventing numerical instabilities. In fact, adding more features, especially if they are not informative, can exacerbate issues like multicollinearity.

Considering these analyses, the most relevant options for preventing numerical instabilities in linear regression are:

- **Add a regularization term**
- **Remove degenerate features**

Final answer: **Add a regularization term, Remove degenerate features**., source_sentence: Consider a classification problem on linearly separable data. We train an SVM model and a logistic regression model. For logistic regression (LR) we add a small regularization term (penalty on weights) in order to make the optimum well-defined. Each model gives us a margin. Consider a datapoint $\mathbf{x}_{0}$ that is correctly classified and strictly outside both margins Which one of the following statements is incorrect ?
sentences: In the context of a classification problem with linearly separable data, both logistic regression (LR) and support vector machines (SVM) have distinct characteristics regarding how they define decision boundaries and which points influence these boundaries.

Let's analyze each statement about the datapoint \(\mathbf{x}_{0}\) that is correctly classified and strictly outside both margins:

1. **Existence of Direction Without Changing LR Decision Boundary**: Since \(\mathbf{x}_{0}\) is outside both margins, moving it slightly in any direction should not cause it to cross the decision boundary of the logistic regression. Therefore, there exists a direction in which we can move \(\mathbf{x}_{0}\) without changing the LR decision boundary after retraining. **(True)**

2. **Support Vector Status of \(\mathbf{x}_{0}\)**: A support vector is a point that lies on the margin (for SVM) or influences the boundary. Since \(\mathbf{x}_{0}\) is strictly outside the margins, it cannot be a support vector. **(True)**

3. **Existence of Direction for Arbitrary Movement Without Changing SVM Decision Boundary**: For SVM, if \(\mathbf{x}_{0}\) is outside both margins, you can move it arbitrarily in many directions without crossing the margin, hence it will not affect the decision boundary. **(True)**

4. **Effect of Removing \(\mathbf{x}_{0}\) on LR Decision Boundary**: Removing \(\mathbf{x}_{0}\) could potentially change the decision boundary, especially since it is a point that contributes to the weight optimization. **(True)**

5. **Effect of Removing \(\mathbf{x}_{0}\) on SVM Decision Boundary**: Since \(\mathbf{x}_{0}\) is outside the margin and not a support vector, removing it will not change the SVM decision boundary. **(True)**

The statement that is incorrect based on this analysis is statement **4**: "If we remove \(\mathbf{x}_{0}\) from the dataset and retrain, this will change the LR decision boundary." 

**Key Takeaway**: The incorrect statement is that removing a point outside the margin will change the logistic regression decision boundary, while in fact, it may not always do so depending on the influence of that point in the overall dataset. 

**Verification Method**: To verify the answer, consider training the logistic regression model with and without \(\mathbf{x}_{0}\), and observe if the weights or decision boundary shift. If they remain the same, this confirms that \(\mathbf{x}_{0}\) did not influence the boundary., To determine whether the statement \( H(\mathcal{S}) = h(1/3) \) is true or false, we need to analyze the Markov chain defined by the probabilities in the given graph and compute the entropy of the source \( \mathcal{S} \).

### Step 1: Understand the Transition Probabilities
From the graph:
- \( p_{S_{n+1} | S_n}(0 | 0) = \frac{1}{2} \)
- \( p_{S_{n+1} | S_n}(1 | 0) = \frac{1}{2} \)
- \( p_{S_{n+1} | S_n}(0 | 1) = \frac{1}{4} \)
- \( p_{S_{n+1} | S_n}(1 | 1) = \frac{3}{4} \)

### Step 2: Compute the Steady-State Distribution
We need the steady-state distribution \( \pi = (\pi_0, \pi_1) \) such that:
\[
\begin{align*}
\pi_0 & = \pi_0 \cdot \frac{1}{2} + \pi_1 \cdot \frac{1}{4}, \\
\pi_1 & = \pi_0 \cdot \frac{1}{2} + \pi_1 \cdot \frac{3}{4}.
\end{align*}
\]
Additionally, we have the normalization condition:
\[
\pi_0 + \pi_1 = 1.
\]

Substituting \( \pi_1 = 1 - \pi_0 \) into the first equation:
\[
\pi_0 = \frac{1}{2} \pi_0 + \frac{1}{4} (1 - \pi_0).
\]
Simplifying this gives:
\[
\pi_0 = \frac{1}{2} \pi_0 + \frac{1}{4} - \frac{1}{4} \pi_0,
\]
\[
\pi_0 = \left(\frac{1}{2} - \frac{1}{4}\right) \pi_0 + \frac{1}{4},
\]
\[
\pi_0 = \frac{1}{4} \pi_0 + \frac{1}{4}.
\]
Moving the terms involving \( \pi_0 \) to one side:
\[
\pi_0 - \frac{1}{4} \pi_0 = \frac{1}{4},
\]
\[
\frac{3}{4} \pi_0 = \frac{1}{4} \implies \pi_0 = \frac{1}{3}.
\]
Then, substituting back to find \( \pi_1 \):
\[
\pi_1 = 1 - \pi_0 = 1 - \frac{1}{3} = \frac{2}{3}.
\]

### Step 3: Calculate the Entropy
The entropy \( H(\mathcal{S}) \) of the source can be computed using the steady-state probabilities:
\[
H(\mathcal{S}) = -\left( \pi_0 \log_2 \pi_0 + \pi_1 \log_2 \pi_1 \right).
\]
Substituting the values:
\[
H(\mathcal{S}) = -\left( \frac{1}{3} \log_2 \frac{1}{3} + \frac{2}{3} \log_2 \frac{2}{3} \right).
\]

### Step 4: Compare with \( h(1/3) \)
The binary entropy function \( h(p) \) is given by:
\[
h(p) = -p \log_2 p - (1-p) \log_2 (1-p).
\]
For \( p = \frac{1}{3} \):
\[
h\left(\frac{1}{3}\right) = -\left(\frac{1}{3} \log_2 \frac{1}{3} + \frac{2}{3} \log_2 \frac{2}{3}\right).
\]

### Conclusion
Thus, \( H(\mathcal{S}) = h\left(\frac{1}{3}\right) \).

### Final Answer
The statement \( H(\mathcal{S}) = h(1/3) \) is **True**.

**Correct Option:** Option 1: True

### Rationale for Incorrect Option
- **Option 2: False**: This option is incorrect because we have shown that the entropy of the source \( H(\mathcal{S}) \) indeed equals the binary entropy \( h\left(\frac{1}{3}\right) \), confirming the statement is true., To understand the given problem, let's first clarify the concepts of SVM (Support Vector Machine) and Logistic Regression, particularly in the context of linearly separable data and the role of margins.

1. **Definitions**:
   - **Support Vector Machine (SVM)**: This is a supervised learning model that finds the optimal hyperplane that separates the data into classes while maximizing the margin (the distance between the hyperplane and the nearest data points from either class, which are called support vectors). Only the data points that are closest to the decision boundary (the support vectors) affect the position of this boundary.
   - **Logistic Regression (LR)**: This is a statistical model used for binary classification. It estimates the probability that a given input point belongs to a particular class. Regularization is often applied in LR to prevent overfitting and ensure that the model remains generalizable.

2. **Margin**: 
   - In SVMs, the margin is defined as the distance between the closest points of the classes to the separating hyperplane. Points that are outside the margin and correctly classified do not influence the decision boundary directly.
   - In LR, the model is less sensitive to the individual data points as long as they are well classified and not close to the decision boundary.

Now, let's evaluate each statement:

1. **Statement 1**: "There exists a direction in which we can slightly move $\mathbf{x}_{0}$ without changing the LR decision boundary after retraining."
   - This is **correct**. Since $\mathbf{x}_{0}$ is outside the margin and correctly classified, moving it slightly will not change the decision boundary of LR.

2. **Statement 2**: "$\mathbf{x}_{0}$ isn't a support vector."
   - This is **correct**. By definition, support vectors are the points closest to the decision boundary. Since $\mathbf{x}_{0}$ is outside the margin, it cannot be a support vector.

3. **Statement 3**: "There exists a direction in which we can arbitrarily move $\mathbf{x}_{0}$ without changing the SVM decision boundary after retraining."
   - This is **correct**. Since $\mathbf{x}_{0}$ is outside the margin, we can move it arbitrarily far without affecting the position of the SVM decision boundary.

4. **Statement 4**: "If we remove $\mathbf{x}_{0}$ from the dataset and retrain, this will change the LR decision boundary."
   - This is **incorrect**. Since $\mathbf{x}_{0}$ is outside the margin and not a support vector, removing it does not affect the LR model's decision boundary.

5. **Statement 5**: "If we remove $\mathbf{x}_{0}$ from the dataset and retrain, this will not change the SVM decision boundary."
   - This is **correct**. Similar to LR, since $\mathbf{x}_{0}$ is not a support vector, its removal will not affect the SVM decision boundary.

Thus, the statement that is incorrect is:

**Answer: 4. If we remove $\mathbf{x}_{0}$ from the dataset and retrain, this will change the LR decision boundary.**, source_sentence: Which of the following are part of the RDF schema language?
sentences: RDF schema language includes the "domain" statement for RDF properties, which specifies the class of subjects that can be used with a particular property. This matches option B. 

Answer: *B: The « domain » statement for RDF properties?*, The RDF schema language specifically includes "domain," which defines the class of resources a property pertains to. This corresponds to option B.

Answer: *B: The « domain » statement for RDF properties?*, To determine whether changing the parameter type of the `add` method from `int` to `Integer` breaks backward compatibility, we first need to understand what backward compatibility means in this context. Backward compatibility refers to the ability of newer versions of a software component (in this case, a class) to accept inputs and operate correctly with the same inputs that were valid in previous versions. 

### Understanding the Types

1. **Primitive Type vs. Wrapper Type**:
   - In Java, `int` is a primitive data type, while `Integer` is an object wrapper class. 
   - This distinction is important because primitives are stored directly as values, while objects (like `Integer`) are references to memory locations where the actual value is stored.

2. **Method Signature Change**:
   - The original method signature is:
     ```java
     public void add(int val)
     ```
   - The proposed change would make it:
     ```java
     public void add(Integer val)
     ```

### Analyzing Backward Compatibility

#### 1. Call Compatibility
- If a client code has previously been calling `add(int)` with primitive integers, this code will **not compile** if the method signature is changed to `add(Integer)`. This means that existing code that uses the `add(int)` method will break because Java will not find a matching method for calls that pass primitive types.

#### 2. Autoboxing
- One important feature of Java is **autoboxing**, which allows automatic conversion between primitive types and their corresponding wrapper classes. If you change the method to accept `Integer`, you might think that existing calls to `add(int)` could still work because of autoboxing:
  ```java
  DataStructure ds = new DataStructure();
  ds.add(5); // This would work if 'add' accepts Integer due to autoboxing.
  ```
- However, **this does not mean backward compatibility is preserved**. While it allows clients to call the method with an `int`, it does not cover all cases.

#### 3. Method Overloading
- If the change involves overloading (having both versions of the method), like:
  ```java
  public void add(int val) { /*...*/ }
  public void add(Integer val) { /*...*/ }
  ```
- This would maintain backward compatibility because both methods exist, and existing code can continue to use the original method without any issues.

### Conclusion
In summary, changing the parameter type from `int` to `Integer` **does break backward compatibility** unless you also keep the original `add(int)` method intact. If you only have the `add(Integer)` method, existing code that calls `add(int)` will fail to compile because there is no matching method for primitive integers. 

Thus, while autoboxing offers some flexibility, it does not ensure backward compatibility when a method's signature is changed in a way that removes support for its previous form. 

**Final Answer**: Yes, changing the parameter type of `add` from `int` to `Integer` breaks backward compatibility because existing calls using primitive `int` will not compile without the original method being retained.
pipeline_tag: sentence-similarity
library_name: sentence-transformers
metrics: cosine_accuracy
model-index: name: SentenceTransformer based on allenai/scibert_scivocab_uncased
results: task: type: triplet
name: Triplet
dataset: name: val eval
type: val-eval
metrics: type: cosine_accuracy
value: 0.593440592288971
name: Cosine Accuracy
verified: no
Likes: 0 | All-time downloads: 44
Created: 2025-06-05 18:32:37