Javascript 基于JS节点的图像分类

我对NodeJs有点陌生。我一直在尝试制作一个API，它可以对图像进行分类，并在Json对象中给出结果。结果是使用NSFWJS进行分数预测

我的任务是，当我传递一个带有{key:value}对的JSON对象时，其中key是“code”，而value是用于获取url对象的代码列表，它应该解析每个图像并给出结果输出

*代码的基本流程*

输入：类似这样的Json对象：-*{'Codes'：['Code1'，'Code2'，'Code3']}*

从值循环到所有对象：

 1. parse through a function to store the image
 2. pas through the model to get the prediction
 3. Stored the resultant in a Json object 

返回最终的Json对象

这是我的实现代码：-

const express = require('express')
const multer = require('multer')
const jpeg = require('jpeg-js')
const tf = require('@tensorflow/tfjs-node')
const nsfw = require('nsfwjs')
const bodyParser=require("body-parser")
const axios = require('axios');
const cheerio = require('cheerio');
var fs = require('fs');
var http = require('http');
var request=require('request');
const app = express()
const upload = multer()


app.use(bodyParser.json()); 
let _model
let file_content;
let test_data;
function convertBuffer()
{
    return new Promise(function(resolve,reject)
        {
            try
            {
                file_content=fs.readFileSync('ans1.png');
                resolve(file_content);
            }
            catch
            {
                reject('Null String')
            }           
        })
}


app.post('/nsfw',async(req,res) =>{

    var arrayCodes=req.body.Codes;
    var jsonObj={};
    var i=0;
    var iterator=function(i){
        if(i>arrayCodes.length)
        {
            console.log("Testing",jsonObj);
            res.json(jsonObj);
            return;
        }
    }
    while(i<arrayCodes.length)
    {
        var imgUrl="http://url/to/image"+String(Codes[i])
        //getImageUrl(imgUrl);
        await axios.get(imgUrl)
            .then(response=>{
                var result=response.data;
                var resultJson=result.facets.Media.productImage.url;
                var localPath="ans1.png"
                var fullUrl = resultJson;

                var download=function(uri,filename,callback){
                    request.head(uri,function(err,res,body){
                        // console.log('Content-Type:',res.headers['content-type']);
                        // console.log('Content-length:',res.headers['content-length']);
                        request(uri).pipe(fs.createWriteStream(filename).on('close',callback));

                    });
                }
                download(fullUrl,localPath,function(){console.log("Done")});
                var convertBufferdata=convertBuffer();
                      convertBufferdata.then(async function(result){
                                var image =await jpeg.decode(file_content, true)
                                const numChannels = 3
                                const numPixels = image.width * image.height
                                const values = new Int32Array(numPixels * numChannels)
                                for (let i = 0; i < numPixels; i++)
                                    for (let c = 0; c < numChannels; ++c)
                                        values[i * numChannels + c] = image.data[i * 4 + c]
                                test_data=tf.tensor3d(values, [image.height, image.width, numChannels], 'int32')
                                var predictions=await _model.classify(test_data);
                                jsonObj[String(arrayAsins[i])]=predictions;
                                console.log('JsonObj',jsonObj);
                                i=i+1;
                                console.log("I going out is",i);
                                iterator(i);
                      },function(err){console.log(err)})
                })
            .catch(error=>{
                i=arrayCodes.length+1;
                console.log(error);
            })
    }
})

const load_model = async () => {
  _model = await nsfw.load()
}

load_model().then(() => app.listen(8080))

const express=require（'express'））
常量multer=require（'multer'）
常量jpeg=require（'jpeg-js'）
const tf=require（“@tensorflow/tfjs node”）
const nsfw=require（'nsfwjs'）
const bodyParser=require（“主体解析器”）
const axios=require（'axios'）；
const cheerio=需要（“cheerio”）；
var fs=需要（'fs'）；
var http=require（'http'）；
var请求=要求（“请求”）；
const app=express（）
const upload=multer（）
use（bodyParser.json（））；
let_模型
让文件包含内容；
让我们测试数据；
函数convertBuffer（）
{
返回新承诺（功能（解决、拒绝）
{
尝试
{
file_content=fs.readFileSync（'ans1.png'）；
解析（文件内容）；
}
抓住
{
拒绝（'空字符串'）
}           
})
}
app.post（'/nsfw'，异步（req，res）=>{
var arrayCodes=请求主体代码；
var jsonObj={}；
var i=0；
变量迭代器=函数（i）{
if（i>arrayCodes.length）
{
日志（“测试”，jsonObj）；
res.json（jsonObj）；
返回；
}
}
而{
var结果=响应数据；
var resultJson=result.facets.Media.productImage.url；
var localPath=“ans1.png”
var fullUrl=resultJson；
var download=函数（uri、文件名、回调）{
head（uri，函数（err，res，body）{
//log（'Content-Type:'，res.headers['Content-Type']）；
//log（'Content-length:'，res.headers['Content-length']）；
请求（uri）.pipe（fs.createWriteStream（filename）.on（'close'，callback））；
});
}
下载（fullUrl，localPath，function（）{console.log（“Done”）}）；
var convertBufferdata=convertBuffer（）；
convertBufferdata.then（异步函数（结果）{
var image=wait jpeg.decode（文件内容，true）
常量numChannels=3
常量numPixels=image.width*image.height
常量值=新的Int32Array（numPixels*numChannels）
for（设i=0；i{
i=阵列代码。长度+1；
console.log（错误）；
})
}
})
const load_model=async（）=>{
_模型=等待nsfw.load（）
}
加载模型（），然后（（）=>app.listen（8080））

我面临的问题是，代码不是完全同步的，因为生成的Json对象的键可能比它应该的多，或者可能不是所有检索到的值都是正确的（这意味着它正在被覆盖）

*每次获取并处理单个图像后，下一个图像将下载/覆盖到同一图像中*

---

重构代码或进行一些更改以修复问题时，任何帮助都将受到感谢。

问题得到解决，在调用异步承诺函数时，创建承诺对象的点被取消，因此我将其从对象外部删除，并在承诺对象返回后调用它。问题得到了解决。问题得到了解决，在调用异步承诺函数时，创建承诺对象的点被取消，因此我在对象外部删除了它，并在承诺对象返回后调用它。问题得到了解决。