Tại sao có bài viết này

Sơ lược

Xin chào ! Mình là Glutis - Một sinh viên ngành toán tại HUST, vài tháng gần đây loay hoay đau đầu với nhiều lỗi lo của các sinh viên sắp ra trường, mình càng thấm thía hơn câu nói của một giám đốc trung tâm tiếng anh từng chia sẻ

“Năm nhất bận thì chắc chắn năm 2 năm 3 sẽ càng bận hơn”.

Quả đúng vậy bao thứ ập đến, ủa vây lấy tôi từ công việc, gia đình, bạn bè, rồi việc trường lớp, khởi nghiệp lọ kia. Ta loay hoay giữa một vùng trời lớn, ta đắn đo suy nghĩ chẳng biết đi về đâu. Những áng trời đẹp đẽ mây trôi vô định chẳng còn hiện trong ánh mắt cậu học trò này mà thay vào đó là sự trĩu nặng trách nhiệm và kỳ vọng. Giờ đây, mình không còn là một cậu học trò chỉ cần học tốt là xong – mà đã thực sự bước vào guồng quay của một “thế giới tư bản” đúng nghĩa.

Tôi thực tập tại một công ty Outsource cho khách hàng người Nhật trong 2 tháng, tổng quan thì tôi thường làm về dữ liệu và Machine Learning là một trong những cái mà tôi hay làm và mang võ công này đi rất nhiều các cuộc thi. Từ những ngày còn chập chững được các anh trong lab cầm tay chỉ từng dòng công thức toán đến những giờ seminar căng thẳng. Tưởng đâu với machine learning tôi đã vững chắc lắm rồi. Rồi đời cũng vả mặt tôi bằng một bài toán khó.

Chả là, tôi cần luyện một model để dự đoán các công ty tại Nhật Bản để làm giàu dữ liệu cho công ty, nghĩ mà xem có data một công ty khác mà còn là dữ liệu revenue thì thật là kinh khủng, dữ liệu doanh thu để huấn luyện mô hình thì lại rất ít.

Vấn đề là ở đây: dữ liệu doanh thu thì lại cực kỳ khan hiếm. Thường thì ae làm model dữ liệu thường phải lên đến vài triệu đến vài tỉ dòng, không thiếu, muốn trường gì có trường đó thiếu thì kêu người ta đi lấy về, trong trường hợp của tôi thì lại khác các ông ạ! Data nó tí tẹo có 40k dòng xong còn null nhiều vaiz chưởng, kêu gọi đi lấy thêm data về thì khó do dữ liệu doanh thu public rất ít. Mà crawl về thì khó cơ. Ấy vậy mà problem thì ta vẫn phải resolve thôi!

Kể cũng ác, cty crawl được data của hơn 5,5tr công ty Nhật mỗi công ty hơn trăm fields

Vậy đó, dữ liệu thì ít, task thì khó, nhưng mô hình thì vẫn phải training, kết quả vẫn phải ra. Chạy đâu cho khỏi cái task này!

Xem tôi giải quyết nó như nào nhé!

Các thách thức

a) Vấn đề chất lượng dữ liệu: Dữ liệu bị thiếu, định dạng không đồng nhất, thiếu sự tích hợp giữa các phòng ban.

b) Overfitting (quá khớp): Đặc biệt xảy ra với dữ liệu có nhiều chiều hoặc kích thước mẫu nhỏ.

c) Khó giải thích: Các mô hình phức tạp như mạng nơ-ron thường hoạt động như một “hộp đen”.

d) Thị trường thay đổi nhanh chóng: Các mô hình huấn luyện từ dữ liệu quá khứ có thể không còn hiệu quả trong thị trường biến động mạnh (ví dụ: đại dịch COVID-19).

e) Thiên lệch trong dữ liệu: Dữ liệu sai lệch hoặc mất cân bằng có thể dẫn đến dự đoán không chính xác.

Sơ lược về bộ dữ liệu

Dữ liệu gồm 5.5 tr dòng, trong đó có 40k dòng là các công ty có revenue dùng để luyện model. Số còn lại không được public, các trường dữ liệu có thể sử dụng được bao gồm (hơn trăm trường nhưng đa số null và không có tác dụng):

corporate_number: Mã số doanh nghiệp duy nhất, dùng để định danh công ty.
employee_count: Số lượng nhân viên hiện tại trong công ty.
capital: Vốn điều lệ hoặc vốn đầu tư đăng ký của công ty.
business_model_codes: Mã hóa các mô hình kinh doanh mà công ty hoạt động.
listing_market_code: Mã sàn giao dịch chứng khoán (nếu công ty đã niêm yết).
postal_code: Mã bưu điện nơi công ty đặt trụ sở.
establish_date_normalized: Ngày thành lập công ty đã được chuẩn hóa định dạng (ví dụ: YYYY-MM-DD).
establish_date_normalized_updated_at: Thời điểm dữ liệu ngày thành lập chuẩn hóa được cập nhật gần nhất.
prefecture: Tỉnh hoặc khu hành chính cấp tỉnh (ví dụ: Tokyo, Osaka…).
city: Thành phố hoặc quận nơi công ty đặt trụ sở.
business_content: Nội dung mô tả hoạt động kinh doanh chính của công ty.
establish_date: Ngày thành lập ban đầu (có thể chưa chuẩn hóa định dạng).
average_age: Độ tuổi trung bình của nhân viên trong công ty.
average_salary: Mức lương trung bình của nhân viên (thường tính theo năm).
group_employee_count: Tổng số nhân viên trong toàn bộ tập đoàn (nếu công ty thuộc một tập đoàn).
management_tools: Các công cụ/phần mềm quản lý được công ty sử dụng (ví dụ: ERP, SAP…).
communication_tools: Công cụ giao tiếp nội bộ như Slack, Microsoft Teams, Zoom…
tech_databases: Hệ quản trị cơ sở dữ liệu mà công ty sử dụng (như MySQL, PostgreSQL…).
revenue: Doanh thu của công ty (năm gần nhất).
tech_clouds: Các nền tảng điện toán đám mây đang sử dụng (như AWS, Azure, GCP…).
tech_languages: Ngôn ngữ lập trình chính được sử dụng trong công ty (Python, Java…).
recruit_skills: Kỹ năng công ty đang tìm kiếm khi tuyển dụng (dựa theo JD).
tech_frameworks: Frameworks công nghệ mà công ty đang sử dụng (React, Django…).
crm_tools: Các công cụ quản lý quan hệ khách hàng như Salesforce, Hubspot…
industry_code: Mã ngành nghề kinh doanh theo tiêu chuẩn phân loại ngành.
nta_city_code: Mã địa phương theo chuẩn của cơ quan thuế Nhật Bản (NTA).
corporate_kind: Loại hình doanh nghiệp (ví dụ: công ty cổ phần, TNHH…).
meta_keywords: Từ khóa mô tả công ty, dùng cho SEO hoặc phân tích dữ liệu.

Data này trông vậy mà lớn đến 155GB nha, đó là đã qua tiền xử lý trước rồi và duplicate data do update version. Dùng kết quả luyện từ 40k công ty để dự đoán 5.5tr công ty còn lại =)).

Tiền Xử lý dữ liệu + Feature engineering

Dữ liệu đầu vào được đọc từ file CSV lớn data_after.csv được truy vấn từ trino thông qua supperset bằng cách query nhiều lần (do quá nặng) với cột ngày được chuẩn hóa về định dạng datetime:

1 2	df_full = pd.read_csv(INPUT_CSV, low_memory=False) df_full['establish_date_normalized'] = pd.to_datetime(df_full['establish_date_normalized'], errors='coerce')

Giá trị nào null thì lấy trung bình cả cột,

Chia batch nhỏ để xử lý multi batch

Dữ liệu sau đó được chia thành nhiều batch nhỏ để xử lý tuần tự, đảm bảo không quá tải bộ nhớ:

1 2	BATCH_SIZE = 10_000 num_batches = (len(df_full) + BATCH_SIZE - 1) // BATCH_SIZE

Tăng cường dữ liệu với Embedding API

Mỗi doanh nghiệp có một trường mô tả business_content, được truyền vào API nội bộ sử dụng mô hình jina-embeddings-v3 để sinh ra vector đặc trưng chiều 32:

def embedding(content):
    payload = {..., "input": [f"{content}", "123"], ...}
    response = requests.post(url, headers=headers, data=payload)
    return response.json()['data'][0]['embedding']

=> Phải làm thế do các feature cũ quá kém chỉ cho tương quan 0.2 trở xuống, dữ liệu cực kỳ rời rạc và nhiều ngoại lai. Cái này do CTO nghĩ rằng triết lý kinh doanh cũng ảnh hưởng rất lớn tới doanh thu.

Xử lý ngoại lai

Ngoại lai

Thay thế outlier sau khi phát hiện outlier thì giới hạn giá trị về biên trên hoặc dưới:

Xử lý từng dòng dữ liệu

Mỗi dòng được xử lý qua hàm process_row() để:

Tính tuổi công ty từ ngày thành lập
Phân loại quy mô công ty dựa vào employee_count thành small, medium, large
Chuẩn hóa một số trường dạng text
Gắn thêm 32 chiều embedding (ko cần phải nén lại nữa do số chiều vẫn ít)

Kết quả trả về là một dictionary đã sẵn sàng để ghi ra file.

def process_row(row):
    ...
    processed["company_scale"] = "small" | "medium" | "large"
    for i in range(32):
        processed[f"embed_{i}"] = emb[i]

Model embeding được dựng trên server lớn và xây dựng theo kiểu phân tán và chạy bằng GPU, tốc độ xử lý cực nhanh, trung bình cứ 5000/phút.

Metric số lần xuất hiện trên các trang tuyển dụng

Metric này cực kỳ hữu ích cho mô hình, cũng đúng thôi công ty nào doanh thu cao thì họ sẽ đầu tư nhiều vào việc tìm kiếm nhân tài và đăng thông tin ở nhiều trang tuyển dụng khác nhau.

Mình chỉ việc dùng sql xong count số lượt xuất hiện cùng với corporate_number rồi inner join với bảng cũ. Tuy nhiên truy vấn này sẽ rất nặng và lâu.

Xử lý song song theo batch

Dữ liệu được xử lý song song với ThreadPoolExecutor, tận dụng đa luồng để tăng tốc độ xử lý API:

with ThreadPoolExecutor(max_workers=20) as executor:
    futures = [executor.submit(process_row, row) for _, row in df_batch.iterrows()]
    for future in tqdm(as_completed(futures), total=len(futures)):
        processed_batch.append(future.result())

Kết quả được lưu từng batch vào thư mục output_batches/:

1	df_result.to_csv(output_file, index=False)

Chuẩn hóa cột số

1
2
3

scaler = StandardScaler()
X_train[num_cols] = scaler.fit_transform(X_train[num_cols])
X_test[num_cols] = scaler.transform(X_test[num_cols])

=> Khúc tạo features tôi đã tạo gần 300 feature nhưng số dùng được chắc độ 5 chục cái =))

Huấn luyện mô hình

Sau khi xử lý dữ liệu và trích xuất đặc trưng (bao gồm embedding), bước tiếp theo là huấn luyện mô hình dự đoán doanh thu (revenue). Đặc biệt, kết hợp cả đặc trưng số và đặc trưng phân loại dưới dạng embedding.

Các cột số học như capital, employee_count, company_age, v.v.

Các cột phân loại như city, prefecture, industry_code, company_scale, được mã hóa bằng embedding học được từ mạng nơ-ron PyTorch.

Toàn bộ dữ liệu được xử lý như sau:

1
2
3

# Biến đổi categorical thành embedding
class EmbeddingGenerator(nn.Module):
    ...

Huấn luyện một mạng đơn giản chỉ để học biểu diễn embedding cho các trường phân loại:

Sử dụng Embedding layers

Tối ưu với Adam và MSELoss

Số epoch = 35, batch_size = 256

Sau huấn luyện, biểu diễn embedding được kết hợp với các cột số để tạo đầu vào cuối cùng:

1 2	X_train_final = np.concatenate([X_train[num_cols], train_embeds], axis=1) X_test_final = np.concatenate([X_test[num_cols], test_embeds], axis=1)

Huấn luyện mô hình XGBoost

Chọn XGBoost Regressor do khả năng xử lý tốt cả dữ liệu số và khả năng kiểm soát overfitting qua early_stopping.

xgb_model = xgb.XGBRegressor(
    objective='reg:squarederror',
    n_estimators=1000,
    max_depth=8,
    learning_rate=0.05,
    subsample=0.8,
    colsample_bytree=0.8,
    early_stopping_rounds=50
)

Mô hình được huấn luyện trên dữ liệu kết hợp (số + embedding), sau đó được đánh giá bằng các chỉ số chuẩn:

R² (R-squared): Độ phù hợp của mô hình
MAE (Mean Absolute Error): Sai số tuyệt đối trung bình
RMSE (Root Mean Squared Error): Sai số bình phương trung bình
Total Relative Error: Độ sai lệch tổng giữa tổng dự đoán và tổng thực tế (truth - predict)/sum

1
2
3

r2 = r2_score(y_test, preds_np)
mae = mean_absolute_error(y_test, preds_np)
rmse = sqrt(mean_squared_error(y_test, preds_np))

Mô hình đạt R² = 0.64 trên tập test, MAE = 3 tỷ

Làm sao để biết được tham số cho mô hình luyện ngon

Tôi dùng phần mềm explorator của bên Nhật rồi testing đủ thứ trên này rồi mới mang tham số ra cho model.

Phân tích kết quả trên tập test

Sau khi dự đoán, khớp kết quả trở lại với tập test gốc:

1
2
3

df_test = raw.loc[test_indices].copy()
df_test['revenue_predict'] = preds_np
df_test['abs_error'] = np.abs(df_test['revenue'] - df_test['revenue_predict'])

Dữ liệu này có thể dùng cho:

Trực quan hóa sai số
Phân tích sai số theo phân khúc (company_scale, industry_code, etc.)

Lưu mô hình embedding (PyTorch)

1	torch.save(embed_model.state_dict(), "embed_model.pth")

Lưu trọng số mô hình embedding bằng định dạng .pth, để dễ dàng nạp lại khi cần tạo embedding từ dữ liệu phân loại mới.

Lưu mô hình dự đoán doanh thu (XGBoost)

1	xgb_model.save_model("xgb_model.json")

Mô hình XGBoost được lưu dưới dạng JSON, đảm bảo tính tương thích cao khi triển khai trong môi trường production hoặc phục vụ API.

Lưu pipeline xử lý dữ liệu

Các thành phần như scaler và mapping categorical đều rất quan trọng, và được lưu bằng joblib:

joblib.dump(scaler, "scaler.pkl")
joblib.dump(cat_maps, "cat_maps.pkl")
joblib.dump(num_cols, "num_cols.pkl")
joblib.dump(cat_cols, "cat_cols.pkl")

Cụ thể:

scaler.pkl: Chuẩn hóa các cột số giống như lúc training
cat_maps.pkl: Bản đồ mã hóa các biến phân loại → số nguyên
num_cols.pkl và cat_cols.pkl: Danh sách cột để tái tạo đúng đầu vào mô hình

Sử dụng mô hình để dự báo

Sau khi huấn luyện và lưu trữ toàn bộ mô hình cũng như thông tin tiền xử lý, bước tiếp theo là sử dụng chúng để dự báo doanh thu cho hàng trăm nghìn công ty trong tập dữ liệu chưa có nhãn.

Tải lại mô hình và thông tin tiền xử lý

Toàn bộ pipeline được khôi phục từ các file .pkl, .json, .pth:

scaler = joblib.load("scaler.pkl")
cat_maps = joblib.load("cat_maps.pkl")
num_cols = joblib.load("num_cols.pkl")
cat_cols = joblib.load("cat_cols.pkl")

Khôi phục mô hình embedding

1
2
3

embed_model = EmbeddingGenerator(cat_maps)
embed_model.load_state_dict(torch.load("embed_model.pth"))
embed_model.eval()

Khôi phục mô hình XGBoost

1 2	xgb_model = xgb.XGBRegressor() xgb_model.load_model("xgb_model.json")

Dự báo theo từng batch

Vì dữ liệu lớn được chia thành các batch (processed_batch_000.csv đến processed_batch_489.csv), sử dụng vòng lặp để xử lý từng file đầu vào và tạo kết quả dự đoán.

Các bước thực hiện cho mỗi batch:

Bước 1: Đọc file dữ liệu đã xử lý.
Bước 2: Ánh xạ lại giá trị phân loại về dạng chỉ số (theo cat_maps).
Bước 3: Chuẩn hóa các giá trị số bằng StandardScaler.
Bước 4: Sinh embedding từ mô hình PyTorch.
Bước 5: Ghép đặc trưng số và embedding thành đầu vào cuối cùng.
Bước 6: Dự báo doanh thu với mô hình XGBoost.

x_cat_tensor = torch.LongTensor(df[cat_cols].values)
cat_embeds = embed_model.forward_embeddings(x_cat_tensor).numpy()
X_input = np.concatenate([df[num_cols].values, cat_embeds], axis=1)
y_pred = xgb_model.predict(X_input)

Dự đoán của mỗi batch được lưu lại cùng với corporate_number:

batch_result = pd.DataFrame({
    "corporate_number": df["corporate_number"],
    "revenue_predict": y_pred
})

Gộp kết quả và xuất ra tệp duy nhất

Toàn bộ các kết quả từ các batch được hợp nhất lại để tạo thành một file .csv duy nhất:

1 2	final_df = pd.concat(all_predictions, ignore_index=True) final_df.to_csv("/kaggle/working/all_predictions.csv", index=False)

Kết quả cuối cùng này là dự đoán doanh thu cho toàn bộ doanh nghiệp trong hệ thống, và có thể dùng cho các mục đích:

Gợi ý kinh doanh hoặc tiếp thị tự động
Phân nhóm khách hàng theo tiềm năng
Tạo dashboard phân tích tài chính tự động
Dùng làm đầu vào cho các mô hình downstream như phân loại rủi ro

Deploy model lên torchserve

Mục đích là gọi model như gọi API, tạo thành luôn 1 service

Kiến trúc của torchserve:

1	scp -r ./artifacts cty@ip:/home/cty/workspaces/salessmart_revenue

1	ssh cty@ip

1	cd /home/cty/workspaces/salessmart_revenue

1	artifacts config.properties hybrid_handler.py logs main.py model_def.py model_store pyproject.toml README.md uv.lock

Tạo file config.properties

number_of_gpu=1 
disable_token_authorization=true
inference_address=http://0.0.0.0:8080
management_address=http://0.0.0.0:8081
allow_anonymous_inference_access=true
models={\
  "hybrid_revenue_model": {\
    "minWorkers": 4,\
    "maxWorkers": 4\
  }\
}

Tạo file hybrid_handler.py

import torch
import torch.nn as nn
import xgboost as xgb
import numpy as np
import os
import json
import joblib
import pandas as pd

from ts.torch_handler.base_handler import BaseHandler
from ts.utils.util import PredictionException
from model_def import EmbeddingGenerator

class HybridModelHandler(BaseHandler):
    def __init__(self):
        super().__init__()
        self.initialized = False

    def initialize(self, context):
        self.manifest = context.manifest
        properties = context.system_properties
        model_dir = properties.get("model_dir")

        with open(os.path.join(model_dir, 'cat_maps.json'), 'r', encoding='utf-8') as f:
            self.cat_maps = json.load(f)

        with open(os.path.join(model_dir, 'column_info.json'), 'r') as f:
            column_info = json.load(f)
            self.cat_cols = column_info['cat_cols']
            self.num_cols = column_info['num_cols']

        self.scaler = joblib.load(os.path.join(model_dir, 'scaler.joblib'))

        # Đảo ngược cat_maps để tra cứu string -> code (mã số)
        self.cat_maps_rev = {col: {v: int(k) for k, v in M.items()} for col, M in self.cat_maps.items()}

        self.embed_model = EmbeddingGenerator(self.cat_maps, embed_dim=10)
        self.embed_model.load_state_dict(torch.load(os.path.join(model_dir, 'embed_model.pt')))
        self.embed_model.eval()

        self.xgb_model = xgb.Booster()
        self.xgb_model.load_model(os.path.join(model_dir, 'xgb_model.json'))

        self.initialized = True
        print("Handler success with model and artifact.")

    def preprocess(self, data):
        input_list = data[0].get("body")
        if isinstance(input_list, (bytes, bytearray)):
            input_list = json.loads(input_list.decode('utf-8'))

        # Chuyển input thành DataFrame
        df = pd.DataFrame(input_list)

        # Tiền xử lý các cột phân loại (categorical)
        cat_features = []
        for col in self.cat_cols:
            # Lấy mã cho giá trị 'missing' làm giá trị mặc định
            missing_code = self.cat_maps_rev[col].get('missing', 0)
            # Ánh xạ giá trị string sang mã số, nếu không có thì dùng mã 'missing'
            codes = df[col].astype(str).map(self.cat_maps_rev[col]).fillna(missing_code).astype(int)
            cat_features.append(codes.values.reshape(-1, 1))

        x_cat = np.concatenate(cat_features, axis=1)
        x_cat_tensor = torch.LongTensor(x_cat)

        # Tiền xử lý các cột số (numerical) - phiên bản an toàn
        # Tạo một DataFrame trống với các cột và thứ tự chính xác
        df_num = pd.DataFrame(columns=self.num_cols)
        # Ghép dữ liệu từ input vào, các cột thiếu sẽ tự động là NaN
        df_num = pd.concat([df_num, df[self.num_cols]], ignore_index=True)
        # Điền 0 vào bất kỳ giá trị nào bị thiếu (cả do thiếu cột và giá trị gốc là NaN)
        df_num.fillna(0, inplace=True)

        x_num_scaled = self.scaler.transform(df_num)

        return x_cat_tensor, x_num_scaled

    def inference(self, data):
        x_cat_tensor, x_num_scaled = data

        with torch.no_grad():
            embeds = self.embed_model.forward_embeddings(x_cat_tensor).numpy()

        final_features = np.concatenate([x_num_scaled, embeds], axis=1)
        dmatrix = xgb.DMatrix(final_features)

        predictions = self.xgb_model.predict(dmatrix)
        return predictions

    def postprocess(self, data):
        return [data.tolist()]

Create model_def.py

import torch.nn as nn
import torch
class EmbeddingGenerator(nn.Module):
    def __init__(self, cat_maps, embed_dim=10):
        super().__init__()
        # Lấy số lượng category từ cat_maps
        cat_sizes = {col: len(cat_maps[col]) for col in cat_maps}
        self.embeddings = nn.ModuleList([
            nn.Embedding(cat_sizes[col], embed_dim) for col in cat_maps.keys()
        ])

        # === THÊM LẠI LỚP BỊ THIẾU ===
        total_embed_dim = len(cat_maps) * embed_dim
        self.out_layer = nn.Linear(total_embed_dim, 1)

    def forward_embeddings(self, x_cat):
        # Hàm này chỉ lấy các vector embedding, dùng cho handler
        cat_embeds = [emb(x_cat[:, i]) for i, emb in enumerate(self.embeddings)]
        return torch.cat(cat_embeds, dim=1)

    def forward(self, x_cat):
        # Hàm này để khớp với kiến trúc lúc training
        embeddings = self.forward_embeddings(x_cat)
        return self.out_layer(embeddings)

Create foldel model_store

1	mkdir model_store

Install package

pip install pandas joblib scikit-learn xgboost
pip install torch --index-url https://download.pytorch.org/whl/cpu
pip install torchserve torch-model-archiver
pip install torchserve torch-model-archiver xgboost scikit-learn joblib pandas

torch-model-archiver --model-name hybrid_revenue_model \
                     --version 1.0 \
                     --handler hybrid_handler.py \
                     --serialized-file artifacts/embed_model.pt \
                     --extra-files "artifacts/xgb_model.json,artifacts/scaler.joblib,artifacts/cat_maps.json,artifacts/column_info.json" \
                     --export-path .

torch-model-archiver --model-name hybrid_revenue_model \
                     --version 1.0 \
                     --handler hybrid_handler.py \
                     --serialized-file artifacts/embed_model.pt \
                     --extra-files "artifacts/xgb_model.json,artifacts/scaler.joblib,artifacts/cat_maps.json,artifacts/column_info.json,model_def.py" \
                     --export-path . --force
mv hybrid_revenue_model.mar model_store/

Run

1	torchserve --start --ncs --model-store model_store --models hybrid_revenue_model.mar --ts-config config.properties

Test

1	curl http://localhost:8081/models

good response:

{
  "models": [
    {
      "modelName": "hybrid_revenue_model",
      "modelUrl": "hybrid_revenue_model.mar"
    }
  ]
}

1	curl http://localhost:8080/ping

good response:

1
2
3

{
    "status": "Healthy"
}

Curl

1	http://ip:8580/predictions/hybrid_revenue_model

body:

[
    {
        "biz_B2C": 0,
        "industry_code": "0",
        "city": "1007",
        "embed_18": 0.071999,
        "embed_7": 0.094529,
        "embed_13": -0.025469,
        "embed_23": 0.061958,
        "embed_28": -0.068081,
        "embed_22": -0.020449,
        "embed_15": -0.094529,
        "embed_31": 0.014388,
        "embed_11": 0.25469,
        "embed_29": -0.033551,
        "capital": 50000000.0,
        "embed_6": -0.072489,
        "embed_16": -0.181222,
        "embed_27": -0.010653,
        "establish_year": 2018.0,
        "biz_model_count": 0,
        "embed_5": 0.011388,
        "embed_1": -0.171426,
        "embed_12": 0.044816,
        "communication_tools": "210",
        "nta_city_id": "196",
        "company_age": 7.0,
        "prefecture": "26",
        "embed_24": -0.049469,
        "biz_B2B": 0,
        "embed_26": 0.011877,
        "nta_prefecture_id": "4",
        "embed_4": 0.006765,
        "cluster": "0",
        "embed_20": -0.108243,
        "embed_0": 0.102856,
        "embed_8": 0.002862,
        "listing_market_code": "17",
        "months": 86.0,
        "embed_3": 0.002495,
        "management_tools": "107",
        "embed_14": -0.031591,
        "embed_19": -0.025469,
        "count_corporate_number": 20,
        "embed_2": 0.03550971,
        "embed_25": 0.037714,
        "embed_10": -0.004653,
        "embed_30": 0.059509,
        "embed_9": -0.949714,
        "years": 17.0,
        "company_scale": "8453",
        "embed_17": 0.087672,
        "embed_21": 0.034285,
        "employee_count": 36.0
    }
]

Kết quả

[
    'revenue': 12.555.567.000
]

Đánh giá kết quả

Giờ này, dự đoán ra rồi vậy làm sao để biết cái dự đoán đó nó có oke ko đối với 1 cty, tôi cần tìm 1 chỉ số để áng chừng chất lượng.

Dựa vào đầu vào, tôi cho rằng nếu dữ liệu đầu vào bị null nhiều thì kết quả dự đoán ra sẽ không tốt. Tôi tính lại tỷ lệ số bản ghi không null và so sánh nó với độ lệch abs_error dự đoán

=> Kết quả trông nó cũng giống giống phân phối chuẩn 🙂

=> Cần tìm 1 chỉ số khác tỷ lệ nghịch với độ lệch dự đoán, tính trung bình nơi có sai số cao nhất 65%:

1 2	mid_score = 65 df_all_results["confidence_score1"] = ((df_all_results["input_quality_score"] - mid_score)**2)

Chuẩn hóa lại về dạng [0 - 1]

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
df_all_results["input_quality_percent"] = scaler.fit_transform(df_all_results[["confidence_score1"]]) * 100

=> Ta được một chỉ số khá là tuyến tính 🙂, chung cũng được

Kết quả sau khi làm mịn

=> Tuy chưa oke nhưng mà chỉ số này có thể khăng định, nếu input_quality_percent mà cao thì độ lệch dự đoán thấp, còn input_quality_percent mà thấp hoặc tầm trung thì không kết luận được gì.

Kết luận

Do là dự án công ty nên tôi ko public tí hình ảnh nào ra đâu nha. Chỉ nói qua cách làm cho mọi người hình dung được thôi.

Xây dựng model dự báo revenue các công ty tại Nhật Bản