AI 助理
备案控制台
开发者社区 人工智能 文章 正文

五子棋简易AI算法1

2023-10-30 335
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 基本思想设置不同连接方式的权值并进行存储

一、基本思想：五子棋存在多种连接方式，这也就决定了每一个空位的权值有所不同，我们对五子棋的不同连接方式设置权值，然后遍历棋盘，算出每一个空位上的权值，选择权值最大的空位下棋，所以这个算法的关键就在于：1.设置并且存储不同连接方式及其对应的权值 2.计算棋盘空位上的权值。

二、设置不同连接方式的权值并进行存储

棋子的连接分为活连与死连，假设0代表空位，1代表黑棋，2代表白旗，如010为活连，01（遇到边界）为死连为不同连接方式设置对应权值：

假设0代表空位，1代表黑棋，2代表白旗

权值表（还可以细分）

连接方式 权值 010 50 0110 150 01110 500 011110 3000 020 50 0220 150 02220 500 022220 3000 01 30 011 90 0111 300 01111 3000 02 30 022 90 0222 300 02222 3000

设置好权值表后，就要考虑如何存储权值表，因为权值表中的数据是用来后续计算空位总权值所需的。这里我们考虑用哈希表进行存储“连接方式——权值”这样子的键值对

Key-Value ： 键值对

HashMap：

将键值对一起存入 ，可以通过键来查询对应的值

将连子情况作为Key ，权值分作为Value

1: 键不能重复，值可以重复

2： HashMap 存储优势是 查询时是O1的时间复杂度

3： HashMap 存储原理：

1： 用key来计算一个hash值 (当作唯一标识)，hash值然后作为下标 ，然后将k-v存储在数组中对应下标位置
操作：

实例化： HashMap codeMap = new HashMap();
方法： code.put(key,value);/ value = code.get(key);

static HashMap codeMap = new HashMap<> ();
static int[][] codeArrray = new int[16][16]; //创建用来存储权值的二维数组

// 静态代码块
static{
    codeMap.put ("010", 50);
    codeMap.put ("0110", 150);
    codeMap.put ("01110", 500);
    codeMap.put ("011110", 3000);

    codeMap.put ("020", 50);
    codeMap.put ("0220", 150);
    codeMap.put ("02220", 500);
    codeMap.put ("022220", 3000);

    codeMap.put ("01", 30);
    codeMap.put ("011", 90);
    codeMap.put ("0111", 300);
    codeMap.put ("01111", 3000);

    codeMap.put ("02", 30);
    codeMap.put ("022", 90);
    codeMap.put ("0222", 300);
    codeMap.put ("02222", 3000);

    Integer integer = codeMap.get ("010");
    System.out.println (integer);

三、遍历表格计算权值

如图一个五子棋盘：image.png
尝试计算a、b两个空位处的权值大小，我们可以发现空位处的连接可以往上、下、左、右、左上、右上、左下、右下一共8个方向进行搜索，同时我们再规定一个空位的权值由八个方向的连接带来的权值简单相加得到（规则不唯一）。

对于a，往左的连接为01，权值30；往下的连接为01，权值30；往右下的连接010，权值50，故a处的权值为30+30+50=110

对于b，往左的连接为022，权值90；往上的连接为01，权值30；往左上的连接为011，权值90，故b处的权值为90+30+90=210

有了上面的举例，下面通过遍历计算每一个空位的权值

private static void getCodeArray(int[][] arr){

    for(int i = 0; i < arr.length; i++){
        for(int j = 0; j < arr[i].length; j++){
            int chessNum = arr[i][j];
            // 遍历所有的空格
            if(chessNum == 0){
                toRight (i, j, arr);    //往右走的权值
                toLeft(i,j,arr);
                toUp(i,j,arr);
                toDown(i,j,arr);
                toLeftUp(i,j,arr);  //往左上走的权值
                toRightup(i,j,arr);
                toLeftDown(i,j,arr);
                toRightDown(i,j,arr);
            }
        }
    }

上面的代码中往8个方向计算权值，但是方法还未定义，下面以往右和往左上为例

往右：

private static void toRight(int i, int j, int[][] chessArray){
    // 等于0
    int chessNum = chessArray[i][j];
    // 右边是0/墙 return
    if(j + 1 >= chessArray[i].length || chessArray[i][j + 1] == 0){
        return;
    }
    // 右边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i][j + 1];
    String codeStr = "" + chessNum + chessNumR1;
    // 右边第二颗 0/与第一颗相同的/不同的/墙
    for(int m = j + 2; m < chessArray[i].length; m++){
        int chessNumRn = chessArray[i][m];
        if(chessNumRn != 0){
            if(chessNumR1 == chessNumRn){
                // 找到相同的就拼接一个棋子标识
                codeStr += chessNumR1;
            } else if(chessNumR1 != chessNumRn){
                // 找到不相同的就结束循环
                break;
            }
        } else{
            // 活连的结尾 就结束循环
            codeStr += "0";
            break;
        }

    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;

}

往左上：

private static void toLeftUp(int i, int j, int[][] chessArray) {
// 等于0
int chessNum = chessArray[i][j];
// 左上边是0/墙 return
if(i - 1 <= -1||j - 1<= -1|| chessArray[i - 1][j - 1] == 0){
return;
}
// 左上边第一个颗是1/2 记录下来
int chessNumR1 = chessArray[i - 1][j - 1];
String codeStr = "" + chessNum + chessNumR1;
// 左上边第二颗 0/与第一颗相同的/不同的/墙
for(int k = i - 2; k > -1; k--) {
for (int m = j - 2; m > -1; m--) {
int chessNumRn = chessArray[k][m];
if (chessNumRn != 0) {
if (chessNumR1 == chessNumRn) {
// 找到相同的就拼接一个棋子标识
codeStr += chessNumR1;
} else if (chessNumR1 != chessNumRn) {
// 找到不相同的就结束循环
break;
}
} else {
// 活连的结尾 就结束循环
codeStr += "0";
break;
}

        }
    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;
}

这里无论是往哪个方向，计算出来的权值都需要累加到codeArray对应位置，codeArray是已经定义的存储权值的二维数组

完整代码：

package com.zsj0929;
import java.util.HashMap;

public class AI {// 会在类使用的时候初始化
static HashMap codeMap = new HashMap<> ();
static int[][] codeArrray = new int[16][16];

// 静态代码块
static{
    codeMap.put ("010", 50);
    codeMap.put ("0110", 150);
    codeMap.put ("01110", 500);
    codeMap.put ("011110", 3000);

    codeMap.put ("020", 50);
    codeMap.put ("0220", 150);
    codeMap.put ("02220", 500);
    codeMap.put ("022220", 3000);

    codeMap.put ("01", 30);
    codeMap.put ("011", 90);
    codeMap.put ("0111", 300);
    codeMap.put ("01111", 3000);

    codeMap.put ("02", 30);
    codeMap.put ("022", 90);
    codeMap.put ("0222", 300);
    codeMap.put ("02222", 3000);

    Integer integer = codeMap.get ("010");
    System.out.println (integer);
}

public static void main(String[] args){
    int[][] arr = {
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
            {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    };
    // 遍历计算所有可以下棋的地方的权值
    getCodeArray (arr);
    // 获取矩阵中权值最大的位置

    for(int i = 0; i < codeArrray.length; i++){
        for(int j = 0; j < codeArrray[i].length; j++){
            System.out.print (codeArrray[i][j] + "     ");
        }
        System.out.println ();
    }
}

private static void getCodeArray(int[][] arr){

    for(int i = 0; i < arr.length; i++){
        for(int j = 0; j < arr[i].length; j++){
            int chessNum = arr[i][j];
            // 遍历所有的空格
            if(chessNum == 0){
                toRight (i, j, arr);    //往右走的权值
                toLeft(i,j,arr);
                toUp(i,j,arr);
                toDown(i,j,arr);
                toLeftUp(i,j,arr);  //往左上走的权值
                toRightup(i,j,arr);
                toLeftDown(i,j,arr);
                toRightDown(i,j,arr);
            }
        }
    }

}

private static void toRightDown(int i, int j, int[][] chessArray) {
    // 等于0
    int chessNum = chessArray[i][j];
    // 右下边是0/墙 return
    if(i + 1 >= chessArray.length||j + 1>=chessArray.length || chessArray[i + 1][j + 1] == 0){
        return;
    }
    // 右下边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i + 1][j + 1];
    String codeStr = "" + chessNum + chessNumR1;
    // 右下边第二颗 0/与第一颗相同的/不同的/墙
    for(int k = i + 2; k < chessArray.length; k++) {
        for (int m = j + 2; m < chessArray[i].length; m++) {
            int chessNumRn = chessArray[k][m];
            if (chessNumRn != 0) {
                if (chessNumR1 == chessNumRn) {
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if (chessNumR1 != chessNumRn) {
                    // 找到不相同的就结束循环
                    break;
                }
            } else {
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;
}

private static void toLeftDown(int i, int j, int[][] chessArray) {
    // 等于0
    int chessNum = chessArray[i][j];
    // 左下边是0/墙 return
    if(i + 1 >= chessArray.length||j - 1 <= -1 || chessArray[i + 1][j - 1] == 0){
        return;
    }
    // 左下边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i + 1][j - 1];
    String codeStr = "" + chessNum + chessNumR1;
    // 左下边第二颗 0/与第一颗相同的/不同的/墙
    for(int k = i + 2; k < chessArray.length; k++) {
        for (int m = j - 2; m >= -1; m--) {
            int chessNumRn = chessArray[k][m];
            if (chessNumRn != 0) {
                if (chessNumR1 == chessNumRn) {
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if (chessNumR1 != chessNumRn) {
                    // 找到不相同的就结束循环
                    break;
                }
            } else {
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;
}

private static void toRightup(int i, int j, int[][] chessArray) {
    // 等于0
    int chessNum = chessArray[i][j];
    // 右上边是0/墙 return
    if(i - 1 <= -1||j + 1>=chessArray.length || chessArray[i - 1][j + 1] == 0){
        return;
    }
    // 右上边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i - 1][j + 1];
    String codeStr = "" + chessNum + chessNumR1;
    // 右上边第二颗 0/与第一颗相同的/不同的/墙
    for(int k = i - 2; k > -1; k--) {
        for (int m = j + 2; m < chessArray[i].length; m++) {
            int chessNumRn = chessArray[k][m];
            if (chessNumRn != 0) {
                if (chessNumR1 == chessNumRn) {
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if (chessNumR1 != chessNumRn) {
                    // 找到不相同的就结束循环
                    break;
                }
            } else {
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;
}

private static void toLeftUp(int i, int j, int[][] chessArray) {
    // 等于0
    int chessNum = chessArray[i][j];
    // 左上边是0/墙 return
    if(i - 1 <= -1||j - 1<= -1|| chessArray[i - 1][j - 1] == 0){
        return;
    }
    // 左上边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i - 1][j - 1];
    String codeStr = "" + chessNum + chessNumR1;
    // 左上边第二颗 0/与第一颗相同的/不同的/墙
    for(int k = i - 2; k > -1; k--) {
        for (int m = j - 2; m > -1; m--) {
            int chessNumRn = chessArray[k][m];
            if (chessNumRn != 0) {
                if (chessNumR1 == chessNumRn) {
                    // 找到相同的就拼接一个棋子标识
                    codeStr += chessNumR1;
                } else if (chessNumR1 != chessNumRn) {
                    // 找到不相同的就结束循环
                    break;
                }
            } else {
                // 活连的结尾 就结束循环
                codeStr += "0";
                break;
            }

        }
    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;
}

private static void toDown(int i, int j, int[][] chessArray) {
    // 等于0
    int chessNum = chessArray[i][j];
    // 下边是0/墙 return
    if(i + 1 >= chessArray.length || chessArray[i + 1][j] == 0){
        return;
    }
    // 下边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i + 1][j];
    String codeStr = "" + chessNum + chessNumR1;
    // 下边第二颗 0/与第一颗相同的/不同的/墙
    for(int k = i + 2; k < chessArray.length; k++){
        int chessNumRn = chessArray[k][j];
        if(chessNumRn != 0){
            if(chessNumR1 == chessNumRn){
                // 找到相同的就拼接一个棋子标识
                codeStr += chessNumR1;
            } else if(chessNumR1 != chessNumRn){
                // 找到不相同的就结束循环
                break;
            }
        } else{
            // 活连的结尾 就结束循环
            codeStr += "0";
            break;
        }

    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;

}

private static void toUp(int i, int j, int[][] chessArray) {
    // 等于0
    int chessNum = chessArray[i][j];
    // 上边是0/墙 return
    if(i - 1 <= -1 || chessArray[i - 1][j] == 0){
        return;
    }
    // 上边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i - 1][j];
    String codeStr = "" + chessNum + chessNumR1;
    // 上边第二颗 0/与第一颗相同的/不同的/墙
    for(int k = i - 2; k > -1; k--){
        int chessNumRn = chessArray[k][j];
        if(chessNumRn != 0){
            if(chessNumR1 == chessNumRn){
                // 找到相同的就拼接一个棋子标识
                codeStr += chessNumR1;
            } else if(chessNumR1 != chessNumRn){
                // 找到不相同的就结束循环
                break;
            }
        } else{
            // 活连的结尾 就结束循环
            codeStr += "0";
            break;
        }

    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;
}

private static void toLeft(int i, int j, int[][] chessArray) {
    // 等于0
    int chessNum = chessArray[i][j];
    // 左边是0/墙 return
    if(j - 1 <= -1 || chessArray[i][j - 1] == 0){
        return;
    }
    // 左边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i][j - 1];
    String codeStr = "" + chessNum + chessNumR1;
    // 左边第二颗 0/与第一颗相同的/不同的/墙
    for(int m = j - 2; m > -1; m--){
        int chessNumRn = chessArray[i][m];
        if(chessNumRn != 0){
            if(chessNumR1 == chessNumRn){
                // 找到相同的就拼接一个棋子标识
                codeStr += chessNumR1;
            } else if(chessNumR1 != chessNumRn){
                // 找到不相同的就结束循环
                break;
            }
        } else{
            // 活连的结尾 就结束循环
            codeStr += "0";
            break;
        }

    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;
}

private static void toRight(int i, int j, int[][] chessArray){
    // 等于0
    int chessNum = chessArray[i][j];
    // 右边是0/墙 return
    if(j + 1 >= chessArray[i].length || chessArray[i][j + 1] == 0){
        return;
    }
    // 右边第一个颗是1/2 记录下来
    int chessNumR1 = chessArray[i][j + 1];
    String codeStr = "" + chessNum + chessNumR1;
    // 右边第二颗 0/与第一颗相同的/不同的/墙
    for(int m = j + 2; m < chessArray[i].length; m++){
        int chessNumRn = chessArray[i][m];
        if(chessNumRn != 0){
            if(chessNumR1 == chessNumRn){
                // 找到相同的就拼接一个棋子标识
                codeStr += chessNumR1;
            } else if(chessNumR1 != chessNumRn){
                // 找到不相同的就结束循环
                break;
            }
        } else{
            // 活连的结尾 就结束循环
            codeStr += "0";
            break;
        }

    }
    Integer codeValue = codeMap.get (codeStr);
    if(codeValue == null){
        return;
    }
    // 将权值分存入 一个 新的权值二维数组
    codeArrray[i][j] += codeValue;

}
文章标签：
存储
人工智能
算法
关键词：
算法ai
AI算法
AI五子棋
五子棋AI
五子棋算法
妍妍阿里云
目录
相关文章
daiziteng-27425
|
2月前
|
传感器 人工智能 监控
智慧工地 AI 算法方案
智慧工地AI算法方案通过集成多种AI算法，实现对工地现场的全方位安全监控、精准质量检测和智能进度管理。该方案涵盖平台层、展现层与应用层、基础层，利用AI技术提升工地管理的效率和安全性，减少人工巡检成本，提高施工质量和进度管理的准确性。方案具备算法精准高效、系统集成度高、可扩展性强和成本效益显著等优势，适用于人员安全管理、施工质量监控和施工进度管理等多个场景。
daiziteng-27425
77 0
蚝油菜花
|
20天前
|
机器学习/深度学习 人工智能 算法
Enhance-A-Video：上海 AI Lab 推出视频生成质量增强算法，显著提升 AI 视频生成的真实度和细节表现
Enhance-A-Video 是由上海人工智能实验室、新加坡国立大学和德克萨斯大学奥斯汀分校联合推出的视频生成质量增强算法，能够显著提升视频的对比度、清晰度和细节真实性。
蚝油菜花
65 8
Enhance-A-Video：上海 AI Lab 推出视频生成质量增强算法，显著提升 AI 视频生成的真实度和细节表现
阿里云开发者
|
3天前
|
机器学习/深度学习 存储 人工智能
淘天算法工程师玩转《黑神话》，多模态大模型如何成为天命AI
淘天集团未来生活实验室的算法工程师们以ARPG游戏《黑神话：悟空》为平台，探索多模态大模型（VLM）在仅需纯视觉输入和复杂动作输出场景中的能力边界。他们提出了一种名为VARP的新框架，该框架由动作规划系统和人类引导的轨迹系统组成，成功在90%的简单和中等难度战斗场景中取得胜利。研究展示了VLMs在传统上由强化学习主导的任务中的潜力，并提供了宝贵的人类操作数据集，为未来研究奠定了基础。
阿里云开发者
27 6
ZOMI酱
|
1月前
|
机器学习/深度学习 缓存 人工智能
【AI系统】QNNPack 算法
QNNPACK是Marat Dukhan开发的量化神经网络计算加速库，专为移动端优化，性能卓越。本文介绍QNNPACK的实现，包括间接卷积算法、内存重排和间接缓冲区等关键技术，有效解决了传统Im2Col+GEMM方法存在的空间消耗大、缓存效率低等问题，显著提升了量化神经网络的计算效率。
ZOMI酱
43 6
【AI系统】QNNPack 算法
ZOMI酱
|
1月前
|
存储 人工智能 缓存
【AI系统】Im2Col 算法
Caffe 作为早期的 AI 框架，采用 Im2Col 方法优化卷积计算。Im2Col 将卷积操作转换为矩阵乘法，通过将输入数据重排为连续内存中的矩阵，减少内存访问次数，提高计算效率。该方法首先将输入图像转换为矩阵，然后利用 GEMM 库加速计算，最后将结果转换回原格式。这种方式显著提升了卷积计算的速度，尤其适用于通道数较多的卷积层。
ZOMI酱
56 5
【AI系统】Im2Col 算法
ZOMI酱
|
1月前
|
存储 机器学习/深度学习 人工智能
【AI系统】Winograd 算法
本文详细介绍Winograd优化算法，该算法通过增加加法操作来减少乘法操作，从而加速卷积计算。文章首先回顾Im2Col技术和空间组合优化，然后深入讲解Winograd算法原理及其在一维和二维卷积中的应用，最后讨论算法的局限性和实现步骤。Winograd算法在特定卷积参数下表现优异，但其应用范围受限。
ZOMI酱
45 2
【AI系统】Winograd 算法
六月的雨在钉钉
|
1月前
|
人工智能 算法
AI+脱口秀，笑点能靠算法创造吗
脱口秀是一种通过幽默诙谐的语言、夸张的表情与动作引发观众笑声的表演艺术。每位演员独具风格，内容涵盖个人情感、家庭琐事及社会热点。尽管我尝试用AI生成脱口秀段子，但AI缺乏真实的情感共鸣和即兴创作能力，生成的内容显得不够自然生动，难以触及人心深处的笑点。例如，AI生成的段子虽然流畅，却少了那份不期而遇的惊喜和激情，无法真正打动观众。 简介：脱口秀是通过幽默语言和夸张表演引发笑声的艺术形式，AI生成的段子虽流畅但缺乏情感共鸣和即兴创作力，难以达到真人表演的效果。
六月的雨在钉钉
101 5
ZOMI酱
|
1月前
|
存储 人工智能 缓存
【AI系统】布局转换原理与算法
数据布局转换技术通过优化内存中数据的排布，提升程序执行效率，特别是对于缓存性能的影响显著。本文介绍了数据在内存中的排布方式，包括内存对齐、大小端存储等概念，并详细探讨了张量数据在内存中的排布，如行优先与列优先排布，以及在深度学习中常见的NCHW与NHWC两种数据布局方式。这些布局方式的选择直接影响到程序的性能，尤其是在GPU和CPU上的表现。此外，还讨论了连续与非连续张量的概念及其对性能的影响。
ZOMI酱
68 3
ZOMI酱
|
1月前
|
机器学习/深度学习 人工智能 算法
【AI系统】内存分配算法
本文探讨了AI编译器前端优化中的内存分配问题，涵盖模型与硬件内存的发展、内存划分及其优化算法。文章首先分析了神经网络模型对NPU内存需求的增长趋势，随后详细介绍了静态与动态内存的概念及其实现方式，最后重点讨论了几种节省内存的算法，如空间换内存、计算换内存、模型压缩和内存复用等，旨在提高内存使用效率，减少碎片化，提升模型训练和推理的性能。
ZOMI酱
71 1
大淘宝技术
|
机器学习/深度学习 新零售 人工智能
让机器读懂视频：亿级淘宝视频背后的多模态AI算法揭秘
本文内容大纲： 1、多模态在视频分类算法中的应用探索 2、视频分类算法中的层次化分类器的设计 3、总结和展望
大淘宝技术
5103 0
让机器读懂视频：亿级淘宝视频背后的多模态AI算法揭秘

热门文章

最新文章

  • 1
    基于改进遗传优化的BP神经网络金融序列预测算法matlab仿真
  • 2
    局域网屏幕监控系统中的Python数据结构与算法实现
  • 3
    机器学习算法的优化与改进：提升模型性能的策略与方法
  • 4
    室内障碍物射线追踪算法matlab模拟仿真
  • 5
    排队算法的matlab仿真,带GUI界面
  • 6
    婚恋交友系统平台 相亲交友平台系统 婚恋交友系统APP 婚恋系统源码 婚恋交友平台开发流程 婚恋交友系统架构设计 婚恋交友系统前端/后端开发 婚恋交友系统匹配推荐算法优化
  • 7
    单目标问题的烟花优化算法求解matlab仿真,对比PSO和GA
  • 8
    员工上网行为监控中的Go语言算法：布隆过滤器的应用
  • 9
    强化学习之父Richard Sutton给出一个简单思路，大幅增强所有RL算法
  • 10
    调研180多篇论文，这篇综述终于把大模型做算法设计理清了
  • 1
    客户在哪儿AI的ToB获客服务和AI外呼机器人的有何不同
    145
  • 2
    生成式AI的未来发展方向
    103
  • 3
    客户在哪儿AI的企业全历史行为数据与企业信息查询平台上的数据有何区别
    75
  • 4
    打卡WAIC 2024！中兴的AI科技好牛
    42
  • 5
    ChaosMeta for AI：混沌工程让AI稳定性更上一层楼
    295
  • 6
    30% 代码由 AI 生成，单测准确率达到 90%，我在阿里巴巴国际站推广通义灵码
    7738
  • 7
    AI 时代程序员还“香”吗？别错过这场 OG & 跨界技术人的坦白局！
    182
  • 8
    智能家居：AI让生活更便捷
    178
  • 9
    探索软件测试的未来：AI与自动化的融合
    48
  • 10
    AI时代你一定要知道的Agent概念
    94

    • 相关课程

    更多
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • AI情绪鼓励师模型微调实操教学
  • 相册服务中的故事生成算法介绍
  • 跨越N次元 一键变身AI漫画人
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台

    • 相关实验场景

    更多
  • 体育赛事！零代码生成运动风格AI写真。
  • 【涂鸦即艺术】基于云应用开发平台CAP部署AI实时生图绘板
  • 使用容器计算服务 ACS 算力快速搭建生成式 AI 会话应用
  • SAE 极速部署专属 AI 证件照神器
  • 流水线运行出错排查难？AI帮你智能排查
  • 以电商场景为例搭建AI语义搜索应用
    • 下一篇
    阿里云开通OSS存储服务详细流程