数据控|突破是我们的每一步datahold.cn

R语言卷积神经网络模型示例
```
library(torch)

convnet <- nn_module(
  "convnet",
  
  initialize = function() {
    
    # nn_conv2d(in_channels, out_channels, kernel_size)
    self$conv1 <- nn_conv2d(1, 16, 3)
    self$conv2 <- nn_conv2d(16, 32, 3)
    self$conv3 <- nn_conv2d(32, 64, 3)
    
    self$output <- nn_linear(2304, 3)

  },
  
  forward = function(x) {
    
    x %>% 
      self$conv1() %>% 
      nnf_relu() %>%
      nnf_max_pool2d(2) %>%
      self$conv2() %>% 
      nnf_relu() %>%
      nnf_max_pool2d(2) %>%
      self$conv3() %>% 
      nnf_relu() %>%
      nnf_max_pool2d(2) %>%
      torch_flatten(start_dim = 2) %>%
      self$output()
      
  }
)

model <- convnet()
```
简要解析如下：
1. 导入库：library(torch)用于加载 torch 库，这是 R 的一个深度学习框架。
2. 定义模型结构：
  - 使用nn_module定义一个新的模块类convnet。
  - 初始化函数initialize中：
    nn_conv2d(1, 16, 3)：定义了一个二维卷积层，输入通道数为1，输出通道数为16，卷积核大小为3×3。
    nn_conv2d(16, 32, 3)和nn_conv2d(32, 64, 3)：后续的卷积层，分别从16通道转换到32通道，再到64通道。
    nn_linear(2304, 3)：定义一个全连接层，输入大小2304，输出大小为3。
3. 前向传播函数forward：
  - 数据流动通过各层，依次经过卷积、ReLU激活、最大池化（nnf_max_pool2d(2)，池化窗口大小为2）。
  - 在经过三次卷积-激活-池化之后，将输出展平成一维（torch_flatten(start_dim = 2)），再通过全连接层生成最终输出。
4. 模型实例化：model <- convnet()创建了一个新的convnet模型实例。
这个卷积神经网络主要用于处理二维图像输入，并通过特征提取和降维，最终输出一个具有3个类别的预测结果。
2024年11月12日
道之所以称其大
道无边，宙不停，称为大。大者，涵盖一切，无所不包也。走其正路，则德；逆德而为之，不可久矣，是为明德而存。
2024年11月2日

torch和luz在dataloader、张量和R对象的训练

通过测试，dataloader的速度最快。张量和R对象的速度一样。

library(torch)
library(luz)

# input dimensionality (number of input features)
d_in <- 3
# number of observations in training set
n <- 1000

# 生成一个1000x3的矩阵，其元素为从正态分布生成的随机数
x <- torch_randn(n, d_in)
# 定义线性关系的系数
coefs <- c(0.2, -1.3, -0.5)
# 计算目标变量y，使其成为输入x的线性组合，并添加噪声
y <- x$matmul(coefs)$unsqueeze(2) + torch_randn(n, 1)
# 使用输入和目标张量创建一个数据集对象
ds <- tensor_dataset(x, y)
# 构建一个数据加载器，批量大小为100，并启用随机洗牌以随机化数据顺序
dl <- dataloader(ds, batch_size = 100, shuffle = TRUE)
# 将隐藏层的神经元数量设置为32
# dimensionality of hidden layer
d_hidden <- 32
# 将输出特征或预测的数量设为1
# output dimensionality (number of predicted features)
d_out <- 1

# 使用torch包初始化一个神经网络模块
net <- nn_module(
    # 接收输入维度、隐藏层维度和输出维度作为参数
  initialize = function(d_in, d_hidden, d_out) {
    # 构建一个由三个部分组成的序列化神经网络
    self$net <- nn_sequential(
        # 从输入层到隐藏层的线性变换
      nn_linear(d_in, d_hidden),
    #   对隐藏层输出应用ReLU激活函数
      nn_relu(),
    #   从隐藏层到输出层的线性变换
      nn_linear(d_hidden, d_out)
    )
  },
#   定义网络的前向传递，将initialize中定义的序列模型应用于输入x
  forward = function(x) {
    self$net(x)
  }
)

# 初始化模型以进行训练
fitted <- net %>%
# 设置损失函数为均方误差（MSE）,指定Adam优化算法
  setup(loss = nn_mse_loss(), optimizer = optim_adam) %>%
#   配置模型的超参数
  set_hparams(
    d_in = d_in,   # 设置输入维度
    d_hidden = d_hidden,   # 设置隐藏层的神经元数量
    d_out = d_out   # 设置输出维度
  ) %>%
   # 使用提供的数据加载器dl训练模型
#    dl: 包含训练数据集的数据加载器
# 指定训练过程运行200个周期，即将整个数据集迭代200次
  fit(dl, epochs = 200)  

# 替换dl为张量
fitted <- net %>%
  setup(loss = nn_mse_loss(), optimizer = optim_adam) %>%
  set_hparams(
    d_in = d_in,
    d_hidden = d_hidden, d_out = d_out
  ) %>%
  fit(list(x, y), epochs = 200)

# 替换dl为R对象
fitted <- net %>%
  setup(loss = nn_mse_loss(), optimizer = optim_adam) %>%
  set_hparams(
    d_in = d_in,
    d_hidden = d_hidden, d_out = d_out
  ) %>%
  fit(list(as.matrix(x), as.matrix(y)), epochs = 200)

2024年11月1日

CSS的justify-content实现居中
center可以换成其他属性，比如space-between或space-around。
```
.container {
  border: 2px solid #806868;
  display: flex;
  justify-content: center
}
```
展开/折叠结果

第一段
第二段
第三段


展开/折叠结果

第一段
第二段
第三段


展开/折叠结果

第一段
第二段
第三段
2024年10月31日
CSS中的弹性盒子
本来应该是两个段落的内容可以横向排列在容器中。主要依靠display: flex;来实现。示例如下：
```
<!DOCTYPE HTML>
<html>
<head>
	<style>
		.container {
			border: solid 2px #806868;
			display: flex;
			height: 100px;
		}
		.item {
			border: 2px solid #457081;
			margin: 10px;
		}
	</style>
</head>
<body>
	<div class="container">
		<p class="item">第一段</p>
		<p class="item">第二段</p>
	</div>
</body>
</html>
```
展开/折叠结果
第一段
第二段
2024年10月30日

C#计算考试分数平均数并显示超过平均数的人

景珍	林惠洋	成蓉	洪南昌	龙玉民	单江开	田武山	王三明
90	65	88	70	46	81	100	68

上面是一些同学的姓名和对应的考试分数，请输出他们的平均分和高于平均分的同学姓名。输出结果如下：

平均分是76，高于平均分的有：
景珍成蓉单江开田武山

using System;
using System.Collections.Generic;
using System.Text;

namespace projAboveAvg
{
    class Program
    {
        static void Main(string[] args)
        {
            int mean = 0;
            int [] scores = new int[]
            {
                90,65,88,70,46,81,100,68
            };
            string [] names = new string[]
            {
                "景珍","林惠洋","成蓉","洪南昌","龙玉民","单江开","田武山","王三明"
            };
            foreach(int x in scores)
            {
                mean = mean + x;
            }
            mean = mean / scores.Length;
            Console.WriteLine("平均分是{0}，高于平均分的有：",mean);
            for (int i=0; i<scores.Length;i++)
            {
                if (scores[i]>=mean)
                {
                    Console.Write("{0} ",names[i]);
                }
            }
        }
    }
}

2024年10月29日

模块化神经网络

library(torch)
# input dimensionality (number of input features)
# 输入维度（特征的数量）被设定为3，每个输入数据点有3个特征
d_in <- 3
# number of observations in training set
# 训练集中的观测数量被设定为100
n <- 100
# 创建一个100行3列的矩阵x
x <- torch_randn(n, d_in)
# 定义了一个包含系数的向量coefs
coefs <- c(0.2, -1.3, -0.5)
# 进行矩阵乘法运算，将矩阵x与系数coefs相乘
# 并对每个元素添加噪声（通过unsqueeze添加一个额外的维度）
# 最终生成目标变量y。
y <- x$matmul(coefs)$unsqueeze(2) + torch_randn(n, 1)
# 隐藏层32个维度
d_hidden <-32
# 输出层维度为1
d_out <- 1
# 创建序列模型
net <- nn_sequential(
  nn_linear(d_in, d_hidden),   # 全连接层，线性层
  nn_relu(),   # 激活函数，引入非线性层
  nn_linear(d_hidden, d_out)   # 线性层，从隐藏层输出
)
# 初始化Adam优化器
opt <- optim_adam(net$parameters)
### training loop --------------------------------------

for (t in 1:200) {
  
  ### -------- Forward pass --------
  # 向前传递，通过net生成预测值
  y_pred <- net(x)
  
  ### -------- Compute loss -------- 
  # 使用均方误差（MSE）计算预测值y_pred与实际值y之间的损失
  loss <- nnf_mse_loss(y_pred, y)
  # 每10个周期输出一次损失值
  if (t %% 10 == 0)
    cat("Epoch: ", t, "   Loss: ", loss$item(), "\n")
  
  ### -------- Backpropagation --------
  # 在反向传播之前重置梯度为零
  opt$zero_grad()
  # 使用反向传播计算损失相对于网络参数的梯度
  loss$backward()
  
  ### -------- Update weights -------- 
  # 根据计算出的梯度更新网络的权重，以减少下一次迭代中的损失
  opt$step()

}

展开/折叠结果

Epoch:  10    Loss:  3.248455 
Epoch:  20    Loss:  3.051522
Epoch:  30    Loss:  2.866707 
Epoch:  40    Loss:  2.689961 
Epoch:  50    Loss:  2.51879
Epoch:  60    Loss:  2.350682 
Epoch:  70    Loss:  2.18356 
Epoch:  80    Loss:  2.018582 
Epoch:  90    Loss:  1.856642 
Epoch:  100    Loss:  1.700728
Epoch:  110    Loss:  1.553768 
Epoch:  120    Loss:  1.417934 
Epoch:  130    Loss:  1.294667 
Epoch:  140    Loss:  1.187055 
Epoch:  150    Loss:  1.096451
Epoch:  160    Loss:  1.022662 
Epoch:  170    Loss:  0.9643999 
Epoch:  180    Loss:  0.9189036 
Epoch:  190    Loss:  0.8844466 
Epoch:  200    Loss:  0.8586743

2024年10月28日

CSS文字相对位置

<!DOCTYPE html>
<html>
    <head>
        <style>
            strong {
                position: relative;
                bottom: 20px;
            }
        </style>
    </head>
    <body>
        <p>这<strong>是</strong>一句话。</p>
    </body>
</html>

这是一句话。

2024年10月27日

torch的模块

library(torch)
# 线性层，输入特征5，输出特征16，常用于神经网络的第一层
l <- nn_linear(in_features = 5, out_features = 16)
l
l$weight
l$bias
# 生成一个尺寸为 [50, 5] 的随机张量 x，
# 其中包含50个样本，每个样本有5个特征。
# 数据服从标准正态分布。
x <- torch_randn(50, 5)
# x 传递给线性层 l，得到输出 output
output <- l(x)
# 获取并返回输出张量的尺寸，即 [50, 16]
output$size()
# 用于跟踪生成 output 张量的计算图中的梯度函数。
output$grad_fn

# 定义损失函数为output的均值
loss <- output$mean()
# loss的反向传播
loss$backward()
# 获取线性层 l 的权重参数的梯度。
# 这些梯度用于更新权重，
# 以最小化损失函数。
l$weight$grad

# 多层感知机，模型是通过 nn_sequential 组合多个神经网络模块构建
mlp <- nn_sequential(
  nn_linear(10, 32),
  nn_relu(),
  nn_linear(32, 64),
  nn_relu(),
  nn_linear(64, 1)
)

# 调用该模块
mlp(torch_randn(5, 10))

2024年10月26日

利用自动微分来计算梯度并优化函数

# 加载torch包
library(torch)

# 设置常量a和b
a <- 1
b <- 5

# rosenbrock函数
rosenbrock <- function(x) {
  x1 <- x[1]
  x2 <- x[2]
  (a - x1)^2 + b * (x2 - x1^2)^2
}

# 迭代数2
num_iterations <- 2

# x被初始化为一个值为-1和1的张量k
# 并且requires_grad = TRUE表示需要为该张量计算梯度。
x <- torch_tensor(c(-1, 1), requires_grad = TRUE)

# optimizer使用optim_lbfgs设置
# 这是L-BFGS优化算法的实现
# line_search_fn参数设置为"strong_wolfe"，这是一种线搜索方法
optimizer <- optim_lbfgs(x, line_search_fn = "strong_wolfe")

# calc_loss函数用于清零现有的梯度，计算Rosenbrock函数的值
# 显示该值，然后调用backward()来计算梯度。
calc_loss <- function() {
  optimizer$zero_grad()

  value <- rosenbrock(x)
  cat("Value is: ", as.numeric(value), "\n")

  value$backward()
  value
}

# 循环运行指定的迭代次数（num_iterations）
# 在每次迭代中，打印迭代次数并调用optimizer$step(calc_loss)
# 这会使用L-BFGS算法执行一次优化步骤。
for (i in 1:num_iterations) {
  cat("\nIteration: ", i, "\n")
  optimizer$step(calc_loss)
}

2024年10月24日