fine_tuned_ballerina_coderank

SentenceTransformer based on nomic-ai/CodeRankEmbed

This is a sentence-transformers model finetuned from nomic-ai/CodeRankEmbed. It maps sentences & paragraphs to a 768-dimensional dense vector space and can be used for semantic textual similarity, semantic search, paraphrase mining, text classification, clustering, and more.

Model Details

Model Description

• Model Type: Sentence Transformer
• Base model: nomic-ai/CodeRankEmbed <!-- at revision 3c4b60807d71f79b43f3c4363786d9493691f8b1 -->
• Maximum Sequence Length: 8192 tokens
• Output Dimensionality: 768 dimensions
• Similarity Function: Cosine Similarity

<!-- - **Training Dataset:** Unknown --> <!-- - **Language:** Unknown --> <!-- - **License:** Unknown -->

Model Sources

• Documentation: Sentence Transformers Documentation
• Repository: Sentence Transformers on GitHub
• Hugging Face: Sentence Transformers on Hugging Face

Full Model Architecture

SentenceTransformer(
  (0): Transformer({'max_seq_length': 8192, 'do_lower_case': False, 'architecture': 'NomicBertModel'})
  (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})
)

Usage

Direct Usage (Sentence Transformers)

First install the Sentence Transformers library:

pip install -U sentence-transformers

Then you can load this model and run inference.

from sentence_transformers import SentenceTransformer

# Download from the 🤗 Hub
model = SentenceTransformer("DidulaThavishaPro/fine_tuned_ballerina_coderank")
# Run inference
queries = [
    "Represent this query for searching relevant code: Create a game in ballerina using the PyGame library.",
]
documents = [
    'import ballerina/io;\nimport ballerina/random;\n\n// This function creates a simple number guessing game in Ballerina\n// Since Ballerina doesn\'t have a GUI library like PyGame, we\'ll create\n// a text-based game that demonstrates game loop concepts\n// The game will generate a random number and let the player guess it\n// Returns true if the player wants to play again, false otherwise\nfunction playGuessingGame(int minRange, int maxRange, int maxAttempts) returns boolean|error {\n    // Generate a random number between minRange and maxRange\n    int secretNumber = check random:createIntInRange(minRange, maxRange + 1);\n    int attempts = 0;\n    boolean gameRunning = true;\n    \n    io:println(string `Welcome to the Number Guessing Game!`);\n    io:println(string `Guess a number between ${minRange} and ${maxRange}`);\n    io:println(string `You have ${maxAttempts} attempts.`);\n    \n    // Game loop - similar to PyGame\'s event loop\n    while gameRunning && attempts < maxAttempts {\n        attempts += 1;\n        io:println(string `\\nAttempt ${attempts}/${maxAttempts}`);\n        \n        // Get player input\n        string input = io:readln("Enter your guess: ");\n        int|error guess = int:fromString(input);\n        \n        if guess is error {\n            io:println("Invalid input! Please enter a number.");\n            attempts -= 1; // Don\'t count invalid inputs\n            continue;\n        }\n        \n        // Check the guess\n        if guess == secretNumber {\n            io:println(string `Congratulations! You guessed the number ${secretNumber} in ${attempts} attempts!`);\n            gameRunning = false;\n        } else if guess < secretNumber {\n            io:println("Too low! Try again.");\n        } else {\n            io:println("Too high! Try again.");\n        }\n        \n        // Check if out of attempts\n        if attempts >= maxAttempts && guess != secretNumber {\n            io:println(string `Game Over! The number was ${secretNumber}`);\n            gameRunning = false;\n        }\n    }\n    \n    // Ask if player wants to play again\n    string playAgain = io:readln("\\nPlay again? (yes/no): ");\n    return playAgain.toLowerAscii() == "yes";\n}\n\n// Main game initialization and loop function\nfunction initializeGame() returns error? {\n    boolean running = true;\n    \n    // Main game loop - similar to PyGame\'s main loop\n    while running {\n        boolean|error continueGame = playGuessingGame(1, 100, 7);\n        \n        if continueGame is error {\n            io:println("An error occurred: " + continueGame.message());\n            running = false;\n        } else {\n            running = continueGame;\n        }\n    }\n    \n    io:println("Thanks for playing!");\n}',
    'import ballerina/http;\n\n// Function to make a POST request with the specified parameters\n// Takes the URL, headers map, and payload map as inputs\n// Returns the HTTP response or an error if the request fails\nfunction makePostRequest(string url, map<string> headers, map<json> payload) returns http:Response|error {\n    // Create an HTTP client with the base URL\n    http:Client httpClient = check new (url);\n    \n    // Make the POST request with headers and JSON payload\n    http:Response response = check httpClient->post("/", payload, headers);\n    \n    return response;\n}',
    'import ballerina/io;\n\n// Calculate if a year is a leap year\nfunction isLeapYear(int year) returns boolean {\n    if (year % 400 == 0) {\n        return true;\n    }\n    if (year % 100 == 0) {\n        return false;\n    }\n    if (year % 4 == 0) {\n        return true;\n    }\n    return false;\n}\n\n// Get the number of days in a given month\nfunction getDaysInMonth(int month, int year) returns int {\n    int[] daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];\n    if (month == 2 && isLeapYear(year)) {\n        return 29;\n    }\n    return daysInMonth[month - 1];\n}\n\n// Calculate the day of week for a given date using Zeller\'s congruence\n// Returns 0 = Sunday, 1 = Monday, ..., 6 = Saturday\nfunction getDayOfWeek(int year, int month, int day) returns int {\n    int m = month;\n    int y = year;\n    \n    if (m < 3) {\n        m = m + 12;\n        y = y - 1;\n    }\n    \n    int k = y % 100;\n    int j = y / 100;\n    \n    int h = (day + (13 * (m + 1)) / 5 + k + k / 4 + j / 4 - 2 * j) % 7;\n    \n    // Convert to Sunday = 0 format\n    int dayOfWeek = (h + 6) % 7;\n    return dayOfWeek;\n}\n\n// Get month name\nfunction getMonthName(int month) returns string {\n    string[] months = ["January", "February", "March", "April", "May", "June",\n                       "July", "August", "September", "October", "November", "December"];\n    return months[month - 1];\n}\n\n// Format and print calendar for a given month and year\nfunction printCalendar(int month, int year) {\n    string monthName = getMonthName(month);\n    io:println(string `   ${monthName} ${year}`);\n    io:println("Su Mo Tu We Th Fr Sa");\n    \n    int firstDay = getDayOfWeek(year, month, 1);\n    int daysInMonth = getDaysInMonth(month, year);\n    \n    // Print leading spaces\n    string line = "";\n    int i = 0;\n    while (i < firstDay) {\n        line = line + "   ";\n        i = i + 1;\n    }\n    \n    // Print days\n    int day = 1;\n    int currentDayOfWeek = firstDay;\n    \n    while (day <= daysInMonth) {\n        if (day < 10) {\n            line = line + string ` ${day} `;\n        } else {\n            line = line + string `${day} `;\n        }\n        \n        currentDayOfWeek = currentDayOfWeek + 1;\n        \n        if (currentDayOfWeek == 7) {\n            io:println(line);\n            line = "";\n            currentDayOfWeek = 0;\n        }\n        \n        day = day + 1;\n    }\n    \n    // Print remaining line if exists\n    if (line != "") {\n        io:println(line);\n    }\n}',
]
query_embeddings = model.encode_query(queries)
document_embeddings = model.encode_document(documents)
print(query_embeddings.shape, document_embeddings.shape)
# [1, 768] [3, 768]

# Get the similarity scores for the embeddings
similarities = model.similarity(query_embeddings, document_embeddings)
print(similarities)
# tensor([[ 0.4549, -0.0116, -0.0348]])

<!-- ### Direct Usage (Transformers) <details><summary>Click to see the direct usage in Transformers</summary> </details> --> <!-- ### Downstream Usage (Sentence Transformers) You can finetune this model on your own dataset. <details><summary>Click to expand</summary> </details> --> <!-- ### Out-of-Scope Use *List how the model may foreseeably be misused and address what users ought not to do with the model.* --> <!-- ## Bias, Risks and Limitations *What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model.* --> <!-- ### Recommendations *What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.* -->

Training Details

Training Dataset

Unnamed Dataset

• Size: 512 training samples
• Columns: <code>anchor</code>, <code>positive</code>, <code>negative_1</code>, <code>negative_2</code>, and <code>negative_3</code>
• Approximate statistics based on the first 512 samples:

  	anchor	positive	negative_1	negative_2	negative_3
  type	string	string	string	string	string
  details	<ul><li>min: 15 tokens</li><li>mean: 32.95 tokens</li><li>max: 205 tokens</li></ul>	<ul><li>min: 60 tokens</li><li>mean: 327.53 tokens</li><li>max: 1812 tokens</li></ul>	<ul><li>min: 56 tokens</li><li>mean: 338.29 tokens</li><li>max: 1465 tokens</li></ul>	<ul><li>min: 56 tokens</li><li>mean: 325.32 tokens</li><li>max: 1154 tokens</li></ul>	<ul><li>min: 56 tokens</li><li>mean: 329.93 tokens</li><li>max: 1465 tokens</li></ul>

• Samples:

  anchor	positive	negative_1	negative_2	negative_3
  <code>Represent this query for searching relevant code: Create a ballerina program to convert a given list of strings to float values</code>	<code>// This function converts a string array to a float array<br>// It iterates through each string element and parses it to float<br>// Returns an array of float values or an error if parsing fails<br>function convertStringToFloat(string[] strList) returns float[]|error {<br> float[] floats = [];<br> foreach string s in strList {<br> // Parse each string to float using float:fromString<br> float|error floatValue = float:fromString(s);<br> if floatValue is error {<br> return floatValue;<br> }<br> floats.push(floatValue);<br> }<br> return floats;<br>}</code>	<code>import ballerina/lang.'float;<br><br>// Simple linear model for binary classification<br>// This represents a basic single-layer perceptron as a simplified alternative to a neural network<br>// since Ballerina doesn't have ML libraries. The model learns weights to separate data into two classes.<br><br>type LinearModel record {|<br> float[] weights;<br> float bias;<br> float learningRate;<br>|};<br><br>// Initialize a linear model with given input dimensions<br>function createModel(int inputDim, float learningRate = 0.01) returns LinearModel {<br> float[] weights = [];<br> int i = 0;<br> while i < inputDim {<br> weights.push(0.0);<br> i += 1;<br> }<br> return {<br> weights: weights,<br> bias: 0.0,<br> learningRate: learningRate<br> };<br>}<br><br>// Sigmoid activation function<br>function sigmoid(float x) returns float {<br> return 1.0 / (1.0 + float:pow(2.718281828459045, -x));<br>}<br><br>// Forward pass - make a prediction<br>function predict(LinearModel model, float[] input) returns float {<br> float sum = model.bi...</code>	<code>import ballerina/io;<br><br>// LinearRegression represents a simple linear regression model<br>// We'll use the formula: y = mx + b where m is slope and b is intercept<br>// This implementation uses the least squares method to calculate m and b<br>type LinearRegression record {<br> float slope;<br> float intercept;<br>};<br><br>// Train the linear regression model using least squares method<br>// Given arrays of x values (features) and y values (targets)<br>// Calculates slope (m) and intercept (b) using formulas:<br>// m = (nΣ(xy) - ΣxΣy) / (nΣ(x²) - (Σx)²)<br>// b = (Σy - mΣx) / n<br>function trainLinearRegression(float[] x, float[] y) returns LinearRegression|error {<br> if x.length() != y.length() || x.length() == 0 {<br> return error("Input arrays must have the same non-zero length");<br> }<br> <br> int n = x.length();<br> float sumX = 0.0;<br> float sumY = 0.0;<br> float sumXY = 0.0;<br> float sumX2 = 0.0;<br> <br> foreach int i in 0 ..< n {<br> sumX += x[i];<br> sumY += y[i];<br> sumXY += x[i] * y...</code>	<code>import ballerina/io;<br><br>// Define a record type to represent a student with name and grades<br>type Student record {<br> string name;<br> int[] grades;<br>};<br><br>// Function to calculate the average of grades<br>// Takes an array of integers and returns the average as a float<br>// Handles empty array case by returning 0.0<br>function getAverage(int[] grades) returns float {<br> if grades.length() == 0 {<br> return 0.0;<br> }<br> <br> int sum = 0;<br> foreach int grade in grades {<br> sum += grade;<br> }<br> <br> return <float>sum / <float>grades.length();<br>}<br><br>// Main function to process students and calculate their averages<br>public function main() {<br> // Input data as an array of Student records<br> Student[] students = [<br> {name: "Alice", grades: [90, 92, 78]},<br> {name: "Bob", grades: [86, 92, 82]}<br> ];<br> <br> // Calculate and print average for each student<br> foreach Student student in students {<br> string name = student.name;<br> int[] grades = student.grades;<br> ...</code>
  <code>Represent this query for searching relevant code: Create a ballerina program to prompt the user for a number (x) and then print the list of its factors in increasing order.</code>	<code>import ballerina/io;<br><br>// This function finds all factors of a given number<br>// A factor is a number that divides the given number evenly (remainder is 0)<br>// Since we iterate from 1 to x, the factors are naturally in increasing order<br>function findFactors(int x) returns int[] {<br> int[] factors = [];<br> <br> // Find all factors by checking each number from 1 to x<br> foreach int i in 1 ... x {<br> if x % i == 0 {<br> factors.push(i);<br> }<br> }<br> <br> return factors;<br>}<br><br>public function main() returns error? {<br> // Prompt user for input<br> io:println("Enter a number: ");<br> string input = io:readln();<br> <br> // Convert string input to integer<br> int x = check int:fromString(input);<br> <br> // Find factors<br> int[] factors = findFactors(x);<br> <br> // Print the factors<br> io:println("The factors of ", x, " are:");<br> foreach int factor in factors {<br> io:println(factor);<br> }<br>}</code>	<code>import ballerina/io;<br><br>// To calculate factorial, we multiply all numbers from n down to 1<br>// For example: 5! = 5 * 4 * 3 * 2 * 1 = 120<br>// We use an iterative approach with a while loop<br>// Start with factorial = 1, then multiply by n, n-1, n-2, ... until we reach 1<br>function calculateFactorial(int n) returns int {<br> int factorial = 1;<br> int current = n;<br> <br> while current > 1 {<br> factorial *= current;<br> current -= 1;<br> }<br> <br> return factorial;<br>}<br><br>public function main() {<br> // Get input from the user<br> io:println("Enter a number: ");<br> string input = io:readln();<br> <br> // Convert string to integer<br> int|error n = int:fromString(input);<br> <br> if n is int {<br> // Calculate the factorial<br> int result = calculateFactorial(n);<br> <br> // Print out the result<br> io:println("The factorial of the given number is: ", result);<br> } else {<br> io:println("Invalid input. Please enter a valid integer.");<br> }<br>}</code>	<code>import ballerina/io;<br><br>// This function takes a word or phrase as input<br>// Converts it to an array of characters<br>// Sorts the characters alphabetically<br>// Returns the sorted characters as a string array for processing<br>function getSortedCharacters(string input) returns string[] {<br> // Convert string to array of characters<br> string[] characters = [];<br> foreach int i in 0 ..< input.length() {<br> characters.push(input.substring(i, i + 1));<br> }<br> <br> // Sort the characters alphabetically<br> string[] sortedCharacters = characters.sort();<br> <br> return sortedCharacters;<br>}<br><br>// Helper function to print sorted characters (simulates the ballerina output)<br>function printSortedCharacters(string input) {<br> string[] sortedChars = getSortedCharacters(input);<br> foreach string char in sortedChars {<br> io:println(char);<br> }<br>}</code>	<code>import ballerina/io;<br><br>public function main() returns error? {<br> // Read input from user<br> string numStr = io:readln("Enter a number: ");<br> <br> // Convert string to integer<br> int num = check int:fromString(numStr.trim());<br> <br> // Calculate and print the square<br> int square = num * num;<br> io:println("The square of the number is: ", square);<br>}</code>
  <code>Represent this query for searching relevant code: Given a list of strings, write a ballerina code snippet to print all strings that begin with a letter 'a'.</code>	<code>import ballerina/io;<br><br>// Function to filter strings that begin with letter 'a' (case-insensitive)<br>// Takes an array of strings as input<br>// Returns an array containing only strings that start with 'a' or 'A'<br>// We'll iterate through the input array and check the first character<br>function filterStringsStartingWithA(string[] items) returns string[] {<br> string[] result = [];<br> <br> foreach string item in items {<br> // Check if string is not empty and starts with 'a' or 'A'<br> if item.length() > 0 {<br> string firstChar = item.substring(0, 1).toLowerAscii();<br> if firstChar == "a" {<br> result.push(item);<br> }<br> }<br> }<br> <br> return result;<br>}<br><br>// Helper function to print the filtered strings<br>function printStringsStartingWithA(string[] items) {<br> string[] filtered = filterStringsStartingWithA(items);<br> foreach string item in filtered {<br> io:println(item);<br> }<br>}</code>	<code>import ballerina/io;<br><br>// Iterate through the array and check if each string starts with "java"<br>// Use Ballerina's string:startsWith() function for prefix matching<br>// Collect matching items in a new array and return it<br>function searchItemsStartingWith(string[] arr, string prefix) returns string[] {<br> string[] result = [];<br> foreach string item in arr {<br> if item.startsWith(prefix) {<br> result.push(item);<br> }<br> }<br> return result;<br>}<br><br>// Main function to demonstrate the usage<br>public function main() {<br> string[] arr = ["ballerina", "c++", "java", "java-script"];<br> string[] result = searchItemsStartingWith(arr, "java");<br> io:println(result);<br>}</code>	<code>import ballerina/io;<br><br>// This function creates a pyramid pattern with asterisks<br>// For each row i (0 to h-1):<br>// - Print (h-i-1) spaces for left padding<br>// - Print (i+1) asterisks followed by spaces<br>// - Move to next line<br>function pyramid(int h) {<br> int i = 0;<br> while i < h {<br> // Print leading spaces<br> int j = 0;<br> while j < h - i - 1 {<br> io:print(" ");<br> j = j + 1;<br> }<br> <br> // Print asterisks with spaces<br> j = 0;<br> while j < i + 1 {<br> io:print("* ");<br> j = j + 1;<br> }<br> <br> // Print newline<br> io:println("");<br> i = i + 1;<br> }<br>}</code>	<code>import ballerina/io;<br><br>// This function takes an array of strings (names) and returns them sorted alphabetically.<br>// Ballerina provides built-in array sort methods that can be used for this purpose.<br>// We'll use the sort() method with a key function to sort the names in ascending order.<br>function sortNames(string[] names) returns string[] {<br> // Create a copy of the array to avoid modifying the original<br> string[] sortedNames = names.clone();<br> <br> // Sort the array alphabetically using Ballerina's sort function<br> // The sort is done in-place and returns the sorted array<br> string[] result = sortedNames.sort();<br> <br> return result;<br>}<br><br>// Main function to demonstrate the usage<br>public function main() {<br> string[] names = ["Robert", "Asher", "Aster", "Athena"];<br> string[] sortedNames = sortNames(names);<br> <br> io:println(sortedNames);<br>}</code>

• Loss: <code>MultipleNegativesRankingLoss</code> with these parameters:

  {
      "scale": 20.0,
      "similarity_fct": "cos_sim",
      "gather_across_devices": false
  }
  

Training Hyperparameters

Non-Default Hyperparameters

• per_device_train_batch_size: 1
• learning_rate: 2e-05
• num_train_epochs: 2
• warmup_ratio: 0.1

All Hyperparameters

<details><summary>Click to expand</summary>

• overwrite_output_dir: False
• do_predict: False
• eval_strategy: no
• prediction_loss_only: True
• per_device_train_batch_size: 1
• per_device_eval_batch_size: 8
• per_gpu_train_batch_size: None
• per_gpu_eval_batch_size: None
• gradient_accumulation_steps: 1
• eval_accumulation_steps: None
• torch_empty_cache_steps: None
• learning_rate: 2e-05
• weight_decay: 0.0
• adam_beta1: 0.9
• adam_beta2: 0.999
• adam_epsilon: 1e-08
• max_grad_norm: 1.0
• num_train_epochs: 2
• max_steps: -1
• lr_scheduler_type: linear
• lr_scheduler_kwargs: {}
• warmup_ratio: 0.1
• warmup_steps: 0
• log_level: passive
• log_level_replica: warning
• log_on_each_node: True
• logging_nan_inf_filter: True
• save_safetensors: True
• save_on_each_node: False
• save_only_model: False
• restore_callback_states_from_checkpoint: False
• no_cuda: False
• use_cpu: False
• use_mps_device: False
• seed: 42
• data_seed: None
• jit_mode_eval: False
• bf16: False
• fp16: False
• fp16_opt_level: O1
• half_precision_backend: auto
• bf16_full_eval: False
• fp16_full_eval: False
• tf32: None
• local_rank: 0
• ddp_backend: None
• tpu_num_cores: None
• tpu_metrics_debug: False
• debug: []
• dataloader_drop_last: False
• dataloader_num_workers: 0
• dataloader_prefetch_factor: None
• past_index: -1
• disable_tqdm: False
• remove_unused_columns: True
• label_names: None
• load_best_model_at_end: False
• ignore_data_skip: False
• fsdp: []
• fsdp_min_num_params: 0
• fsdp_config: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
• fsdp_transformer_layer_cls_to_wrap: None
• accelerator_config: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
• parallelism_config: None
• deepspeed: None
• label_smoothing_factor: 0.0
• optim: adamw_torch_fused
• optim_args: None
• adafactor: False
• group_by_length: False
• length_column_name: length
• project: huggingface
• trackio_space_id: trackio
• ddp_find_unused_parameters: None
• ddp_bucket_cap_mb: None
• ddp_broadcast_buffers: False
• dataloader_pin_memory: True
• dataloader_persistent_workers: False
• skip_memory_metrics: True
• use_legacy_prediction_loop: False
• push_to_hub: False
• resume_from_checkpoint: None
• hub_model_id: None
• hub_strategy: every_save
• hub_private_repo: None
• hub_always_push: False
• hub_revision: None
• gradient_checkpointing: False
• gradient_checkpointing_kwargs: None
• include_inputs_for_metrics: False
• include_for_metrics: []
• eval_do_concat_batches: True
• fp16_backend: auto
• push_to_hub_model_id: None
• push_to_hub_organization: None
• mp_parameters:
• auto_find_batch_size: False
• full_determinism: False
• torchdynamo: None
• ray_scope: last
• ddp_timeout: 1800
• torch_compile: False
• torch_compile_backend: None
• torch_compile_mode: None
• include_tokens_per_second: False
• include_num_input_tokens_seen: no
• neftune_noise_alpha: None
• optim_target_modules: None
• batch_eval_metrics: False
• eval_on_start: False
• use_liger_kernel: False
• liger_kernel_config: None
• eval_use_gather_object: False
• average_tokens_across_devices: True
• prompts: None
• batch_sampler: batch_sampler
• multi_dataset_batch_sampler: proportional
• router_mapping: {}
• learning_rate_mapping: {}

</details>

Training Logs

<details><summary>Click to expand</summary> </details>

Framework Versions

• Python: 3.12.12
• Sentence Transformers: 5.1.2
• Transformers: 4.57.3
• PyTorch: 2.9.0+cu126
• Accelerate: 1.12.0
• Datasets: 4.0.0
• Tokenizers: 0.22.1

Citation

BibTeX

Sentence Transformers

@inproceedings{reimers-2019-sentence-bert,
    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
    author = "Reimers, Nils and Gurevych, Iryna",
    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
    month = "11",
    year = "2019",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/1908.10084",
}

MultipleNegativesRankingLoss

@misc{henderson2017efficient,
    title={Efficient Natural Language Response Suggestion for Smart Reply},
    author={Matthew Henderson and Rami Al-Rfou and Brian Strope and Yun-hsuan Sung and Laszlo Lukacs and Ruiqi Guo and Sanjiv Kumar and Balint Miklos and Ray Kurzweil},
    year={2017},
    eprint={1705.00652},
    archivePrefix={arXiv},
    primaryClass={cs.CL}
}

<!-- ## Glossary *Clearly define terms in order to be accessible across audiences.* --> <!-- ## Model Card Authors *Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction.* --> <!-- ## Model Card Contact *Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors.* -->