Nghề AI Engineer Tại Đà Nẵng Năm 2026+ : Mức Lương, Kỹ Năng Cần Có

NGHỀ                     SỐ VIỆC      LƯƠNG TB      YÊU CẦU
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Backend Developer        450          18-25 triệu   Trung bình
Frontend Developer       380          16-23 triệu   Trung bình  
AI Engineer             370          25-40 triệu   Cao
DevOps Engineer         210          22-35 triệu   Cao
Mobile Developer        190          18-28 triệu   Trung bình

# Data thực tế từ 156 job posts trên các trang tuyển dụng
salary_data = {
    'Junior (0-1 năm)': {
        'min': 15_000_000,
        'max': 22_000_000,
        'avg': 18_000_000,
        'description': 'Mới ra trường hoặc chuyển ngành, có basic knowledge'
    },
    'Middle (1-3 năm)': {
        'min': 22_000_000,
        'max': 35_000_000,
        'avg': 28_000_000,
        'description': 'Đã làm được 2-3 projects AI, hiểu workflow'
    },
    'Senior (3-5 năm)': {
        'min': 35_000_000,
        'max': 55_000_000,
        'avg': 42_000_000,
        'description': 'Lead được team, design architecture'
    },
    'Lead/Expert (5+ năm)': {
        'min': 55_000_000,
        'max': 80_000_000,
        'avg': 65_000_000,
        'description': 'Research, tư vấn chiến lược AI cho công ty'
    }
}

# Ví dụ tính lương net
def calculate_net_salary(gross_salary):
    """
    Tính lương net từ gross (trước thuế)
    BHXH: 10.5%, BHYT: 1.5%, BHTN: 1%, Thuế TNCN: ~10-15%
    """
    social_insurance = gross_salary * 0.105
    health_insurance = gross_salary * 0.015
    unemployment_insurance = gross_salary * 0.01
    
    taxable_income = gross_salary - social_insurance - health_insurance - unemployment_insurance - 11_000_000
    
    if taxable_income <= 0:
        tax = 0
    elif taxable_income <= 5_000_000:
        tax = taxable_income * 0.05
    elif taxable_income <= 10_000_000:
        tax = taxable_income * 0.10 - 250_000
    else:
        tax = taxable_income * 0.15 - 750_000
    
    net_salary = gross_salary - social_insurance - health_insurance - unemployment_insurance - tax
    
    return round(net_salary)

# Test case
print(f"Gross: 35 triệu → Net: {calculate_net_salary(35_000_000):,} VNĐ")
# Output: Gross: 35 triệu → Net: 27,587,500 VNĐ

# Task 1: Load và preprocess ảnh
import os
from PIL import Image
import numpy as np

def load_images_from_folder(folder_path, target_size=(224, 224)):
    """
    Load tất cả ảnh từ folder, resize về cùng size
    """
    images = []
    labels = []
    
    # Giả sử folder có cấu trúc: /dogs/img1.jpg, /cats/img2.jpg
    for category in os.listdir(folder_path):
        category_path = os.path.join(folder_path, category)
        
        if not os.path.isdir(category_path):
            continue
            
        for img_name in os.listdir(category_path):
            try:
                img_path = os.path.join(category_path, img_name)
                img = Image.open(img_path)
                img = img.resize(target_size)
                img_array = np.array(img) / 255.0  # Normalize về 0-1
                
                images.append(img_array)
                labels.append(1 if category == 'dogs' else 0)
            except Exception as e:
                print(f"Error loading {img_name}: {e}")
    
    return np.array(images), np.array(labels)

# Task 2: Data augmentation để tăng dataset
from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.2
)

# Tạo thêm 5x dữ liệu
# Trong thực tế ở Đà Nẵng, nhiều công ty làm OCR cho văn bản tiếng Việt
# hoặc phân tích ảnh sản phẩm cho e-commerce

import numpy as np
import matplotlib.pyplot as plt

class LinearRegressionFromScratch:
    """
    Implement Linear Regression bằng Gradient Descent
    Đây là câu hỏi interview phổ biến tại các công ty Đà Nẵng
    """
    def __init__(self, learning_rate=0.01, n_iterations=1000):
        self.lr = learning_rate
        self.n_iter = n_iterations
        self.weights = None
        self.bias = None
        self.loss_history = []
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        
        # Initialize parameters
        self.weights = np.zeros(n_features)
        self.bias = 0
        
        # Gradient Descent
        for i in range(self.n_iter):
            # Forward pass: y_pred = X * w + b
            y_pred = np.dot(X, self.weights) + self.bias
            
            # Calculate loss (MSE)
            loss = np.mean((y_pred - y) ** 2)
            self.loss_history.append(loss)
            
            # Backward pass: Calculate gradients
            dw = (2 / n_samples) * np.dot(X.T, (y_pred - y))
            db = (2 / n_samples) * np.sum(y_pred - y)
            
            # Update parameters
            self.weights -= self.lr * dw
            self.bias -= self.lr * db
            
            if i % 100 == 0:
                print(f"Iteration {i}: Loss = {loss:.4f}")
    
    def predict(self, X):
        return np.dot(X, self.weights) + self.bias

# Test với dữ liệu giả lập giá nhà ở Đà Nẵng
# Features: diện tích (m2), số phòng, khoảng cách đến biển (km)
X_train = np.array([
    [50, 2, 5],   # 50m2, 2 phòng, cách biển 5km
    [70, 3, 3],
    [100, 4, 1],
    [45, 1, 7],
    [120, 5, 0.5]
])

y_train = np.array([1.5, 2.3, 4.5, 1.2, 6.0])  # Giá tỷ VNĐ

model = LinearRegressionFromScratch(learning_rate=0.001, n_iterations=1000)
model.fit(X_train, y_train)

# Dự đoán giá căn hộ 80m2, 3 phòng, cách biển 2km
X_test = np.array([[80, 3, 2]])
predicted_price = model.predict(X_test)
print(f"\nDự đoán giá: {predicted_price[0]:.2f} tỷ VNĐ")

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

# Dataset thực tế: Câu hỏi khách hàng về menu, giờ mở cửa, địa chỉ
class ChatbotDataset(Dataset):
    def __init__(self, questions, intents):
        """
        questions: List câu hỏi tiếng Việt
        intents: List nhãn (menu, hours, location, booking)
        """
        self.questions = questions
        self.intents = intents
        self.vocab = self._build_vocab()
        
    def _build_vocab(self):
        # Tokenize tiếng Việt đơn giản (thực tế dùng underthesea)
        vocab = {'<PAD>': 0, '<UNK>': 1}
        idx = 2
        for question in self.questions:
            for word in question.lower().split():
                if word not in vocab:
                    vocab[word] = idx
                    idx += 1
        return vocab
    
    def __len__(self):
        return len(self.questions)
    
    def __getitem__(self, idx):
        question = self.questions[idx]
        intent = self.intents[idx]
        
        # Convert text to indices
        tokens = [self.vocab.get(word, self.vocab['<UNK>']) 
                  for word in question.lower().split()]
        
        return torch.tensor(tokens), intent

# Simple LSTM model
class IntentClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_classes):
        super(IntentClassifier, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, num_classes)
        
    def forward(self, x):
        embedded = self.embedding(x)
        lstm_out, (hidden, _) = self.lstm(embedded)
        # Lấy hidden state của timestep cuối
        output = self.fc(hidden[-1])
        return output

# Training loop
def train_chatbot(model, train_loader, epochs=50, lr=0.001):
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=lr)
    
    for epoch in range(epochs):
        total_loss = 0
        correct = 0
        total = 0
        
        for questions, intents in train_loader:
            optimizer.zero_grad()
            
            outputs = model(questions)
            loss = criterion(outputs, intents)
            
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
            
            _, predicted = torch.max(outputs.data, 1)
            total += intents.size(0)
            correct += (predicted == intents).sum().item()
        
        if epoch % 10 == 0:
            acc = 100 * correct / total
            print(f'Epoch {epoch}: Loss={total_loss:.4f}, Accuracy={acc:.2f}%')

# Data mẫu từ một quán cafe thực tế tại Đà Nẵng
sample_questions = [
    "Menu có những gì",
    "Giá cà phê sữa bao nhiêu",
    "Quán mở cửa lúc mấy giờ",
    "Địa chỉ ở đâu",
    "Làm sao để đặt bàn",
    "Có món ăn vặt không",
    "Giờ đóng cửa là mấy giờ",
    "Quán ở đường nào"
]

sample_intents = [0, 0, 1, 2, 3, 0, 1, 2]  # 0:menu, 1:hours, 2:location, 3:booking

# Initialize model
vocab_size = 1000  # Giả sử
model = IntentClassifier(vocab_size=vocab_size, embedding_dim=128, 
                         hidden_dim=256, num_classes=4)

print(f"Model có {sum(p.numel() for p in model.parameters())} parameters")

import torch
import torchvision
from torchvision import transforms
from PIL import Image

# Sử dụng pretrained model (transfer learning)
class LicensePlateDetector:
    """
    Detect và đọc biển số xe Việt Nam
    Use case: Bãi đỗ xe tại các tòa nhà, TTTM ở Đà Nẵng
    """
    def __init__(self):
        # Load pretrained YOLOv5 (object detection)
        self.detector = torch.hub.load('ultralytics/yolov5', 'yolov5s', 
                                        pretrained=True)
        
        # Load OCR model (có thể dùng EasyOCR hoặc PaddleOCR)
        # Ở đây demo đơn giản
        self.ocr_model = None  # Trong thực tế cần train riêng
        
    def detect_plate(self, image_path):
        """
        Detect vị trí biển số trong ảnh
        """
        img = Image.open(image_path)
        results = self.detector(img)
        
        # Filter chỉ lấy license plate
        plates = []
        for *box, conf, cls in results.xyxy[0]:
            if cls == 'license_plate':  # Giả sử đã train model nhận biết
                x1, y1, x2, y2 = map(int, box)
                plate_img = img.crop((x1, y1, x2, y2))
                plates.append(plate_img)
        
        return plates
    
    def read_plate(self, plate_image):
        """
        OCR để đọc ký tự trên biển số
        Format biển số Đà Nẵng: 43A-123.45 hoặc 43B-456.78
        """
        # Preprocess
        transform = transforms.Compose([
            transforms.Resize((64, 256)),
            transforms.ToTensor(),
        ])
        
        img_tensor = transform(plate_image)
        
        # OCR (simplified, thực tế cần model phức tạp hơn)
        # Trả về string: "43A-12345"
        plate_number = "43A-12345"  # Mock data
        
        return plate_number
    
    def process_entry(self, image_path, parking_lot_db):
        """
        Full workflow: xe vào bãi
        """
        plates = self.detect_plate(image_path)
        
        if len(plates) == 0:
            return {"success": False, "message": "Không phát hiện biển số"}
        
        plate_number = self.read_plate(plates[0])
        
        # Lưu vào database
        entry_time = torch.datetime.now()
        parking_lot_db[plate_number] = {
            'entry_time': entry_time,
            'fee': 0
        }
        
        return {
            "success": True,
            "plate": plate_number,
            "entry_time": entry_time
        }

# Demo
detector = LicensePlateDetector()
# result = detector.process_entry("car_image.jpg", parking_db)

# File: train.py
import mlflow
import mlflow.pytorch

def train_with_mlflow():
    """
    Train model và track với MLflow
    Đây là kỹ năng bắt buộc tại các công ty product
    """
    mlflow.set_experiment("danang-chatbot")
    
    with mlflow.start_run():
        # Log parameters
        mlflow.log_param("learning_rate", 0.001)
        mlflow.log_param("epochs", 50)
        mlflow.log_param("batch_size", 32)
        
        # Train model (code ở trên)
        # model = train_chatbot(...)
        
        # Log metrics
        mlflow.log_metric("train_accuracy", 0.95)
        mlflow.log_metric("val_accuracy", 0.92)
        
        # Log model
        mlflow.pytorch.log_model(model, "model")
        
        # Log artifacts (biểu đồ, confusion matrix)
        # plt.savefig("confusion_matrix.png")
        # mlflow.log_artifact("confusion_matrix.png")

# File: deploy.py
from fastapi import FastAPI, File, UploadFile
import torch

app = FastAPI()

# Load model
model = torch.load("model.pth")
model.eval()

@app.post("/predict")
async def predict(file: UploadFile = File(...)):
    """
    API endpoint để predict
    Deploy lên Railway hoặc AWS với Docker
    """
    # Read image
    contents = await file.read()
    image = Image.open(BytesIO(contents))
    
    # Preprocess và predict
    # result = model.predict(image)
    
    return {"prediction": "result"}

# Dockerfile
"""
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "deploy:app", "--host", "0.0.0.0", "--port", "8000"]
"""

Week 1-2: Python cơ bản (if/else, loop, function, OOP)
Week 3-4: NumPy, Pandas
Week 5-6: Math (Linear Algebra, Calculus cơ bản)
Week 7-8: Matplotlib, data visualization

Project: Phân tích dữ liệu bán hàng của một quán cafe Đà Nẵng

Week 1-2: Scikit-learn (Linear Regression, Logistic Regression)
Week 3-4: Decision Tree, Random Forest
Week 5-6: SVM, K-means clustering  
Week 7-8: Model evaluation, hyperparameter tuning

Project: Dự đoán giá nhà tại Đà Nẵng (dataset từ batdongsan.com.vn)

Week 1-2: Neural Network cơ bản
Week 3-4: PyTorch fundamentals
Week 5-6: CNN cho Computer Vision
Week 7-8: RNN/LSTM cho NLP

Project: Chatbot tiếng Việt hoặc phân loại ảnh sản phẩm

# Overfitting: Model học quá fit với training data, không generalize tốt

# Cách fix:
# 1. Regularization (L1, L2)
model = nn.Linear(100, 10)
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.01) # L2

# 2. Dropout
class ModelWithDropout(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(100, 50)
        self.dropout = nn.Dropout(0.5)
        self.fc2 = nn.Linear(50, 10)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout(x)  # Randomly drop 50% neurons
        return self.fc2(x)

# 3. Early stopping
best_val_loss = float('inf')
patience = 5
counter = 0

for epoch in range(100):
    # Train...
    val_loss = validate(model, val_loader)
    
    if val_loss < best_val_loss:
        best_val_loss = val_loss
        torch.save(model.state_dict(), 'best_model.pth')
        counter = 0
    else:
        counter += 1
        if counter >= patience:
            print("Early stopping!")
            break

class BatchNorm1d:
    """
    Câu hỏi interview thực tế tại FPT Software
    """
    def __init__(self, num_features, eps=1e-5, momentum=0.1):
        self.eps = eps
        self.momentum = momentum
        self.running_mean = np.zeros(num_features)
        self.running_var = np.ones(num_features)
        
    def forward(self, x, training=True):
        if training:
            mean = np.mean(x, axis=0)
            var = np.var(x, axis=0)
            
            # Update running statistics
            self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * mean
            self.running_var = (1 - self.momentum) * self.running_var + self.momentum * var
        else:
            mean = self.running_mean
            var = self.running_var
        
        # Normalize
        x_norm = (x - mean) / np.sqrt(var + self.eps)
        return x_norm