import json
import os
import time
import requests
url = "http://192.168.20.146:5001/upLoadImg_api"
src_dir = "cz_1"
images = os.listdir(src_dir)
images = sorted(images, key=lambda x: int(x.split(".")[0]))
for image in images:
    file = os.path.join(src_dir, image)
    files = {'image': open(file, 'rb')}
    start_time = time.time()
    r = requests.post(url=url, files=files)
    end_time = time.time()
    print(end_time-start_time, r.content)

import tensorflow as tf
from tensorflow.keras import datasets
(x, y), (x_val, y_val) = datasets.mnist.load_data()
# 加载数据
x = tf.convert_to_tensor(x, dtype=tf.float32) / 255.
y = tf.convert_to_tensor(y, dtype=tf.int32)
print(x.shape, y.shape)
# 将x、y转为tensorflow的db
train_dataset = tf.data.Dataset.from_tensor_slices((x, y))
# 设置batch
train_dataset = train_dataset.batch(200)

# [b, 784] => [b, 256] => [b, 128] => [b, 10]
# []
# 这是在计算过程中需要的参数，也是梯度下降时要变化的东西
w1 = tf.Variable(tf.random.truncated_normal([784, 256], stddev=0.1))
b1 = tf.Variable(tf.zeros([256]))
w2 = tf.Variable(tf.random.truncated_normal([256, 128], stddev=0.1))
b2 = tf.Variable(tf.zeros([128]))
w3 = tf.Variable(tf.random.truncated_normal([128, 10], stddev=0.1))
b3 = tf.Variable(tf.zeros([10]))

lr = 1e-3

for step, (x, y) in enumerate(train_dataset):
    # x:[128, 28, 28]
    # y:[128]
    # [b, 28, 28] => [b, 28*28]
    x = tf.reshape(x, [-1, 28*28])

    with tf.GradientTape() as tape:
        # x:[b, 28*28]
        # h1 = x@w1 + b1
        # [b, 784]@[784, 256] + [256]=>[b,256] + [256] => [b, 256]
        h1 = x@w1 + b1
        h1 = tf.nn.relu(h1)
        # [b, 256] => [b, 128]
        h2 = h1@w2 + b2
        h2 = tf.nn.relu(h2)
        # [b, 128] => [b, 10]
        out = h2@w3 + b3

        # compute loss
        # out: [b, 10]
        # y:[b] => [b, 10]
        y = tf.one_hot(y, depth=10)

        # mse = mean(sum(y-out)^2)
        # [b,10]
        loss = tf.square(y-out)
        # mean: scalar
        loss = tf.reduce_mean(loss)
	# 梯度计算
    grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])
    # 梯度更新
    # w1 = w1 - lr * grads[0]
    w1.assign_sub(lr * grads[0])
    b1.assign_sub(lr * grads[1])
    w2.assign_sub(lr * grads[2])
    b2.assign_sub(lr * grads[3])
    w3.assign_sub(lr * grads[4])
    b3.assign_sub(lr * grads[5])

    if step % 100 == 0:
        print(step, 'loss', float(loss))

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets, optimizers, Sequential, layers


def data_pre_process(x, y):
    x = tf.cast(x, dtype=tf.float32) / 255.
    y = tf.cast(y, dtype=tf.int32)

    return x, y


def dataLoader():
    (x, y), (x_val, y_val) = datasets.fashion_mnist.load_data()
    db = tf.data.Dataset.from_tensor_slices((x, y))
    db = db.map(data_pre_process).batch(128)

    db_val = tf.data.Dataset.from_tensor_slices((x_val, y_val))
    db_val = db_val.map(data_pre_process).batch(128)

    return db, db_val


if __name__ == "__main__":
    # 数据加载
    db, db_val = dataLoader()

    model = Sequential([
        layers.Dense(256, activation=tf.nn.relu),
        layers.Dense(128, activation=tf.nn.relu),
        layers.Dense(64, activation=tf.nn.relu),
        layers.Dense(32, activation=tf.nn.relu),
        layers.Dense(10, activation=tf.nn.relu),
    ])
    model.build(input_shape=[None, 28*28])
    model.summary()

    optimizers = optimizers.Adam(lr=1e-3)
    # 迭代
    for epoch in range(30):
        # 每次迭代过程中会根据batchsize分块计算
        for step, (x, y) in enumerate(db):
            x = tf.reshape(x, [-1, 28*28])
            # 梯度计算
            with tf.GradientTape() as tape:
                logits = model(x)
                y_onehot = tf.one_hot(y, depth=10)
                loss_mse = tf.reduce_mean(tf.losses.MSE(y_onehot, logits))
                loss_ce = tf.reduce_mean(tf.losses.categorical_crossentropy(y_onehot, logits, from_logits=True))

            grads = tape.gradient(loss_ce, model.trainable_variables)
            # 梯度更新
            optimizers.apply_gradients(zip(grads, model.trainable_variables))

            if step % 100 == 0:
                print(epoch, step, 'loss:', float(loss_ce), float(loss_mse))
        # 测试/验证集精度计算
        total_correct = 0
        total_num = 0
        for x, y in db_val:
            x = tf.reshape(x, [-1, 28*28])
            logits = model(x)
            prob = tf.nn.softmax(logits, axis=1)

            pred = tf.argmax(prob, axis=1)
            pred = tf.cast(pred, dtype=tf.int32)

            correct = tf.equal(pred, y)
            correct = tf.reduce_sum(tf.cast(correct, dtype=tf.int32))
            total_correct += int(correct)
            total_num += x.shape[0]

        acc = total_correct/total_num
        print(epoch, 'test acc:', float(acc))

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import datasets, optimizers, Sequential, layers


def data_pre_process(x, y):
    x = tf.cast(x, dtype=tf.float32) / 255.
    y = tf.cast(y, dtype=tf.int32)

    return x, y


def dataLoader():
    (x, y), (x_val, y_val) = datasets.fashion_mnist.load_data()
    x = x.reshape(60000, 28*28)
    y = tf.one_hot(y, depth=10)
    db = tf.data.Dataset.from_tensor_slices((x, y))
    db = db.map(data_pre_process).batch(128)

    db_val = tf.data.Dataset.from_tensor_slices((x_val, y_val))
    db_val = db_val.map(data_pre_process).batch(128)

    return db, db_val


if __name__ == "__main__":
    db, db_val = dataLoader()

    model = Sequential([
        layers.Dense(256, activation=tf.nn.relu),
        layers.Dense(128, activation=tf.nn.relu),
        layers.Dense(64, activation=tf.nn.relu),
        layers.Dense(32, activation=tf.nn.relu),
        layers.Dense(10, activation=tf.nn.relu),
    ])
    model.build(input_shape=[None, 28*28])
    model.summary()
    # compile中会提供若干参数，如梯度优化方式、误差计算方式、精度评定方式，当然还有更多参数，请阅读文档
    model.compile(optimizer=optimizers.Adam(lr=0.0001), loss=tf.losses.CategoricalCrossentropy(from_logits=True),
                  metrics=['accuracy'])
	# fit即开始训练，需要输入db和要迭代的次数，注意db中的x和y要和model的输入与输出维度一致
    model.fit(db, epochs=1000)

conv1 = Conv2D(64, 3, activation='relu', padding='same')(inputs)