Mellum-4b-sft-all

5

9

4.0B

llama

by

JetBrains

Language Model

OTHER

4B params

New

5 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

9GB+ RAM

Mobile

Laptop

Server

Quick Summary

AI model with specialized capabilities.

Device Compatibility

Mobile

4-6GB RAM

Laptop

16GB RAM

Server

GPU

Minimum Recommended

4GB+ RAM

Code Examples

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

Sample Usagepythontransformers

import json
from transformers import AutoTokenizer, AutoModelForCausalLM

example = """
<filename>Utils.kt
package utils

fun multiply(x: Int, y: Int): Int {
    return x * y
}

<filename>Config.kt
package config

object Config {
    const val DEBUG = true
    const val MAX_VALUE = 100
}

<filename>Example.kt
<fim_suffix>
fun main() {
    val result = calculateSum(5, 10)
    println(result)
}
<fim_prefix>fun calculateSum(a: Int, b: Int): Int {
<fim_middle>
"""

tokenizer = AutoTokenizer.from_pretrained('JetBrains/Mellum-4b-sft-all')
model = AutoModelForCausalLM.from_pretrained('JetBrains/Mellum-4b-sft-all')
encoded_input = tokenizer(example, return_tensors='pt', return_token_type_ids=False)
out = model.generate(
    **encoded_input,
    max_new_tokens=100,
)

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.

Replicate

One-click model deployment

Easiest Setup

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

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