机器学习笔记——（HW01）

读取文件操作

常见的读写操作：

with open(r'filename.txt') as f:
   data_user=pd.read_csv(f)  #文件的读操作

with open('data.txt', 'w') as f:
   f.write('hello world')  #文件的写操作

相关参数：

r:	以只读方式打开文件。文件的指针将会放在文件的开头。这是**默认模式**。
rb: 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+: 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+:以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w:	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb:	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+:	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+:以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a:	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab:	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+:	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+:以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
————————————————
版权声明：本文为CSDN博主「ckSpark」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/MsSpark/article/details/86745391

file对象的属性：

file.read([size])   将文件数据作为字符串返回，可选参数size控制读取的字节数
file.readlines([size])   返回文件中行内容的列表，size参数可选
file.write(str)   将字符串写入文件
file.writelines(strings)   将字符串序列写入文件
file.close()   关闭文件
file.closed	表示文件已经被关闭，否则为False

file.mode	Access文件打开时使用的访问模式
file.encoding	文件所使用的编码
file.name	文件名
file.newlines	未读取到行分隔符时为None，只有一种行分隔符时为一个字符串，当文件有多种类型的行结束符时，则为一个包含所有当前所遇到的行结束的列表
file.softspace	为0表示在输出一数据后，要加上一个空格符，1表示不加。这个属性一般程序员用不着，由程序内部使用
————————————————
版权声明：本文为CSDN博主「ckSpark」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/MsSpark/article/details/86745391

List list() 函数

list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

#要注意encoding编码，编码方式可以通过使用记事本打开csv文件，然后在界面右下角查看
path='HW1\\test\\test.csv'
with open(path, 'r',encoding='utf-8') as fp:
    data = list(csv.reader(fp))
print(data)

返回的结果：

[['id', 'A', 'B', 'C', 'D'], 
['1', '1', '0', '1', '0'], 
['2', '0', '1', '0', '0'], 
['3', '0', '0', '1', '1']]

修改代码成：

path='HW1\\test\\test.csv'
with open(path, 'r',encoding='utf-8') as fp:
    data = list(csv.reader(fp))
    #添加该行代码
    #截取从第二行、第二列开始的所有数据
    #将data转换成float类型
    data = np.array(data[1:])[:, 1:].astype(float)
print(data)

返回结果：

[[1. 0. 1. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 1.]]

对于截取某一列的数据：

data = [[1,2,6],
        [3,4,7]]
data = np.array(data)
print(data[:,0])
print(data[:,1])
print(data[:,2])
print(data[1,:])
print(data[:, 1:])
————————————————
版权声明：本文为CSDN博主「Sophia要一直努力」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_41555408/article/details/104677806

结果如下

[1 3]
[2 4]
[6 7]
[3 4 7]
[[2 6]
 [4 7]]

del

del 在 python 中的作用是删除变量，接触对变量的引用

s[:-1]

等价于 s[0:len(s)]，除了最后一个元素的切片

s='abcdefg'
print(s[0])
print(s[-2])
print(s[1:4])
print(s[1:4:2])
print(s[-1:1:-1])
print(len(s))
#输出
a
f
bcd
bd
gfedc
7

基本框架

DataSet

关于继承module模型

构造简单模型

class MLP(nn.Module):
# 声明模型参数层
    def __init__(self, **kwargs):
# 初始化
# **kwargs 表示函数接收可变长度的关键字参数字典
# super() 用来调用父类
        super(MLP,self).__init__(**kwargs)
        self.hidden = nn.Linear(784,256) # 声明隐藏层
        self.act = nn.ReLU()  # 添加激活函数
        self.output = nn.Linear(256,10)  # 添加输出层
# 定义模型向前计算
    def forward(self,x):
        a = self.act(self.hidden(x))
        return self.output(a)

X = torch.rand(2,784)
#随机产生两组样本
net = MLP() # 调用父类
print(net) # 查看MLP结构
# 网络模型为：隐藏层Linear(in_features=784, out_features=256, bias=True)
# 激活函数：ReLU()
# 输出层为：Linear(in_features=256, out_features=10, bias=True)
net(X) # 输出结果，输出2行10列的tensor

————————————————
版权声明：本文为CSDN博主「孔夫子的高压锅」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/gaokaojiayou/article/details/105779156

构造复杂模型

class FancyMLP(nn.Module):
    def __init__(self):
        super(FancyMLP, self).__init__()

        self.rand_weight = torch.rand((20, 20), requires_grad=False) #常数参数
#         权重参数不迭代
        self.linear = nn.Linear(20, 20)

    def forward(self, x):
        x = self.linear(x)
        # 使用创建的常数参数
        x = nn.functional.relu(torch.mm(x, self.rand_weight.data) + 1)
        # 复用全连接层。等价于两个全连接层共享参数
        x = self.linear(x)
        # 控制流，这里我们需要调用item函数来返回标量进行比较
        while x.norm().item() > 1:
            x /= 2
        if x.norm().item() < 0.8:
            x *= 10
        return x.sum()

X = torch.rand(2, 20)
net = FancyMLP()
print(net) # 只有一层结构
net(X)
————————————————
版权声明：本文为CSDN博主「孔夫子的高压锅」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/gaokaojiayou/article/details/105779156

class NestMLP(nn.Module):
    def __init__(self):
        super(NestMLP, self).__init__()
        self.net = nn.Sequential(nn.Linear(40, 30), nn.ReLU())

    def forward(self, x):
        return self.net(x)

net = nn.Sequential(NestMLP(), nn.Linear(30, 20), FancyMLP())
#嵌套调用FancyMLP和Sequential
X = torch.rand(2, 40)
print(net) # 多层复合网络模型
net(X)  
————————————————
版权声明：本文为CSDN博主「孔夫子的高压锅」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/gaokaojiayou/article/details/105779156

浅析PyTorch中nn.Module的使用
更新时间：2019年08月18日 10:52:30 作者：Steven·简谈
这篇文章主要介绍了浅析PyTorch中nn.Module的使用，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

torch.nn.Modules 相当于是对网络某种层的封装，包括网络结构以及网络参数和一些操作

torch.nn.Module 是所有神经网络单元的基类

查看源码
初始化部分：

def __init__(self):
  self._backend = thnn_backend
  self._parameters = OrderedDict()
  self._buffers = OrderedDict()
  self._backward_hooks = OrderedDict()
  self._forward_hooks = OrderedDict()
  self._forward_pre_hooks = OrderedDict()
  self._state_dict_hooks = OrderedDict()
  self._load_state_dict_pre_hooks = OrderedDict()
  self._modules = OrderedDict()
  self.training = True

属性解释：

_parameters：字典，保存用户直接设置的 Parameter
_modules：子 module，即子类构造函数中的内容
_buffers：缓存
_backward_hooks与_forward_hooks：钩子技术，用来提取中间变量
training：判断值来决定前向传播策略

方法定义：

def forward(self, *input):
 raise NotImplementedError

没有实际内容，用于被子类的 forward() 方法覆盖

且 forward 方法在 call 方法中被调用：

def __call__(self, *input, **kwargs):
 for hook in self._forward_pre_hooks.values():
    hook(self, input)
  if torch._C._get_tracing_state():
    result = self._slow_forward(*input, **kwargs)
  else:
    result = self.forward(*input, **kwargs)
  ...
  ...

实例展示
简单搭建：

import torch.nn as nn
import torch.nn.functional as F
 
class Net(nn.Module):
  def __init__(self, n_feature, n_hidden, n_output):
    super(Net, self).__init__()
    self.hidden = nn.Linear(n_feature, n_hidden)
    self.out = nn.Linear(n_hidden, n_output)
 
  def forward(self, x):
    x = F.relu(self.hidden(x))
    x = self.out(x)
    return x

Net 类继承了 torch 的 Module 和 init 功能

hidden 是隐藏层线性输出

out 是输出层线性输出

打印出网络的结构：

net = Net(n_feature=10, n_hidden=30, n_output=15)
print(net)
Net(
 (hidden): Linear(in_features=10, out_features=30, bias=True)
 (out): Linear(in_features=30, out_features=15, bias=True)
)

在函数的名称后加 “" 的函数一般是就地改变值，而不加 "” 的一般不是就地改变值。