With the rise of GPT and advancements in AI, the big model field is rapidly growing. This article explores the different roles in big model engineering, including data, platform, algorithm, and deployment engineers, and provides insights into how backend developers can transition to this booming field.

With the explosive rise of GPT, the big model direction has recently been receiving more and more opportunities and developments. As a backend developer who has been working for a few years with CRUD, it feels like backend development is getting more competitive.

Hello, everyone, I’m Feiyu.

With the explosive rise of GPT, the big model direction has recently been receiving more and more opportunities and developments.

❝ Also, as a backend developer who has been working for a few years with CRUD, it feels like backend development is becoming more competitive.

This is not to encourage everyone to quickly switch to big models, but to first understand the new industry, the new opportunities, and better plan your future career development.

❝ Currently, there are still relatively few job openings for big model positions, and there have been many training programs for big models (most of them are just to profit from beginners, so don’t be deceived).

Currently, big model engineers have the following directions:

• Big Model Data Engineer:
  Data cleaning / ETL / Data Engine / Pipeline

• Big Model Platform Engineer:
  Distributed training / Big model clusters / Engineering infrastructure

• Big Model Algorithm Engineer:
  Search & recommendation / Chatbots / AIGC, etc.

• Big Model Deployment Engineer:
  Inference acceleration / Cross-platform / Edge intelligence / Embedded systems, etc.

Currently, for data engineers, especially experienced data engineers, there is a significant shortage.

❝ Pay more attention to data and accumulate experience in building high-quality training/testing datasets. Having a sense of data is the most direct and most suitable skill for future work.

For those who want to work in application development, it’s recommended to focus on a specific vertical field.

❝ For example, chatbots, Q&A systems, financial/medical/education fields, find a specific scenario and focus on perfecting it.

Daily Problem

Problem Description
❝ Given a binary tree, determine whether it is a balanced binary tree.

Solution Approach
❝ Recursion

Three points to note:

• The left subtree must be a balanced binary tree.

• The right subtree must be a balanced binary tree.

• The height difference between the left and right subtrees must not exceed 1.

Code Implementation

• Java Code:

class Solution {
    public boolean isBalanced(TreeNode root) {
        return depth(root) != -1;
    }

    public int depth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = depth(root.left);
        int right = depth(root.right);
        if (Math.abs(left - right) > 1 || left == -1 || right == -1) {
            return -1;
        }
        return Math.max(left, right) + 1;
    }
}

• Python Code:

class Solution:
    def isBalanced(self, root):
        return self.depth(root)!= -1

    def depth(self, root):
        if root is None:
            return 0
        left = self.depth(root.left)
        right = self.depth(root.right)
        if abs(left - right) > 1 or left == -1 or right == -1:
            return -1
        return max(left, right) + 1

• Go Code:

func (s *Solution) IsBalanced(root *TreeNode) bool {
    return s.Depth(root)!= -1
}

func (s *Solution) Depth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    left := s.Depth(root.Left)
    right := s.Depth(root.Right)
    if abs(left-right) > 1 || left == -1 || right == -1 {
        return -1
    }
    return max(left, right) + 1
}

func abs(a int) int {
    if a < 0 {
        return -a
    }
    return a
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

Complexity Analysis

• Time Complexity: O(n), where n is the number of nodes in the binary tree.

• Space Complexity: O(n). In the worst case, if the binary tree degenerates into a linked list, the recursion will need O(n) stack space.