RUDOLPH 2.7B

Math QA (few-shot режим)
**|3+4=7|2+1=3|4+3=7|8+1=9|3+2=5|2+2=4|1+6=7|3+2=5|9+2=**11|

import numpy as np
from PIL import Image
import os
import cv2
import re
import base64
from io import BytesIO
import time

import kfserving

import torch
import ruclip

import sys

from rudalle.image_prompts import ImagePrompts
from rudolph.model import get_rudolph_model, ruDolphModel, FP16Module
from rudolph import utils
from rudolph.model.utils import get_attention_mask
from rudalle import get_tokenizer
from vae import get_vae
from rudolph.api import ruDolphApi

import requests
from PIL import Image, ImageDraw
import io
from app.utils import *
    
class KFServingRUDOLPHModel(kfserving.KFModel):

    def __init__(self, name: str):
        super().__init__(name)
        self.name = name

        self.device = torch.device('cuda:0')
        self.cache_dir = './weights'
        self.vae_dir = './weights/vqgan.gumbelf8-sber.model.ckpt'
        self.tokenizer_weights = './weights/bpe.model'
        
        self.gpu = True
        self.ready = False

    def load(self):

        self.model_fbc2 = get_rudolph_model('2.7B', pretrained=False, fp16=True, device=self.device)
        self.model_fbc2.load_state_dict(torch.load(f'{self.cache_dir}/pytorch_model.bin'))

        self.tokenizer = get_tokenizer(path=self.tokenizer_weights)
        self.vae = get_vae(dwt=False, filename=self.vae_dir).to(self.device)

        self.api = ruDolphApi(self.model_fbc2, self.tokenizer, self.vae, bs=48)
        
        self.ready = True

    def image_generation(self, text):
        images_num, codebooks_num = 1, 12
        top_k, top_p = 1024, 0.99
        pil_images, scores = self.api.dream(
            text=text, images_num=images_num, codebooks_num=codebooks_num,
            top_k=top_k, top_p=top_p, special_token='<LT_T2I>'
        )

        return {"ok": True, "image": encode_img(np.array(pil_images[0]))}

    def captioning(self, pil_img):
        result = self.api.image_captioning(
            pil_img, early_stop=32, generations_num=48, captions_num=5, seed=42,
            l_special_token='<LT_I2T>'
        )
        return {"ok": True, "text": result[0]["text"]}

    def text_generation(self, text):
        top_k, top_p = 64, 0.8
        texts_num = 48
        temperature = 0.9

        text_answer = self.api.generate_texts(
            template=text,
            top_k=top_k, top_p=top_p, texts_num=texts_num, seed=42, temperature=temperature,
            special_token='<LT_T2T>',
            early_stop=32,
        )[:5]
        return {"ok": True, "text": text_answer[0]}
    
    def predict(self, request):
        request = request['instances'][0]
        try:
            text = request['text']
            image = None
            if 'image' in request and request['image'] is not None:
                image = decode_img(request['image'])

            if request['task'] == 'T2I':
                result_data = self.image_generation(text)
            elif request['task'] == 'I2T':
                result_data = self.captioning(image)
            elif request['task'] == 'T2T':
                result_data = self.text_generation(text)
            else:
                return {"ok": False, "error": "Unknown task"}
        except Exception as err:
            info_str = f"query={request['text']} | image={image is not None}"
            return {"ok": False, "error": f'Error while generating: {err}
 INFO: {info_str}'}
        return result_data

{'ok': True,
 'text': 'Вид на морское побережье и горы из окна'})

from rudolph_deploy import KFServingRUDOLPHModel

model = KFServingRUDOLPHModel("kfserving-RUDOLPH")
model.load()

# zero-shot text generation
result = model.predict({
     "instances": [
     {
     "task": "T2T",
     "text": 'Вид на морское побережье и '
     }
     ]
     }
)

"Res: ", result