基于飞桨实现高光谱反演：通过遥感数据获取土壤某物质含量

dataset = pd.read_csv(data/data48548/data.csv)#读取数据集  
# df转array  
values = dataset.values  
# 原始数据标准化，为了加速收敛
                    
scaler = MinMaxScaler(feature_range=(0, 1))  
scaled = scaler.fit_transform(values)  
data = scaled  

ratio = 0.8 # 训练集和验证集
                  的划分比例  
offset = int(data.shape[0]*ratio)  
train_data = data[:offset]  
test_data = data[offset:]  

def reader_creator(train_data):    
    def reader():    
        for d in train_data:    
            yield d[:-1], d[-1:]    
    return reader  

BUF_SIZE=50  
BATCH_SIZE=20  

#用于训练的数据提供器，每次从缓存中随机读取批次
                  大小的数据  
train_reader = paddle.batch(  
    paddle.reader.shuffle(reader_creator(train_data),   
                          buf_size=BUF_SIZE),                      
    batch_size=BATCH_SIZE)     
#用于测试的数据提供器，每次从缓存中随机读取批次
                  大小的数据  
test_reader = paddle.batch(  
    paddle.reader.shuffle(reader_creator(test_data),  
                          buf_size=BUF_SIZE),  
    batch_size=BATCH_SIZE)   

#定义张量
          变量x，表示14维的特征值
x = fluid.layers.data(name=x, shape=[14], dtype=float32)
#定义张量
          y,表示1维的目标值
y = fluid.layers.data(name=y, shape=[1], dtype=float32)
#定义一个简单的线性网络,连接输入和输出的全连接层
#input:输入tensor;
#size:该层输出单元的数目
#act:激活函数
          
y_predict=fluid.layers.fc(input=x,size=1,act=None)

cost = fluid.layers.square_error_cost(input=y_predict, label=y) #求一个batch的损失值
avg_cost = fluid.layers.mean(cost)  

optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)
opts = optimizer.minimize(avg_cost)

for pass_id in range(EPOCH_NUM):                                  #训练EPOCH_NUM轮
    # 开始训练并输出最后一个batch的损失值
    train_cost = 0
    for batch_id, data in enumerate(train_reader()):              #遍历train_reader迭代器
        train_cost = exe.run(program=fluid.default_main_program(),#运行主程序
                             feed=feeder.feed(data),              #喂入一个batch的训练数据，根据feed_list和data提供的信息，将输入数据转成一种特殊的数据结构
                             fetch_list=[avg_cost])    
        if batch_id % 40 == 0:
            print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0][0]))    #打印最后一个batch的损失值
        iter=iter+BATCH_SIZE
        iters.append(iter)
        train_costs.append(train_cost[0][0])


    # 开始测试并输出最后一个batch的损失值
    test_cost = 0
    for batch_id, data in enumerate(test_reader()):               #遍历test_reader迭代器
        test_cost= exe.run(program=test_program, #运行测试cheng
                            feed=feeder.feed(data),               #喂入一个batch的测试数据
                            fetch_list=[avg_cost])                #fetch均方误差
    print(Test:%d, Cost:%0.5f % (pass_id, test_cost[0][0]))     #打印最后一个batch的损失值

with fluid.scope_guard(inference_scope):#修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope。
    #从指定目录中加载 推理model(inference model)
    [inference_program,                             #推理的program
     feed_target_names,                             #需要在推理program中提供数据的变量名称
     fetch_targets] = fluid.io.load_inference_model(#fetch_targets: 推断结果
                                    model_save_dir, #model_save_dir:模型训练路径 
                                    infer_exe)      #infer_exe: 预测用executor
    #获取预测数据
    infer_reader = paddle.batch(reader_creator(test_data),  #测试数据
                          batch_size=20)                #从测试数据中读取一个大小为20的batch数据
    #从test_reader中分割x
    test_data = next(infer_reader())
    test_x = np.array([data[0] for data in test_data]).astype("float32")
    test_y= np.array([data[1] for data in test_data]).astype("float32")
    results = infer_exe.run(inference_program,                #预测模型
    feed={feed_target_names[0]: np.array(test_x)},  #输入光谱数据
    fetch_list=fetch_targets)            #得到推测含量

飞桨官网地址：

https://www.paddlepaddle.org.cn/

飞桨开源框架项目地址：

GitHub: 

https://github.com/PaddlePaddle/Paddle 

Gitee: 

https://gitee.com/paddlepaddle/Paddle