Javascript TensorFlow-要构建哪个模型？

我们正在创建房地产的元搜索。我想根据tensorflow.js sequential model的某些指标来预测运行时间（列表将联机的时间）

我有以下资料：

  listing.buyingPrice,
  listing.foreClosure ? 1 :0,
  listing.leasehold ? 1 : 0,
  listing.squareMeter,
  listing.rooms,
  listing.grossReturn,
  listing.locationFactor.score

这是我正在使用的代码：

const createModel = () => {
  // Create a sequential model
  const model = tf.sequential();

  // Add a single hidden layer
  model.add(tf.layers.dense({inputShape: [shapeLength], units: 50, useBias: true}));


  // Add an output layer
  model.add(tf.layers.dense({units: 1, useBias: true}));

  return model;
};


async function trainModel(model, inputs, labels) {
  // Prepare the model for training.
  const learningRate = 0.0001;
  model.compile({
    optimizer: tf.train.adam(learningRate),
    loss: tf.losses.meanSquaredError,
    metrics: ['mse'],
  });

  const batchSize = 32;
  const epochs = 50;

  return await model.fit(inputs, labels, {
    batchSize,
    epochs,
    shuffle: true
  });
}


const shapeLength=7;
const convertListing = (listing) => ([
  listing.buyingPrice,
  listing.foreClosure ? 1 :0,
  listing.leasehold ? 1 : 0,
  listing.squareMeter,
  listing.rooms,
  listing.grossReturn,
  listing.locationFactor.score
]);

const convertToTensor =(listings) => {
  // Wrapping these calculations in a tidy will dispose any
  // intermediate tensors.

  return tf.tidy(() => {
    // Step 1. Shuffle the data
    tf.util.shuffle(listings);

    // Step 2. Convert data to Tensor
    const inputs = listings.map(listing =>
      convertListing(listing)
    );
    const labels = listings.map(listing => listing.runningTime);

    const inputTensor = tf.tensor2d(inputs, [inputs.length, shapeLength]);
    const labelTensor = tf.tensor2d(labels, [labels.length, 1]);

    return {
      inputs: inputTensor,
      labels: labelTensor,
    }
  });
};

const modelCreated = createModel();

export const doTraining = async () => {
  const listings = await findExactMatch({
    rented:false,
    active:false,
    zip:'10243',
  }, OBJECT_TYPES.APARTMENTBUY);

  const filteredListings = listings.filter(listing =>
    listing.runningTime>=0
    && listing.buyingPrice>=0
    && listing.runningTime <100
    && listing.rooms>0
    && listing.squareMeter >0
    && listing.grossReturn >0
    && listing.locationFactor.score>0
  );
  const tensorData = convertToTensor(filteredListings);
  const {inputs, labels} = tensorData;
// Train the model
  await trainModel(modelCreated, inputs, labels);
  console.log('Done Training');

  filteredListings.map(listing=>{
    console.log(listing.runningTime)
  });
  for(let i=0;i<10;i++){
    console.log('Real running time',filteredListings[i].runningTime)
    console.log('Predicted runningTime',await testModel(filteredListings[i],tensorData));
  }

};

export const testModel = async (listing) => {

    const input = convertListing(listing);
    const inputData = tf.tensor2d([input], [1, shapeLength]);


  const result = modelCreated.predict(inputData);
  return result.dataSync()[0];
}

constcreatemodel=（）=>{
//创建一个顺序模型
const model=tf.sequential（）；
//添加单个隐藏层
add（tf.layers.dense（{inputShape:[shapeLength]，单位：50，useBias:true}））；
//添加一个输出层
add（tf.layers.dense（{units:1，useBias:true}））；
收益模型；
};
异步功能列车模型（模型、输入、标签）{
//为培训准备模型。
常数学习率=0.0001；
model.compile({
优化器：tf.train.adam（learningRate），
损失：tf.loss.meanSquaredError，
指标：['mse']，
});
常数batchSize=32；
常数纪元=50；
返回等待模型拟合（输入、标签、{
批量大小，
时代，
洗牌：对
});
}
常数形状长度=7；
const convertListing=（列表）=>([
上市价格，
上市公司丧失抵押品赎回权？1:0，
listing.leasehold？1:0，
1.2平方米，
房源，
listing.grossReturn，
listing.locationFactor.score
]);
const converttosensor=（列表）=>{
//将这些计算包装在一个整洁的文件中可以处理任何
//中间张量。
返回tf.tidy（（）=>{
//步骤1.洗牌数据
tf.util.shuffle（列表）；
//步骤2.将数据转换为张量
const inputs=listings.map（listing=>
上市公司（上市公司）
);
const labels=listings.map（listing=>listing.runningTime）；
常量inputSensor=tf.tensor2d（输入[inputs.length，shapeLength]）；
常数labelTensor=tf.tensor2d（标签[labels.length，1]）；
返回{
输入：输入传感器，
标签：labelTensor，
}
});
};
const modelCreated=createModel（）；
export const doTraining=async（）=>{
const listings=等待findExactMatch({
是假,，
活动：错误，
邮政编码：'10243'，
}，对象类型：APARTMENTBUY）；
const filteredListings=listings.filter（listing=>
listing.runningTime>=0
&&listing.buyingPrice>=0
&&清单1.runningTime 0
&&清单1.0平方米>0
&&listing.grossReturn>0
&&listing.locationFactor.score>0
);
常数tensorData=转换器传感器（过滤器列表）；
常量{输入，标签}=张量数据；
//训练模型
等待列车模型（模型创建、输入、标签）；
console.log（“完成培训”）；
filteredListings.map（清单=>{
console.log（listing.runningTime）
});
for（设i=0；i{
常量输入=转换列表（列表）；
常量inputData=tf.tensor2d（[input]，[1，shapeLength]）；
const result=modelCreated.predict（输入数据）；
返回result.dataSync（）[0]；
}

---

我使用了大约3000个列表。问题是，我预测的运行时间远远不够。如何改进这一点？我的模型是否正确？：）

我认为你应该重新考虑这个模型。你能给我一些提示吗？：）