def preprocess(data: list, max_length: int):
"""
입력을 받아서 딥러닝 모델이 학습 가능한 포맷으로 변경하는 함수입니다.
기본 제공 알고리즘은 char2vec이며, 기본 모델이 MLP이기 때문에, 입력 값의 크기를 모두 고정한 벡터를 리턴합니다.
문자열의 길이가 고정값보다 길면 긴 부분을 제거하고, 짧으면 0으로 채웁니다.
:param data: 문자열 리스트 ([문자열1, 문자열2, ...])
:param max_length: 문자열의 최대 길이
:return: 벡터 리스트 ([[0, 1, 5, 6], [5, 4, 10, 200], ...]) max_length가 4일 때
"""
vectorized_data1 = []
vectorized_data2 = []
for datum in data:
s1, s2 = datum.strip().split("\t")
vectorized_data1.append(decompose_str_as_one_hot(s1, warning=False))
vectorized_data2.append(decompose_str_as_one_hot(s2, warning=False))
def to_zero_padded(vectorized_data):
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, :length] = np.array(seq)[:length]
else:
zero_padding[idx, :length] = np.array(seq)
return zero_padding
zero_padding1 = to_zero_padded(vectorized_data1)
zero_padding2 = to_zero_padded(vectorized_data2)
return zero_padding1, zero_padding2
def preprocess(data: list, max_length: int):
"""
입력을 받아서 딥러닝 모델이 학습 가능한 포맷으로 변경하는 함수입니다.
기본 제공 알고리즘은 char2vec이며, 기본 모델이 MLP이기 때문에, 입력 값의 크기를 모두 고정한 벡터를 리턴합니다.
문자열의 길이가 고정값보다 길면 긴 부분을 제거하고, 짧으면 0으로 채웁니다.
:param data: 문자열 리스트 ([문자열1, 문자열2, ...])
:param max_length: 문자열의 최대 길이
:return: 벡터 리스트 ([[0, 1, 5, 6], [5, 4, 10, 200], ...]) max_length가 4일 때
"""
left_vectorized_data = [decompose_str_as_one_hot(datum, warning=False)[0] for datum in data]
right_vectorized_data = [decompose_str_as_one_hot(datum, warning=False)[1] for datum in data]
left_zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
right_zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, left_seq in enumerate(left_vectorized_data):
left_length = len(left_seq)
if left_length >= max_length:
length = max_length
left_zero_padding[idx, :length] = np.array(left_seq)[:length]
else:
left_zero_padding[idx, :left_length] = np.array(left_seq)
for idx, right_seq in enumerate(right_vectorized_data):
right_length = len(right_seq)
if right_length >= max_length:
length = max_length
right_zero_padding[idx, :length] = np.array(right_seq)[:length]
else:
right_zero_padding[idx, :right_length] = np.array(right_seq)
return left_zero_padding, right_zero_padding
def preprocess_pre(data: list, max_length: int):
"""
입력을 받아서 딥러닝 모델이 학습 가능한 포맷으로 변경하는 함수입니다.
기본 제공 알고리즘은 char2vec이며, 기본 모델이 MLP이기 때문에, 입력 값의 크기를 모두 고정한 벡터를 리턴합니다.
문자열의 길이가 고정값보다 길면 긴 부분을 제거하고, 짧으면 0으로 채웁니다.
:param data: 문자열 리스트 ([문자열1, 문자열2, ...])
:param max_length: 문자열의 최대 길이
:return: 벡터 리스트 ([[0, 1, 5, 6], [5, 4, 10, 200], ...]) max_length가 4일 때
"""
def text_norm(sent):
sent = re.sub('[\,\<\>\(\)\+\-\=\&\@\#\$]', '', sent)
sent = re.sub('\.{2,}', '..', sent)
sent = re.sub('\~+', '~', sent)
sent = re.sub('\!+', '!', sent)
sent = re.sub('\?+', '?', sent)
sent = re.sub('ㅋ{1,}|ㅎ{1,}', 'ㅋ', sent)
sent = re.sub('ㅜ{1,}|ㅠ{1,}|ㅠㅜ|ㅜㅠ\ㅡㅜ\ㅜㅡ\ㅡㅠ\ㅠㅡ', 'ㅠㅠ', sent)
return sent
vectorized_data = [
decompose_str_as_one_hot(datum, warning=False) for datum in data
]
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, (max_length - length):] = np.array(seq)[:length]
else:
zero_padding[idx, (max_length - length):] = np.array(seq)
return zero_padding
def preprocess_post(data: list, max_length: int):
"""
입력을 받아서 딥러닝 모델이 학습 가능한 포맷으로 변경하는 함수입니다.
기본 제공 알고리즘은 char2vec이며, 기본 모델이 MLP이기 때문에, 입력 값의 크기를 모두 고정한 벡터를 리턴합니다.
문자열의 길이가 고정값보다 길면 긴 부분을 제거하고, 짧으면 0으로 채웁니다.
:param data: 문자열 리스트 ([문자열1, 문자열2, ...])
:param max_length: 문자열의 최대 길이
:return: 벡터 리스트 ([[0, 1, 5, 6], [5, 4, 10, 200], ...]) max_length가 4일 때
"""
def text_norm(sent):
sent = re.sub('ac[\d]+', 'Q', sent)
sent = re.sub('mv[\d]+', 'Z', sent)
return sent
vectorized_data = [
decompose_str_as_one_hot(datum, warning=False) for datum in data
]
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, :length] = np.array(seq)[:length]
else:
zero_padding[idx, :length] = np.array(seq)
return zero_padding
def preprocess(data: list, max_length: int):
"""
입력을 받아서 딥러닝 모델이 학습 가능한 포맷으로 변경하는 함수입니다.
기본 제공 알고리즘은 char2vec이며, 기본 모델이 MLP이기 때문에, 입력 값의 크기를 모두 고정한 벡터를 리턴합니다.
문자열의 길이가 고정값보다 길면 긴 부분을 제거하고, 짧으면 0으로 채웁니다.
:param data: 문자열 리스트 ([문자열1, 문자열2, ...])
:param max_length: 문자열의 최대 길이
:return: 벡터 리스트 ([[0, 1, 5, 6], [5, 4, 10, 200], ...]) max_length가 4일 때
"""
vectorized_data = [
decompose_str_as_one_hot(datum, warning=False) for datum in data
]
# local largestSize is = 90
# largestSize = 0
# for vector in vectorized_data:
# largestSize = max(len(vector), largestSize)
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, :length] = np.array(seq)[:length]
else:
zero_padding[idx, :length] = np.array(seq)
return zero_padding
def preprocess(data: list, max_length: int):
"""
입력을 받아서 딥러닝 모델이 학습 가능한 포맷으로 변경하는 함수입니다.
기본 제공 알고리즘은 char2vec이며, 기본 모델이 MLP이기 때문에, 입력 값의 크기를 모두 고정한 벡터를 리턴합니다.
문자열의 길이가 고정값보다 길면 긴 부분을 제거하고, 짧으면 0으로 채웁니다.
:param data: 문자열 리스트 ([문자열1, 문자열2, ...])
:param max_length: 문자열의 최대 길이
:return: 벡터 리스트 ([[0, 1, 5, 6], [5, 4, 10, 200], ...]) max_length가 4일 때
"""
vectorized_data1 = []
vectorized_data2 = []
vectorized_data1_lengths = []
vectorized_data2_lengths = []
for datum in data:
s1, s2 = datum.strip().split("\t")
onehot1 = decompose_str_as_one_hot(s1, warning=False)
onehot2 = decompose_str_as_one_hot(s2, warning=False)
vectorized_data1.append(onehot1)
vectorized_data2.append(onehot2)
vectorized_data1_lengths.append(len(onehot1))
vectorized_data2_lengths.append(len(onehot2))
# one hot length
#v_data_lens = [len(x) for x in (vectorized_data1 + vectorized_data2)]
#df = pd.DataFrame(data={'vectorized_data_length': v_data_lens})
#print(df.describe(percentiles=[0.95, 0.997]))
def to_zero_padded(vectorized_data):
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, :length] = np.array(seq)[:length]
else:
zero_padding[idx, :length] = np.array(seq)
return zero_padding
zero_padding1 = to_zero_padded(vectorized_data1)
zero_padding2 = to_zero_padded(vectorized_data2)
return zero_padding1, zero_padding2, np.array(
vectorized_data1_lengths), np.array(vectorized_data2_lengths)
def vectorize_data(data, max_length):
vectorized_data = [
decompose_str_as_one_hot(datum, warning=False) for datum in data
]
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, :length] = np.array(seq)[:length]
else:
zero_padding[idx, :length] = np.array(seq)
return np.array(zero_padding)
def preprocess(data: list, max_length: int):
vectorized_data = [decompose_str_as_one_hot(datum, warning=False) for datum in data]
print("longest length: ", len(max(vectorized_data, key=len)))
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
lens1 = np.zeros((len(vectorized_data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = min(len(seq), max_length)
lens1[idx] = np.pad(np.arange(length)+1, (0, max_length - length), 'constant')
if length >= max_length:
length = max_length
zero_padding[idx, :length] = np.array(seq)[:length]
else:
zero_padding[idx, :length] = np.array(seq)
return list(zip(zero_padding, lens1))
def preprocess2(data: list, max_length: int):
"""
입력을 받아서 딥러닝 모델이 학습 가능한 포맷으로 변경하는 함수입니다.
기본 제공 알고리즘은 char2vec이며, 기본 모델이 MLP이기 때문에, 입력 값의 크기를 모두 고정한 벡터를 리턴합니다.
문자열의 길이가 고정값보다 길면 긴 부분을 제거하고, 짧으면 0으로 채웁니다.
:param data: 문자열 리스트 ([문자열1, 문자열2, ...])
:param max_length: 문자열의 최대 길이
:return: 벡터 리스트 ([[0, 1, 5, 6], [5, 4, 10, 200], ...]) max_length가 4일 때
"""
sen1 = []
sen2 = []
for datum in data:
spl = datum.split('\t')
if not len(spl) == 2:
print('2개로 안나뉨 : ', len(spl))
sen1.append(decompose_str_as_one_hot(spl[0], warning=False))
sen2.append(decompose_str_as_one_hot(spl[1], warning=False))
pad_sen1 = np.zeros((len(data), max_length), dtype=np.int32)
pad_sen2 = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(sen1):
length = len(seq)
if length >= max_length:
length = max_length
pad_sen1[idx, :length] = np.array(seq)[:length]
else:
pad_sen1[idx, :length] = np.array(seq)
for idx, seq in enumerate(sen2):
length = len(seq)
if length >= max_length:
length = max_length
pad_sen2[idx, :length] = np.array(seq)[:length]
else:
pad_sen2[idx, :length] = np.array(seq)
return pad_sen1, pad_sen2
def preprocess(data: list, max_length: int, save_data=None):
MAX_TOKEN = 1024
# input1
if not save_data:
counter1 = Counter()
for datum in tqdm(data, mininterval=1, bar_format='{r_bar}\n'):
counter1.update(create_ngram(datum, warning=False))
token_list = [
token for token, count in counter1.most_common(MAX_TOKEN)
]
save_data = {
'token_list': token_list,
}
token_dict = {token: i for i, token in enumerate(save_data['token_list'])}
zero_padding1 = np.zeros((len(data), max_length), dtype=np.uint16)
zero_padding2 = np.zeros((len(data), 1 + 250), dtype=np.uint8)
idx = 0
for datum in tqdm(data, mininterval=1, bar_format='{r_bar}\n'):
# tokens = [token_dict[token] for token in create_ngram(datum, warning=False) if token in token_dict]
one_hot = decompose_str_as_one_hot(datum, warning=False)
# input 1
length = len(one_hot)
if length >= max_length:
zero_padding1[idx, :max_length] = np.array(one_hot)[:max_length]
else:
zero_padding1[idx, :length] = np.array(one_hot)
# input2
zero_padding2[idx, 0] = len(datum)
counter = Counter(one_hot)
counted = np.array([counter[i] for i in range(250)])
zero_padding2[idx, 1:251] = counted
idx += 1
zero_padding1 = zero_padding1.reshape(len(data), -1)
zero_padding2 = zero_padding2.reshape(len(data), -1)
return zero_padding1, zero_padding2, save_data
def preprocess(data: list, max_length: int):
def text_norm(sent):
sent = re.sub('\.{2,}', '..', sent)
sent = re.sub('\~+', '~', sent)
sent = re.sub('\!+', '!', sent)
sent = re.sub('\?+', '?', sent)
sent = re.sub('ㅋ{1,}|ㅎ{1,}', 'ㅋ', sent)
sent = re.sub('ㅜ{1,}|ㅠ{1,}|ㅠㅜ|ㅜㅠ\ㅡㅜ\ㅜㅡ\ㅡㅠ\ㅠㅡ', 'ㅠㅠ', sent)
return sent
vectorized_data = [
decompose_str_as_one_hot(datum, warning=False) for datum in data
]
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, (max_length - length):] = np.array(seq)[:length]
else:
zero_padding[idx, (max_length - length):] = np.array(seq)
return zero_padding
def preprocess(data: list, max_length: int):
vectorized_data = [
decompose_str_as_one_hot(datum, warning=False) for datum in data
]
zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
for idx, seq in enumerate(vectorized_data):
length = len(seq)
if length >= max_length:
length = max_length
zero_padding[idx, (max_length - length):] = np.array(seq)[:length]
else:
zero_padding[idx, (max_length - length):] = np.array(seq)
return zero_padding
# def preprocess_post(data: list, max_length: int):
# def text_norm(sent):
# sent = re.sub('[\,\<\>\(\)\+\-\=\&\@\#\$]', '', sent)
# sent = re.sub('\.{2,}', '..', sent)
# sent = re.sub('\~+', '~', sent)
# sent = re.sub('\!+', '!', sent)
# sent = re.sub('\?+', '?', sent)
# sent = re.sub('ㅋ{1,}|ㅎ{1,}', 'ㅋ', sent)
# sent = re.sub('ㅜ{1,}|ㅠ{1,}|ㅠㅜ|ㅜㅠ\ㅡㅜ\ㅜㅡ\ㅡㅠ\ㅠㅡ', 'ㅠㅠ', sent)
# return sent
# vectorized_data = [decompose_str_as_one_hot(text_norm(datum), warning=False) for datum in data]
# zero_padding = np.zeros((len(data), max_length), dtype=np.int32)
# for idx, seq in enumerate(vectorized_data):
# length = len(seq)
# if length >= max_length:
# length = max_length
# zero_padding[idx, :length] = np.array(seq)[:length]
# else:
# zero_padding[idx, :length] = np.array(seq)
# return zero_padding
