import { ref, reactive, onMounted, watch } from "vue";

// import * as tf from "@tensorflow/tfjs";
import {
  sequential,
  layers,
  train,
  data,
  util,
  tensor2d,
  tensor1d,
  split,
  io,
  loadLayersModel,
  tidy,
  linspace,
} from "@tensorflow/tfjs";

import * as tfvis from "@tensorflow/tfjs-vis";

const housedata=data.csv({
  "/csv/kc_house_data.mp3"
  //"https://attachment.0sm.com/node0/2023/04/86434431EA805A03-fb7b9f9426927d4e.mp3
})

// 提取x，y值并捕获数据集用于绘制
const pointsDataset = housedata.map((record) => ({
  x: record.sqft_living,
  y: record.price,
}));
points = await pointsDataset.toArray();
//console.log(points);

if (points.length % 2 !== 0) {
  points.pop();
}
util.shuffle(points);
plot(points, "Square Feet");

// 提取特征并将其存储在张量里
// 输入的张量 对应x轴
const featureValues = points.map((p) => p.x);
const featureTensor = tensor2d(featureValues, [featureValues.length, 1]);

// 输出的张量 对应y轴
const labelValues = points.map((p) => p.y);
const labelTensor = tensor2d(labelValues, [labelValues.length, 1]);
// 打印
// featureTensor.print();
// labelTensor.print();

// 对tensor进行归一化处理
normalisedFeature = normalise(featureTensor);
normalisedLabel = normalise(labelTensor);
// 内存管理
featureTensor.dispose();
labelTensor.dispose();

// 打印
normalisedFeature.tensor.print();
// normalisedLabel.tensor.print();

// 逆归一化处理打印
// denormalise(normalisedFeature.tensor,normalisedFeature.min,normalisedFeature.max).print()

// 数据拆分为训练和测试两块
[trainingFeatureTensor, testingFeatureTensor] = split(
  normalisedFeature.tensor,
  2
);
[trainingLabelTensor, testingLabelTensor] = split(normalisedLabel.tensor, 2);
trainingFeatureTensor.print(true);

// 归一化处理
function normalise(tensor, previousMin = null, previousMax = null) {
  const min = previousMin || tensor.min();
  const max = previousMax || tensor.max();
  const normalisedTensor = tensor.sub(min).div(max.sub(min));
  return { tensor: normalisedTensor, min, max };
}

// 逆归一化处理
function denormalise(tensor, min, max) {
  const denormalisedTensor = tensor.mul(max.sub(min)).add(min);
  return denormalisedTensor;
}

// tfjs-vis渲染
async function plot(pointsarray, featurename, predictedpointsarray = null) {
  // const values = [pointsarray.slice(0, 1000)];
  const values = [pointsarray];
  const series = ["original"];
  if (Array.isArray(predictedpointsarray)) {
    values.push(predictedpointsarray);
    series.push("predict");
  }

  tfvis.render.scatterplot(
    { name: `${featurename} vs 房价` },
    { values, series },
    {
      xLabel: featurename,
      yLabel: "价格",
    }
  );
}

// 创建模型（最简单的线性回归模型，单图层，单个输入，伪激活函数）
function createModel() {
  // 创建模型
  const model = sequential();
  // 增加图层
  model.add(
    layers.dense({
      units: 1,
      useBias: true,
      activation: "sigmoid",
      inputDim: 1,
    })
  );
  // 模型编译优化
  // const optimizer = train.sgd(0.1);
  const optimizer = train.adam();
  model.compile({
    loss: "meanSquaredError",
    optimizer,
  });
  return model;
}

// 训练模型函数 拟合(带vis)
async function trainModel(model, trainingFeatureTensor, trainingLabelTensor) {
  const { onBatchEnd, onEpochEnd } = tfvis.show.fitCallbacks(
    { name: "训练表现" },
    ["loss"]
  );

  // 进行拟合
  return model.fit(trainingFeatureTensor, trainingLabelTensor, {
    batchSize: 32, // 梯度更新的样本数
    epochs: 100, // 训练迭代次数
    validationSplit: 0.2, // 验证拆分
    /**
     * 0 到 1 之间的浮点数：训练数据的一部分 用作验证数据。该模型将区分这部分 训练数据，不会对其进行训练，并将评估损失和 每个纪元结束时此数据的任何模型指标。 在随机播放之前，从提供的 x 和 y 数据中的最后一个样本中选择验证数据。
     */
    callbacks: {
      //训练回调
      onEpochEnd,
      onEpochBegin: async function () {
        await plotPredictionLine();
        const layer = mymodel.getLayer(undefined, 0);
        tfvis.show.layer({ name: "图层 1" }, layer);
      },
    },
  });
}

async function htrain() {
  // 创建模型
  const model = createModel();
  mymodel = model;
  // 打印model信息
  // model.summary();

  // tfvis渲染model.summary信息
  tfvis.show.modelSummary({ name: "模型摘要" }, model);

  // 获取模型图层
  const layer = model.getLayer(undefined, 0);

  // 渲染图层信息
  tfvis.show.layer({ name: "图层 1" }, layer);

  // 预测线
  await plotPredictionLine();

  // 数据拟合
  const result = await trainModel(
    model,
    trainingFeatureTensor,
    trainingLabelTensor
  );
  // await trainModelwithoutvis(model, trainingFeatureTensor, trainingLabelTensor)

  // 训练损失
  const trainingloss = result.history.loss.pop();
  console.log(trainingloss);

  // 平均损失
  const validationloss = result.history.val_loss.pop();
  console.log(validationloss);

  const losstensor = model.evaluate(testingFeatureTensor, testingLabelTensor);

  // 测试损失
  const loss = await losstensor.dataSync();
  console.log(loss[0]);
}

// 预测线
async function plotPredictionLine() {
  const [xs, ys] = tidy(() => {
    const normalisedXs = linspace(0, 1, 100);
    const normalisedYs = mymodel.predict(normalisedXs.reshape([100, 1]));

    const xs = denormalise(
      normalisedXs,
      normalisedFeature.min,
      normalisedFeature.max
    );
    const ys = denormalise(
      normalisedYs,
      normalisedLabel.min,
      normalisedLabel.max
    );

    return [xs.dataSync(), ys.dataSync()];
  });

  const predictedpoints = Array.from(xs).map((val, index) => {
    return { x: val, y: ys[index] };
  });

  await plot(points, "square feet", predictedpoints);
}

// 数据预测
async function predict() {
  const predictionInput = parseInt(uservalue.value);

  tidy(() => {
    const inputTensor = tensor1d([predictionInput]);
    const normaliseInput = normalise(
      inputTensor,
      normalisedFeature.min,
      normalisedFeature.max
    );
    const normaliseOutputTensor = mymodel.predict(normaliseInput.tensor);
    const outputTensor = denormalise(
      normaliseOutputTensor,
      normalisedLabel.min,
      normalisedLabel.max
    );
    const outputValue = outputTensor.dataSync()[0];
    console.log(outputValue);
  });
}