经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » NumPy » 查看文章
从 Numpy+Pytorch 到 TensorFlow JS：总结和常用平替整理
来源：cnblogs　　作者：埠默笙声声声脉　　时间：2022/11/23 18:51:16　　对本文有异议

demo展示

这是一个剪刀石头布预测模型，会根据最近20局的历史数据训练模型，神经网络输入为最近2局的历史数据。

如何拥有较为平滑的移植体验？

一些碎碎念

  • JavaScript 不存在像 numpy 之于 python 一样著名且好用的数据处理库，所以请放弃对 JavaScript 原生类型 Array 进行操作的尝试，转而寻找基于 TensorFlow JS API 的解决方法。
  • JavaScript 作为一门前端语言，一大特色是包含了大量异步编程（即代码不是顺序执行的，浏览器自有一套标准去调整代码的执行顺序），这是为了保证前端页面不被卡死，所必备的性质。也因此，TensorFlow JS的函数中，许多输入输出传递的都不是数据，而是Promise对象。很多功能支持异步，但如果没有完全搞懂异步编程，不妨多用同步的思路：用 tf.Tensor.arraySync() 把 Tensor 的值取出，具体来说是将 Tensor 对象以同步的方式（即立即执行）拷贝生成出一个新的 array 对象。
  • Promise 对象是ES6新增的对象，一般与then一起使用，但掌握 async & await 就够了，这是更简洁的写法。
  • 多关注 API 文档中对象方法的返回类型，返回 Promise 对象则与异步编程相关，如果要获取Promise对象储存的值，需要在有 async function 包裹的代码中前置 await 关键字。
  • Pytorch 中的张量可以通过索引访问其元素，而 TensorFlow JS 则不能，需要转换为 array 进行访问。

常用平替整理

将张量转换为数组

  • Python, Pytorch：
  1. tensor = torch.tensor([1,2,3])
  2. np_array = tensor.numpy()
  • JS, tfjs：
  1. // 方式一：arraySync()
  2. let tensor = tf.tensor1d([1,2,3]);
  3. let array = tensor.arraySync();
  4. console.log(array); // [1,2,3]
  5.  
  6. // 方式二：在async函数体内操作
  7. async function fun() {
  8.     let tensor = tf.tensor1d([1,2,3]);
  9.     let array = await tensor.array();
  10.     console.log(array); // [1,2,3]
  11. }
  12. fun();
  14. // 注意，下面的写法是不行的，因为async函数的返回值是Promise对象
  15. array = async function (){
  16.     return await tensor.array();
  17. }();
  18. console.log(array); // Promise object
  19.  
  20. // 方式三：用then取出async函数返回Promise对象中的值
  21. let a
  22. (async function() {
  23.     let array = await tensor.array(); 
  24.     return array
  25. })().then(data => {a = data;})
  26. console.log(a); // [1,2,3]

访问张量中的元素

  • Python，Pytorch：
  1. tensor = torch.tensor([1,2,3])
  2. print(tensor[0])
  3. print(tensor[-1])
  • JS，tfjs（不能直接通过访问tensor，需要转换成array）：
  1. const tensor = tf.tensor1d([1,2,3]);
  2. const array = tensor.arraySync();
  3. console.log(array[0]);
    console.log(array[array.length - 1]);

获取字典/对象的关键字

  • Python：
  1. actions = {'up':[1,0,0,0], 'down':[0,1,0,0], 'left':[0,0,1,0], 'right':[0,0,0,1]}
  2. actions_keys_list = list(actions.keys())
  • JS：
  1. const actions = {'up':[1,0,0,0], 'down':[0,1,0,0], 'left':[0,0,1,0], 'right':[0,0,0,1]};
  2. const actionsKeysArray = Object.keys(actions);

“先进先出”栈

  • Python：
  1. memory = [1,2,3]
  2. memory.append(4) # 入栈
  3. memory.pop(0) # 出栈
  • JS：
  1. let memory = [1,2,3];
  2. memory.push(4); // 入栈
  3. memory.splice(0,1); // 出栈

“后进先出”栈

  • Python：
  1. memory = [1,2,3]
  2. memory.append(4) # 入栈
  3. memory.pop() # 出栈
  • JS：
  1. let memory = [1,2,3];
  2. memory.push(4); // 入栈
  3. memory.pop(); // 出栈

根据概率分布采样元素

  • Python，Numpy：
  1. actions = ['up','down','left','right']
  2. prob = [0.1, 0.4, 0.4, 0.1]
  3. sample_action = np.random.choice(actions, p=prob))
  • JS，tfjs：
  1. const actions = ['up', 'down', 'left', 'right'];
  2. const prob = [0.1, 0.4, 0.4, 0.1];
  3. sampleActionIndex = tf.multinomial(prob, 1, null, true).arraySync(); // tf.Tensor 不能作为索引，需要用 arraySync() 同步地传输为 array
  4. sampleAction = actions[sampleActionIndex];

找到数组中最大值的索引（Argmax）

  • Python，Numpy，Pyorch：
  1. actions = ['up', 'down', 'left', 'right']
  2. prob = [0.1, 0.3, 0.5, 0.1]
  3. prob_tensor = torch.tensor(prob)
  4. action_max_prob = actions[np.array(prob).argmax()] # np.array 可以作为索引
  5. action_max_prob = actions[prob_tensor.argmax().numpy()] # torch.tensor 不能作为索引，需要转换为 np.array
  • JS, tfjs：
  1. const actions = ['up', 'down', 'left', 'right'];
  2. const prob = [0.1, 0.3, 0.5, 0.1];
  3. const probTensor = tf.tensor1d(prob); 
  4. const actionsMaxProb = actions[probTensor.argmax().arraySync()]; // tf.Tensor 不能作为索引，需要用 arraySync()同步地传输为 array

生成等差数列数组

  • Python：
  1. range_list = list(range(1,10,1))
  • JS, tfjs：
  1. const rangeArray = tf.range(1, 10, 1).arraySync();

打乱数组

  • Python：
  1. actions = ['up', 'down', 'left', 'right']
  2. print(random.shuffle(actions))
  • tfjs：（1）用 tf.util 类操作，处理常规的需求。
  1. const actions = ['up', 'down', 'left', 'right'];
    tf.util.shuffle(actions);
    console.log(actions);

 （2）用 tf.data.shuffle 操作，不建议，该类及其方法一般仅与 神经网络模型更新 绑定使用。

 极简逻辑回归

  • Python，Numpy，Pytorch：
  1. import numpy as np
  2. import torch
  3. from torch import nn
  4. import random
  7. class Memory(object):
  8.     # 向Memory输送的数据可以是list，也可以是np.array
  9.     def __init__(self, size=100, batch_size=32):
  10.         self.memory_size = size
  11.         self.batch_size = batch_size
  12.         self.main = []
  13.         
  14.     def save(self, data):
  15.         if len(self.main) == self.memory_size:
  16.             self.main.pop(0)
  17.         self.main.append(data)
  19.     def sample(self):
  20.         samples = random.sample(self.main, self.batch_size)
  21.         return map(np.array, zip(*samples))
  22.     
  23.     
  24. class Model(object):
  25.     # Model中所有方法的输入和返回都是np.array
  26.     def __init__(self, lr=0.01, device=None):
  27.         self.LR = lr
  28.         self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # 调用GPU 若无则CPU
  29.         self.network = nn.Sequential(nn.Flatten(), 
  30.                                      nn.Linear(10, 32),
  31.                                      nn.ReLU(),
  32.                                      nn.Linear(32, 5),
  33.                                      nn.Softmax(dim=1)).to(self.device)
  34.         self.loss = nn.CrossEntropyLoss(reduction='mean')
  35.         self.optimizer =  torch.optim.Adam(self.network.parameters(), lr=self.LR)
  36.       
  37.     def predict_nograd(self, _input):
  38.         with torch.no_grad():
  39.             _input = np.expand_dims(_input, axis=0)
  40.             _input = torch.from_numpy(_input).float().to(self.device)
  41.             _output = self.network(_input).cpu().numpy()
  42.             _output = np.squeeze(_output)
  43.         return _output
  44.             
  45.     def update(self, input_batch, target_batch):
  46.         # 设置为训练模式
  47.         self.network.train()
  48.         _input_batch = torch.from_numpy(input_batch).float().to(self.device)
  49.         _target_batch = torch.from_numpy(target_batch).float().to(self.device)
  50.         
  51.         self.optimizer.zero_grad()
  52.         _evaluate_batch = self.network(_input_batch)
  53.         batch_loss = self.loss(_evaluate_batch, _target_batch)
  54.         batch_loss.backward()
  55.         self.optimizer.step()
  56.         batch_loss = batch_loss.item()
  57.         
  58.         # 设置为预测模式
  59.         self.network.eval()
  62. if __name__ == '__main__':
  63.     memory = Memory()
  64.     model = Model()
  65.     
  66.     # 产生数据并输送到内存中
  67.     # 假设一个5分类问题
  68.     for i in range(memory.memory_size):
  69.         example = np.random.randint(0,2,size=10)
  70.         label = np.eye(5)[np.random.randint(0,5)]
  71.         data = [example, label]
  72.         memory.save(data)
  73.     
  74.     # 训练100次，每次从内存中随机抽取一个batch的数据
  75.     for i in range(100):
  76.         input_batch, target_batch = memory.sample()
  77.         model.update(input_batch, target_batch)
  78.     
  79.     # 预测
  80.     prediction = model.predict_nograd(np.random.randint(0,2,size=10))
  81.     print(prediction)
  • JS，tfjs（网页应用一般不使用GPU）：
  1. const Memory = {
  2.     memorySize : 100,
  3.     main : [],
  5.     saveData : function (data) {
  6.         // data = [input:array, label:array]
  7.         if (this.main.length == this.memorySize) {
  8.             this.main.splice(0,1);
  9.         }
  10.         this.main.push(data);
  11.     },
  13.     getMemoryTensor: function () {
  14.         let inputArray = [],
  15.         labelArray = [];
  16.         for (let i = 0; i < this.main.length; i++) {
  17.             inputArray.push(this.main[i][0])
  18.             labelArray.push(this.main[i][1])
  19.         }
  20.         return {
  21.             inputBatch: tf.tensor2d(inputArray),
  22.             labelBatch: tf.tensor2d(labelArray)
  23.         }
  24.     }
  25. }
  27. const Model = {
  28.     batchSize: 32,
  29.     epoch: 200,
  30.     network: tf.sequential({
  31.         layers: [
  32.             tf.layers.dense({inputShape: [10], units: 16, activation: 'relu'}),
  33.             tf.layers.dense({units: 5, activation: 'softmax'}),
  34.         ]
  35.     }),
  36.     
  37.     compile: function () {
  38.         this.network.compile({
  39.             optimizer: tf.train.sgd(0.1),
  40.             shuffle: true,
  41.             loss: 'categoricalCrossentropy',
  42.             metrics: ['accuracy']
  43.         });
  44.     },
  46.     predict: function (input) {
  47.         // input = array
  48.         // Return tensor1d
  49.         return this.network.predict(tf.tensor2d([input])).squeeze();
  50.     },
  52.     update: async function (inputBatch, labelBatch) {
  53.         // inputBatch = tf.tensor2d(memorySize × 10)
  54.         // labelBatch = tf.tensor2d(memorySize × 5)
  55.         this.compile();
  57.         await this.network.fit(inputBatch, labelBatch, {
  58.             epochs: this.epoch,
  59.             batchSize: this.batchSize
  60.         }).then(info => {
  61.             console.log('Final accuracy', info.history.acc);
  62.         });
  63.     }
  64. }
  66. // 假设一个5分类问题
  67. // 随机生成样例和标签，并填满内存
  68. let example, label, rnd, data;
  69. for (let i = 0; i < Memory.memorySize; i++) {
  70.     example = tf.multinomial(tf.tensor1d([.5, .5]), 10).arraySync();
  71.     rnd = Math.floor(Math.random()*5);
  72.     label = tf.oneHot(tf.tensor1d([rnd], 'int32'), 5).squeeze().arraySync();
  73.     data = [example, label];
  74.     Memory.saveData(data);
  75. }
  77. // 将内存中储存的数据导出为tensor，并训练模型
  78. let {inputBatch, labelBatch} = Memory.getMemoryTensor();
  79. Model.update(inputBatch, labelBatch);

 

 

 

 

 

 

 

原文链接：https://www.cnblogs.com/wsy950409/p/16421861.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

NumPy热门文章

  • 报错No?module?named?numpy问题的解决办法
  • 详解Numpy中的数组拼接、合并操作（concatenate, append, stack, hstack, vstack, r_, c_等）
  • 基于Numpy.convolve使用Python实现滑动平均滤波的思路详解
  • numpy中np.dstack()、np.hstack()、np.vstack()用法
  • numpy linalg模块的具体使用方法
  • 从 Numpy+Pytorch 到 TensorFlow JS：总结和常用平替整理
  • 纯numpy数值微分法实现手写数字识别
  • numpy中计算相关系数的np.corrcoef
  • python numpy中cumsum的用法详解
  • numpy中的meshgrid函数的使用

    • NumPy推荐文章

  • 【大语言模型基础】60行Numpy教你实现GPT-原理与代码详解
  • 【技术积累】Python中的NumPy库【一】
  • 在树莓派上使用numpy实现简单的神经网络推理，pytorch在服务器或PC上训练好模型保存成numpy格式的数据，推理在树莓派上加载模型
  • 关于Python常用函数中NumPy的使用
  • Numpy&nbsp;数组索引的实现
  • 从 Numpy+Pytorch 到 TensorFlow JS：总结和常用平替整理
  • 纯numpy卷积神经网络实现手写数字识别的实践
  • 纯numpy数值微分法实现手写数字识别
  • python数学建模之Numpy?应用介绍与Pandas学习
  • python数学建模是加深Numpy和Pandas学习

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号