RoFormer: Asenqed ⵢⴻⵜⵜⵡⴰⵙⵏⴻⵔⵏⴰⵏ ⵙ ⵓⵙⴻⴽⵛⴻⵎ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵓⵄⴻⴷⴷⵉ

ⵉⵎⵓⴷⴻⵍ ⵏ ⵜⵎⵓⵖⵍⵉⵡⵉⵏ ⵏ ⵜⵎⵓⵖⵍⵉⵡⵉⵏ ⵜⵜⵡⴰⵙⵙⴻⵏ ⵙ ⵜⵣⴻⵎⵎⴰⵔⵏⵙⴻⵏ ⵏ ⵓⵙⵏⴻⴼⵍⵉ ⴷ ⵓⵙⴼⴻⵀⴻⵎ ⵏ ⵓⴹⵔⵉⵙ ⵉⵅⵓⵚⵚⴻⵏ. ⵜⵜⴽⴻⵍⴼⴻⵏ ⵖⴻⴼ ⵓⵙⵙⴻⴼⵀⴻⵎ ⵏ ⵓⵙⵡⵉⵔ ⴷ ⵜⵎⴻⵏⴹⴰⵡⵜ ⵏ ⵡⴰⵡⴰⵍⴻⵏ - ⵍⴻⵛⵖⴰⵍ ⴰⵢⴷⴻⴳ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵓⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵎⴹⵉⵇ ⴰⵇⴱⵓⵔ ⵙⵙⴻⴽⵏⴻⵏⵜⴷ ⵜⵉⵍⵉⵙⴰⵏⵙⴻⵏⵜ. ⵎⴰ ⵏⴻⵙⵙⴻⵎⵔⴰⵙ ⴰⵅⴻⵚⵚⴰⵔⴰ, ⴰⵎⴹⴰⵏ ⵏ ROFORMER, ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⵙ ⴰⵙⴻⵎⵔⴻⵙ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵓⵄⴻⴷⴷⵉ (RoPE), ⵢⴻⵜⵜⵄⴰⵡⴰⴷ ⵢⴻⵜⵜⴱⴻⴷⴷⵉⵍⴻⵏ ⴰⴱⵔⵉⴷⵏⵏⴻⵖ ⵏ ⵓⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵎⴹⵉⵇ.

ⴰⵙⴻⴽⵍⴻⵙ ⴰⵎⴹⵉⵇ ⴰⵇⴱⵓⵔ

ⵉⵎⵙⵓⴷⴷⵙⴻⵏ ⵜⵜⴳⴻⵏ ⴰⴹⵔⵉⵙ ⴰⵎ ⵜⵎⴻⵣⴳⵓⵏⵜ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ, ⵢⴻⵔⵏⴰ ⵜⵜⴰⴵⴵⴰⵏ ⴰⵙⴻⵇⴷⴻⵛ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵙ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵉ ⵍⵎⴻⵏⴷ ⵏ ⵜⵎⵓⵙⵙⵏⵉ ⵎⴻⵇⵇⵔⴻⵏ. ⴷ ⴰⵛⵓ ⴽⴰⵏ, ⵜⴰⵣⵎⴻⵔⵜⴰ ⵜⴻⵡⵡⵉⴷ ⴰⵖⴱⴻⵍⵏⵏⴻⵙ: agnosticisme ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵍⴻⵎⵜⴻⵍ ⵖⴻⵔ ⵍⵇⴰⵏⵓⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵜ. ⴰⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵎⴹⵉⵇ ⴷ ⵏⴻⵜⵜⴰ ⴰⵢ ⴷ ⵜⵉⵔⵉⵔⵉⵜ, ⴰⴷ ⴷⵢⴻⴼⴽ ⵉ ⵢⴰⵍ ⴰⴼⴻⵔⴷⵉⵙ ⴰⵙⴻⵏⵇⴻⴷ ⵓⵏⵏⵉⴳ ⴰⵢ ⴷⵢⴻⵙⵙⴽⴰⵏⴰⵢⴻⵏ ⴰⵎⴹⵉⵇⵏⵏⴻⵙ ⵏ ⵜⵎⴻⵣⴳⵓⵏⵜ.

ⴰⵙⴻⴽⴽⵉⵍ ⵏ ⵓⵎⴹⵉⵇ ⴰⵎⵓⵍⵍⵉ

ⴷⴻⴳ ⵜⴰⵣⵡⴰⵔⴰ, ⵉⵎⵓⴹⴰⵏ ⴰⵎ BERT ⵙⵙⴻⵇⴷⴰⵛⴻⵏ ⵉⵙⴻⵎⵔⴻⵙ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵎⵓⵖⵍⵉ, ⵜⵜⴰⴽⴻⵏⴷ ⴰⴼⴻⵔⴷⵉⵙ ⵏ ⵜⵎⵓⵖⵍⵉ ⵉ ⵢⴰⵍ ⴰⵎⴹⵉⵇ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵓⴹⵔⵉⵙ. ⵜⴰⵎⴻⵥⵍⴰⴰ, ⵖⴰⵙ ⴰⴽⴽⴻⵏ ⴷ ⵙⵔⵉⴷ, ⵎⴰⵛⴰ ⵙ ⵜⵖⴰⵡⵍⴰ ⵓⵔ ⵜⴻⵙⵄⵉ ⴰⵔⴰ ⵜⴰⵣⵎⴻⵔⵜ ⴰⴷ ⵜⵇⴰⴱⴻⵍ ⵉⴱⴻⴷⴷⴰⵍⴻⵏ ⵏ ⵜⴻⵖⵣⵉ ⵏ ⵜⵎⴻⵣⴳⵓⵏⵜ, ⵏⴻⵖ ⴰⴷ ⵜⴻⵙⵎⴻⴽⵜⵉ ⵙ ⵜⵎⵉⴹⵔⴰⵏⵜ ⵏ ⵜⵎⵉⴹⵔⴰⵏⵜ ⴳⴰⵔ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ, ⴷ ⴰⵢⴻⵏ ⵢⴻⵙⵄⴰⵏ ⴰⵣⴰⵍ ⴰⵎⴻⵇⵇⵔⴰⵏ ⵉ ⵡⴻⴼⵀⴰⵎ ⵏ ⵡⴰⵟⴰⵙ ⵏ ⵜⴳⴻⵎⵎⵉⵡⵉⵏ ⵏ ⵜⵓⵜⵍⴰⵢⵜ.

ⴰⵙⴻⴽⴽⵉⵍ ⵏ ⵓⵎⴹⵉⵇ ⴰⵏⴻⵎⴳⴰⵍ

ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⵜⵡⴰⵟⵟⴼⴻⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⴷⵉⵏⴰⵎⵉⵜ ⵏ ⵜⵓⵜⵍⴰⵢⵜ, ⵜⵜⵡⴰⵙⴻⴽⴽⵔⴻⵏⴷ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ, ⵙ ⵓⵙⴽⴰⵙⵉ ⵖⴻⴼ ⵜⵖⴻⵔⵖⴻⵔⵜ ⴳⴰⵔ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ (tokens) ⵎⴰⵞⵞⵉ ⵖⴻⴼ ⵢⵉⵎⵓⴽⴰⵏⵏⵙⴻⵏ ⵉⵎⴳⴻⵔⵔⴰⴷⴻⵏ (absolues). ⵖⴰⵙ ⴰⴽⴽⴻⵏ ⵙⵄⴰⵏ ⵍⴼⴰⵢⴷⴰ ⵏ ⵜⵎⵓⵖⵍⵉ, ⵉⴱⴻⵔⴷⴰⵏⴰ ⵙⵙⴻⴽⵏⴻⵏⴷ ⴰⵃⵔⵉⵛ ⵏ ⵓⵙⵙⴻⴹⵔⵓ, ⵢⴻⵔⵏⴰ ⵓⵔ ⵣⵎⵉⵔⴻⵏ ⴰⵔⴰ ⴰⴷ ⵙⴷⵓⴽⴽⵍⴻⵏ ⵙ ⵜⵖⴰⵡⵍⴰ ⴷⴻⴳ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵓⵙⵃⵓⵍⴼⵓ ⵏ ⵢⵉⵎⴰⵏ ⵏ Transformers, ⴷⵖⴰ ⴷ ⴰⵢⴰ ⴰⵢ ⵢⴻⵙⵙⴻⵎⵖⴻⵔⴻⵏ ⵍⴼⴰⵢⴷⴰⵏⵙⴻⵏ.

ROFORMER ⴷ ⵓⵙⴻⴽⵛⴻⵎ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵓⵄⴻⴷⴷⵉ

ⵙ ⵓⵙⵙⵏⴻⵏ ⵏ ⵜⵎⵉⴹⵔⴰⵏⵜ ⵏ ⵜⴻⵙⵏⴰⵜⵡⵉⵍⵉⵏ ⵏ ⵓⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵎⴹⵉⵇ ⵢⴻⵍⵍⴰⵏ, ROFORMER ⵢⴻⵙⵙⴻⴽⵛⴻⵎⴷ Rotary Position Embedding (RoPE), ⴷ ⵜⴰⵖⴰⵡⵙⴰ ⴰⵢ ⵢⴻⵙⴷⵓⴽⴽⵍⴻⵏ ⵍⴼⴰⵢⴷⴰⵜ ⵏ ⵢⵉⵙⴰⵍⵍⴻⵏ ⵏ ⵓⵎⴹⵉⵇ absolu ⴷ ⵡⵉⴷ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵡⴰⵔ ⵎⴰ ⵍⵍⴰⵏⵜ ⵜⵖⴰⵡⵙⵉⵡⵉⵏⵏⵙⴻⵏⵜ.

ⴰⵙⴻⴽⵛⴻⵎ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵓⵄⴻⴷⴷⵉ

RoPE ⵢⴻⵜⵜⵃⴻⵜⵜⵉⵎ ⵉⵙⴰⵍⴰⵏ ⵏ ⵓⵎⴹⵉⵇ ⵙ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵜⵎⴰⵜⵔⵉⵛⴻⵙ ⵏ ⵜⵎⵓⵖⵍⵉ, ⴷⵖⴰ ⴰⵢⴰ ⵢⴻⵙⵙⴰⵡⴹⴻⵏ ⴰⵎⴹⴰⵏ ⴰⴷ ⵢⴻⴼⵀⴻⵎ ⵎⴰⵞⵞⵉ ⴽⴰⵏ ⴰⵏⴷⴰ ⵢⴻⵍⵍⴰ ⵓⴹⵔⵉⵙ, ⵎⴰⵛⴰ ⴰⵎⴻⴽ ⵉ ⵢⴻⵜⵜⵡⴰⵇⵇⴻⵏ ⵖⴻⵔ ⵢⴰⵍ ⴰⴹⵔⵉⵙ ⵏⵏⵉⴹⴻⵏ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵓⴹⵔⵉⵙ.

Credit: ArXiv

ⵢⴻⵜⵜⴽⴻⵎⵎⵉⵍ ⵙ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵜⴳⴻⵎⵎⵉ, ⵢⴻⵜⵜⵡⴰⵍⵉ ⵉⵎⵓⴽⴰⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⴷ ⵜⵉⵏⴻⵇⵇⵉⴹⵉⵏ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵡⴰⵟⴰⵙ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵙⵎⴻⴽⵜⵉⵏ ⴰⵙⵙⴰⵖⴻⵏⵏⵙⴻⵏⵜ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ. ⴰⵖⴻⵔⵔⴰⴱⵓⴰ ⵢⴻⵜⵜⴰⴵⴵⴰ ⴰⵎⴹⵉⵇ ⴰⴷ ⵢⴻⵃⵔⴻⵣ ⵢⴻⵔⵏⴰ ⴰⴷ ⵢⴻⵙⵙⴻⵇⴷⴻⵛ ⴰⵎⴰ ⴷ ⵜⵉⴳⵏⴰⵜⵉⵏ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵎⵓⵖⵍⵉ absolu ⴰⵎⴰ ⴷ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵎⵓⵖⵍⵉ ⴷⴰⵅⴻⵍ ⵏ ⵜⵎⴻⵥⵍⴰⵉⵏⴻⵙ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵢⵉⵎⴰⵏ.

ⴰⵙⵙⴻⴹⵔⵓ ⵏ RoPE

ⴰⵙⵙⴻⴹⵔⵓ ⵏ RoPE ⵢⴻⵜⵜⵃⴻⵜⵜⵉⵎⴷ ⴰⵙⴻⴽⵛⴻⵎ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵢⴰⵍ ⴰⴼⴻⵔⴷⵉⵙ ⴷⴻⴳ ⵢⵉⵡⴻⵜ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵓⵄⴻⴷⴷⵉ, ⴷ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵜⵎⴻⵥⴷⵉⵜⴰ ⴷⴰⵅⴻⵍ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵢⵉⵎⴰⵏ ⵏ Transformer. ⴰⴽⴰⵣⴰ ⵢⴻⵜⵜⴰⴵⴵⴰ ⵜⴰⴼⵙⴻⵔⵜ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵙ ⵜⵖⴰⵡⵍⴰ, ⵙ ⵜⵖⴰⵡⵍⴰ, ⵙ ⵜⵖⴰⵡⵍⴰ, ⵙ ⵜⵖⴻⵎⵎⴰⵔ ⵏ ⵜⵎⴻⵣⴳⵓⵏⵜ ⵢⴻⵎⴳⴰⵔⴰⴷⴻⵏ ⵢⴻⵔⵏⴰ ⵢⴻⵜⵜⴰⵟⵟⴰⴼ ⵍⵙⴰⵙ ⵏ ⵡⴰⵙⵙⴰⵖⴻⵏ ⴳⴰⵔ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵡⴰⵔ ⵎⴰ ⵢⴻⵍⵍⴰⴷ ⵓⵙⵡⵉⵔ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵙ ⵜⵖⴰⵡⵍⴰ.

ⵜⴰⵣⵡⴰⵔⴰ, ⴰⴷ ⵜⴻⵃⵡⴰⴵⴻⴹ ⵜⴰⵖⵓⵍⵜ ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵜⴻⵙⵏⵓⵍⴼⵓⴹ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵜ, ⵙⵢⵉⵏ ⴰⴷ ⵜⴻⵙⴷⵓⴽⴽⵍⴻⴹ ⵉⴼⴻⵔⴷⵉⵙⴻⵏⴰ ⴷⴻⴳ ⵓⵎⴹⴰⵏⵉⴽ. ⴰⵎⴻⴷⵢⴰ ⴷⴷⴰⵡⴰ ⵢⴻⵜⵜⵡⴰⵍⵉ ⴱⴻⵍⵍⵉ ⵜⴻⵙⵙⵏⴻⴹ ⴰⵙⵏⵓⵍⴼⵓ ⵏ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵓⵙⵎⴻⵍ ⴷⴻⴳ Keras.

ⴰⵃⵔⵉⵛ ⴰⵎⴻⵣⵡⴰⵔⵓ: ⵙⵙⴻⴼⵀⴻⵎ ⵜⴰⵖⵓⵍⵜ ⵏ ⵓⵙⴻⵎⵔⴻⵙ ⵏ ⵓⵄⴻⴷⴷⵉ

ⵜⴰⵖⵓⵍⵜⴰ ⵜⴻⵙⵏⵓⵍⴼⵓⴷ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵢⴻⵜⵜⵓⵏⴻⴼⴽⴻⵏ ⵙ ⵜⴻⵖⵣⵉ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ, ⴷ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ.

from tensorflow.keras.layers import Layer
import numpy as np

def get_rotary_embedding(dim, max_seq_len):
    inv_freq = 1.0 / (10000 ** (tf.range(0, dim, 2, dtype=tf.float32) / dim))
    t = tf.range(max_seq_len, dtype=tf.float32)
    freqs = tf.einsum('i,j->ij', t, inv_freq)
    emb = tf.concat((tf.cos(freqs), tf.sin(freqs)), axis=-1)
    return emb

inv_freq = 1.0 / (10000 ** (tf.range(0, dim, 2, dtype=tf.float32) / dim))

ⵜⴰⴳⵣⴻⵎⵜⴰ ⵜⴻⵜⵜⵃⴻⵙⵙⵉⵙⴷ ⴰⵙⴻⵏⵇⴻⵙ ⵏ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⵙ ⵍⵙⴰⵙ ⵏ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵜ. ⵜⵉⵙⴼⵉⴼⵉⵏⴰ ⵜⵜⵡⴰⵙⴻⵇⴷⴰⵛⴻⵏⵜ ⴷⴻⴳ ⵓⵙⵏⵓⵍⴼⵓ ⵏ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ, ⴷ ⴰⵢⴻⵏ ⵢⴻⵜⵜⵄⴰⵡⴰⵏⴻⵏ ⴷⴻⴳ ⵓⵙⵏⵓⵍⴼⵓ ⵏ ⵢⵉⵙⴰⵍⵍⴻⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⴷⴻⴳ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ. ⵜⴰⵎⴻⵥⵍⴰⴰ ⵜⴻⵙⵄⴰ ⴰⵣⴰⵍ ⵍⴰⴷⵖⴰ ⴷⴻⴳ ⵍⴻⵛⵖⴰⵍ ⴰⵏⴷⴰ ⴰⵢ ⴷⵢⴻⵜⵜⵉⵍⵉ ⵓⵙⵙⴻⴼⵀⴻⵎ ⵏ ⵓⵙⵏⴰⵙ ⴷ ⵓⵙⵙⴻⵎⵔⴻⵙ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵙ ⵜⵖⴰⵡⵍⴰ, ⴰⵎ ⴷⴻⴳ ⵓⵙⴻⵍⴽⴻⵎ ⵏ ⵜⵓⵜⵍⴰⵢⵜ ⵜⴰⵎⴰⴳⵏⵓⵜ ⵏⴻⵖ ⴷⴻⴳ ⵓⵙⴻⵍⵎⴻⴷ ⵏ ⵜⵎⴻⵣⴳⵓⵏⵜ ⵏ ⵡⴰⴽⵓⴷ.

ⴷⴻⴳ ⵜⵜⴼⴰⵚⵉⵍ:

• ⵜⴼ.ⵔⴰⵏⴳⴻ(0, ⴷⵉⵎ, 2, dtype=ⵜⴼ.float32) ⵢⴻⵙⵏⵓⵍⴼⵓⴷ ⵢⵉⵡⴻⵏ ⵏ ⵓⵙⵡⵉⵔ ⵏ ⵡⴰⵣⴰⵍⴻⵏ ⵢⴻⴱⴷⴰⵏ ⵙⴻⴳ 0 ⴰⵔ ⴷⵉⵎ (ⴰⵃⵔⵉⵛ), ⵢⴻⵜⵜⴽⴻⵎⵎⵉⵍ ⵙ 2. ⴱⴻⵍⵍⵉ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ tensoragi ⴷ ⵉⴹⵓⵎⴰⵏ ⵏ 32 ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵢⴻⵜⵜⵡⴰⵙⴼⴻⴹⴻⵏ. ⵎⴰ ⵢⴻⵍⵍⴰ ⴷⵉⵎ ⴷ 8, ⴰⵎⴻⴷⵢⴰ, ⴰⵢⴰ ⴰⴷ ⴷⵢⴻⴼⴽ [0, 2, 4, 6].

• Tensor ⵉ ⴷⵢⴻⵜⵜⵡⴰⵙⵏⵓⵍⴼⴰⵏ ⵙ ⵜⴼ.ⵔⴰⵏⴳⴻ ⵢⴻⵜⵜⵡⴰⴱⴹⴰ ⵙⵢⴻⵏ ⵙ ⵜⵖⴰⵔⴰ (ⴷⵉⵎ) ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ. ⵜⴰⵎⴻⵥⵍⴰⴰ ⵜⴻⵙⵙⴻⵎⵔⴰⵙ ⵉⴹⵔⵉⵙⴻⵏⴰ ⴰⵔⵎⴰ ⴷ ⵢⵉⵡⴻⵏ ⵏ ⵓⵎⴹⴰⵏ ⴳⴰⵔ 0 ⴷ 1 (ⴰⵃⵔⵉⵛ ⵎⴰ ⵢⴻⵍⵍⴰ ⴷⵉⵎ ⴷ ⴰⵎⴹⴰⵏ, ⵢⴻⵜⵜⵡⴰⵃⴻⵜⵜⴻⵎ ⵛⵡⵉⵟ ⵎⴰ ⵢⴻⵍⵍⴰ ⴷⵉⵎ ⴷ ⴰⵎⴹⴰⵏ, ⴰⵛⴽⵓ ⴰⵃⵔⵉⵛ ⵏ ⵓⵎⴹⴰⵏ ⵢⴻⵜⵜⵄⴻⴷⴷⴰⵢ ⵢⴰⵍ ⴰⵣⴰⵍ ⵏⵏⵉⴹⴻⵏ). ⵎⴰ ⵏⴽⴻⵎⵎⴻⵍ ⴰⵎⴻⴷⵢⴰ ⵙ ⴷⵉⵎ = 8, ⵎⴰ ⵏⴻⴱⴹⴰ ⵖⴻⴼ 8, ⴰⴷ ⴷⵏⴰⴼ [0,0, 0,25, 0,5, 0,75].

• ⵜⴰⵎⵀⴻⵍⵜ ⵏ 10000 ** (...) ⵜⴻⵙⵏⴻⵔⵏⴰⵢ 10.000 ⵙ ⵜⴻⵣⵎⴻⵔⵜ ⵏ ⵢⴰⵍ ⴰⴼⴻⵔⴷⵉⵙ ⴷⴻⴳ ⵜⴻⵏⵙⵓⵔⵜ ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⵓⵇⴱⴻⵍ. ⵜⴰⵙⴻⵇⵇⴰⵎⵓⵜ ⵏ 10.000 ⴷ ⵜⵉⵏ ⴰⵢ ⴷⵢⴻⵜⵜⵡⴰⴼⴻⵔⵏⴻⵏ ⴽⵔⴰ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵙ ⵜⵖⴰⵡⵍⴰ, ⵎⴰⵛⴰ ⵜⴻⵜⵜⵡⴰⴼⵔⴻⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵜⵜⵡⴰⴹⴻⵎⵏⴻⵏⵜ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵢⴻⵎⴳⴻⵔⵔⴰⴷⴻⵏ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵓⵙⵡⵉⵔ ⵎⴻⵇⵇⵔⴻⵏ, ⴷ ⴰⵢⴻⵏ ⴰⵢ ⵢⴻⵜⵜⵄⴰⵡⴰⵏⴻⵏ ⴰⵎⴹⵉⵇ ⴰⴷ ⵢⴻⵎⴳⴻⵔⵔⴰⴷ ⴳⴰⵔ ⵢⵉⵎⵓⴽⴰⵏ ⵢⴻⵎⴳⴻⵔⵔⴰⴷⴻⵏ ⵙ ⵜⵖⴰⵡⵍⴰ ⵓⴳⴰⵔ. ⵉ [0.0, 0.25, 0.5, 0.75], ⴰⴷ ⵢⴻⵙⵙⵉⵡⴻⴹ ⵙ ⵜⵎⴻⵥⵍⴰ ⵏ ⵜⴻⵣⵎⴻⵔⵜ ⵉ ⵢⴰⵍ ⵢⵉⵡⴻⵏ, ⴰⴷ ⴷⵢⴻⴳⵍⵓ ⵙ ⵡⴰⵣⴰⵍⴻⵏ ⵎⴻⵇⵇⵔⴻⵏ ⴰⵟⴰⵙ ⵉ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵢⵓⴳⴰⵔⴻⵏ.

• ⴷⴻⴳ ⵜⴰⴳⴳⴰⵔⴰ, ⴰⴷ ⴷⵏⴰⴼ ⵜⴰⵣⵎⴻⵔⵜ ⵏ ⵜⵎⵓⵖⵍⵉ ⵙ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵎⵓⵖⵍⵉ (1/x) ⵏ ⵡⴰⵣⴰⵍⴻⵏ ⵙⴻⴳ ⵓⵙⵡⵉⵔ ⵉⵄⴻⴷⴷⴰⵏ. ⵜⵉⵙⴼⵉⴼⵉⵏ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⴷ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ ⵉ ⵢⵉⴹⵔⵉⵙⴻⵏ ⵢⵓⴳⴰⵔⴻⵏ, ⴰⵏⴰⵎⴻⴽⵉⵙ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏⵏⵉⴳ ⵏ ⵜⵎⴻⵣⴳⵓⵏⵜ ⴰⴷ ⵙⵄⵓⵏ ⵜⵉⵙⴼⵉⴼⵉⵏ ⵜⵉⵎⴻⵥⵢⴰⵏⵉⵏ, ⴰⵢⴰ ⴰⴷ ⵉⵃⴰⵣ ⴰⵎⴻⴽ ⴰⵔⴰ ⵜⵜⵡⴰⵙⴻⴽⴽⵔⴻⵏ ⵢⵉⵎⵓⴽⴰⵏⵏⵙⴻⵏ ⴷⴻⴳ ⵓⵎⴹⴰⵏ. ⴰⵢⴰ ⵢⴻⵜⵜⴰⴵⴵⴰ ⵉⴱⴻⵔⴷⴰⵏ ⴰⴷ ⵜⵜⵡⴰⵙⴻⴽⴽⵔⴻⵏ ⵙ ⵜⴰⵔⵔⴰⵢⵜ ⴰⵏⴷⴰ ⴰⵔⴰ ⵣⴻⵎⵔⴻⵏ ⴰⴷ ⴷⵜⵜⵡⴰⴼⴻⵔⵏⴻⵏ ⵢⵉⵎⵓⴽⴰⵏ ⵏ ⵜⵎⴻⵥⵔⵉ ⵙ ⵢⵉⵎⴻⵥⵍⴰ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵍⴻⵎⵜⴻⵍ.

ⵜⴰⵖⴻⵛⵜ:

freqs = tf.einsum('i,j->ij', t, inv_freq)

ⵉⵙⴻⵇⴷⴰⵛ ⵜⴰⵖⵓⵍⵜ ⵏ TensorFlow ⵜⴼ.ⴻⵉⵏⵙⵓⵎ, ⴷ ⴰⵍⵍⴰⵍ ⵉ ⵢⴻⵜⵜⴰⴵⴵⴰⵏ ⴰⵙⴻⴱⴷⴻⴷ ⵙ ⵜⵖⴰⵡⵍⴰ ⴷ ⵜⵖⴰⵡⵍⴰ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ tensor ⵙ ⵓⵙⴻⵇⴷⴻⵛ ⵏ ⵜⵎⴻⵥⵔⵉ ⵏ ⵓⵙⴷⵓⴽⴽⴻⵍ ⵏ Einstein.

ⵜⴰⵎⴻⵥⵍⴰⴰ ⵜⴻⵜⵜⵃⴻⵙⵙⵉⵙ ⵙ ⵜⵖⴰⵡⵍⴰ ⴰⴼⴰⵔⵉⵙ ⵏ ⴱⴻⵔⵔⴰ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜ ⴷ inv_freq, ⴷⵖⴰ ⴷ ⴰⵢⴰ ⴰⵢ ⴷⵢⴻⵜⵜⴰⵡⵉⵏ ⵎⴰⵜⵔⵉⵅ ⴰⵏⴷⴰ ⵢⴰⵍ ⴰⴼⴻⵔⴷⵉⵙ (ⵉ, ⵊ) ⴷ ⴰⴼⴰⵔⵉⵙ ⵏ ⵓⴼⴻⵔⴷⵉⵙ ⵉ-ⵜⵀ ⵏ ⵜ ⴷ . ⵊ-ⴰⴼⴻⵔⴷⵉⵙ ⵏ inv_freq. ⵎⴰⵜⵔⵉⵅⴰ (ⴼⵔⴻⵇⵙ) ⵢⴻⵜⵜⴳⴻⵏⵙⵉⵙⴷ ⵜⵉⵖⴱⵓⵍⴰ ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ ⵉ ⵓⵙⵏⵓⵍⴼⵓ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ.

ⴰⵃⵔⵉⵛ ⵡⵉⵙ 2: Tasga ⵏ Keras ⵏ Useqdec ⵉ Usemres ⵏ Rotary

ⵜⵓⵔⴰ, ⴰⴷ ⴷⵏⴻⵙⵏⵓⵍⴼⵓ ⵜⴰⵙⴼⵉⴼⵜ ⵏ Keras ⵏ ⵓⵙⵎⴻⵍ ⵉ ⵢⴻⵜⵜⵇⴰⴷⴰⵔⴻⵏ ⵉⴱⴻⵔⴷⴰⵏ ⵏ ⵓⵙⵎⴻⵍ ⵏ ⵓⵙⵎⴻⵍ. ⵜⴰⵙⴼⵉⴼⵜⴰ ⵜⴻⵜⵜⵡⴰⵍⵉ ⴱⴻⵍⵍⵉ ⴰⵙⴻⵏⵇⴻⴷ ⵏ ⵓⵙⵎⴻⵍ ⵢⴻⵙⵄⴰ ⵜⴰⵍⵖⴰ (tajumma_n_tferkit, ⵜⵉⵖⵣⵉ_ⵏ_tmezgunt, asemres_dim).

class RotaryEmbeddingLayer(Layer):
    def __init__(self, dim, max_seq_len, **kwargs):
        super().__init__(**kwargs)
        self.dim = dim
        self.max_seq_len = max_seq_len
        self.rotary_embeddings = get_rotary_embedding(dim, max_seq_len)

    def call(self, inputs):
        seq_len = tf.shape(inputs)[1]
        embeddings = self.rotary_embeddings[:seq_len]
        
        cos_emb = embeddings[:, None, :self.dim // 2]
        sin_emb = embeddings[:, None, self.dim // 2:]
        
        # Decompose inputs into sine and cosine components
        inputs_cos = inputs[..., :self.dim // 2]
        inputs_sin = inputs[..., self.dim // 2:]
        
        # Apply rotary embeddings
        rotated_cos = inputs_cos * cos_emb - inputs_sin * sin_emb
        rotated_sin = inputs_sin * cos_emb + inputs_cos * sin_emb
        
        return tf.concat([rotated_cos, rotated_sin], axis=-1)

    def get_config(self):
        config = super().get_config()
        config.update({
            "dim": self.dim,
            "max_seq_len": self.max_seq_len
        })
        return config

ⵜⴰⵖⴻⵛⵜ ibeddilen = self.rotary_embeddings[:seq_len] ⵜⴻⵜⵜⴼⴻⵔⵔⵉⴹ ⵜⴰⵖⵓⵍⵜ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵉⵡⴰⵜⴰⵏ ⵏ ⵢⵉⴱⴻⴷⴷⵉⵍⴻⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵢⴻⵜⵜⵡⴰⵃⴻⵙⴱⴻⵏ ⵓⵇⴱⴻⵍ ⵙ ⵍⵙⴰⵙ ⵏ ⵜⴻⵖⵣⵉ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⵓⵙⵎⴻⵍ ⵏ ⵜⵓⵔⴰ. ⵉⵎⵉ ⵜⵓⵖⵣⵉ ⵏ ⵜⵎⴻⵣⵣⵓⴳⵉⵏ ⵜⴻⵣⵎⴻⵔ ⴰⴷ ⵜⴻⵎⴳⴰⵔⴰⴷ ⵙⴻⴳ ⵢⵉⵡⴻⵜ ⵏ ⵜⵎⴻⵣⴳⵓⵏⵜ ⵖⴻⵔ ⵜⴰⵢⴻⴹ, ⵜⴰⵎⵀⴻⵍⵜⴰ ⵏ ⵓⵙⵇⴻⵔⴷⴻⵛ ⵜⴻⴹⵎⴻⵏ ⴱⴻⵍⵍⵉ ⴰⵍⴰ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⴻⵥⵔⵉⵡⵉⵏ ⵉ ⴷⵢⴻⵜⵜⴰⵡⵉⵏ ⵙ ⵜⵓⵖⵣⵉ ⵏ ⵜⵎⴻⵣⵣⵓⴳⵉⵏ ⵏ ⵜⵉⴷⴻⵜ ⴰⵔⴰ ⵢⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⵏ.

ⴰⵎⴳⵉⵔⴻⴷ ibeddilen ⵢⴻⵜⵜⴰⵟⵟⴰⴼ ⵜⵓⵔⴰ ⴰⵙⴻⵏⵇⴻⴷ ⵏ ⵜⴰⵍⵖⴰ (seq_len, embedding_dim), ⴰⵏⴷⴰ seq_len ⴷ ⵜⵓⵖⵣⵉ ⵏ ⵜⵎⴻⵣⵣⵓⴳⵉⵏ ⴷⴻⴳ ⵜⴼⴻⵔⴽⵉⵜ ⵏ ⵜⵓⵔⴰ, ⵎⴰ ⴷ embedding_dim ⴷ ⵜⴰⵖⴻⵛⵜ ⵏ ⵢⵉⵙⴻⴽⴽⵉⵍⴻⵏ. Tensora ⵢⴻⵙⵄⴰ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏ ⵢⴰⵍ ⴰⵎⴹⵉⵇ ⴷⴻⴳ ⵜⵎⴻⵣⴳⵓⵏⵜ ⴰⵍⴰⵎⵎⴰ ⴷ seq_len.

ⴻⵎⴱ = ⵜⴼ.concat ((ⵜⴼ.cos (ⵉⴼⴻⵔⴷⵉⵙⴻⵏ), ⵜⴼ.ⵙⵉⵏ (ⵉⴼⴻⵔⴷⵉⵙⴻⵏ)), ⴰⵅⵅⴰⵎ=-1) ⵢⴻⵙⴷⵓⴽⴽⴻⵍ ⵉⴱⴻⴷⴷⵉⵍⴻⵏ ⵏ ⵙⵉⵏ ⴷ cosin ⵏ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵓⵎⴹⵉⵇ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵜⴻⵏⵙⵓⵔ:

-ⵜⴼ.cos(ⴼⵔⴻⵇⵙ) ⴷ ⵜⴼ.ⵙⵉⵏ(ⴼⵔⴻⵇⵙ) ⵙⵙⴻⵇⴷⴰⵛⴻⵏ ⴰⴱⴻⴷⴷⴻⵍ ⵏ cosin ⴷ ⵙⵉⵏ, ⵙ ⵜⵎⴻⵔⵏⴰ, ⵙ ⵜⵎⴻⵥⴷⵉⵜ ⵏ ⴼⵔⴻⵇⵙ. Tensor ⴼⵔⴻⵇⵙ ⵢⴻⵙⵄⴰ ⴰⵣⴰⵍ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⵉ ⵢⴰⵍ ⴰⵎⴹⵉⵇ ⴷⴻⴳ ⵜⴼⴻⵍⵡⵉⵜ ⵏ ⵓⵙⵎⴻⵍ ⴷ ⵢⴰⵍ ⴰⵃⵔⵉⵛ ⵏ ⵓⵎⴹⵉⵇ ⵏ ⵓⵙⵎⴻⵍ, ⵢⴻⵜⵜⵡⴰⵃⵙⴻⴱ ⵙ ⵍⵙⴰⵙ ⵏ ⵢⵉⵎⵓⴽⴰⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⴷ ⵜⴼⴻⵍⵡⵉⵢⵉⵏ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⵏ ⵜⴼⴻⵍⵡⵉⵜ ⵏ ⵓⵙⵎⴻⵍ. ⵜⵉⵙⵏⴰⵜⵉⵏ ⵏ ⵙⵉⵏⴻ ⴷ cosine ⵜⵜⵡⴰⵙⴻⵇⴷⴰⵛⴻⵏⵜ ⵙ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ, ⴷⵖⴰ ⴷ ⴰⵢⴰ ⴰⵢ ⴷⵢⴻⵜⵜⴰⵡⵉⵏ ⵙⵉⵏ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵢⵉⵡⴻⵜ ⵏ ⵜⴰⵍⵖⴰ ⴰⵎ ⴼⵔⴻⵇⵙ. ⵉⴱⴻⴷⴷⴰⵍⴻⵏⴰ ⵜⵜⵄⴰⵡⴰⵏⴻⵏ ⴷⴻⴳ ⵓⵙⵏⵉⵍⴻⵙ ⵏ ⵓⵎⴹⵉⵇ ⵙ ⵜⴰⵔⵔⴰⵢⵜ ⴰⵔⴰ ⴷⵢⴻⵟⵟⴼⴻⵏ ⴰⵏⴰⵎⴻⴽ ⵏ ⵜⵛⵉⵔⴹⴰⵔⵜ ⵏ ⵡⴰⵙⵙⴰⵖⴻⵏ ⵏ ⵓⵎⴹⵉⵇ, ⴷⵖⴰ ⵙ ⵡⴰⵢⴰ, ⵜⵜⴼⴻⵀⵀⵉⵎⴻⵏ ⵜⴰⵣⵎⴻⵔⵜ ⵏ ⵓⵎⴷⴰⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⵢⴻⴼⵀⴻⵎ ⵉⵎⵓⴽⴰⵏ ⵏ ⵓⵙⵡⵉⵔ.

-ⵜⴼ.concat((ⵜⴼ.cos(ⵉⴼⴻⵔⴷⵉⵙⴻⵏ), ⵜⴼ.ⵙⵉⵏ(ⵉⴼⴻⵔⴷⵉⵙⴻⵏ)), ⴰⵖⴻⵔⵙⵉⵡ=-1) ⵢⴻⵜⵜⵇⴰⴷⴰⵔ ⵜⵉⵖⴱⵓⵍⴰ ⵢⴻⵜⵜⵡⴰⴱⴻⴷⴷⵍⴻⵏ ⵙ ⵜⵎⴻⵥⴷⵉⵜ ⴷ ⵜⵎⴻⵥⴷⵉⵜ ⵖⴻⴼ ⵜⵖⴻⵔⵖⴻⵔⵜ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ (ⵢⴻⵜⵜⵡⴰⵙⵎⴻⴽⵜⴰⵢ ⵙ ⴰⵖⴻⵔⵙⵉⵡ=-1). ⴰⵙⴷⵓⴽⴽⴻⵍ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏⴰ ⵜⴰⵎⴰ ⵙ ⵜⴰⵎⴰ ⵢⴻⵜⵜⵏⴻⵔⵏⵉ ⵙ ⵜⵖⴰⵡⵍⴰ ⵙ ⵙⵉⵏ ⵏ ⵢⵉⴱⴻⵔⴷⴰⵏ ⵏ ⵜⵖⴰⵔⴰ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⴼⵔⴻⵇⵙ, ⵙ ⵓⵣⴳⴻⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵢⴻⵜⵜⴳⴻⵏⵙⵉⵙⴷ ⴰⵣⴰⵍ ⵢⴻⵜⵜⵡⴰⴱⴻⴷⴷⵍⴻⵏ ⵙ cosine ⵎⴰ ⴷ ⴰⵣⴳⴻⵏ ⵡⵉⵙ ⵙⵉⵏ ⵢⴻⵜⵜⴳⴻⵏⵙⵉⵙⴷ ⴰⵣⴰⵍ ⵢⴻⵜⵜⵡⴰⴱⴻⴷⴷⵍⴻⵏ ⵙ ⵙⵉⵏⴻ ⵉ ⵢⴰⵍ ⴰⵎⴹⵉⵇ. ⵜⴰⵙⴻⵎⵔⴻⵙⵜ ⵜⴻⵜⵜⴹⴻⵎⵎⵉⵍ ⴱⴻⵍⵍⵉ ⵢⴰⵍ ⴰⵙⴻⵏⵇⴻⴷ ⵏ ⵓⵎⴹⵉⵇ ⵢⴻⵙⵄⴰ ⴰⵎⴰ ⴷ ⵉⵙⴰⵍⴰⵏ ⵏ ⵙⵉⵏⵓⵙ ⴰⵎⴰ ⴷ ⵉⵙⴰⵍⴰⵏ ⵏ cosinus, ⴷ ⴰⵢⴻⵏ ⴰⵢ ⵢⴻⵜⵜⴰⴵⴵⴰⵏ ⴰⵃⵔⴰⵣ ⵏ ⵢⵉⵙⴰⵍⴰⵏ ⴰⵎⴰ ⵖⴻⴼ ⵜⵖⴻⵔⵖⴻⵔⵜ ⴰⵎⴰ ⵖⴻⴼ ⵜⴼⴰⵣⴰ ⵏ ⵜⵎⵉⴹⵔⴰⵏⵜ ⵏ ⵓⵎⴹⵉⵇ.

• ⴰⵙⴻⵏⵇⴻⴷ ⴻⵎⴱ ⵢⴻⵜⵜⵡⴰⵇⵇⵏⴻⵏ ⵢⴻⵜⵜⵃⴰⴷⴰⵔ ⵜⵓⵔⴰ ⵜⵉⵖⴱⵓⵍⴰ ⵏ ⵜⵖⴻⵔⵖⴻⵔⵜ ⵉⴽⴻⵎⵍⴻⵏ ⵉ ⵢⵉⵎⵓⴽⴰⵏ ⵏ ⵓⵙⵎⴻⵍ. ⵜⴰⵍⵖⴰ ⵏ ⴻⵎⴱ ⴰⴷ ⵜⵉⵍⵉ ⴰⵎ ⴼⵔⴻⵇⵙ ⴷⴻⴳ ⵙⵏⴰⵜ ⵏ ⵜⵎⵉⴹⵔⴰⵏⵉⵏⵉⵙ ⵜⵉⵎⴻⵣⵡⵓⵔⴰ (ⵢⴻⵜⵜⵡⴰⵇⵇⵏⴻⵏ ⵖⴻⵔ ⵢⵉⵎⵓⴽⴰⵏ ⵏ ⵜⵎⴻⵣⵡⴰⵔⵓⵜ ⴷ ⵜⵎⵉⴹⵔⴰⵏⵉⵏ ⵏ ⵓⵙⵎⴻⵍ), ⵎⴰⵛⴰ ⵜⴰⵎⵉⴹⵔⴰⵏⵜⵉⵙ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ ⴰⴷ ⵜⵉⵍⵉ ⵙⵏⴰⵜ ⵏ ⵜⵉⴽⴽⴰⵍ ⵎⴻⵇⵇⴻⵔ, ⴰⴷ ⵜⴻⵃⵙⴻⴱ ⴰⵎⴰ ⴷ ⴰⵣⴰⵍ ⵏ ⵙⵉⵏⴻ ⴰⵎⴰ ⴷ ⴰⵣⴰⵍ ⵏ cosine. ⵉⴼⴻⵔⴷⵉⵙⴻⵏⴰ ⵜⵜⵡⴰⵙⴻⵇⴷⴰⵛⴻⵏ ⵉ ⵓⴱⴻⴷⴷⴻⵍ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ ⵓⵙⵎⴻⵍ ⵙ ⵓⵙⵏⴻⵔⵏⵉ ⵏ ⵢⵉⵙⴰⵍⵍⴻⵏ ⵏ ⵓⵎⴹⵉⵇ ⵙ ⵜⴰⵔⵔⴰⵢⵜ ⵏ ⵓⵙⵡⵉⵔ ⵏ ⵜⵎⵓⵖⵍⵉ.

-cos_emb = ⴰⵙⴻⴽⴽⵉⵍ [:, Ulac, : ⵉⵎⴰⵏⵉⵙ.ⴷⵉⵎ // 2] :

1. Asekkil ⴰⵎⴻⵣⵡⴰⵔⵓ : ⴰⵏⴰⵎⴻⴽⵉⵙ "ⴼⵔⴻⵏ ⴰⴽⴽ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵢⴻⵍⵍⴰⵏ ⴷⴻⴳ ⵜⴼⴻⵍⵡⵉⵜⴰ," ⴷⵖⴰ, ⴷⴻⴳ ⵜⴰⵍⵓⴼⵜⴰ, ⵢⴻⵜⵜⵎⴻⵙⵍⴰⵢⴷ ⵖⴻⴼ ⵡⴰⴽⴽ ⵉⵎⵓⴽⴰⵏ ⵢⴻⵍⵍⴰⵏ ⴷⴻⴳ ⵜⴼⴻⵍⵡⵉⵜ.

2. Ulac ⵢⴻⵜⵜⵡⴰⵙⴻⵇⴷⴻⵛ ⴰⴽⴽⴻⵏ ⴰⴷ ⵢⴻⵔⵏⵓ ⵍⵇⵉⴷⴰⵔ ⵏ ⵜⵎⴻⵔⵏⴰ, ⴷⵖⴰ ⴷ ⴰⵢⴰ ⴰⵔⴰ ⵢⴻⵔⵔⴻⵏ ⴰⵙⴻⵏⵇⴻⴷ ⵏ 3 ⵏ ⵍⵇⵉⴷⴰⵔ. ⴰⵢⴰ ⵢⴻⵜⵜⵉⵍⵉⴷ ⵙ ⵡⴰⵟⴰⵙ ⴰⴽⴽⴻⵏ ⴰⴷ ⵢⴻⵜⵜⵡⴰⴹⵎⴻⵏ ⵓⵙⴷⵓⴽⴽⴻⵍ ⴷ ⴽⵔⴰ ⵏ ⵜⵎⴻⵥⵔⵉⵡⵉⵏ ⵉ ⵢⴻⵜⵜⵔⴰⴵⵓⵏ ⵜⵉⴽⵛⵉⵡⵉⵏ ⵏ ⵓⵎⴹⴰⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ. ⴰⵎⴻⴷⵢⴰ, ⵎⵉ ⴰⵔⴰ ⵜⵉⴷⵜⴻⵙⵙⴻⵡⵊⴻⴷⴹ ⵙ ⵜⵎⴻⵔⵏⴰ ⵏ ⵢⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵙ ⵜⵎⴻⵥⴷⵉⵜ ⵏⵉⴹⴻⵏ ⵢⴻⵍⵍⴰⵏ ⴷ 3 ⵏ ⵜⵖⴰⵡⵙⵉⵡⵉⵏ, ⵉⵍⴰⵇ ⴰⴷ ⵜⵜⵡⴰⵙⴻⵎⵍⴻⵏⵜ ⵜⵖⴰⵡⵙⵉⵡⵉⵏⵏⵏⵉ ⵙ ⵍⵇⴰⵏⵓⵏ ⵏ ⵓⵙⵉⵡⴻⴹ.

3. :ⵙⴻⵍⴼ.ⴷⵉⵎ // 2, ⵢⴻⵜⵜⴼⴻⵔⵔⵉⴹ ⴰⵣⴳⴻⵏ ⴰⵎⴻⵣⵡⴰⵔⵓ ⵏ ⵜⵎⵉⴹⵔⴰⵏⵜ ⴷⴻⴳ ⵜⵖⴻⵔⵖⴻⵔⵜ ⵜⴰⵏⴻⴳⴳⴰⵔⵓⵜ. ⵉⵎⵉ embedding_dimension ⵢⴻⵜⵜⵡⴰⵙⵏⴻⵔⵏⴰ ⵙ ⵙⵉⵏ ⵏ ⵢⵉⴱⴻⵔⴷⴰⵏ ⴰⴽⴽⴻⵏ ⴰⴷ ⴷⵢⴻⵙⴷⵓⴽⴽⴻⵍ ⴰⵎⴰ ⴷ ⴰⵣⴰⵍ ⵏ ⵙⵉⵏ ⴰⵎⴰ ⴷ ⴰⵣⴰⵍ ⵏ cosine, ⵜⴱⴻⴷⴷⵉ ⵙ 2 ⵙ ⵜⵖⴰⵡⵍⴰ ⵜⴻⵜⵜⴼⴻⵔⵔⵉⴹ ⴽⴰⵏ ⵉⴼⴻⵔⴷⵉⵙⴻⵏ ⵏ cosine ⵏ ⵜⵎⴻⵥⴷⵉⵢⵉⵏ.

ⴰⴹⵔⵉⵙ ⵡⵉⵙ 3: ⴰⵙⴷⵓⴽⴽⴻⵍ ⵙ ⵍⴻⵎⵜⴻⵍ ⵏ ⴽⴻⵔⴰⵙ

ⴷⴻⴼⴼⵉⵔ ⵎⴰ ⵜⴻⵙⴱⴻⴷⴷⴻⴹ ⴰⵙⵡⵉⵔ ⵏ ⵓⵙⴻⵎⵔⴻⵙ ⵏ ⵓⵄⴻⴱⴱⵓⴹ, ⵜⵣⴻⵎⵔⴻⴹ ⴰⴷ ⵜⵜⴻⵙⴷⵓⴽⴽⵍⴻⴹ ⴷⴻⴳ ⵓⵎⴹⴰⵏⵉⴽ ⵏ ⴽⴻⵔⴰⵙ. ⵢⴻⵙⵙⴻⴼⴽ ⴰⴷ ⵜⴻⵜⵜⵡⴰⵙⵇⴻⴷⵛⴻⴹ ⵜⴻⵙⴼⵉⴼⵜⴰ ⵉ ⵜⵎⴻⵥⴷⵉⵢⵉⵏⵉⴽ ⵓⵇⴱⴻⵍ ⴰⴷ ⵜⴻⵏⵜⴻⵙⵙⴻⵞⵞⴻⴹ ⴷⴻⴳ ⵜⴻⵙⴼⵉⴼⵉⵏ ⵏ ⵜⵎⵓⵖⵍⵉ ⵏⴻⵖ ⴷⴻⴳ ⴽⵔⴰ ⵏ ⵜⴻⵙⴼⵉⴼⵉⵏ ⵏ ⵍⴻⵎⵜⴻⵍ ⵉ ⴷⵉⵜⴻⴷⴷⵓⵏ.

ⴰⵜⴰⵏ ⵓⵎⴻⴷⵢⴰ ⵉⵙⴻⵀⵍⴻⵏ ⵏ ⵡⴰⵎⴻⴽ ⴰⵔⴰ ⵜⴻⵙⴷⵓⴽⴽⵍⴻⴹ ⵉⴱⴻⵔⴷⴰⵏ ⵏ ⵜⵎⴻⵥⴷⵉⵜ ⴷⴻⴳ ⵢⵉⵡⴻⵏ ⵏ ⵓⵎⴹⴰⵏ:

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Embedding, Dense

max_seq_len = 512
embedding_dim = 64

inp = Input(shape=(max_seq_len,))
x = Embedding(input_dim=10000, output_dim=embedding_dim)(inp)
x = RotaryEmbeddingLayer(dim=embedding_dim, max_seq_len=max_seq_len)(x)
# Add your model's layers here, e.g., Transformer blocks
x = Dense(1, activation='sigmoid')(x)

model = Model(inputs=inp, outputs=x)
model.summary()