Python和Numpy构建神经网络模型预测波士顿房价

代码所需文件housing.data
链接：https://pan.baidu.com/s/1oZbuUAtnEFf44w2tkUorpg
提取码：ntr1
构建一个基于下图13个因素进行房价预测的模型

# 导入需要用到的package
import numpy as np
import matplotlib.pyplot as pltdef load_data():# 从文件导入数据datafile = './housing.data'data = np.fromfile(datafile, sep=' ')# 每条数据包括14项，其中前面13项是影响因素，第14项是相应的房屋价格中位数feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]feature_num = len(feature_names)# 将原始数据进行Reshape，变成[N, 14]这样的形状data = data.reshape([data.shape[0] // feature_num, feature_num])# 将原数据集拆分成训练集和测试集# 这里使用80%的数据做训练，20%的数据做测试# 测试集和训练集必须是没有交集的ratio = 0.8offset = int(data.shape[0] * ratio)training_data = data[:offset]# 计算train数据集的最大值，最小值，平均值maximums, minimums, avgs = training_data.max(axis=0),\training_data.min(axis=0),\training_data.sum(axis=0) / training_data.shape[0]# 对数据进行归一化处理for i in range(feature_num):#print(maximums[i], minimums[i], avgs[i])data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])# 训练集和测试集的划分比例training_data = data[:offset]test_data = data[offset:]return training_data, test_dataclass Network(object):def __init__(self, num_of_weights):# 随机产生w的初始值# 为了保持程序每次运行结果的一致性，此处设置固定的随机数种子# np.random.seed(0)self.w = np.random.randn(num_of_weights, 1)self.b = 0.def forward(self, x):z = np.dot(x, self.w) + self.breturn zdef loss(self, z, y):error = z - ynum_samples = error.shape[0]cost = error * errorcost = np.sum(cost) / num_samplesreturn costdef gradient(self, x, y):z = self.forward(x)N = x.shape[0]gradient_w = 1. / N * np.sum((z - y) * x, axis=0)gradient_w = gradient_w[:, np.newaxis]gradient_b = 1. / N * np.sum(z - y)return gradient_w, gradient_bdef update(self, gradient_w, gradient_b, eta=0.01):self.w = self.w - eta * gradient_wself.b = self.b - eta * gradient_bdef train(self, training_data, num_epoches, batch_size=10, eta=0.01):n = len(training_data)losses = []for epoch_id in range(num_epoches):# 在每轮迭代开始之前，将训练数据的顺序随机的打乱，# 然后再按每次取batch_size条数据的方式取出np.random.shuffle(training_data)# 将训练数据进行拆分，每个mini_batch包含batch_size条的数据mini_batches = [training_data[k:k + batch_size] for k in range(0, n, batch_size)]for iter_id, mini_batch in enumerate(mini_batches):# print(self.w.shape)# print(self.b)x = mini_batch[:, :-1]y = mini_batch[:, -1:]a = self.forward(x)loss = self.loss(a, y)gradient_w, gradient_b = self.gradient(x, y)self.update(gradient_w, gradient_b, eta)losses.append(loss)print('Epoch {:3d} / iter {:3d}, loss = {:.4f}'.format(epoch_id, iter_id, loss))return losses# 获取数据
train_data, test_data = load_data()# 创建网络
net = Network(13)
# 启动训练
losses = net.train(train_data, num_epoches=50, batch_size=100, eta=0.1)# 画出损失函数的变化趋势
plot_x = np.arange(len(losses))
plot_y = np.array(losses)
plt.plot(plot_x, plot_y)
plt.show()

运行结果：

Epoch   0 / iter   0, loss = 0.3777
Epoch   0 / iter   1, loss = 0.3285
Epoch   0 / iter   2, loss = 0.2757
Epoch   0 / iter   3, loss = 0.3729
Epoch   0 / iter   4, loss = 0.1333
Epoch   1 / iter   0, loss = 0.3939
Epoch   1 / iter   1, loss = 0.2654
Epoch   1 / iter   2, loss = 0.2978
Epoch   1 / iter   3, loss = 0.3355
Epoch   1 / iter   4, loss = 0.6185
Epoch   2 / iter   0, loss = 0.4056
Epoch   2 / iter   1, loss = 0.2857
Epoch   2 / iter   2, loss = 0.2786
Epoch   2 / iter   3, loss = 0.2712
Epoch   2 / iter   4, loss = 0.5689
Epoch   3 / iter   0, loss = 0.2229
Epoch   3 / iter   1, loss = 0.3562
Epoch   3 / iter   2, loss = 0.3143
Epoch   3 / iter   3, loss = 0.3225
Epoch   3 / iter   4, loss = 0.0956
Epoch   4 / iter   0, loss = 0.3202
Epoch   4 / iter   1, loss = 0.2770
Epoch   4 / iter   2, loss = 0.3372
Epoch   4 / iter   3, loss = 0.2469
Epoch   4 / iter   4, loss = 0.1560
Epoch   5 / iter   0, loss = 0.2791
Epoch   5 / iter   1, loss = 0.2548
Epoch   5 / iter   2, loss = 0.3007
Epoch   5 / iter   3, loss = 0.3109
Epoch   5 / iter   4, loss = 0.1631
Epoch   6 / iter   0, loss = 0.3691
Epoch   6 / iter   1, loss = 0.3011
Epoch   6 / iter   2, loss = 0.2135
Epoch   6 / iter   3, loss = 0.2157
Epoch   6 / iter   4, loss = 0.4304
Epoch   7 / iter   0, loss = 0.2703
Epoch   7 / iter   1, loss = 0.2913
Epoch   7 / iter   2, loss = 0.2247
Epoch   7 / iter   3, loss = 0.2806
Epoch   7 / iter   4, loss = 0.3282
Epoch   8 / iter   0, loss = 0.2186
Epoch   8 / iter   1, loss = 0.2956
Epoch   8 / iter   2, loss = 0.2893
Epoch   8 / iter   3, loss = 0.2334
Epoch   8 / iter   4, loss = 0.1080
Epoch   9 / iter   0, loss = 0.2720
Epoch   9 / iter   1, loss = 0.2500
Epoch   9 / iter   2, loss = 0.2554
Epoch   9 / iter   3, loss = 0.2230
Epoch   9 / iter   4, loss = 0.3167
Epoch  10 / iter   0, loss = 0.2516
Epoch  10 / iter   1, loss = 0.2183
Epoch  10 / iter   2, loss = 0.2480
Epoch  10 / iter   3, loss = 0.2532
Epoch  10 / iter   4, loss = 0.2529
Epoch  11 / iter   0, loss = 0.2471
Epoch  11 / iter   1, loss = 0.1995
Epoch  11 / iter   2, loss = 0.2431
Epoch  11 / iter   3, loss = 0.2603
Epoch  11 / iter   4, loss = 0.0497
Epoch  12 / iter   0, loss = 0.2953
Epoch  12 / iter   1, loss = 0.2202
Epoch  12 / iter   2, loss = 0.1838
Epoch  12 / iter   3, loss = 0.2122
Epoch  12 / iter   4, loss = 0.4517
Epoch  13 / iter   0, loss = 0.2460
Epoch  13 / iter   1, loss = 0.2652
Epoch  13 / iter   2, loss = 0.1917
Epoch  13 / iter   3, loss = 0.1824
Epoch  13 / iter   4, loss = 0.5421
Epoch  14 / iter   0, loss = 0.2678
Epoch  14 / iter   1, loss = 0.1879
Epoch  14 / iter   2, loss = 0.2311
Epoch  14 / iter   3, loss = 0.1936
Epoch  14 / iter   4, loss = 0.0858
Epoch  15 / iter   0, loss = 0.2504
Epoch  15 / iter   1, loss = 0.2325
Epoch  15 / iter   2, loss = 0.1389
Epoch  15 / iter   3, loss = 0.2258
Epoch  15 / iter   4, loss = 0.3085
Epoch  16 / iter   0, loss = 0.1968
Epoch  16 / iter   1, loss = 0.2143
Epoch  16 / iter   2, loss = 0.1871
Epoch  16 / iter   3, loss = 0.2282
Epoch  16 / iter   4, loss = 0.0626
Epoch  17 / iter   0, loss = 0.2001
Epoch  17 / iter   1, loss = 0.2177
Epoch  17 / iter   2, loss = 0.1988
Epoch  17 / iter   3, loss = 0.1888
Epoch  17 / iter   4, loss = 0.1423
Epoch  18 / iter   0, loss = 0.2279
Epoch  18 / iter   1, loss = 0.2517
Epoch  18 / iter   2, loss = 0.1425
Epoch  18 / iter   3, loss = 0.1638
Epoch  18 / iter   4, loss = 0.1511
Epoch  19 / iter   0, loss = 0.2041
Epoch  19 / iter   1, loss = 0.1792
Epoch  19 / iter   2, loss = 0.1684
Epoch  19 / iter   3, loss = 0.2202
Epoch  19 / iter   4, loss = 0.1024
Epoch  20 / iter   0, loss = 0.1829
Epoch  20 / iter   1, loss = 0.1547
Epoch  20 / iter   2, loss = 0.1689
Epoch  20 / iter   3, loss = 0.2449
Epoch  20 / iter   4, loss = 0.1568
Epoch  21 / iter   0, loss = 0.1654
Epoch  21 / iter   1, loss = 0.1765
Epoch  21 / iter   2, loss = 0.1631
Epoch  21 / iter   3, loss = 0.2279
Epoch  21 / iter   4, loss = 0.1282
Epoch  22 / iter   0, loss = 0.1716
Epoch  22 / iter   1, loss = 0.1853
Epoch  22 / iter   2, loss = 0.2120
Epoch  22 / iter   3, loss = 0.1486
Epoch  22 / iter   4, loss = 0.1048
Epoch  23 / iter   0, loss = 0.1944
Epoch  23 / iter   1, loss = 0.1901
Epoch  23 / iter   2, loss = 0.1447
Epoch  23 / iter   3, loss = 0.1686
Epoch  23 / iter   4, loss = 0.1152
Epoch  24 / iter   0, loss = 0.1904
Epoch  24 / iter   1, loss = 0.1510
Epoch  24 / iter   2, loss = 0.1516
Epoch  24 / iter   3, loss = 0.1830
Epoch  24 / iter   4, loss = 0.4108
Epoch  25 / iter   0, loss = 0.2076
Epoch  25 / iter   1, loss = 0.1427
Epoch  25 / iter   2, loss = 0.2165
Epoch  25 / iter   3, loss = 0.0994
Epoch  25 / iter   4, loss = 0.0347
Epoch  26 / iter   0, loss = 0.1714
Epoch  26 / iter   1, loss = 0.1893
Epoch  26 / iter   2, loss = 0.1221
Epoch  26 / iter   3, loss = 0.1699
Epoch  26 / iter   4, loss = 0.0563
Epoch  27 / iter   0, loss = 0.2228
Epoch  27 / iter   1, loss = 0.1105
Epoch  27 / iter   2, loss = 0.1266
Epoch  27 / iter   3, loss = 0.1767
Epoch  27 / iter   4, loss = 0.1282
Epoch  28 / iter   0, loss = 0.1914
Epoch  28 / iter   1, loss = 0.1426
Epoch  28 / iter   2, loss = 0.1306
Epoch  28 / iter   3, loss = 0.1622
Epoch  28 / iter   4, loss = 0.0444
Epoch  29 / iter   0, loss = 0.1888
Epoch  29 / iter   1, loss = 0.1400
Epoch  29 / iter   2, loss = 0.1674
Epoch  29 / iter   3, loss = 0.1185
Epoch  29 / iter   4, loss = 0.0511
Epoch  30 / iter   0, loss = 0.1351
Epoch  30 / iter   1, loss = 0.1429
Epoch  30 / iter   2, loss = 0.1674
Epoch  30 / iter   3, loss = 0.1355
Epoch  30 / iter   4, loss = 0.6274
Epoch  31 / iter   0, loss = 0.1871
Epoch  31 / iter   1, loss = 0.1476
Epoch  31 / iter   2, loss = 0.1210
Epoch  31 / iter   3, loss = 0.1181
Epoch  31 / iter   4, loss = 0.2849
Epoch  32 / iter   0, loss = 0.1416
Epoch  32 / iter   1, loss = 0.1233
Epoch  32 / iter   2, loss = 0.1400
Epoch  32 / iter   3, loss = 0.1589
Epoch  32 / iter   4, loss = 0.2137
Epoch  33 / iter   0, loss = 0.1274
Epoch  33 / iter   1, loss = 0.1675
Epoch  33 / iter   2, loss = 0.1450
Epoch  33 / iter   3, loss = 0.1224
Epoch  33 / iter   4, loss = 0.1024
Epoch  34 / iter   0, loss = 0.1329
Epoch  34 / iter   1, loss = 0.1472
Epoch  34 / iter   2, loss = 0.1628
Epoch  34 / iter   3, loss = 0.0992
Epoch  34 / iter   4, loss = 0.3712
Epoch  35 / iter   0, loss = 0.1419
Epoch  35 / iter   1, loss = 0.1507
Epoch  35 / iter   2, loss = 0.1386
Epoch  35 / iter   3, loss = 0.1102
Epoch  35 / iter   4, loss = 0.0792
Epoch  36 / iter   0, loss = 0.1259
Epoch  36 / iter   1, loss = 0.1685
Epoch  36 / iter   2, loss = 0.1326
Epoch  36 / iter   3, loss = 0.0859
Epoch  36 / iter   4, loss = 0.4206
Epoch  37 / iter   0, loss = 0.1141
Epoch  37 / iter   1, loss = 0.1527
Epoch  37 / iter   2, loss = 0.1300
Epoch  37 / iter   3, loss = 0.1128
Epoch  37 / iter   4, loss = 0.0758
Epoch  38 / iter   0, loss = 0.1438
Epoch  38 / iter   1, loss = 0.1239
Epoch  38 / iter   2, loss = 0.0929
Epoch  38 / iter   3, loss = 0.1391
Epoch  38 / iter   4, loss = 0.1156
Epoch  39 / iter   0, loss = 0.1265
Epoch  39 / iter   1, loss = 0.0943
Epoch  39 / iter   2, loss = 0.1143
Epoch  39 / iter   3, loss = 0.1518
Epoch  39 / iter   4, loss = 0.1370
Epoch  40 / iter   0, loss = 0.1220
Epoch  40 / iter   1, loss = 0.1379
Epoch  40 / iter   2, loss = 0.1167
Epoch  40 / iter   3, loss = 0.1046
Epoch  40 / iter   4, loss = 0.0347
Epoch  41 / iter   0, loss = 0.1424
Epoch  41 / iter   1, loss = 0.1198
Epoch  41 / iter   2, loss = 0.0876
Epoch  41 / iter   3, loss = 0.1216
Epoch  41 / iter   4, loss = 0.0984
Epoch  42 / iter   0, loss = 0.1110
Epoch  42 / iter   1, loss = 0.0929
Epoch  42 / iter   2, loss = 0.1213
Epoch  42 / iter   3, loss = 0.1384
Epoch  42 / iter   4, loss = 0.0717
Epoch  43 / iter   0, loss = 0.1180
Epoch  43 / iter   1, loss = 0.1312
Epoch  43 / iter   2, loss = 0.0810
Epoch  43 / iter   3, loss = 0.1263
Epoch  43 / iter   4, loss = 0.0319
Epoch  44 / iter   0, loss = 0.1297
Epoch  44 / iter   1, loss = 0.1299
Epoch  44 / iter   2, loss = 0.0984
Epoch  44 / iter   3, loss = 0.0881
Epoch  44 / iter   4, loss = 0.0838
Epoch  45 / iter   0, loss = 0.1049
Epoch  45 / iter   1, loss = 0.1272
Epoch  45 / iter   2, loss = 0.0955
Epoch  45 / iter   3, loss = 0.1153
Epoch  45 / iter   4, loss = 0.0400
Epoch  46 / iter   0, loss = 0.1068
Epoch  46 / iter   1, loss = 0.0776
Epoch  46 / iter   2, loss = 0.1252
Epoch  46 / iter   3, loss = 0.1186
Epoch  46 / iter   4, loss = 0.1686
Epoch  47 / iter   0, loss = 0.0918
Epoch  47 / iter   1, loss = 0.1058
Epoch  47 / iter   2, loss = 0.1187
Epoch  47 / iter   3, loss = 0.1058
Epoch  47 / iter   4, loss = 0.0958
Epoch  48 / iter   0, loss = 0.0771
Epoch  48 / iter   1, loss = 0.0963
Epoch  48 / iter   2, loss = 0.1055
Epoch  48 / iter   3, loss = 0.1288
Epoch  48 / iter   4, loss = 0.2914
Epoch  49 / iter   0, loss = 0.1209
Epoch  49 / iter   1, loss = 0.0658
Epoch  49 / iter   2, loss = 0.1141
Epoch  49 / iter   3, loss = 0.0974
Epoch  49 / iter   4, loss = 0.2922

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

C语言随笔（三）双色球问题
双色球问题：两种颜色红球+蓝球（6+1）红球1-16 蓝球1-16 打印双色球中奖信息红色球不能重复蓝球和红球可以重复#include<stdio.h> #include<time.h> #include<stdlib.h> void main() {//引入随机数种子生成随机数srand((unsigned int)time(NULL));//定…...
2024/4/28 17:04:20
Oracle入门--PL/SQL、游标、存储过程、自定义函数、触发器、MyBatis 操作(6)
1. PL/SQL 1.1 概述PL/SQL ,Oracle 对SQL扩展1.2 语法：基本语法-- 基本语法，（declare、exception可省略） declare-- 声明，定义变量 begin-- 代码exception--异常处理 end;2.1 PLSQL–游标 2.1.1 什么是游标游标是系统为用户开设的一个数据缓冲区,存放SQL语句的执行结果。我…...
2024/4/28 0:40:38
PHP丨PHP基础知识之流程控制for循环「理论篇」
今天公司同事在看for循环，那么我们今天就来讲讲for循环吧！for循环是编程语言中一种循环语句，而循环语句由循环体及循环的判定条件两部分组成，其表达式为：for（单次表达式;条件表达式;末尾循环体）{中间循环体；}。for循环语法1.语句最简形式为：for( ; ; )2.一般形式为：f…...
2024/4/28 11:28:41
hive表分区
创建表分区 create table t_t5(id int,name string) partitioned by(country string) row format delimited fields terminated by ,;编辑数据上传数据 hadoop fs -put t5.txt /user/hive/warehouse/db1.db/t_t5查看表数据 hive> select * from t_t5; OK Time taken: 0.06…...
2024/4/28 8:12:54
15天前端学习-第九天（个人记录）
简易3D效果 perspective-origin:3D的景深基点位置(看物体的角度),搭配transform的scaleZ()厚度,能让物体延伸。 transform:scale3d(宽x,高y,厚度z); transform:rotate3d(1x,1y,1z,角度); 前三个值(只能写1,0)表示轴是否要旋转,第四个值表示旋转的角度。 backface-visibility:hi…...
2024/4/28 6:16:39
CentOS7.6 源码安装 Redis-5.0.8
获取RedisRedis网站Redis官网：https://redis.io/GitHub-Redis：https://github.com/antirez/redisRedis中文官方网站：http://www.redis.cn/Redis中文网：https://www.redis.net.cn/下载Redis源码包【1】https://redis.io/download【2】https://github.com/antirez/redis/rele…...
2024/4/28 0:45:08
BI 可以代替报表吗？
BI 主要侧重于数据分析，虽然可以进行数据钻取、联动、切片、旋转等操作，但是展现的结果通常为网格、分组、交叉这几类简单格式的报表；而报表主要侧重于数据展现，可以支持复杂格式的表格数据呈现，且支持数据填报，把页面数据更新入库。如果项目里边有格式较为复杂的报表，一…...
2024/4/27 23:09:54
pycharm-python3.7下安装xlutils,防报错版
1.file—>下拉框选中settings2.project3.4.搜索xlutils，然后可以选择固定版本（）勾选specity version，下拉如果报错：pip._vendor.urllib3.exceptions.ReadTimeoutError: HTTPSConnectionPool(host=‘files.pythonhosted.org’, port=443): Read timed out.说明源有问题…...
2024/4/15 4:22:29
拿数问题【动态规化dp】
问题描述给一个序列，里边有 n 个数，每一步能拿走一个数，比如拿第 i 个数， Ai = x，得到相应的分数 x，但拿掉这个 Ai 后，x+1 和 x-1 (如果有 Aj = x+1 或 Aj = x-1 存在) 就会变得不可拿（但是有 Aj = x 的话可以继续拿这个 x）。求最大分数。 Input 第一行包含一个整数 …...
2024/4/28 16:11:32
systemctl服务部署错误：code=exited, status=217/USER
在centos8下给tomcat注册systemctl服务时报错：Process: 2688 ExecStart=/usr/local/tomcat/apache-tomcat-9.0.36/bin/startup.sh (code=exited, status=217/USER)我的配置文件[Unit] Description=Tomcat9 servlet After=syslog.target network.target[Service] Type=forkingU…...
2024/4/27 23:42:48
数据可视化——鸢尾花数据集的分析与散点图的绘制
** 数据可视化——鸢尾花数据集的分析及散点图的绘制话不多说，直接上代码。我们先来看一下鸢尾花数据集。#读取鸢尾花卉数据集，绘制“花瓣长度”和“花瓣宽度”特征之间的散点图。 import numpy as np import pandas as pd from sklearn.cluster import KMeans#K-means算法…...
2024/4/28 8:40:30
python值得学习吗？
python值得学习吗？大家好，我是一名刚毕业不到一年的本科学生，因不满之前碌碌无为的工作而果断辞职来学习python。因为我的专业是通信工程，本来打算想去网络安全的，但因为网络安全的就业范围窄，而且我也希望到时候能留在成都工作，所以就毅然决然的选择了python。那么我…...
2024/4/27 22:06:18
前端时间作为参数查询某一时间段的条件查询
前端：vue后端：springboot QueryWrapper前端vue组件：a-range-picker<a-range-picker:ranges="{ Today: [moment(), moment()], This Month: [moment(), moment().endOf(month)] }"@change="onChange" /> import moment from moment;data() {retur…...
2024/4/28 5:47:28
浏览器的兼容性问题
浏览器兼容性问题专题内容介绍(如何解决浏览器兼容性问题) 常见的browserhacks解决方案1-- 浏览器css样式初始化解决方案2-- 浏览器私有属性解决方案3-- css hack 解决方案4-- 自动化插件常见的browserhacks 具体的可以内容可以参考http://browserhacks.com/#ie 解决方案…...
2024/4/28 8:00:15
golang的垃圾回收（GC）机制
golang的垃圾回收（GC）机制介绍触发GC机制每当触发的时候，在主GC线程中就会走如下的GC流程：stop the world：标记：清理：start the world：综上：介绍 golang的垃圾回收采用的是标记-清理（Mark-and-Sweep）算法就是先标记出需要回收的内存对象快，然后在清理掉；在这…...
2024/4/28 8:43:22
React 源码解析
https://react.jokcy.me/...
2024/4/28 5:11:35
搞懂排序算法-选择排序
搞懂排序算法-选择排序 1 选择排序算法思想从序列中找出最大的那个元素，然后与末尾的元素交换位置忽略第一步中找到的最大元素，重复执行步骤1，直到全部元素有序。代码： public static void selectSort(Integer[] array){for (int end = array.length - 1; end > 0; en…...
2024/4/28 16:49:58
RabbitMQ安装及配置
一、安装Erlang 下载地址：https://www.erlang.org/downloads 本文选择OTP 23.0 Windows 64-bit Binary File (90666409) 设置环境变量，新建ERLANG_HOME修改环境变量path，增加Erlang变量至path，%ERLANG_HOME%\bin 打开cmd命令框，输入erl 如图Erlang安装完成。二、安装Rabb…...
2024/4/24 12:49:37
关于储存单位
本文涉及的概念：字 word 字节 byte 位 bit 字长单位转换： 1 Byte = 8 bits 1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB 1 TB = 1024 GB 1 PB = 1024 TB 1 EB = 1024 PB 1 ZB = 1024 EB 1 YB = 1024 ZB位 bit（比特）计算机内部数据储存的最小单位，1bit 表示1个二进…...
2024/4/24 12:49:38
浅谈Android BroadcastReceiver
浅谈Android BroadcastReceiver 文章目录浅谈Android BroadcastReceiver简介广播的类型广播的发送Android系统当中自带的Broadcast Action使用广播接收器的一般步骤1.实现一个广播接收器，继承自BroadcastReceiver类，重写onReceive（）方法2.注册广播接收器静态注册动态注册实…...
2024/4/24 12:49:38

Python和Numpy构建神经网络模型预测波士顿房价

相关文章

最新文章