def __init__(self,
num_labels = 194,
hidden_size = 768,
hidden_dropout_prob = 0.1,
):
super().__init__(get_kobert_config())
self.num_labels = num_labels
self.kobert = get_kobert_model()
self.dropout = nn.Dropout(hidden_dropout_prob)
self.classifier = nn.Linear(hidden_size, num_labels)
self.init_weights()
def __init__(
self,
backbone: None,
vocab_size: int,
seq_len: int,
intent_class_num: int,
entity_class_num: int,
d_model=512,
nhead=8,
num_encoder_layers=6,
dim_feedforward=2048,
dropout=0.1,
activation="relu",
pad_token_id: int = 0,
):
super(EmbeddingTransformer, self).__init__()
self.backbone = backbone
self.seq_len = seq_len
self.pad_token_id = pad_token_id
if backbone is None:
self.encoder = nn.TransformerEncoder(
TransformerEncoderLayer(d_model, nhead, dim_feedforward,
dropout, activation),
num_encoder_layers,
LayerNorm(d_model),
)
else: # pre-defined model architecture use
if backbone == "kobert":
self.encoder = get_kobert_model()
elif backbone == "distill_kobert":
self.encoder = get_distilkobert_model()
elif backbone == "koelectra":
self.encoder = ElectraModel.from_pretrained(
"monologg/koelectra-small-v2-discriminator")
d_model = self.encoder.config.hidden_size
self.embedding = nn.Embedding(vocab_size, d_model)
self.position_embedding = nn.Embedding(self.seq_len, d_model)
self.intent_feature = nn.Linear(d_model, intent_class_num)
self.entity_feature = nn.Linear(d_model, entity_class_num)
input_ids = tokenizer.convert_tokens_to_ids(tokenizer.tokenize(s))
valid_length.append(len(input_ids))
target_ids = [1] * 32
target_ids[:len(input_ids)] = input_ids
target.append(target_ids)
return target, valid_length
from kobert_transformers import get_kobert_model
from kobert_transformers import get_tokenizer
tokenizer = get_tokenizer()
input_ids, valid_length = gen_input_ids(
tokenizer=tokenizer, sentence=["한국어 모델을 공유합니다.", "두번째 문장입니다."])
model = get_kobert_model()
model.eval()
input_ids = torch.LongTensor(input_ids)
attention_mask = gen_attention_mask(input_ids, valid_length)
attention_mask = torch.LongTensor(attention_mask)
token_type_ids = torch.zeros_like(input_ids)
sequence_output, pooled_output = model(input_ids, attention_mask,
token_type_ids)
pooled_output
import tensorflow as tf
import tensorflow_hub as hub
import requests
import io
import numpy as np
import requests
import tensorflow as tf
import tensorflow_hub as hub
import torch
from PIL import Image
from kobert_transformers import get_kobert_model
from kobert_transformers import get_tokenizer
# CNN 모델 로드
cnn_model = hub.KerasLayer("https://tfhub.dev/google/bit/m-r101x1/1")
# NLP 모델 및 토크나이저 로드
tokenizer = get_tokenizer()
nlp_model = get_kobert_model()
nlp_model.eval()
# 조회수 예측 모델 로드
model = keras.models.load_model("third_train_model")
def preprocess_image(image):
image = np.array(image)
# reshape into shape [batch_size, height, width, num_channels]
img_reshaped = tf.reshape(
image, [1, image.shape[0], image.shape[1], image.shape[2]])
# Use `convert_image_dtype` to convert to floats in the [0,1] range.
image = tf.image.convert_image_dtype(img_reshaped, tf.float32)
return image
