java后端工程师+AI大模型开发进修ing（研一版‖day61）

import torch
import config
from src.dataset import get_dataloader
from src.model import InputMethodModel
from src.predict import predict_batch


def evaluate(model, test_dataloader, device):
    top1_acc_count = 0
    top5_acc_count = 0
    total_count = 0
    #模型进入到评估模式
    model.eval()
    #不进行梯度计算
    with torch.no_grad():
        for inputs, targets in test_dataloader:
            inputs, targets = inputs.to(device), targets.tolist()
            top5_indexes_list = predict_batch(model, inputs)
            for target, top5_index in zip(targets, top5_indexes_list):
                total_count += 1
                if target == top5_index[0]:
                    top1_acc_count += 1
                if target in top5_index:
                    top5_acc_count += 1
    return top1_acc_count / total_count, top5_acc_count / total_count


def run_evaluate():
    # 1. 确定设备
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    # 2.词表
    with open(config.MODELS_DIR / 'vocab.txt', 'r', encoding='utf-8') as f:
        vocab_list = [line.strip() for line in f.readlines()]
    word2index = {word: index for index, word in enumerate(vocab_list)}
    index2word = {index: word for index, word in enumerate(vocab_list)}

    # 3.模型
    model = InputMethodModel(vocab_size=len(vocab_list)).to(device)
    model.load_state_dict(torch.load(config.MODELS_DIR / 'model.pt'))
    #4,数据集
    test_dataloader = get_dataloader(train=False)

    #5评估逻辑
    top1_acc, top5_acc = evaluate(model, test_dataloader, device)
    print("评估结果")
    print(f"top1_acc: {top1_acc}")
    print(f"top5_acc: {top5_acc}")

if __name__ == '__main__':
    run_evaluate()

代码随想录

复原IP地址

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如："0.1.2.201" 和 "192.168.1.1" 是有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址 ，这些地址可以通过在 s 中插入 '.' 来形成。你不能重新排序或删除 s 中的任何数字。你可以按任何顺序返回答案。

示例 1：
复制代码
输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]
示例 2：
复制代码
输入：s = "0000"
输出：["0.0.0.0"]
示例 3：
复制代码
输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

java 复制代码

class Solution {
    List<String> result = new ArrayList<>();
    StringBuilder stringBuilder = new StringBuilder();
    private void back(String s, int ids, int number) {
        if(ids == s.length() && number == 4) {
            result.add(stringBuilder.toString());
            return;
        }
        if(ids == s.length() || number == 4) {
            return;
        }
        for(int i = ids; i < s.length() && i - ids < 3 && Integer.parseInt(s.substring(ids,i + 1)) >= 0 && Integer.parseInt(s.substring(ids,i + 1)) <= 255; i++) {
            if(i - ids > 0 && s.charAt(ids) - '0' == 0) {
                continue;
            }  
            stringBuilder.append(s.substring(ids,i + 1));
            if(number < 3)
            stringBuilder.append(".");
            back(s, i + 1, ++number);
            number--;
            stringBuilder.delete(ids + number, i + number + 2);
        }
    }

    public List<String> restoreIpAddresses(String s) {
        back(s,0,0);
        return result;
    }
}

子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：
复制代码
输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
复制代码
输入：nums = [0]
输出：[[],[0]]

java 复制代码

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new LinkedList<>();

    private void back(int[] nums, int ids) {
        result.add(new ArrayList(path));

        if(ids >= nums.length) {
            return;
        }
        for(int i = ids; i < nums.length; i++) {
            path.add(nums[i]);
            back(nums, i + 1);
            path.removeLast();
        }
    }

    public List<List<Integer>> subsets(int[] nums) {
        back(nums, 0);
        return result;
    }
}