nand utils Java 代码精简之道

发布时间 : 2025-04-04

作者 : 小编

访问数量 : 23

扫码分享至微信

Java 代码精简之道

作者 | 常意

来源 | 阿里巴巴中间件（ID：Aliware_2018）

古语有云：

道为术之灵，术为道之体；以道统术，以术得道。

其中：“道”指“规律、道理、理论”，“术”指“方法、技巧、技术”。意思是：“道”是“术”的灵魂，“术”是“道”的肉体；可以用“道”来统管“术”，也可以从“术”中获得“道”。

在拜读大佬“孤尽”的文章《Code Review是苦涩但有意思的修行》时，感受最深的一句话就是：“优质的代码一定是少即是多的精兵原则”，这就是大佬的代码精简之“道”。

工匠追求“术”到极致，其实就是在寻“道”，且离悟“道”也就不远了，亦或是已经得道，这就是“工匠精神”——一种追求“以术得道”的精神。如果一个工匠只满足于“术”，不能追求“术”到极致去悟“道”，那只是一个靠“术”养家糊口的工匠而已。作者根据多年来的实践探索，总结了大量的 Java 代码精简之“术”，试图阐述出心中的 Java 代码精简之“道”。

利用语法

1.1.利用三元表达式

普通：

String title;if (isMember(phone)) {title = "会员";} else {title = "游客";}

精简：

String title = isMember(phone) ? "会员" : "游客";

注意：对于包装类型的算术计算，需要注意避免拆包时的空指针问题。

1.2.利用 for-each 语句

从 Java 5 起，提供了 for-each 循环，简化了数组和集合的循环遍历。 for-each 循环允许你无需保持传统 for 循环中的索引就可以遍历数组，或在使用迭代器时无需在 while 循环中调用 hasNext 方法和 next 方法就可以遍历集合。

普通：

double values = ...;for(int i = 0; i < values.length; i++) {double value = values[i];// TODO: 处理value}List<Double> valueList = ...;Iterator<Double> iterator = valueList.iterator;while (iterator.hasNext) {Double value = iterator.next;// TODO: 处理value}

精简：

double values = ...;for(double value : values) {// TODO: 处理value}List<Double> valueList = ...;for(Double value : valueList) {// TODO: 处理value}

1.3.利用 try-with-resource 语句

所有实现 Closeable 接口的“资源”，均可采用 try-with-resource 进行简化。

普通：

BufferedReader reader = ;try {reader = new BufferedReader(new FileReader("cities.csv"));String line;while ((line = reader.readLine) != ) {// TODO: 处理line}} catch (IOException e) {log.error("读取文件异常", e);} finally {if (reader != ) {try {reader.close;} catch (IOException e) {log.error("关闭文件异常", e);}}}

精简：

try (BufferedReader reader = new BufferedReader(new FileReader("test.txt"))) {String line;while ((line = reader.readLine) != ) {// TODO: 处理line}} catch (IOException e) {log.error("读取文件异常", e);}

1.4.利用 return 关键字

利用 return 关键字，可以提前函数返回，避免定义中间变量。

普通：

public static boolean hasSuper(@Non List<UserDO> userList) {boolean hasSuper = false;for (UserDO user : userList) {if (Boolean.TRUE.equals(user.getIsSuper)) {hasSuper = true;break;}}return hasSuper;}

精简：

public static boolean hasSuper(@Non List<UserDO> userList) {for (UserDO user : userList) {if (Boolean.TRUE.equals(user.getIsSuper)) {return true;}}return false;}

1.5.利用 static 关键字

利用 static 关键字，可以把字段变成静态字段，也可以把函数变为静态函数，调用时就无需初始化类对象。

普通：

public final class GisHelper {public double distance(double lng1, double lat1, double lng2, double lat2) {// 方法实现代码}}GisHelper gisHelper = new GisHelper;double distance = gisHelper.distance(116.178692D, 39.967115D, 116.410778D, 39.899721D);

精简：

public final class GisHelper {public static double distance(double lng1, double lat1, double lng2, double lat2) {// 方法实现代码}}double distance = GisHelper.distance(116.178692D, 39.967115D, 116.410778D, 39.899721D);

1.6.利用 lambda 表达式

Java 8 发布以后，lambda 表达式大量替代匿名内部类的使用，在简化了代码的同时，更突出了原有匿名内部类中真正有用的那部分代码。

普通：

new Thread(new Runnable {public void run {// 线程处理代码}}).start;

精简：

new Thread( -> {// 线程处理代码}).start;

1.7.利用方法引用

方法引用（::），可以简化 lambda 表达式，省略变量声明和函数调用。

普通：

Arrays.sort(nameArray, (a, b) -> a.compareToIgnoreCase(b));List<Long> userIdList = userList.stream.map(user -> user.getId).collect(Collectors.toList);精简：

Arrays.sort(nameArray, String::compareToIgnoreCase);List<Long> userIdList = userList.stream.map(UserDO::getId).collect(Collectors.toList);

1.8.利用静态导入

静态导入（import static），当程序中大量使用同一静态常量和函数时，可以简化静态常量和函数的引用。

普通：

List<Double> areaList = radiusList.stream.map(r -> Math.PI * Math.pow(r, 2)).collect(Collectors.toList);...

精简：

import static java.lang.Math.PI;import static java.lang.Math.pow;import static java.util.stream.Collectors.toList;List<Double> areaList = radiusList.stream.map(r -> PI * pow(r, 2)).collect(toList);...

注意：静态引入容易造成代码阅读困难，所以在实际项目中应该警慎使用。

1.9.利用 unchecked 异常

Java 的异常分为两类：Checked 异常和 Unchecked 异常。Unchecked 异常继承了RuntimeException ，特点是代码不需要处理它们也能通过编译，所以它们称作 Unchecked 异常。利用 Unchecked 异常，可以避免不必要的 try-catch 和 throws 异常处理。

普通：

@Servicepublic class UserService {public void createUser(UserCreateVO create, OpUserVO user) throws BusinessException {checkOperatorUser(user);...}private void checkOperatorUser(OpUserVO user) throws BusinessException {if (!hasPermission(user)) {throw new BusinessException("用户无操作权限");}...}...}@RestController@RequestMapping("/user")public class UserController {@Autowiredprivate UserService userService;@PostMapping("/createUser")public Result<Void> createUser(@RequestBody @Valid UserCreateVO create, OpUserVO user) throws BusinessException {userService.createUser(create, user);return Result.success;}...}

精简：

@Servicepublic class UserService {public void createUser(UserCreateVO create, OpUserVO user) {checkOperatorUser(user);...}private void checkOperatorUser(OpUserVO user) {if (!hasPermission(user)) {throw new BusinessRuntimeException("用户无操作权限");}...}...}@RestController@RequestMapping("/user")public class UserController {@Autowiredprivate UserService userService;@PostMapping("/createUser")public Result<Void> createUser(@RequestBody @Valid UserCreateVO create, OpUserVO user) {userService.createUser(create, user);return Result.success;}...}

利用注解

2.1.利用 Lombok 注解

Lombok 提供了一组有用的注解，可以用来消除Java类中的大量样板代码。

普通：

public class UserVO {private Long id;private String name;public Long getId {return this.id;}public void setId(Long id) {this.id = id;}public String getName {return this.name;}public void setName(String name) {this.name = name;}...}

精简：

@Getter@Setter@ToStringpublic class UserVO {private Long id;private String name;...}

2.2.利用 Validation 注解

普通：

@Getter@Setter@ToStringpublic class UserCreateVO { @NotBlank(message = "用户名称不能为空")private String name;@Not(message = "公司标识不能为空")private Long companyId;...}@Service@Validatedpublic class UserService {public Long createUser(@Valid UserCreateVO create) {// TODO: 创建用户return ;}}

精简：

@Getter@Setter@ToStringpublic class UserCreateVO {@NotBlank(message = "用户名称不能为空")private String name;@Not(message = "公司标识不能为空")private Long companyId;...}@Service@Validatedpublic class UserService {public Long createUser(@Valid UserCreateVO create) {// TODO: 创建用户return ;}}

2.3.利用 @Non 注解

Spring 的 @Non 注解，用于标注参数或返回值非空，适用于项目内部团队协作。只要实现方和调用方遵循规范，可以避免不必要的空值判断，这充分体现了阿里的“新六脉神剑”提倡的“因为信任，所以简单”。

普通：

public List<UserVO> queryCompanyUser(Long companyId) {// 检查公司标识if (companyId == ) {return ;}// 查询返回用户List<UserDO> userList = userDAO.queryByCompanyId(companyId);return userList.stream.map(this::transUser).collect(Collectors.toList);}Long companyId = 1L;List<UserVO> userList = queryCompanyUser(companyId);if (CollectionUtils.isNotEmpty(userList)) {for (UserVO user : userList) {// TODO: 处理公司用户}}

精简：

public @Non List<UserVO> queryCompanyUser(@Non Long companyId) {List<UserDO> userList = userDAO.queryByCompanyId(companyId);return userList.stream.map(this::transUser).collect(Collectors.toList);}Long companyId = 1L;List<UserVO> userList = queryCompanyUser(companyId);for (UserVO user : userList) {// TODO: 处理公司用户}

2.4.利用注解特性

注解有以下特性可用于精简注解声明：

1、当注解属性值跟默认值一致时，可以删除该属性赋值；

2、当注解只有value属性时，可以去掉value进行简写；

3、当注解属性组合等于另一个特定注解时，直接采用该特定注解。

普通：

@Lazy(true);@Service(value = "userService")@RequestMapping(path = "/getUser", method = RequestMethod.GET)

精简：

@Lazy@Service("userService")@GetMapping("/getUser")

利用泛型

3.1.泛型接口

在 Java 没有引入泛型前，都是采用 Object 表示通用对象，最大的问题就是类型无法强校验并且需要强制类型转换。

普通：

public interface Comparable {public int compareTo(Object other);}@Getter@Setter@ToStringpublic class UserVO implements Comparable {private Long id;@Overridepublic int compareTo(Object other) {UserVO user = (UserVO)other;return Long.compare(this.id, user.id);}}

精简：

public interface Comparable<T> {public int compareTo(T other);}@Getter@Setter@ToStringpublic class UserVO implements Comparable<UserVO> {private Long id;@Overridepublic int compareTo(UserVO other) {return Long.compare(this.id, other.id);}}

3.2.泛型类

普通：

@Getter@Setter@ToStringpublic class IntPoint {private Integer x;private Integer y;}@Getter@Setter@ToStringpublic class DoublePoint {private Double x;private Double y;}

精简：

@Getter@Setter@ToStringpublic class Point<T extends Number> {private T x;private T y;}

3.3.泛型方法

普通：

public static Map<String, Integer> newHashMap(String[] keys, Integer[] values) {// 检查参数非空if (ArrayUtils.isEmpty(keys) || ArrayUtils.isEmpty(values)) {return Collections.emptyMap;}// 转化哈希映射Map<String, Integer> map = new HashMap<>;int length = Math.min(keys.length, values.length);for (int i = 0; i < length; i++) {map.put(keys[i], values[i]);}return map;}...

精简：

public static <K, V> Map<K, V> newHashMap(K[] keys, V[] values) {// 检查参数非空if (ArrayUtils.isEmpty(keys) || ArrayUtils.isEmpty(values)) {return Collections.emptyMap;}// 转化哈希映射Map<K, V> map = new HashMap<>;int length = Math.min(keys.length, values.length);for (int i = 0; i < length; i++) {map.put(keys[i], values[i]);}return map;}...

利用自身方法

4.1.利用构造方法

构造方法，可以简化对象的初始化和设置属性操作。对于属性字段较少的类，可以自定义构造方法。

普通：

@Getter@Setter@ToStringpublic class PageDataVO<T> {private Long totalCount;private List<T> dataList;}PageDataVO<UserVO> pageData = new PageDataVO<>;pageData.setTotalCount(totalCount);pageData.setDataList(userList);return pageData;...

精简：

@Getter@Setter@ToString@NoArgsConstructor@AllArgsConstructorpublic class PageDataVO<T> {private Long totalCount;private List<T> dataList;}return new PageDataVO<>(totalCount, userList);

注意：如果属性字段被替换时，存在构造函数初始化赋值问题。比如把属性字段title替换为 nickname ，由于构造函数的参数个数和类型不变，原有构造函数初始化语句不会报错，导致把原title值赋值给 nickname 。如果采用 Setter 方法赋值，编译器会提示错误并要求修复。

4.2.利用 Set 的 add 方法

利用 Set 的 add 方法的返回值，可以直接知道该值是否已经存在，可以避免调用 contains 方法判断存在。

普通：

以下案例是进行用户去重转化操作，需要先调用 contains 方法判断存在，后调用add方法进行添加。

Set<Long> userIdSet = new HashSet<>;List<UserVO> userVOList = new ArrayList<>;for (UserDO userDO : userDOList) {if (!userIdSet.contains(userDO.getId)) {userIdSet.add(userDO.getId);userVOList.add(transUser(userDO));}}

精简：

Set<Long> userIdSet = new HashSet<>;List<UserVO> userVOList = new ArrayList<>;for (UserDO userDO : userDOList) {if (userIdSet.add(userDO.getId)) {userVOList.add(transUser(userDO));}}

4.3.利用 Map 的 computeIfAbsent 方法

利用 Map 的 computeIfAbsent 方法，可以保证获取到的对象非空，从而避免了不必要的空判断和重新设置值。

普通：

Map<Long, List<UserDO>> roleUserMap = new HashMap<>;for (UserDO userDO : userDOList) {Long roleId = userDO.getRoleId;List<UserDO> userList = roleUserMap.get(roleId);if (Objects.is(userList)) {userList = new ArrayList<>;roleUserMap.put(roleId, userList);}userList.add(userDO);}

精简：

Map<Long, List<UserDO>> roleUserMap = new HashMap<>;for (UserDO userDO : userDOList) {roleUserMap.computeIfAbsent(userDO.getRoleId, key -> new ArrayList<>).add(userDO);}

4.4.利用链式编程

链式编程，也叫级联式编程，调用对象的函数时返回一个this对象指向对象本身，达到链式效果，可以级联调用。链式编程的优点是：编程性强、可读性强、代码简洁。

普通：

StringBuilder builder = new StringBuilder(96);builder.append("select id, name from ");builder.append(T_USER);builder.append(" where id = ");builder.append(userId);builder.append(";");

精简：

StringBuilder builder = new StringBuilder(96);builder.append("select id, name from ").append(T_USER).append(" where id = ").append(userId).append(";");

利用工具方法

5.1.避免空值判断

普通：

if (userList != && !userList.isEmpty) {// TODO: 处理代码}

精简：

if (CollectionUtils.isNotEmpty(userList)) {// TODO: 处理代码}

5.2.避免条件判断

普通：

double result;if (value <= MIN_LIMIT) {result = MIN_LIMIT;} else {result = value;}

精简：

double result = Math.max(MIN_LIMIT, value);

5.3.简化赋值语句

普通：

public static final List<String> ANIMAL_LIST;static {List<String> animalList = new ArrayList<>;animalList.add("dog");animalList.add("cat");animalList.add("tiger");ANIMAL_LIST = Collections.unmodifiableList(animalList);}

精简：

// JDK流派public static final List<String> ANIMAL_LIST = Arrays.asList("dog", "cat", "tiger");// Guava流派public static final List<String> ANIMAL_LIST = ImmutableList.of("dog", "cat", "tiger");

注意：Arrays.asList 返回的 List 并不是 ArrayList ，不支持 add 等变更操作。

5.4.简化数据拷贝

普通：

UserVO userVO = new UserVO;userVO.setId(userDO.getId);userVO.setName(userDO.getName);...userVO.setDescription(userDO.getDescription);userVOList.add(userVO);

精简：

UserVO userVO = new UserVO;BeanUtils.copyProperties(userDO, userVO);userVOList.add(userVO);

反例：

List<UserVO> userVOList = JSON.parseArray(JSON.toJSONString(userDOList), UserVO.class);

精简代码，但不能以过大的性能损失为代价。例子是浅层拷贝，用不着 JSON 这样重量级的武器。

5.5.简化异常断言

普通：

if (Objects.is(userId)) {throw new IllegalArgumentException("用户标识不能为空");}

精简：

Assert.not(userId, "用户标识不能为空");

注意：可能有些插件不认同这种判断，导致使用该对象时会有空指针警告。

5.6.简化测试用例

把测试用例数据以 JSON 格式存入文件中，通过 JSON 的 parseObject 和 parseArray 方法解析成对象。虽然执行效率上有所下降，但可以减少大量的赋值语句，从而精简了测试代码。

普通：

@Testpublic void testCreateUser {UserCreateVO userCreate = new UserCreateVO;userCreate.setName("Changyi");userCreate.setTitle("Developer");userCreate.setCompany("AMAP");...Long userId = userService.createUser(OPERATOR, userCreate);Assert.assertNot(userId, "创建用户失败");}精简：

@Testpublic void testCreateUser {String jsonText = ResourceHelper.getResourceAsString(getClass, "createUser.json");UserCreateVO userCreate = JSON.parseObject(jsonText, UserCreateVO.class);Long userId = userService.createUser(OPERATOR, userCreate);Assert.assertNot(userId, "创建用户失败");}

建议：JSON 文件名最好以被测试的方法命名，如果有多个版本可以用数字后缀表示。

5.7.简化算法实现

一些常规算法，已有现成的工具方法，我们就没有必要自己实现了。

普通：

int totalSize = valueList.size;List<List<Integer>> partitionList = new ArrayList<>;for (int i = 0; i < totalSize; i += PARTITION_SIZE) {partitionList.add(valueList.subList(i, Math.min(i + PARTITION_SIZE, totalSize)));}

精简：

List<List<Integer>> partitionList = ListUtils.partition(valueList, PARTITION_SIZE);

5.8.封装工具方法

一些特殊算法，没有现成的工具方法，我们就只好自己亲自实现了。

普通：

比如，SQL 设置参数值的方法就比较难用，setLong 方法不能设置参数值为。

// 设置参数值if (Objects.non(user.getId)) {statement.setLong(1, user.getId);} else {statement.set(1, Types.BIGINT);}...

精简：

我们可以封装为一个工具类 SqlHelper ，简化设置参数值的代码。

/** SQL辅助类 */public final class SqlHelper {/** 设置长整数值 */public static void setLong(PreparedStatement statement, int index, Long value) throws SQLException {if (Objects.non(value)) {statement.setLong(index, value.longValue);} else {statement.set(index, Types.BIGINT);}}...}// 设置参数值SqlHelper.setLong(statement, 1, user.getId);

利用数据结构

6.1.利用数组简化

对于固定上下限范围的 if-else 语句，可以用数组+循环来简化。

普通：

public static int getGrade(double score) {if (score >= 90.0D) {return 1;}if (score >= 80.0D) {return 2;}if (score >= 60.0D) {return 3;}if (score >= 30.0D) {return 4;}return 5;}

精简：

private static final double SCORE_RANGES = new double {90.0D, 80.0D, 60.0D, 30.0D};public static int getGrade(double score) {for (int i = 0; i < SCORE_RANGES.length; i++) {if (score >= SCORE_RANGES[i]) {return i + 1;}}return SCORE_RANGES.length + 1;}

思考：上面的案例返回值是递增的，所以用数组简化是没有问题的。但是，如果返回值不是递增的，能否用数组进行简化呢？答案是可以的，请自行思考解决。

6.2.利用 Map 简化

对于映射关系的 if-else 语句，可以用Map来简化。此外，此规则同样适用于简化映射关系的 switch 语句。

普通：

public static String getBiologyClass(String name) {switch (name) {case "dog" :return "animal";case "cat" :return "animal";case "lavender" :return "plant";...default :return ;}}

精简：

private static final Map<String, String> BIOLOGY_CLASS_MAP= ImmutableMap.<String, String>builder.put("dog", "animal").put("cat", "animal").put("lavender", "plant")....build;public static String getBiologyClass(String name) {return BIOLOGY_CLASS_MAP.get(name);}

已经把方法简化为一行代码，其实都没有封装方法的必要了。

6.3.利用容器类简化

Java 不像 Python 和 Go ，方法不支持返回多个对象。如果需要返回多个对象，就必须自定义类，或者利用容器类。常见的容器类有 Apache 的 Pair 类和 Triple 类， Pair 类支持返回 2 个对象， Triple 类支持返回 3 个对象。

普通：

@Setter@Getter@ToString@AllArgsConstructorpublic static class PointAndDistance {private Point point;private Double distance;}public static PointAndDistance getNearest(Point point, Point[] points) {// 计算最近点和距离...// 返回最近点和距离return new PointAndDistance(nearestPoint, nearestDistance);}

精简：

public static Pair<Point, Double> getNearest(Point point, Point[] points) {// 计算最近点和距离...// 返回最近点和距离return ImmutablePair.of(nearestPoint, nearestDistance);}

6.4.利用 ThreadLocal 简化

ThreadLocal 提供了线程专有对象，可以在整个线程生命周期中随时取用，极大地方便了一些逻辑的实现。用 ThreadLocal 保存线程上下文对象，可以避免不必要的参数传递。

普通：

由于 DateFormat 的 format 方法线程非安全（建议使用替代方法），在线程中频繁初始化 DateFormat 性能太低，如果考虑重用只能用参数传入 DateFormat 。例子如下：

public static String formatDate(Date date, DateFormat format) {return format.format(date);}public static List<String> getDateList(Date minDate, Date maxDate, DateFormat format) {List<String> dateList = new ArrayList<>;Calendar calendar = Calendar.getInstance;calendar.setTime(minDate);String currDate = formatDate(calendar.getTime, format);String maxsDate = formatDate(maxDate, format);while (currDate.compareTo(maxsDate) <= 0) {dateList.add(currDate);calendar.add(Calendar.DATE, 1);currDate = formatDate(calendar.getTime, format);}return dateList;}

精简：

可能你会觉得以下的代码量反而多了，如果调用工具方法的地方比较多，就可以省下一大堆 DateFormat 初始化和传入参数的代码。

private static final ThreadLocal<DateFormat> LOCAL_DATE_FORMAT = new ThreadLocal<DateFormat> {@Overrideprotected DateFormat initialValue {return new SimpleDateFormat("yyyyMMdd");}};public static String formatDate(Date date) {return LOCAL_DATE_FORMAT.get.format(date);}public static List<String> getDateList(Date minDate, Date maxDate) {List<String> dateList = new ArrayList<>;Calendar calendar = Calendar.getInstance;calendar.setTime(minDate);String currDate = formatDate(calendar.getTime);String maxsDate = formatDate(maxDate);while (currDate.compareTo(maxsDate) <= 0) {dateList.add(currDate);calendar.add(Calendar.DATE, 1);currDate = formatDate(calendar.getTime);}return dateList;}

注意：ThreadLocal 有一定的内存泄露的风险，尽量在业务代码结束前调用 remove 方法进行数据清除。

利用 Optional

在 Java 8 里，引入了一个 Optional 类，该类是一个可以为的容器对象。

7.1.保证值存在

普通：

Integer thisValue;if (Objects.non(value)) {thisValue = value;} else {thisValue = DEFAULT_VALUE;}

精简：

Integer thisValue = Optional.ofable(value).orElse(DEFAULT_VALUE);

7.2.保证值合法

普通：

Integer thisValue;if (Objects.non(value) && value.compareTo(MAX_VALUE) <= 0) {thisValue = value;} else {thisValue = MAX_VALUE;}

精简：

Integer thisValue = Optional.ofable(value).filter(tempValue -> tempValue.compareTo(MAX_VALUE) <= 0).orElse(MAX_VALUE);

7.3.避免空判断

普通：

String zipcode = ;if (Objects.non(user)) {Address address = user.getAddress;if (Objects.non(address)) {Country country = address.getCountry;if (Objects.non(country)) {zipcode = country.getZipcode;}}}

精简：

String zipcode = Optional.ofable(user).map(User::getAddress).map(Address::getCountry).map(Country::getZipcode).orElse;

利用 Stream

流（Stream）是Java 8的新成员，允许你以声明式处理数据集合，可以看成为一个遍历数据集的高级迭代器。流主要有三部分构成：获取一个数据源→数据转换→执行操作获取想要的结果。每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象，这就允许对其操作可以像链条一样排列，形成了一个管道。流（Stream）提供的功能非常有用，主要包括匹配、过滤、汇总、转化、分组、分组汇总等功能。

8.1.匹配集合数据

普通：

boolean isFound = false;for (UserDO user : userList) {if (Objects.equals(user.getId, userId)) {isFound = true;break;}}

精简：

boolean isFound = userList.stream.anyMatch(user -> Objects.equals(user.getId, userId));

8.2.过滤集合数据

普通：

List<UserDO> resultList = new ArrayList<>;for (UserDO user : userList) {if (Boolean.TRUE.equals(user.getIsSuper)) {resultList.add(user);}}

精简：

List<UserDO> resultList = userList.stream.filter(user -> Boolean.TRUE.equals(user.getIsSuper)).collect(Collectors.toList);

8.3.汇总集合数据

普通：

double total = 0.0D;for (Account account : accountList) {total += account.getBalance;}

精简：

double total = accountList.stream.mapToDouble(Account::getBalance).sum;

8.4.转化集合数据

普通：

List<UserVO> userVOList = new ArrayList<>;for (UserDO userDO : userDOList) {userVOList.add(transUser(userDO));}

精简：

List<UserVO> userVOList = userDOList.stream.map(this::transUser).collect(Collectors.toList);

8.5.分组集合数据

普通：

Map<Long, List<UserDO>> roleUserMap = new HashMap<>;for (UserDO userDO : userDOList) {roleUserMap.computeIfAbsent(userDO.getRoleId, key -> new ArrayList<>).add(userDO);}

精简：

Map<Long, List<UserDO>> roleUserMap = userDOList.stream.collect(Collectors.groupingBy(UserDO::getRoleId));

8.6.分组汇总集合

普通：

Map<Long, Double> roleTotalMap = new HashMap<>;for (Account account : accountList) {Long roleId = account.getRoleId;Double total = Optional.ofable(roleTotalMap.get(roleId)).orElse(0.0D);roleTotalMap.put(roleId, total + account.getBalance);}

精简：

roleTotalMap = accountList.stream.collect(Collectors.groupingBy(Account::getRoleId, Collectors.summingDouble(Account::getBalance)));

8.7.生成范围集合

Python 的 range 非常方便，Stream 也提供了类似的方法。

普通：

int array1 = new int[N];for (int i = 0; i < N; i++) {array1[i] = i + 1;}int array2 = new int[N];array2[0] = 1;for (int i = 1; i < N; i++) {array2[i] = array2[i - 1] * 2;}

精简：

int array1 = IntStream.rangeClosed(1, N).toArray;int array2 = IntStream.iterate(1, n -> n * 2).limit(N).toArray;

利用程序结构

9.1.返回条件表达式

条件表达式判断返回布尔值，条件表达式本身就是结果。

普通：

public boolean isSuper(Long userId)UserDO user = userDAO.get(userId);if (Objects.non(user) && Boolean.TRUE.equals(user.getIsSuper)) {return true;}return false;}

精简：

public boolean isSuper(Long userId)UserDO user = userDAO.get(userId);return Objects.non(user) && Boolean.TRUE.equals(user.getIsSuper);}

9.2.最小化条件作用域

最小化条件作用域，尽量提出公共处理代码。

普通：

Result result = summaryService.reportWorkDaily(workDaily);if (result.isSuccess) {String message = "上报工作日报成功";dingtalkService.sendMessage(user.getPhone, message);} else {String message = "上报工作日报失败:" + result.getMessage;log.warn(message);dingtalkService.sendMessage(user.getPhone, message);}

精简：

String message;Result result = summaryService.reportWorkDaily(workDaily);if (result.isSuccess) {message = "上报工作日报成功";} else {message = "上报工作日报失败:" + result.getMessage;log.warn(message);}dingtalkService.sendMessage(user.getPhone, message);

9.3.调整表达式位置

调整表达式位置，在逻辑不变的前提下，让代码变得更简洁。

普通1：

String line = readLine;while (Objects.non(line)) {... // 处理逻辑代码line = readLine;}

普通2：

for (String line = readLine; Objects.non(line); line = readLine) {... // 处理逻辑代码}

精简：

String line;while (Objects.non(line = readLine)) {... // 处理逻辑代码}

注意：有些规范可能不建议这种精简写法。

9.4.利用非空对象

在比较对象时，交换对象位置，利用非空对象，可以避免空指针判断。

普通：

private static final int MAX_VALUE = 1000;boolean isMax = (value != && value.equals(MAX_VALUE));boolean isTrue = (result != && result.equals(Boolean.TRUE));

精简：

private static final Integer MAX_VALUE = 1000;boolean isMax = MAX_VALUE.equals(value);boolean isTrue = Boolean.TRUE.equals(result);

利用设计模式

10.1.模板方法模式

模板方法模式（Template Method Pattern）定义一个固定的算法框架，而将算法的一些步骤放到子类中实现，使得子类可以在不改变算法框架的情况下重定义该算法的某些步骤。

普通：

@Repositorypublic class UserValue {/** 值操作 */@Resource(name = "stringRedisTemplate")private ValueOperations<String, String> valueOperations;/** 值模式 */private static final String KEY_FORMAT = "Value:User:%s";/** 设置值 */public void set(Long id, UserDO value) {String key = String.format(KEY_FORMAT, id);valueOperations.set(key, JSON.toJSONString(value));}/** 获取值 */public UserDO get(Long id) {String key = String.format(KEY_FORMAT, id);String value = valueOperations.get(key);return JSON.parseObject(value, UserDO.class);}...}@Repositorypublic class RoleValue {/** 值操作 */@Resource(name = "stringRedisTemplate")private ValueOperations<String, String> valueOperations;/** 值模式 */private static final String KEY_FORMAT = "Value:Role:%s";/** 设置值 */public void set(Long id, RoleDO value) {String key = String.format(KEY_FORMAT, id);valueOperations.set(key, JSON.toJSONString(value));}/** 获取值 */public RoleDO get(Long id) {String key = String.format(KEY_FORMAT, id);String value = valueOperations.get(key);return JSON.parseObject(value, RoleDO.class);}...}

精简：

public abstract class AbstractDynamicValue<I, V> {/** 值操作 */@Resource(name = "stringRedisTemplate")private ValueOperations<String, String> valueOperations;/** 设置值 */public void set(I id, V value) {valueOperations.set(getKey(id), JSON.toJSONString(value));}/** 获取值 */public V get(I id) {return JSON.parseObject(valueOperations.get(getKey(id)), getValueClass);}.../** 获取主键 */protected abstract String getKey(I id);/** 获取值类 */protected abstract Class<V> getValueClass;}@Repositorypublic class UserValue extends AbstractValue<Long, UserDO> {/** 获取主键 */@Overrideprotected String getKey(Long id) {return String.format("Value:User:%s", id);}/** 获取值类 */@Overrideprotected Class<UserDO> getValueClass {return UserDO.class;}}@Repositorypublic class RoleValue extends AbstractValue<Long, RoleDO> {/** 获取主键 */@Overrideprotected String getKey(Long id) {return String.format("Value:Role:%s", id);}/** 获取值类 */@Overrideprotected Class<RoleDO> getValueClass {return RoleDO.class;}}

10.2.建造者模式

建造者模式（Builder Pattern）将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

普通：

public interface DataHandler<T> {/** 解析数据 */public T parseData(Record record);/** 存储数据 */public boolean storeData(List<T> dataList);}public <T> long executeFetch(String tableName, int batchSize, DataHandler<T> dataHandler) throws Exception {// 构建下载会话DownloadSession session = buildSession(tableName);// 获取数据数量long recordCount = session.getRecordCount;if (recordCount == 0) {return 0;}// 进行数据读取long fetchCount = 0L;try (RecordReader reader = session.openRecordReader(0L, recordCount, true)) {// 依次读取数据Record record;List<T> dataList = new ArrayList<>(batchSize);while ((record = reader.read) != ) {// 解析添加数据T data = dataHandler.parseData(record);if (Objects.non(data)) {dataList.add(data);}// 批量存储数据if (dataList.size == batchSize) {boolean isContinue = dataHandler.storeData(dataList);fetchCount += batchSize;dataList.clear;if (!isContinue) {break;}}}// 存储剩余数据if (CollectionUtils.isNotEmpty(dataList)) {dataHandler.storeData(dataList);fetchCount += dataList.size;dataList.clear;}}// 返回获取数量return fetchCount;}// 使用案例long fetchCount = odpsService.executeFetch("user", 5000, new DataHandler {/** 解析数据 */@Overridepublic T parseData(Record record) {UserDO user = new UserDO;user.setId(record.getBigint("id"));user.setName(record.getString("name"));return user;}/** 存储数据 */@Overridepublic boolean storeData(List<T> dataList) {userDAO.batchInsert(dataList);return true;}});

精简：

public <T> long executeFetch(String tableName, int batchSize, Function<Record, T> dataParser, Function<List<T>, Boolean> dataStorage) throws Exception {// 构建下载会话DownloadSession session = buildSession(tableName);// 获取数据数量long recordCount = session.getRecordCount;if (recordCount == 0) {return 0;}// 进行数据读取long fetchCount = 0L;try (RecordReader reader = session.openRecordReader(0L, recordCount, true)) {// 依次读取数据Record record;List<T> dataList = new ArrayList<>(batchSize);while ((record = reader.read) != ) {// 解析添加数据T data = dataParser.apply(record);if (Objects.non(data)) {dataList.add(data);}// 批量存储数据if (dataList.size == batchSize) {Boolean isContinue = dataStorage.apply(dataList);fetchCount += batchSize;dataList.clear;if (!Boolean.TRUE.equals(isContinue)) {break;}}}// 存储剩余数据if (CollectionUtils.isNotEmpty(dataList)) {dataStorage.apply(dataList);fetchCount += dataList.size;dataList.clear;}}// 返回获取数量return fetchCount;}// 使用案例long fetchCount = odpsService.executeFetch("user", 5000, record -> {UserDO user = new UserDO;user.setId(record.getBigint("id"));user.setName(record.getString("name"));return user;}, dataList -> {userDAO.batchInsert(dataList);return true;});

普通的建造者模式，实现时需要定义 DataHandler 接口，调用时需要实现 DataHandler 匿名内部类，代码较多较繁琐。而精简后的建造者模式，充分利用了函数式编程，实现时无需定义接口，直接使用 Function 接口；调用时无需实现匿名内部类，直接采用 lambda 表达式，代码较少较简洁。

10.3.代理模式

Spring 中最重要的代理模式就是 AOP (Aspect-Oriented Programming，面向切面的编程)，是使用 JDK 动态代理和 CGLIB 动态代理技术来实现的。

普通：

@Slf4j@RestController@RequestMapping("/user")public class UserController {/** 用户服务 */@Autowiredprivate UserService userService;/** 查询用户 */@PostMapping("/queryUser")public Result<?> queryUser(@RequestBody @Valid UserQueryVO query) {try {PageDataVO<UserVO> pageData = userService.queryUser(query);return Result.success(pageData);} catch (Exception e) {log.error(e.getMessage, e);return Result.failure(e.getMessage);}}...}

精简1：

基于 @ControllerAdvice 的异常处理：

@RestController@RequestMapping("/user")public class UserController {/** 用户服务 */@Autowiredprivate UserService userService;/** 查询用户 */@PostMapping("/queryUser")public Result<PageDataVO<UserVO>> queryUser(@RequestBody @Valid UserQueryVO query) {PageDataVO<UserVO> pageData = userService.queryUser(query);return Result.success(pageData);}...}@Slf4j@ControllerAdvicepublic class GlobalControllerAdvice {/** 处理异常 */@ResponseBody@ExceptionHandler(Exception.class)public Result<Void> handleException(Exception e) {log.error(e.getMessage, e);return Result.failure(e.getMessage);}}

精简2：

基于 AOP 的异常处理：

// UserController代码同"精简1"@Slf4j@Aspectpublic class WebExceptionAspect {/** 点切面 */@Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")private void webPointcut {}/** 处理异常 */@AfterThrowing(pointcut = "webPointcut", throwing = "e")public void handleException(Exception e) {Result<Void> result = Result.failure(e.getMessage);writeContent(JSON.toJSONString(result));}...}

利用删除代码

“少即是多”，“少”不是空白而是精简，“多”不是拥挤而是完美。删除多余的代码，才能使代码更精简更完美。

11.1.删除已废弃的代码

删除项目中的已废弃的包、类、字段、方法、变量、常量、导入、注解、注释、已注释代码、Maven包导入、MyBatis的SQL语句、属性配置字段等，可以精简项目代码便于维护。

普通：

import lombok.extern.slf4j.Slf4j;@Slf4j@Servicepublic class ProductService {@Value("discardRate")private double discardRate;...private ProductVO transProductDO(ProductDO productDO) {ProductVO productVO = new ProductVO;BeanUtils.copyProperties(productDO, productVO);// productVO.setPrice(getDiscardPrice(productDO.getPrice));return productVO;}private BigDecimal getDiscardPrice(BigDecimal originalPrice) {...}}

精简：

@Servicepublic class ProductService {...private ProductVO transProductDO(ProductDO productDO) {ProductVO productVO = new ProductVO;BeanUtils.copyProperties(productDO, productVO);return productVO;}}

11.2.删除接口方法的public

对于接口(interface)，所有的字段和方法都是 public 的，可以不用显式声明为 public 。

普通：

public interface UserDAO {public Long countUser(@Param("query") UserQuery query);public List<UserDO> queryUser(@Param("query") UserQuery query);}

精简：

public interface UserDAO {Long countUser(@Param("query") UserQuery query);List<UserDO> queryUser(@Param("query") UserQuery query);}

11.3.删除枚举构造方法的 private

对于枚举(menu)，构造方法都是 private 的，可以不用显式声明为 private 。

普通：

public enum UserStatus {DISABLED(0, "禁用"),ENABLED(1, "启用");private final Integer value;private final String desc;private UserStatus(Integer value, String desc) {this.value = value;this.desc = desc;}...}

精简：

public enum UserStatus {DISABLED(0, "禁用"),ENABLED(1, "启用");private final Integer value;private final String desc;UserStatus(Integer value, String desc) {this.value = value;this.desc = desc;}...}

11.4.删除 final 类方法的 final

对于 final 类，不能被子类继承，所以其方法不会被覆盖，没有必要添加 final 修饰。

普通：

public final Rectangle implements Shape {...@Overridepublic final double getArea {return width * height;}}

精简：

public final Rectangle implements Shape {...@Overridepublic double getArea {return width * height;}}

11.5.删除基类 implements 的接口

如果基类已 implements 某接口，子类没有必要再 implements 该接口，只需要直接实现接口方法即可。

普通：

public interface Shape {...double getArea;}public abstract AbstractShape implements Shape {...}public final Rectangle extends AbstractShape implements Shape {...@Overridepublic double getArea {return width * height;}}

精简：

...public final Rectangle extends AbstractShape {...@Overridepublic double getArea {return width * height;}}

11.6.删除不必要的变量

不必要的变量，只会让代码看起来更繁琐。

普通：

public Boolean existsUser(Long userId) {Boolean exists = userDAO.exists(userId);return exists;}

精简：

public Boolean existsUser(Long userId) {return userDAO.exists(userId);}

后记

古语又云：

有道无术，术尚可求也；有术无道，止于术。

意思是：有“道”而无“术”，“术”还可以逐渐获得；有“术”而无“道”，就可能止步于“术”了。所以，我们不要仅满足于从实践中总结“术”，因为“道”的表现形式是多变的；而应该上升到“道”的高度，因为“术”背后的道理是相通的。当遇到新的事物时，我们可以从理论中找到“道”、从实践中找出“术”，尝试着去认知新的事物。

本文作者：陈昌毅，花名常意，地图技术专家。

☞一文浓缩 60 年，程序员不可不知的开源秘史！

☞CSDN总部落户长沙，共建中国开发者产业中心城市！

☞雷军喜提第四家上市公司，金山云上市首日暴涨 40%

☞CycleGan人脸转为漫画脸，牛掰的知识又增加了！| 附代码

☞触发死锁怎么办？MySQL 的死锁系列：锁的类型以及加锁原理了解一下！

☞带血的战士| 吴忌寒传

#AI分享# 一文浅谈Transforme性能优化的常见方法

前言

自 BERT 出现以来，NLP 领域已经进入了大模型的时代，大模型虽然效果好，但是毕竟不是人人都有着丰富的 GPU 资源，在训练时往往就捉襟见肘，出现显存 out of memory 的问题，或者训练时间非常非常的久，因此，这篇文章主要解决的问题就是如何在 GPU 资源受限的情况下训练 transformers 库上面的大模型。

这篇文章源自 @Vadim Irtlach 大佬在 Kaggle 的开源 notebook，感谢原作者的分享，本 NLP 小白觉得受益良多，因此搬运分享给大家，已取得作者授权，大部分内容是照搬翻译过来的，小部分内容结合自己的理解进行了补充和修改，不对的地方请大家批评指正。

尽管 Huggingface 开源的 Transformers 在自然语言处理（NLP）任务中取得了惊人的成功，但由于里面的模型参数数量庞大，即使是使用 GPU 进行训练或者部署，也仍具有非常大的挑战性，因为用如此大的模型进行训练或推理，会很容易发生显存不足（OOM）以及训练时间过长的问题。（这里想吐槽一句的是，kaggle 上面的 NLP 比赛现在动不动就用五折 debert-large-v3，没几块 V100 根本玩不起这种比赛，所以这篇文章对我这种只能用 colab 的 p100 来跑实验的穷学生来说真的是福音啊！）

然而，有很多方法可以避免显存不足以及训练时间过长的方法，这篇文章的主要贡献就是介绍了这些方法的原理以及如何实现，具体包括以下几种方法：

梯度累积（Gradient Accumulation）冻结（Freezing）自动混合精度（Automatic Mixed Precision）8位优化器（8-bit Optimizers）梯度检查点（Gradient Checkpointing）快速分词器（Fast Tokenizers）动态填充（Dynamic Padding）均匀动态填充（Uniform Dynamic Padding）

其中 1-5 是神经网络通用的方法，可以用在任何网络的性能优化上，6-8 是针对 NLP 领域的性能优化方法。

梯度累积

梯度累积背后的想法非常简单，就是为了模拟更大的批量（batch）。有时，为了更好地收敛或提高性能，需要使用大批量进行训练，但是，这通常需要更大的显存。这个问题的一种可能的解决方案是使用较小的批量，但是，一方面，小批量训练会增加训练和推理时间，另一方面，梯度下降算法对批量大小的选择非常敏感，小批量可能会导致不稳定的收敛和性能降低。

所以，我们可以先执行几次前向传播和反向传播，使得梯度进行累积，当我们有足够的计算梯度时，再对参数进行优化，从而利用小显存，模拟大批量的效果，并且训练时间也不会大幅增加。

代码实现

steps = len(loader)# perform validation loop each `validation_steps` training steps!validation_steps = int(validation_steps * gradient_accumulation_steps)for step, batch in enumerate(loader, 1):# prepare inputs and targets for the model and loss function respectively.# forward passoutputs = model(inputs)# computing lossloss = loss_fn(outputs, targets)# accumulating gradients over stepsif gradient_accumulation_steps > 1:loss = loss / gradient_accumulation_steps# backward passloss.backward()# perform optimization step after certain number of accumulating steps and at the end of epochif step % gradient_accumulation_steps == 0 or step == steps:torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm)optimizer.step()model.zero_grad()# perform validation loopif step % validation_steps == 0:validation_loop()

冻结

冻结是一种非常有效的方法，通过取消计算模型某些层中的梯度计算（如 embedding 层，bert 的前几层），可以大大加快训练速度并且降低了显存占用，而且几乎不会损失模型的性能。

深度学习中的一个众所周知的事实是，网络的底层学习输入数据的通用特征，而网络顶层学习目标任务特定的高级特征，所以在对预训练模型进行微调时，一般网络底层的参数都不怎么需要变，这些都是通用的知识，需要学习的是顶层的那些参数，当使用某种优化算法（如 SGD、AdamW 或 RMSprop）执行优化步骤时，网络的底层的梯度就都很小，因此参数几乎保持不变，这也被称为梯度消失，因此，与其花费大量的时间和算力来计算底层这些“无用”梯度，并对此类梯度很小的参数进行优化，不如直接冻结它们，直接不计算梯度也不进行优化。

PyTorch 为关闭梯度计算提供了一个舒适的 API，可以通过 torch.Tensor 的属性 requires_ grad 设置。

代码实现

def freeze(module):"""Freezes module's parameters."""for parameter in module.parameters():parameter.requires_grad = Falsedef get_freezed_parameters(module):"""Returns names of freezed parameters of the given module."""freezed_parameters = []for name, parameter in module.named_parameters():if not parameter.requires_grad:freezed_parameters.append(name)return freezed_parametersimport torchfrom transformers import AutoConfig, AutoModel# initializing modelmodel_path = "microsoft/deberta-v3-base"config = AutoConfig.from_pretrained(model_path)model = AutoModel.from_pretrained(model_path, config=config)# freezing embeddings and first 2 layers of encoderfreeze(model.embeddings)freeze(model.encoder.layer[:2])freezed_parameters = get_freezed_parameters(model)print(f"Freezed parameters: {freezed_parameters}")# selecting parameters, which requires gradients and initializing optimizermodel_parameters = filter(lambda parameter: parameter.requires_grad, model.parameters())optimizer = torch.optim.AdamW(params=model_parameters, lr=2e-5, weight_decay=0.0)

自动混合精度

自动混合精度（AMP）是另一种在不损失最终质量的情况下减少显存消耗和训练时间的方法，该方法由 NVIDIA 和百度研究人员在 2017 年的 “Mixed Precision Training” 论文中提出。该方法背后的关键思想是使用较低的精度将模型的梯度和参数保留在内存中，即不使用全精度（float32），而是使用半精度（例如 float16）将张量保存在内存中。然而，当以较低精度计算梯度时，某些值可能太小，以至于被视为零，这种现象被称为“溢出”。为了防止“溢出”，原始论文的作者提出了一种梯度缩放方法。

PyTorch从1.6 的版本开始提供了一个包：torch.cuda.amp，具有使用自动混合精度所需的功能（从降低精度到梯度缩放），自动混合精度作为上下文管理器实现，因此可以随时随地的插入到训练和推理脚本中。

代码实现

from torch.cuda.amp import autocast, GradScalerscaler = GradScaler()for step, batch in enumerate(loader, 1):# prepare inputs and targets for the model and loss function respectively.# forward pass with `autocast` context managerwith autocast(enabled=True):outputs = model(inputs)# computing lossloss = loss_fn(outputs, targets)# scale gradint and perform backward passscaler.scale(loss).backward()# before gradient clipping the optimizer parameters must be unscaled.scaler.unscale_(optimizer)# perform optimization steptorch.nn.utils.clip_grad_norm_(model.parameters(), max_norm)scaler.step(optimizer)scaler.update()

8-bit Optimizers

8-bit Optimizers 的思想类似于自动混合精度（模型的参数和梯度使用较低的精度保存），但 8-bit Optimizers 还让优化器的状态使用低精度保存。作者（Meta Research）在最初的论文 “8-bit Optimizers via Block-wise Quantization” 中详细介绍了 8-bit Optimizers，表明 8-bit Optimizers 显著降低了显存占用，略微加快了训练速度。

此外，作者研究了不同超参数设置的影响，表明 8-bit Optimizers 对不同的学习率、beta 和权重衰减参数的效果是稳定的，不会降低性能或影响收敛性。因此，作者为 8 位优化器提供了一个高级库，叫做 bitsandbytes。

代码实现

!pip install -q bitsandbytes-cuda110def set_embedding_parameters_bits(embeddings_path, optim_bits=32):"""https://github.com/huggingface/transformers/issues/14819#issuecomment-1003427930"""embedding_types = ("word", "position", "token_type")for embedding_type in embedding_types:attr_name = f"{embedding_type}_embeddings"if hasattr(embeddings_path, attr_name): bnb.optim.GlobalOptimManager.get_instance().register_module_override(getattr(embeddings_path, attr_name), 'weight', {'optim_bits': optim_bits})import bitsandbytes as bnb# selecting parameters, which requires gradientsmodel_parameters = filter(lambda parameter: parameter.requires_grad, model.parameters())# initializing optimizer bnb_optimizer = bnb.optim.AdamW(params=model_parameters, lr=2e-5, weight_decay=0.0, optim_bits=8)# bnb_optimizer = bnb.optim.AdamW8bit(params=model_parameters, lr=2e-5, weight_decay=0.0) # equivalent to the above line# setting embeddings parametersset_embedding_parameters_bits(embeddings_path=model.embeddings)print(f"8-bit Optimizer:\n\n{bnb_optimizer}")

梯度检查点

有时候，即使用了上面的几种方法，显存可能还是不够，尤其是在模型足够大的情况下。那么梯度检查点（Gradient Checkpointing）就是压箱底的招数了，这个方法第一次在 “Training Deep Nets With Sublinear Memory Cost”，作者表明梯度检查点可以显著降低显存利用率，从降低到，其中 n 是模型的层数。这种方法允许在单个 GPU 上训练大型模型，或者提供更多内存以增加批量大小，从而更好更快地收敛。

梯度检查点背后的思想是在小数据块中计算梯度，同时在正向和反向传播过程中从内存中移除不必要的梯度，从而降低内存利用率，但是这种方法需要更多的计算步骤来再现整个反向传播图，其实就是一种用时间来换空间的方法。

▲ 梯度检查点如何在正向和反向传播过程中工作

PyTorch框架里也有梯度检查点的实现，通过这两个函数：torch.utils.checkpoint.checkpoint和 torch.utils.checkpoint.checkpoint_sequential这边引用一段 torch 官网对梯度检查点的介绍。

梯度检查点通过用计算换取内存来工作。检查点部分不是存储整个计算图的所有中间激活以进行反向计算，而是不保存中间激活，而是在反向过程中重新计算它们。它可以应用于模型的任何部分。具体而言，在前向传播中，该函数将以 torch.no_grad() 的方式运行，即不存储中间激活。然而，前向传播保存了输入元组和函数参数。在反向传播时，检索保存的输入和函数，然后再次对函数进行前向传播，现在跟踪中间激活，然后使用这些激活值计算梯度。

此外，HuggingFace Transformers 也支持梯度检查点。梯度检查点可以通过 PreTrainedModel 实例的 gradient_checkpointing_enable 方法执行，一行代码直接搞定！

代码实现

from transformers import AutoConfig, AutoModel# https://github.com/huggingface/transformers/issues/9919from torch.utils.checkpoint import checkpoint# initializing modelmodel_path = "microsoft/deberta-v3-base"config = AutoConfig.from_pretrained(model_path)model = AutoModel.from_pretrained(model_path, config=config)# gradient checkpointingmodel.gradient_checkpointing_enable()print(f"Gradient Checkpointing: {model.is_gradient_checkpointing}")

快速分词器

HuggingFace Transformers 提供两种类型的分词器：基本分词器和快速分词器。它们之间的主要区别在于，快速分词器是在 Rust 上编写的，因为 Python 在循环中非常慢，但在分词的时候又要用到循环。快速分词器是一种非常简单的方法，允许我们在分词的时候获得额外的加速。要使用快速分词器也很简单，只要把 transformers.AutoTokenizer里面的 from_pretrained方法的 use_fast的值修改为 True 就可以了。

▲ 分词器是如何工作的

代码实现

from transformers import AutoTokenizer# initializing Base version of Tokenizermodel_path = "microsoft/deberta-v3-base"tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False)print(f"Base version Tokenizer:\n\n{tokenizer}", end="\n"*3)# initializing Fast version of Tokenizerfast_tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=True)print(f"Fast version Tokenizer:\n\n{fast_tokenizer}")

动态填充

通常来说，模型是用批量数据输入训练的，批中的每个输入必须具有固定大小，即一批量的数据必须是矩阵的表示，所有批量数据的尺寸都一样。固定尺寸通常是根据数据集中的长度分布、特征数量和其他因素来选择的。在 NLP 任务中，输入大小称为文本长度，或者最大长度（max length）。

然而，不同的文本具有不同的长度，为了处理这种情况，研究人员提出了填充标记和截断。当最大长度小于输入文本的长度时，会使用截断，因此会删除一些标记。当输入文本的长度小于最大长度时，会将填充标记，比如 [PAD]，添加到输入文本的末尾，值得注意的是，填充标记不应包含在某些任务的损失计算中（例如掩蔽语言建模或命名实体识别）

▲ 固定长度填充

然而，填充标记有明显的缺点。比如在输入文本相对于选定的最大长度非常短的情况下，效率就很低，需要更多的额外内存，比如我有一条文本长度 512，然后其他文本长度都在 10 左右，那么如果将 max seq 设置为 512，就会导致很多无效计算。

为了防止额外的计算操作，研究人员提出了一种非常有效的方法，就是将批量的输入填充到这一批量的最大输入长度，如下图所示，这种方法可以将训练速度提高 35% 甚至 50%，当然这种方法加速的效果取决于批量的大小以及文本长度的分布，批量越小，加速效果越明显，文本长度分布越不均，加速效果也越好。

▲ 动态填充

均匀动态填充

还有一种基于动态填充的方法，叫做均匀动态填充。其思想是在分 batch 时，先按文本的长度对文本进行排序，这样同一个 batch 里面的文本长度就都差不多。这种方法非常有效，在训练或推理期间的计算量都比动态填充要来的少。但是，不建议在训练期间使用均匀动态填充，因为训练时数据最好是要 shuffer 的，但是推理时如果一次性要推理很多文本的话可以考虑这么做

▲ 均匀动态填充

总结

即使在现代 GPU 上，优化内存和时间也是开发模型的必要步骤，因此，本文介绍了加速训练和减少 transformers 等大型模型内存消耗的最强大、最流行的方法。

参考文献

[1] Performance and Scalability: How To Fit a Bigger Model and Train It Faster

https://huggingface.co/docs/transformers/performance

[2] Speeding up Transformer w/ Optimization Strategies

https://www.kaggle.com/code/rhtsingh/speeding-up-transformer-w-optimization-strategies

[3] Things you can try to speed up training speed and preventing memory shortage if you are using transformers.

https://www.kaggle.com/competitions/AI4Code/discussion/327777

[4] 8-bit Adam and other memory optimizations

https://www.kaggle.com/competitions/feedback-prize-2021/discussion/303131

[5] Fitting larger networks into memory.

https://medium.com/tensorflow/fitting-larger-networks-into-memory-583e3c758ff9

Java 代码精简之道

利用语法

1.1.利用三元表达式

1.2.利用 for-each 语句

1.3.利用 try-with-resource 语句

1.4.利用 return 关键字

1.5.利用 static 关键字

1.6.利用 lambda 表达式

1.7.利用方法引用

1.8.利用静态导入

1.9.利用 unchecked 异常

利用注解

2.2.利用 Validation 注解

2.3.利用 @Non 注解

2.4.利用注解特性

利用泛型

3.2.泛型类

3.3.泛型方法

利用自身方法

4.2.利用 Set 的 add 方法

4.3.利用 Map 的 computeIfAbsent 方法

4.4.利用链式编程

利用工具方法

5.2.避免条件判断

5.3.简化赋值语句

5.4.简化数据拷贝

5.6.简化测试用例

5.7.简化算法实现

利用数据结构

6.2.利用 Map 简化

6.3.利用容器类简化

6.4.利用 ThreadLocal 简化

7.1.保证值存在

7.2.保证值合法

利用 Stream

8.1.匹配集合数据

8.5.分组集合数据

利用程序结构

9.1.返回条件表达式

9.3.调整表达式位置

9.4.利用非空对象

利用设计模式

10.2.建造者模式

10.3.代理模式

利用删除代码

11.1.删除已废弃的代码

11.2.删除接口方法的public

11.3.删除枚举构造方法的 private

11.4.删除 final 类方法的 final

11.5.删除基类 implements 的接口

11.6.删除不必要的变量

后记

#AI分享# 一文浅谈Transforme性能优化的常见方法

前言

梯度累积

代码实现

冻结

代码实现

自动混合精度

代码实现

8-bit Optimizers

代码实现

梯度检查点

▲ 梯度检查点如何在正向和反向传播过程中工作

PyTorch框架里也有梯度检查点的实现，通过这两个函数：torch.utils.checkpoint.checkpoint和 torch.utils.checkpoint.checkpoint_sequential这边引用一段 torch 官网对梯度检查点的介绍。

代码实现

快速分词器

代码实现

动态填充

均匀动态填充

关于我们

产品中心

服务与支持