## 简介

本文用于记录Java项目中使用Redis时，常见的一些操作，并封装为一个工具类。

工具类基于spring的redistemplate。



```java
package com.integration.api.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.TimeUnit;


/**
 * redis操作工具类
 */
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 批量删除对应的value
     *
     * @param keys redis keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern 正则
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key Redis Key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key Redis Key
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    public boolean existsPattern(final String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        return !CollectionUtils.isEmpty(keys);
    }

    /**
     * 读取缓存
     *
     * @param key Redis Key
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate
                .opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key   Redis Key
     * @param value Redis Value
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value, 2, TimeUnit.DAYS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key   Redis Key
     * @param value Redis Value
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return boolean true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key Redis Key
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key     Redis Key
     * @param dataMap Map集合
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key Redis Key
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }

}

```

Java常用的Redis工具类

一分钟教会你如何保存instagram上的图片

原博主：https://www.instagram.com/kimgapju/

![image](https://images.oldmoon.top/images/beauty/beauty1720670365.jpg)



![image](https://images.oldmoon.top/images/beauty/beauty1720670369.jpg)

![image](https://images.oldmoon.top/images/beauty/beauty1720670371.jpg)

20240711欣赏

下面是一段删除图片（文件）的代码，读取某个文件夹下所有的文件名，排序后，按照隔一张删除一个的策略进行批量删除：

```python
import os

# 设置文件夹路径
folder_path = '/path/to/your/folder'

# 获取所有文件名
file_names = os.listdir(folder_path)

# 按文件名排序
file_names.sort()

# 隔一张删除一个
for i in range(1, len(file_names), 2):
    file_path = os.path.join(folder_path, file_names[i])
    if os.path.isfile(file_path):
        os.remove(file_path)
        print(f'Deleted: {file_path}')

```

Python：批量删除本地图片

## Faceswap简介

`FaceSwap` 是一种基于深度学习技术的应用，用于将一个人的面部特征和表情替换到另一个人的脸上。该技术利用生成对抗网络（`GANs`）和自动编码器（`Autoencoders`）等深度学习模型，能够生成逼真且高质量的面部替换效果。

使用 `Faceswap` 的步骤一般分为四步，其中除了第一步外，都可以在Faceswap中完成：
1. 收集素材：原视频，目标人脸的视频/图片
2. 整理素材：将原人物和目标人物的面部图片汇总
3. 训练模型：基于素材训练人脸替换模型
4. 替换人脸：使用训练好的模型进行视频处理

其中 **训练模型** 这一步可以说是最关键、最重要、也是最耗时的，所以这一步的处理需要仔细学习，而在这一步中，最重要的配置应该就是训练模式的选择！



## 各个训练模式介绍(Trainer)

在 `FaceSwap` 项目中，训练模式（如 `dfaker、lae、dlight、original、unbalanced、villain` 等）是指不同的模型架构和训练方法。这些选项决定了模型如何处理数据、如何训练以及生成结果的质量和特性。

> 以下是基于 `NVIDIA RTX 3080/3090` 这类 `GPU` 给出的训练时长建议，请自行对比你的训练资源。

以下是这些模式的简要解释及其适用场景：

### dfaker
- **说明:** `Dfaker` 模式基于 `DeepFake` 概念进行实现，专注于生成高质量的面部替换效果。
- **特点:** 通常会在较长时间训练中生成更高质量和更真实的结果。
- **适用场景:** 当需要高质量的面部替换效果且有充足的训练时间时，适合使用此模式。
- **训练素材:** 高质量且多样的面部图像，最好是同一光照和角度条件下的图像。每个目标人物至少 `1000` 张以上的图片。
- **训练时长:** 长时间训练，推荐至少 `7` 天（`每个 epoch 训练约 1-2 小时，共 100-200 个 epoch`）。

### lae (Light Autoencoder)
- **说明:** `LAE` 是一种轻量级的自动编码器，设计用于快速训练和较低的计算需求。
- **特点:** 训练速度快，对硬件要求较低，但生成效果可能不如其他模式高质量。
- **适用场景:** 适用于硬件资源有限或需要快速生成结果的场景。
- **训练素材:** 中等质量的面部图像，`500-1000` 张图片。多样性可以稍微少一些，但尽量保证光照和角度的一致性。
- **训练时长:** 短时间训练，推荐 `1-3` 天（`每个 epoch 训练约 30 分钟，共 50-100 个 epoch`）。

### dlight
- **说明:** `Dlight` 是 `dfaker` 的简化版本，兼顾训练时间和结果质量。
- **特点:** 在减少训练时间的同时，尽量保持较好的生成效果。
- **适用场景:** 当需要在质量和训练时间之间找到平衡点时，可以选择此模式。
- **训练素材:** 高质量且多样的面部图像，`1000` 张以上的图片。保证图像的多样性，包括不同的表情和角度。
- **训练时长:** 中等时间训练，推荐 `3-5` 天（`每个 epoch 训练约 1 小时，共 100-150 个 epoch`）。

### original
- **说明:** `Original` 模式是最早的 `FaceSwap` 模型，使用经典的自动编码器结构。
- **特点:** 结构简单，易于理解和实现，但生成效果可能不如后来的改进模式。
- **适用场景:** 适合初学者或需要经典实现的场景。
- **训练素材:** 中等质量的面部图像，`500` 张以上的图片。图像的多样性少一些。
- **训练时长:** 中等时间训练，推荐 `2-4` 天（`每个 epoch 训练约 1 小时，共 50-100 个 epoch`）。

### unbalanced
- **说明:** `Unbalanced` 模式专注于不对称的训练，即生成器和判别器的训练速度和频率不同。
- **特点:** 可能在特定数据集上表现更好，但需要对模型进行更多调整。
- **适用场景:** 当数据集存在特定的特征或不均衡时，可以尝试此模式。
- **训练素材:** 高质量且多样的面部图像，`1000` 张以上的图片。尽量包括各种不同的表情和角度。
- **训练时长:** 较长时间训练，推荐 `5-7` 天（`每个 epoch 训练约 1-2 小时，共 100-200 个 epoch`）。

### villain
- **说明:** `Villain` 模式是对经典 `FaceSwap` 模型的进一步优化，通常包括一些先进的技术和调整。
- **特点:** 可能在较短的时间内生成更高质量的结果，但需要更多的计算资源。
- **适用场景:** 当有较好的硬件资源且需要高质量的生成效果时，可以选择此模式。
- **训练素材:** 高质量且多样的面部图像，`1000` 张以上的图片。包括各种不同的表情、光照和角度条件。
- **训练时长:** 长时间训练，推荐 `7-10` 天（`每个 epoch 训练约 1-2 小时，共 150-200 个 epoch`）。

### dfl-h128 (DeepFakeLab H128)
- **说明:** 基于 `DeepFakeLab` 的 `H128` 模型，使用 `128x128` 分辨率的图像进行训练。
- **特点:** 平衡了生成效果和训练时间，适合中等硬件资源。
- **适用场景:** 当需要较高质量的面部替换效果，但训练时间和硬件资源有限时，可以选择此模式。
- **训练素材:** 高质量的面部图像，`800-1000` 张图片。确保图像的多样性和清晰度。
- **训练时长:** 中等时间训练，推荐 `3-5` 天（`每个 epoch 训练约 1 小时，共 100-150 个 epoch`）。

### dfl-sae (DeepFakeLab SAE)
- **说明:** 基于 `DeepFakeLab` 的 `SAE` 模型（自编码器），通常用于更复杂的面部替换任务。
- **特点:** 支持更高的图像分辨率和更复杂的面部替换效果，但需要更多的训练时间和硬件资源。
- **适用场景:** 当有充足的训练时间和硬件资源，并且需要处理复杂的面部替换任务时，适合使用此模式。
- **训练素材:** 高质量的面部图像，`1000` 张以上的图片。多样性和清晰度要求较高。
- **训练时长:** 较长时间训练，推荐 `7-10` 天（`每个 epoch 训练约 1-2 小时，共 150-200 个 epoch`）。

### lightweight
- **说明:** `lightweight` 是轻量级模型，设计用于快速训练和较低的计算需求。
- **特点:** 训练速度快，对硬件要求较低，但生成效果可能不如其他模式高质量。
- **适用场景:** 适用于硬件资源有限或需要快速生成结果的场景。
- **训练素材:** 中等质量的面部图像，`300-500` 张图片。图像的多样性可以稍微少一些。
- **训练时长:** 短时间训练，推荐 `1-2` 天（`每个 epoch 训练约 30 分钟，共 50-100 个 epoch`）。

### phaze-a
- **说明:** `Phaze-A` 模型是一种改进的自动编码器，旨在提高生成效果和训练效率。
- **特点:** 在保持较高质量生成效果的同时，提高训练效率。
- **适用场景:** 当需要在较短的时间内获得高质量结果，可以选择此模式。
- **训练素材:** 高质量的面部图像，`1000` 张以上的图片。包括不同的表情和角度。
- **训练时长:** 中等时间训练，推荐 `4-6` 天（`每个 epoch 训练约 1 小时，共 100-150 个 epoch`）。

### realface
- **说明:** `RealFace` 模型专注于生成逼真的面部替换效果，通常结合先进的生成技术。
- **特点:** 生成效果逼真，但需要较多的训练时间和硬件资源。
- **适用场景:** 当需要高度逼真的面部替换效果，并且有充足的训练时间和硬件资源时，可以选择此模式。
- **训练素材:** 高质量且多样的面部图像，`1000` 张以上的图片。多样性和清晰度要求很高。
- **训练时长:** 长时间训练，推荐 `7-10` 天（`每个 epoch 训练约 1-2 小时，共 150-200 个 epoch`）。

## 总结

选择合适的 `FaceSwap` 模式需要根据具体的硬件资源、训练时间和生成效果要求进行权衡和调整。了解每种模式的特点和适用场景，有助于更有效地进行模型训练和生成高质量的结果。

考虑因素：
- 硬件资源: 如 GPU 的数量和性能，以及显存大小等。
- 训练时间: 可用的训练时间是几天、几周还是几个月。
- 生成效果: 对生成效果的要求是高质量还是快速结果。
- 数据集特性: 数据集是否均衡，是否有特定的特征等。

## 赞助请求V3

**建站因为热爱，生活需要Money，请屏幕前的大佬动动您发财的小手，点击一次以示鼓励，祝您生活愉快！**


<div class="article-ads"></div>

> PS：如果看不到广告，可能是网络原因或被拦截了，那就算了吧。再次祝您生活愉快~~ 🥰

Faceswap训练模式详解（trainer）

twitter:card

twitter:title

https://images.oldmoon.top/images/dingdangdog/oldmoon.png

twitter:image

努力做一只帅气、有才、豁达的老狗！

twitter:description