# googleColab
代码开发和数据分析总是需要一些尝试和错误，而 IPython 包含简化这一过程的工具。本节将简要介绍控制 Python 异常报告的一些选项，然后探讨调试代码错误的工具。



[参考博客](https://blog.xuchunqiu.com/can-we-really-debug-in-google-colab/)

[官方colab使用手册](https://colab.research.google.com/notebooks/basic_features_overview.ipynb)
### 控制异常：%xmode

%xmode 接收一个参数，即模式，有三种可能：Plain（普通）、Context（上下文）和 Verbose（详细）。默认模式是 Context（上下文），输出结果如图所示。普通模式更简洁，提供的信息更少：

```python
%xmode Verbose
```

### Debugging 

用于交互式调试的标准 Python 工具是 `pdb`​，即 Python 调试器。此调试器允许用户逐行遍历代码，以查看可能导致更困难错误的原因。它的 IPython 增强版本是 ipdb，即 IPython 调试器。

有许多方法可以启动和使用这两个调试器;我们不会在这里完全介绍它们。请参阅这两个实用程序的在线文档以了解更多信息。

在 IPython 中，也许最方便的调试界面是 %debug magic 命令。如果你在命中异常后调用它，它会在异常点自动打开一个交互式调试提示。ipdb 提示符可让您浏览堆栈的当前状态、探索可用变量，甚至运行 Python 命令！

```python
%debug
```

```python
> <ipython-input-1-d849e34d61fb>(2)func1()
      1 def func1(a, b):
----> 2     return a / b
      3 

ipdb> print(a)
1
ipdb> print(b)
0
ipdb> quit
```

这使我们不仅可以快速找出导致错误的原因，还可以快速找出导致错误的函数调用。如果希望调试器在引发异常时自动启动，则可以使用 %pdb magic 函数来启用此自动行为：

```shell
%xmode Plain
%pdb on
func2(1)
```

交互式调试器的功能远不止这些--我们甚至可以在堆栈中上下移动，并探索其中的变量值：

```shell
> <ipython-input-1-d849e34d61fb>(2)func1()
      1 def func1(a, b):
----> 2     return a / b
      3 

ipdb> up
> <ipython-input-1-d849e34d61fb>(7)func2()
      5     a = x
      6     b = x - 1
----> 7     return func1(a, b)

ipdb> print(x)
1
ipdb> up
> <ipython-input-6-b2e110f6fc8f>(1)<module>()
----> 1 func2(1)

ipdb> down
> <ipython-input-1-d849e34d61fb>(7)func2()
      5     a = x
      6     b = x - 1
----> 7     return func1(a, b)

ipdb> quit
```

这不仅能让我们快速找出导致错误的原因，还能找出导致错误的函数调用。 如果希望调试器在出现异常时自动启动，可以使用 %pdb 神奇函数来打开这种自动行为：

```python
%xmode Plain
%pdb on
func2(1)
```

```python
Exception reporting mode: Plain
Automatic pdb calling has been turned ON
Traceback (most recent call last):

  File "<ipython-input-9-569a67d2d312>", line 3, in <module>
    func2(1)

1 frames
  File "<ipython-input-1-d849e34d61fb>", line 2, in func1
    return a / b

ZeroDivisionError: division by zero
> <ipython-input-1-d849e34d61fb>(2)func1()
      1 def func1(a, b):
----> 2     return a / b
      3 

ipdb> print(b)
0
ipdb> quit
```

‍

#### Partial list of debugging commands

部分调试命令列表

There are many more available commands for interactive debugging than I've shown here. The following table contains a description of some of the more common and useful ones:

```markdown
Command	Description
l(ist)	Show the current location in the file
h(elp)	Show a list of commands, or find help on a specific command
q(uit)	Quit the debugger and the program
c(ontinue)	Quit the debugger, continue in the program
n(ext)	Go to the next step of the program
<enter>	Repeat the previous command
p(rint)	Print variables
s(tep)	Step into a subroutine
r(eturn)	Return out of a subroutine

```

For more information, use the help command in the debugger, or take a look at ipdb's online documentation.

googleColabDebugMode

出现了`HTTPSConnectionPool(host=‘huggingface.co‘, port=443)`错误的解决方法
在下载huggingface 模型的时候，经常会出现这个错误，`HTTPSConnectionPool(host=‘huggingface.co’, port=443)`，即使你已经有了正确的上网姿势。



如在下载Tokenizer的时候，

`tokenizer = AutoTokenizer.from_pretrained("csebuetnlp/mT5_multilingual_XLSum")`

就会出现以上的错误`HTTPSConnectionPool(host=‘huggingface.co‘, port=443)`

解决的办法可以有两种。

#### 1.直接下载模型
第一种方式，你可以直接的huggingface 上，指定模型的Files and versions 进行下载，全部下载完成以后，设置本地模型的路径，就是下载以后放在本地的文件夹地址。
```python
tokenizer = AutoTokenizer.from_pretrained("模型的本地路径")
```
在这里插入图片描述
这样模型加载的时候，就不会从网上进行下载，而是直接用本地的模型。

![image.png](/static/img/7218a6866cf4dd658bbc1091d37febbf.image.webp)

#### 2.降级requests和urllib3
如果不想手动下载那么多的文件，可以把 `requests` 降到`2.27.1`，`urllib3` 降到`1.25.11`，当然能下载的前提是你已经有了正确的上网姿势。
```python
pip install requests==2.27.1
pip install urllib3==1.25.11
```

就可以看到，模型自己在下载了
```
Downloading (…)okenizer_config.json: 100%|██████████| 375/375 [00:00<?, ?B/s] 
Downloading (…)lve/main/config.json: 100%|██████████| 730/730 [00:00<?, ?B/s] 
Downloading spiece.model: 100%|██████████| 4.31M/4.31M [00:03<00:00, 1.08MB/s]
Downloading (…)cial_tokens_map.json: 100%|██████████| 65.0/65.0 [00:00<00:00, 65.1kB/s]
```
#### 3.直接代理
后面发现，有种方法也是可以用，直接在代码中使用代理：
```python
import os
os.environ["http_proxy"] = "http://127.0.0.1:33210"
os.environ["https_proxy"] = "http://127.0.0.1:33210"
## 注意此处的代理端口主要根据你电脑的代理设置 
```
#### 4. 参考pycharm中的代理检查
![image.png](/static/img/c8878210092c6f40c926fb7f134353a4.image.webp)

HTTPSConnectionPool_huggingface.co

# Windows 开启 OpenSSH 和 远程服务 和 Frp服务
这篇博客详细介绍了如何在 Windows 系统上启用 OpenSSH 和远程服务，及安装和配置 FRP（Fast Reverse Proxy）服务。
1）如何开启 OpenSSH，包括通过「设置」和 PowerShell 安装客户端和服务器的步骤。同时，提供了配置 OpenSSH 服务器和使用 OpenSSH 客户端连接远程 SSH 服务器的指南。
2）如何在 Windows 11 上启用远程桌面连接，包括通过「设置」和「控制面板」的不同方法，并强调了注意事项。
3）如何安装 FRP 客户端，并详细说明了如何设置 FRP 服务在开机时自动启动。
3）如何使用 NSSM（Non-Sucking Service Manager）来管理 FRP 服务的过程。




# 1. OpenSSH

## 1.1  开启 OpenSSH 客户端 / 服务器

**准备条件:**  在开始安装 OpenSSH 之前，请确保你的电脑满足以下条件：

* **操作系统**：Windows 11 或 Windows 10（1809 版本或更高）。
* **PowerShell 版本**：PowerShell 5.1 或以上。
* **管理员权限**：安装 OpenSSH 需要拥有管理员权限。

### 1.1.1 方法 1：通过「设置」安装

1. 使用 `Windows + I` ​快捷键打开「设置」，依次选择「系统」\>「可选功能」。

2. 点击「查看功能」，在搜索框中输入 `OpenSSH` ​进行筛选。

3. 根据需要勾选：

* **OpenSSH 客户端**：可以使用 ssh 命令连接到其他支持 SSH 的设备。
* **OpenSSH 服务器**：允许其他设备通过 SSH 连接到你的电脑。

![](http://p3pp3r.cn:88/static/img/8d2e130481baa3f46cef3c74d5851d4c.network-asset-openssh-windows-p2-20241127124658-w6fy1x2.webp)

4. 选择好后点击「下一步」，然后点击「安装」开始安装过程。

### 1.1.2 方法 2：使用 PowerShell 安装

1. 使用 `Windows + R` ​快捷键打开「运行」对话框，输入 `powershell`​，然后按 `Ctrl + Shift + Enter` ​以管理员权限打开 PowerShell 窗口。

2. 执行以下命令查看 OpenSSH 安装状态：

```
Get-WindowsCapability -Online | Where-Object Name -like 'OpenSSH*'
```

如果返回 `NotPresent`​，表示未安装；返回 `Installed` ​则表示已安装。

3. 根据需要安装 OpenSSH 客户端和服务器组件：

```
# 安装 OpenSSH 客户端
Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0

# 安装 OpenSSH 服务器
Add-WindowsCapability -Online -Name OpenSSH.Server~~~~0.0.1.0
```

![network-asset-openssh-windows-p3-20241127124658-slp7rsd.jpg](/static/img/155e173a6a555881fd3f4dba621ae5de.network-asset-openssh-windows-p3-20241127124658-slp7rsd.webp)
‍

## 1.2 配置 OpenSSH 服务器

当你在 Windows 上安装了 OpenSSH 服务器之后，需要进行一些配置才能接受连接：

1. 使用 `Windows + R` ​快捷键打开「运行」对话框，输入 `powershell`​，然后按 `Ctrl + Shift + Enter` ​以管理员权限打开 PowerShell。

2. 设置 SSHD 服务自动启动：

```
Set-Service -Name sshd -StartupType 'Automatic'
```

3. 启动 SSHD 服务：

```
Start-Service sshd
```

4. 检查 SSH 服务器是否在侦听 22 端口：

```
netstat -an | findstr /i ":22"
```

5. 确保 Windows Defender 防火墙允许 TCP 22 端口的入站连接：

```
Get-NetFirewallRule -Name *OpenSSH-Server* | select Name, DisplayName, Description, Enabled
```


![network-asset-openssh-windows-p4-20241127124658-7yk6s1e.jpg](/static/img/e9d3176216512aad3d32e448c92a8e7a.network-asset-openssh-windows-p4-20241127124658-7yk6s1e.webp)
如规则丢失或被禁用，可以创建新规则：

```
New-NetFirewallRule -Name sshd -DisplayName 'OpenSSH Server (sshd)' -Enabled True -Direction Inbound -Protocol TCP -Action Allow -LocalPort 22
```

6. （可选）如果要修改配置，如设置用户访问权限，可以编辑 `sshd_config` ​配置文件：

```
Start-Process Notepad C:\Programdata\ssh\sshd_config
```

7. 根据需要修改配置文件，保存后关闭记事本。

OpenSSH 服务器配置文件可以在 [sshd_config 手册页](https://man.openbsd.org/sshd_config)中找到。


![network-asset-openssh-windows-p5-20241127124658-r5eyoa7.jpg](/static/img/79039bb4eea9851c8ae81c6f028b8e6c.network-asset-openssh-windows-p5-20241127124658-r5eyoa7.webp)
8. 完成更改后，重启 SSHD 服务应用配置：

```
Restart-Service sshd
```


![network-asset-openssh-windows-p6-20241127124658-5097s2g.jpg](/static/img/ca53bf739fa1d84bac3ebad4bf90dcd2.network-asset-openssh-windows-p6-20241127124658-5097s2g.webp)

按照这些步骤，你的 Windows 就能通过 SSH 协议接受连接了。

‍

‍

## 1.3 使用 OpenSSH 客户端连接远程 SSH 服务器

在 Windows 中安装完 OpenSSH 客户端后，就可以立即与远程 SSH 设备建立连接：

1. 打开命令提示符或 Powershell，执行以下命令来检查 OpenSSH 客户端是否已经正确安装：

```
ssh
```

2. 使用以下命令连接到配置了 SSH 的服务器：

```
ssh [用户名]@[服务器IP]
```


![network-asset-openssh-windows-p7-20241127124658-vemi8jg.jpg](/static/img/7dadbd67ee2001138d8f48654aba26e2.network-asset-openssh-windows-p7-20241127124658-vemi8jg.webp)

3. 首次连接时，会要求你输入密码。如果远程设备使用非标准 22 端口，需要指定端口号：

```
ssh 用户名@服务器名称 -p 端口号
```

‍

# 2. RemoteServer

Windows 11 的远程桌面功能可以让你直接操控另一台电脑，并在上面运行软件、管理系统设置，或者远程解决问题。被控制的电脑称为「远程桌面主机」，而控制端则称为「客户端计算机」。默认情况下，远程桌面功能会使用远程桌面协议（RDP），通过 `TCP 3389` ​端口传输数据。让你可以在 Windows、macOS、iOS 和 Android 设备上连接到 Windows 11 远程桌面主机，而且数据传输经过加密，十分安全可靠。Windows 11 家庭版只能作为客户端计算机，不能作为远程桌面主机，也就是被控制端。详细区别请访问 [Windows 11 家庭版与专业版功能对比](https://www.sysgeek.cn/windows-11-pro-vs-home-different/)。

## 2.1 启用 Windows 11 远程桌面连接（被控端）

为了确保安全，默认情况下，Windows 11 并不允许远程桌面连接，但可以通过以下 2 种方式打开该功能：

### 2.1.1 方法 1：通过「设置」

1. 使用 `Windows + I` ​快捷键打开「设置」，选择「系统」\>「远程桌面」。

2. 打开「远程桌面」开关。

3. 建议保留默认开启的「要求设备使用网络级别身份验证连接（推荐）」设置。

![network-asset-remote-desktop-windows-p2-20241127125219-dbl51nv.jpeg](/static/img/8a2463a65e8f577e6c6bad2111fccd02.network-asset-remote-desktop-windows-p2-20241127125219-dbl51nv.webp)
4. 点击「远程桌面用户」，添加要允许进行远程连接的用户账户。

![network-asset-remote-desktop-windows-p3-20241127125219-rz6m4hp.jpeg](/static/img/a467b85490e1dabfc989b9b1c4f2aa47.network-asset-remote-desktop-windows-p3-20241127125219-rz6m4hp.webp)


### 2.1.2 方法 2：通过「控制面板」

1. 使用 `Windows + R` ​快捷键打开「运行」对话框，执行 `control` ​打开控制面板。

2. 选择「系统和安全」\>「允许远程访问」。

![network-asset-remote-desktop-windows-p4-20241127125220-exdqibs.jpeg](/static/img/9f93b5f142c963661561dd633070dc37.network-asset-remote-desktop-windows-p4-20241127125220-exdqibs.webp)

3. 在「远程桌面」区域中，选择「允许远程连接到此计算机」，并勾选「仅允许运行使用网络级别身份验证的远程桌面的计算机连接（建议）」。

4. 点击「选择用户」，添加要允许进行远程连接的用户账户。

![network-asset-remote-desktop-windows-p5-20241127125220-6eiqrc0.jpeg](/static/img/a85f98e1d2c4aca2266363d276caf638.network-asset-remote-desktop-windows-p5-20241127125220-6eiqrc0.webp)

### 2.1.3 注意事项

* 网络级别身份验证（NLA）可以提高安全性，只有在使用不支持 NLA 的旧版 Windows 系统时，才需要关闭它。
* 启用远程桌面功能后，系统会启动一个名为 `TermService` ​的服务，并监听 `TCP 3389` ​端口的传入连接。还会在 Windows 防火墙中添加例外规则，允许该端口接收经过验证的数据。
* 如果你使用了第三方安全软件，可能需要手动放行 `TCP 3389` ​端口。
* 默认情况下，当前用户和所有管理员组的用户账户都可以远程连接到这台电脑。

## 2.2 连接远程桌面（控制端）

Windows 11 自带的「远程桌面连接」应用，可以让你轻松访问远程电脑：

1. 使用 `Windows + R` ​快捷键打开「运行」对话框，执行 `mstsc` ​打开「远程桌面连接」应用。

2. 在「计算机」输入框中，输入远程电脑的名称或 IP 地址。

3. 输入完成后，点击「连接」按钮，即可开始连接远程电脑。


![network-asset-remote-desktop-windows-p6-20241127125220-uykdd59.jpeg](/static/img/3c7bdf7da12143ba8d33fe2914ef13c9.network-asset-remote-desktop-windows-p6-20241127125220-uykdd59.webp)

默认情况下，远程电脑的桌面会全屏显示，分辨率与客户端电脑相同。屏幕顶部中央会显示一个连接栏，方便你在本地桌面和远程桌面之间切换。你也可以点击图钉按钮固定连接栏。

「远程桌面连接」应用还提供了丰富的配置选项，这里介绍两个常用功能：

* 允许我保存凭据：在「常规」选项卡中，可以输入用户名并勾选「允许我保存凭据」。保存后，下次连接时，系统会自动填充这些信息，无需重复输入。
* 本地资源：在连接对话框中点击「本地资源」选项卡，可以设置是否访问本地打印机、共享剪贴板内容，以及如何处理远程音频。


![network-asset-remote-desktop-windows-p7-20241127125220-g8icxu7.jpeg](/static/img/8ce6da6fd34ef5b6d881adf582529975.network-asset-remote-desktop-windows-p7-20241127125220-g8icxu7.webp)

![network-asset-remote-desktop-windows-p8-20241127125220-jclxh7y.jpeg](/static/img/c6d98f6ad4a374a375f6da11a017ca52.network-asset-remote-desktop-windows-p8-20241127125220-jclxh7y.webp)
‍

# 3. 安装 frp 服务-客户端

1. 下载`frp`​客户端

在github中下载frp, 下载链接: [https://github.com/fatedier/frp/releases](https://github.com/fatedier/frp/releases),注意下载的时候需要结合服务器的版本来选择，例如旧版本: [https://github.com/fatedier/frp/releases/tag/v0.36.2](https://github.com/fatedier/frp/releases/tag/v0.36.2)

![image-20241127162910-lkpmbaj.png](/static/img/e13733134477c4d02a0321f07ba99e96.image-20241127162910-lkpmbaj.webp)

2. 客户端配置文件`frpc.ini`​如下:

​`[客户端对应为frpc开头的运行程序以及文件]`​

```python
[common]
# 配置服务端对外的ip地址 随意填写的
server_addr = 111.23.36.33
#配置服务端监听的端口
server_port = 7000

#如果服务端配置token，将服务端配置的token复制到此处#
#token = 8d262f2b-6dba-4a8d-857e-8a53d1d439e2
#pool_count = 5

#我这里是配置端口范围转发
[range:services]
#类型为tcp
type = tcp
#本地ip地址通常为127.0.0.1
local_ip = 0.0.0.0
#本地要映射的端口范围 bendi
local_port = 8080
#映射到服务端的端口范围 fangwen
remote_port = 7500
```

3. 客户端运行，用下面的命令（该方法不适合自启动）：

    ```shell
    frpc.exe -c frpc.ini
    ```



# 4.  Windows 设置 frpc 开机自动启动 电脑时钟管理

新建 frpc.bat,内容如下(放到自己 frpc 实际目录下):

```php
@echo off
:home
frpc -c frpc.ini
goto home
```

打开开始菜单，输入 “任务计划程序” 将会自动搜索，接着打开它。

![network-asset-6a687f946eb8a27493bdc33b2116521a-20241127154233-k7w7s6i.png](/static/img/9a3129ec217f48dc8d7b9d7897bf21e8.network-asset-6a687f946eb8a27493bdc33b2116521a-20241127154233-k7w7s6i.webp)

点击右侧的 “创建任务”，名称随意填写，安全选项选择 “不管用户是否登录都要运行”，当然你也可以选择 “只在用户登录时运行”。

选择 “不管用户是否登录都要运行” 可以让你的电脑在断电自动启动后自动运行 frp，你就可以远程桌面连接电脑了。

“使用最高权限运行” 也是可选的，根据个人需要可以选上。

最后勾选 “隐藏”，就不会在启动时弹出命令行窗口了。


![network-asset-78662b6c3687fe93b6c17cd9e30ba0a2-20241127154325-m4cwk3t.png](/static/img/98488a4d9a5d746f2cf55e3eb72ee431.network-asset-78662b6c3687fe93b6c17cd9e30ba0a2-20241127154325-m4cwk3t.webp)

接着转到 “触发器” 页，点击新建，选择 “启动时”

![network-asset-d2843a7c1bd1be9969cc71eb2686da5e-20241127154325-4kdupmp.png](/static/img/9817f89124e28970bf4dd0a6cdf6871b.network-asset-d2843a7c1bd1be9969cc71eb2686da5e-20241127154325-4kdupmp.webp)

接着转到 “操作” 页，点击新建，选择 “启动程序”

在程序或脚本一栏选择第一步创建的 start.bat，下面的 “起始于” 填写 start.bat 的路径（不要包含 start.bat）

例如你的 start.bat 在 E:\\frp\\start.bat，那么你只需要在 “起始于” 填写 E:\\frp\\
![network-asset-e48e75db8c3c640c3547f0cc39de606c-20241127154325-1t1u2ij.png](/static/img/41a6407bce9b89a0ddc1b4708facde32.network-asset-e48e75db8c3c640c3547f0cc39de606c-20241127154325-1t1u2ij.webp)

接着返回 “常规” 页，点击确定，此时会要求输入密码，输入你的电脑密码，然后点击确定即可。

以后就会开机自动启动 frp 了，并且不会弹出命令提示符窗口。

# 5.  nssm 管理 frpc

1. 下载与安装： 

    因为服务端客户端不能总用 cmd 窗口打开,故注册为系统服务，需用到 [nssm](http://nssm.cc) 软件来进行配置，[下载链接](https://nssm.cc/download)，注意 `需要关闭防火墙`​​

2. 根据电脑配置选择 32/64 位运行程序，把下载到的` nssm.exe `​放到` C:\Windows\System32 `​下，其他可以不要

![image-20241127161753-wprgbxs.png](/static/img/b393dab275ec228c70de2f51e87bfe39.image-20241127161753-wprgbxs.webp)

3. 使用管理员运行`cmd`​跳转到`exe`​所在目录，直接执行命令` nssm install frp`​


![image-20241127162314-rlik1ja.png](/static/img/975987b23bfa63e5ee496ef176d6b380.image-20241127162314-rlik1ja.webp)

其中，`Path `​程序路径；`Startup directory`​ 选择 `Path `​会自动配置；`Arguments`​ 为启动参数，`frps `​配置为` -c frps.ini`​，`frpc`​ 配置为 `-c frpc.ini`​

4. 其他命令行, 注意一般remove完后需要重启机器

```shell
# 启动服务 frpc为安装服务时自定义名称 如:frp_amd64
nssm start frpc

# 停止服务
nssm stop frpc

# 编辑服务配置
nssm edit frpc

# 删除服务
nssm remove frpc
```

‍

Windows 开启 OpenSSH 和 远程服务 和 Frp服务

# 服务器开发
用于新手购买了阿里云服务器之后，搭建个人网址或者部署其他项目，其中包含服务器的常见命令以及anaconda/node/npm/doker等部分安装包的下载指南。


## 0 服务器的常见操作

* 服务器主机名字修改

```bash
[root@localhost ~]# hostnamectl set-hostname localhost
[root@localhost ~]# bash
[root@test ~]#
```

* 服务器换源处理，本文我们用的是阿里源，阿里源的网址是：​[https://mirrors.aliyun.com/repo/](https://mirrors.aliyun.com/repo/)，下面的截屏可以看到各个版本源的文件名，直接使用 wget 下载，此处实验为centos服务器。

![](/static/img/fe692b35a253041211eef57dd658d43d.image-20241025151634-t0k9q3c.webp)

```bash
wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-vault-8.5.2111.repo
```

* 更新 YUM cache

```bash
yum clean all
yum makecache
```

#### 0.1 文件操作命令

* 强制删除文件/文件

```bash
# 强制删除文件
rm -f my.txt

# 但是删除文件夹
rm -rf myfile
```

* cp 命令

```bash
# 备份一份`config-sample.php` 文件
cp config-sample.php config.php

# 拷贝 wordpress 下的全部文件到 `var/www/html` 下面
cp -r wordpress/*  /var/www/html/
```

## 1 网站开发

### 1.1 node/npm

若要下载特定的版本，需要前往[官方网址](https://nodejs.org/dist/) 自行下载。其中安装路径，可以通过理解目标地址和文件的.xz命名。命令行如下，并且将下载文件存储在`/tmp`​文件下会比较好一点：

```bash
cd /tmp && wget https://nodejs.org/dist/v21.6.2/node-v21.6.2-linux-x64.tar.xz
```

* 执行解压操作：

```bash
tar xvJf node-v21.6.2-linux-x64.tar.xz
```

*  将` /tmp/node-v21.6.2-linux-x64`​ 文件夹移动到` /usr/local `​目录下，并重命名为` node`​

```bash
mv node-v21.6.2-linux-x64 /usr/local/node
```

* 添加软连接到 `/bin`​ 目录

```bash
ln -s /usr/local/node/bin/node /bin/node
ln -s /usr/local/node/bin/npm /bin/npm
```

* 配置环境变量

```bash
echo 'export PATH=/usr/local/node/bin:$PATH' >> /etc/profile
```

* 使环境变量配置生效

```bash
source /etc/profile
```

* 查看 nodejs 和 npm 版本

```bash
node -v
npm -v
```

### 2.0 反向代理

* 自己的服务器的8000端口 **不能请求** 3000端口的数据

  * 出现**跨域**现象？
  *  **跨域**是仅存在于浏览器里的，如果存在跨域的情况，请求就发不出去
  * 所以我们就创建一个**代理**（代理和请求是同域的），把浏览器的请求发到代理服务器，代理再帮我们把请求发到真正的服务器，这样解决跨域。

*  **正向**代理

  代理**客户端** ，服务端不知道真正的客户端是谁
* **反向**代理

  代理**服务器** ，客户端不知道真正的服务端是谁

* **VPN**

  大概就是把你的网线 连到了另一个地方 进入了他们的内网 , 通过一个加密的隧道来连接,不是物理上的连接.

* **nginx**的反向代理是什么？

```bash
# 外在形象就是 只访问8080 
http://localhost:8080/index.html --->代理到 localhost:8000/index.html
http://localhost:8080/api/login  --->代理到 localhost:3000/api/login
```

### 3.0 npm版本有错

步骤 1: 更新系统-此处服务器系统为`centos`​

在安装任何软件之前，我们应该始终确保系统是最新的。可以使用以下命令更新系统：

```bash
sudo yum update
```

步骤2：添加Node.js仓库

默认情况下，yum仓库中没有Node.js软件包。因此，我们需要添加适用于Node.js的仓库。执行以下命令来添加Node.js **18.x**仓库（这个数字可以根据报错修改，不一定是版本为18） ：

```shell
curl -sL https://rpm.nodesource.com/setup_14.x | bash -
```

步骤3：安装Node.js

添加仓库后，我们可以使用yum包管理器安装Node.js。执行以下命令来安装Node.js：

```
yum install -y nodejs
```


### 4.0 anaconda重装

确定下载路径，本文采用`/usr/local/anaconda3`​下载 Anaconda 的安装包 在官网上查找自己需要的版本：[https://repo.anaconda.com/archive/](https://repo.anaconda.com/archive/)

```bash
wget https://repo.anaconda.com/archive/Anaconda3-2022.10-Linux-x86_64.sh
```

安装 Anaconda 对安装程序赋权：

```bash
chmod +x Anaconda3-2022.10-Linux-x86_64.sh
```

执行命令，开始安装：

```bash
./Anaconda3-2022.10-Linux-x86_64.sh 
```

编辑环境

```bsh
vim ~/.bashrc
export PATH="/usr/local/anaconda3/bin:$PATH"
source ~/.bashrc
```

#### 4.1 多用户共享 anaconda 环境

**建立用户**

```bash
# 创建新的用户
sudo adduser tt
# 为用户指定登录密码：
sudo passwd tt
# 为用户指定命令解释程序(通常为/bin/bash)：
sudo usermod -s /bin/bash tt
# 为用户指定用户主目录：
sudo usermod -d /home/ tt
```

**添加用户组**

```bash
sudo groupadd anaconda
```

**更改安装目录的所属群组**：因为本文安装目录为`/usr/local/anaconda3`​； 用户组为 `anaconda`​，故执行命令:

```bash
sudo chgrp -R anaconda /usr/local/anaconda3
```

**更改目录权限:**   对`/usr/local/anaconda3 `​设置拥有者 (此处为 `root`​) 和 所属组组员 的读写权限，执行命令

```bash
sudo chmod 770 -R /usr/local/anaconda3
sudo chmod 777 -R /home
```

**用户管理:**   当需要授予特定用户 user_name 使用 anaconda 的权限时，只需将他添加到用户组 anaconda 中，执行命令

```bash
 usermod -a -G anaconda tt
```

​`该命令会将 user_name：tt 追加到用户组 anaconda 中，而不会改变他之前的分组`​

**用户操作 ：**  当用户被添加到用户组 anaconda 之后，需要做一些初始化工作，才能使用 anaconda，首先切换到对应的用户

```bash
su tt
```

**手动添加环境变量**

```bash
echo 'export PATH="/usr/local/anaconda3/bin:$PATH"' >> ~/.bashrc

# 重新加载文件
source ~/.bashrc

# 对 `bash` 执行 `conda` 初始化
conda init bash

# 重新打开终端，即可使用共享的 anaconda
```

**如果切换用户后，并且配置完成了，还是出现报错** ​`-PermissionError: [Errno 13] Permission denied`​

```bash
**切换到原来的 root 用户下，执行命令:

sudo chown -R $USER:$USER /usr/local/anaconda3
sudo chown -R tt:tt /usr/local/anaconda3
sudo chown -R tt:tt /home
```

​`把 /usr/local/anaconda3 替换成自己的 anaconda 目录即可`​

‍

服务器开发

# pytorch-手写数字识别
使用pytorch框架实现手写数字识别的功能


### 0.0 每日code

```python
import torch.nn as nn 
import  torch.nn.functional as F
from torch.utils.data import DataLoader 
from torch.optim import Adam 
from torchvision.datasets import MNIST
from torchvision.transforms import Compose,ToTensor,Normalize

BATCH_SIZE = 128 

#1. prepare the dataset 
def get_dataloader(train=True) : 
	transform_fn = Compose([
		ToTensor(),
		Normalize(mean = (0.1307,) , std = (0.3081 , ) )
	# the shape of mean and std is the same as the number of channel
])
	dataset= MNIST(root = "./mnist_data" , train =train , transform = transform_fn )
	data_loader = DataLoader(dataset,batch_size=BATCH_SIZE, shuffle = True)
	return data_loader

class MnistModel(nn.Module):
    def __init__(self):
        super(MnistModel,self).__init__()
        self.fc1 = nn.Linear(1*28*28, 28)# fc1 全连接的意思
        self.fc2 = nn.Linear(28 , 10)

    def forward(self,input):
        x = input.view([input.size(0),1*28*28])
        x = self.fc1(x)   # 矩阵乘法+偏置  2. 进行全连接的操作 
        x = F.relu(x)    # 3. 进行激活函数的处理，形状没有变化 
        out = self.fc2(x)   # 4. 输出层
        return F.log_softmax(out)
  
def train(epoch):  # 实现训练的过程
        model = MnistModel()
        optimizer = Adam(model.parameters(),lr=0.001)
        data_loader = get_dataloader()
        for idx,(input,target)in enumerate(data_loader):
            optimizer.zero_grad()
            output = model(input)  #调整模型，得到预测值
            loss  = F.nll_loss(output,target) # 得到损失值
            optimizer.step() # 梯度的更新
            if idx%100 == 0 :  # 没100次更新一次他的loss
                print(loss.item())
	
	    if idx%100 == 0 


if __name__ == '__main__':
    for i in range(3):  # 3 times
        train(i)




```

‍

‍

#### 1. 模型中使用数据加载器的目的

在前面的线性回归模型中,我们使用的数据很少,所以直接把全部数据放到模型中去使用。但是在深度学习中,数据量通常是都非常多,非常大的,如此大量的数据,不可能一次性的在模型中进行向前的计算和反向传播,经常我们会对整个数据进行**随机的打乱顺序**,把数据处理成一个个  
**batch**,同时还会对数进行预处, 所以,接下来我们来学习pytorch中的数据加载的方法

‍

‍

#### 2. 数据集类

	需要继承 在torch中提供数据集的基类  **torch.utils.data.Dataset**

```python
class Dataset(object):
	def __getitem__(self,index):
		raise NotImplementedError 
	def __len__(self):
		raise NotImplementedError 
	def __add__(self,other):
		raise ConcatDataset([self,other])
```

由上已知，我们需要在自定义的数据集类中继承Dataset 类，同时还需要实现两个方法：

1. __len__方法 ： 通过全局的len（）方法获取其中元素的个数
2. __getitem__方法 ： 通过传入索引的方式获取数据集，例如通过dataset[ i ] 获取其中的第 i 条数据

```python
import torch
# import torch.utils.data.Dataset
# import Dataset for torch.utils.data
from torch.utils.data import Dataset 
data_path = r"./Spam-classification/SMSSpamCollection.txt"

# 完成数据集类
class MyDataset(Dataset):
    def __init__(self):
        self.lines = open(data_path).readlines()
    
    def __getitem__(self,index):
        # 获取对应索引的第一条数据
        # return self.lines[index]
        return self.lines[index].strip() # 消去换行
  
    def __len__(self):
        return len(self.lines)
  
if __name__ == '__main__':
    my_dataset = MyDataset()  # 实例化一个对象
    print(my_dataset[1000]) # 打印第一行
    print(len(my_dataset))
  
```

之后对dataset进行实例化，通过迭代获取其中数据

```python
# 打印出部分数据集
for i in range(len(my_dataset)):
    print(i,my_dataset[i])
```

​![image](assets/image-20221217164715-w7javp7.png)​

‍

#### 3. 迭代数据集

目标： 为了实现读取 txt 文件的标签以及其内容，优化 -getitem-函数

```python

    def __getitem__(self,index):
        # 获取对应索引的第一条数据
        cur_line = self.lines[index].strip() # 获取当前行
        label = cur_line[:4].strip()
        content = cur_line[4:].strip()
        return label,content
```

​![image](assets/image-20221217165919-97lfcic.png)​

使用上述的方法能够进行数据的读取,但是其中还有很多内容没有实现:

1. 批处理数据(Batching the data)
2. 打乱数据(Shuffling the data)
3. 使用多线程multiprocessing并行加载数据。

**在pytorch中 torch.utils.data.DataLoader提供了上述的所用方法**

> 其中**参数**含义:
>
> 1. **dataset**:  提前定义的dataset的实例
> 2. **batch_size**: 传入数据的batch的大小,常用128,256等等
> 3. **shuffle**:  bool类型,表示是否在每次获取数据的时候提前**打乱数据**
> 4. **num_workers:    加载**数据的线程数
> 5. **drop_last** : 当最后一个batch里面的个数不足够，则直接删除

```python
from torch.utils.data import Dataset ,DataLoader
# 完成数据集类
class MyDataset(Dataset):
    def __init__(self):
        self.lines = open(data_path).readlines()
  
    def __getitem__(self,index):
        # 获取对应索引的第一条数据
        # return self.lines[index].strip() # 消去换行
        cur_line = self.lines[index].strip() # 获取当前行
        label = cur_line[:4].strip()
        content = cur_line[4:].strip()
        return label,content
  
    def __len__(self):
        return len(self.lines)
  
my_dataset = MyDataset()  # 实例化一个对象
data_loader = DataLoader(dataset = my_dataset , batch_size = 3 ,shuffle = True，drop_last = True )

if __name__ == '__main__':
    for i in data_loader:
        print(i)
        break

```

> 不同的 **batch_size  结果不一样：**
>
> *batch = 3 * 
>
> ​![image](assets/image-20221217170954-5kp6d7o.png)
>
> *batch = 10 * 
>
> ​![image](assets/image-20221217171024-hpnqv5c.png)
>
> 同时 由于shuffle 为 true 所以每一次迭代都会刷新当前的batch内容

基于普通的便利之后，通常遍历参数： index  --- 使用 enumerate方式遍历，则优化代码：

```python
  for index , (label ,context ) in enumerate(data_loader):
        print( index , (label ,context) )
        print("*"*100)

```

	the  result :![image](assets/image-20221217171621-thcqc5t.png)​

> notes:
>
> 1. len(dataset) = 数据集的样本数量
> 2. len(dataloader) = math.ceil( 样本数/ batch_size )  向上取整

‍

#### 4. pytorch 自带的数据集

 pytorch中自带的数据集由两个上层api提供,分别是**torchvision**和**torchtext：**

1. **torchvision ** 提供了对**图片**数据处理相关的api和数据  
    数位置: **torchvision. datasets**, 例: torchvision.datasets. MNIST (手写数  
    字图片数据)
2. **torchtext ** 提供了对文本数据处理相关的API和数据  
    数据位置: **torchtext**.datasets,例如: torchtext.datasets.IMDB (电影评论文本数据)  
    下面我们以Mnist手写数字为例,来看看pytorch如何加截其中自带的数据集  
    使用方法和之前一样:

    > 1. 准备好Dataset实例
    > 2. dataset交给dataloader 打乱顺序,组成batch
    >

##### 4.1 torchversion.datasets

 torchversoin.datasets 中的数据集类(比 torchvision. datasets.MNIST) ,都是继承自  
 Dataset. 意味着:  直接对torchvision.datasets,MNIST 进行**实例化**就可以得到.  Dataset的实例,  但是MNIST API中的参数需要注意一下:

```python
 torchvision.datasets.MNIST(root='/files/', train=True, download=True,
 transform=)
```

1. root参数表示数据存放的位置
2. train: bool类型,表示是使用**训练集**的数据还是**测试集**的数据
3. download: bool类型,表示*是否需要下载数据到root日录*
4. transform: 实现的 <span data-type="text" style="color: var(--b3-font-color1);">对图片的处理函数</span>

```python
import torchvision
from torchvision.datasets import MNIST 

mnist = MNIST(root = "./mnist_data",train = True , download = True )
print(mnist)
```

![image](assets/image-20221217174434-f7pv0cn.png)

‍

‍

#### 5. pytorch-mnist 手写数字识别

>> 作业目标：
>>
>> 1. 知道如何使用Pytorch完成**神经网络**的构建
>> 2. 知道Pytorch中**激活函数**的使用方法
>> 3. 知道Pytorch中**torchvision.transforms**中常见图形处理函数的使用
>> 4. 知道如何**训练模型和如何评估模型**
>>

##### 5.1  torchvision.transforms. ToTensor 

	把一个取值范围 [0,255]的 PIL.Image \ shape ( H,W,C ) 的 numpy.ndarray ,转换成为形状 [C , H , W ]  取值范围是 [ 0 , 1.0  ] 的 torch. FloatTensor

 	其中 ( H , W ,C ) == (**高、宽、**​***通道数*** * * ) ，黑白通道数只有1 ,其中每个像索点的取值为 [0,255] , 彩色图片的通道数为(R,G,B), 每个通道的每个像素点的取值 [0,255],三个通道的颜色相互叠加,形成了各种颜色

```python
from torchvision import transforms
import numpy as np
data  = np.random.randint(0,255,size=12)
img = data.reshape(2,2,3)
print(img.shape)
img_tensor = transforms.ToTensor()(img) # 先实例化然后传入图片img 然后转化为tensor
print(img_tensor)
print(img_tensor.shape)

'''
# way-2
img_tensor = torch.tensor(img)
img_tensor.transpose(0,2) # 交换通道，交换0 2 通道
img_tensor.permute(2,0,1)   # permute函数的作用是对tensor进行转置。
'''
```

​![image](assets/image-20221217181249-pmdj8mh.png)​

‍

##### 5.2 torchvision. transforms. Normalize(mean, std)

给定均值: mean, shape和图片的通道数相同(指的是每个通道的均值),方差:std,和图片的通道数相同(指的是每个通道的方差),将会把`Tensor`​规范化处理。  
 即: `Normalized_image=(image-mean)/std`

  i.  均值和标准差的形状和通道数相同

‍

‍

##### 5.1.3 torchvision.transforms.Compose(transforms)

  
将多个transform组合起来使用。

i.  传入list

ii.   
例如

```python
transforms.Compose([
    torchvision.transforms.ToTensor(),   # 先转化为 Tensor
    torchvision.transforms.Normalize(mean,std)   # 再进行正则化
])


```

‍

#### 6. 准备mnist数据集 Dataset & Dataloader

准备训练集合：

```python
import torchvision
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
from torchvision.datasets import MNIST 
from torchvision.transforms import Compose,ToTensor,Normalize

BATCH_SIZE = 128 


# 准备数据迭代器
def get_dataloader(train=True):
    transform_fn = Compose([
        ToTensor(),
        Normalize(mean=(0.1307,),std=(0.381,))
    ])
    dataset = MNIST(root="./mnist_data",train=True,transform = transform_fn)
    data_loader = DataLoader(dataset , batch_size=BATCH_SIZE , shuffle = True)
    return data_loader
```

#### 7. 构建模型

‍

**补充：**

全联接层 ： 当前一层的神经元和前一层的神经网络相互链接，其核心操作就是 y=wx ， 即 矩阵的乘法，实现对前一层数据的变换

模型的构建使用了一个四层的神经网络，其中包括两个全联接层和一个输出层，第一个全连接层会经过激活函数的处理，将处理后的结果交给下一个全连接层，进行变换后输出结果，那么这个模型有两个点需要注意：

1. 激活函数的使用

2. 每一层数据的形状
3. 模型的损失函数

‍

‍

‍

‍

‍

#### 7.1 激活函数的使用

常见函数： Relu 激活函数 ：

import torch.nn.functional as F 提供, F.relux(x) 即可对

‍

```python
import torch
from torch import nn 
import torch.nn.functional as F

class MnistNet(nn.Module):
	def __init__(self):
		super(MnistNet,self).__init__()
		self.fc1 = nn.Linear(28*28*1,28) # 定义Linear的输入输出形状
		self.fc2 = nn.Linear(28,10). # 定义Linear 的输入和输出的形状
	def forwoard(self,input	):
		'''
		#  : param input :  [batch_size , 1 , 28, 28 ]
		#  : return : 
		''' 
		x = x.view(-1,28*28*1) #对数据形状变形，-1 表示该位置根据后面的形状自动调整
		x = self.fc(x) #[batch_size,28]
		x = F.relu(x). #[batch_size,28]
		x = self.fc2(x) # [batch_size,10]





```

‍

#### 7.2 **模型中数据的形状**

 '''  
 batch_size 形状不可以改变、

1. 原始输入数据的形状 :[batch_size , 1, 28, 28 ]
2. 进行形状修改 ， [batch_size, 28*28 ]
3. 第一个全连接输出的形状： [batch_size, 28] ,
4. 激活函数不会改变数据的形状
5. 第二个全连接层输出的形状：$[batchsize,10]$， 因为手写数字共有10个类别  
    '''

‍

```python
import torch.nn as nn 
import  torch.nn.functional as F
from torch.utils.data import DataLoader 
from torch.optim import Adam 
from torchvision.datasets import MNIST
from torchvison.transforms import Compose,ToTensor,Normalize

BATCH_SIZE = 128 

#1. prepare the dataset 
def get_dataloader(train=True) : 
	transform_fn = Compose([
		ToTensor(),
		Normalize(mean = (0.1307,) , std = (0.3081 , ) )
	# the shape of mean and std is the same as the number of channel
])
	dataset= MNIST(root = "./data" , train =train , transform = transform_fn )
	data_loader = DataLoader(dataset,batch_size=BATCH_SIZE, shuffle = True)
	return data_loader




class MnistModel(nn.Module)：
	def __init__(self):
		super(MnistModel,self).__init__()
		self.fc1 = nn.Linear(1*28*28, 28)# fc1 全连接的意思
		self.fc2 = nn.Linear(28 , 10)

	def forward(self,input):
		# : param input : [batch_size, 1,28,28]
		# : return;
	# 1. 		修改形状
	 # input.view([batch_size, 1*28*28])  通常不直接写 batc_size ，因为可能不能整除
	x = input.view([input.size(0), 1*28*28])
	# input.view([-1,1*28*28]) # 
	# 2. 进行全连接的操作
	x = self.fc1(x) # 矩阵乘法+偏置
	# 3. 进行激活函数的处理，形状没有变化
	x = F.relu(x) 
	# 4. 输出层
	out = self.fc2(x)
	return F.lo_softmax(out)


def train(epoch):  
	# 实现训练的过程
	model = MnistModel()
	optimizer = Adam(model.parameters(),lr=0.001)
	data_loader = get_dataloader()
	for idx,(input,target)in enumerate(data_loader):
		optimizer.zero_grad()
		output = model(input)  #调整模型，得到预测值
		loss  = F.nll_loss(output,targrt) # 得到损失值
		optimizer.step() # 梯度的更新
		if idx%100 == 0 :
			print(loss.item())

if __name__ == '__main__':
	for i in range(3):  # 3 times
		train(i)



```

‍

#### 7.3 **模型损失函数**

> 首先，我们需要明确，我们手写字体识别的问题是一个**多分类问题。**
>
> 逻辑回归中，我们使用sigmoid进行计算对数似然损失来定义我们的2分类的损失
>
> * 在二分类中，我们有正类和负类的概率为： $P(X) = { \frac { 1 }{ 1 + e ^ { -x } } } = \frac{ e^{x}  }{ 1+e^{x} },$ 那么负类的概率为： $1-P(X)$
>
>   * 将这个结果进行**对数似然损失 **
>
>     $$
>     -\sum{y log(P(x))}
>     $$
>
>     可以求得最终的损失。
>
> 那么在多分类中：
>
> 	区别在于不能再使用sigmoid函数来计算当前样本属于某个类别的概率，而应该使用softmax() 函数
>
> * softmax 和 sigmoid 的区别在于我们需要计算的样本属于每个类别的概率，需要多次计算，而sigmoid只需要计算一次：
>
>   * ​`softmax公式：`​
>
>     $$
>     \sigma(z)_j =  \frac{e^{z_j}}{\sum_{k=1}^{n} e^{z_k}}
>     $$
>
>   k 表示为几维度

‍

​![image](assets/image-20221222171724-dm55pz7.png)​

          对于这个`softmax`​输出的结果，是在 [**0,1]**  区间，我们可以把它当做概率和前面2分类的损失一样,多分类的损失只需要再把这个结果进行对数似然损失的计算即可,即 :

$$
J = - \sum{Y log(P) },     其中 P = \frac{e^{z_j}}{\sum_{k=1}^K e^{z_k}}
$$

最后，会计算每个样本的损失，即上式的平均值. 我们把**softmax概率**传入**对数似然损失**得到的损失函数称为 **交叉熵损失. **

在pytorch中有**两种方法**实现交叉熵损失:

```python
criterion = nn.CrossEntropyLoss() 
loss = criterion(input,target)  # 实例化对像，传入input & target   
```

```python
#1. 对输出值计算softmax和取对数
output = F.log_softmax(x,dim=-1)
# 2. 使用torch中的带权损失
loss = F.nll_loss(output,target)
```

带权损失定义为： 

$$
l_n = - \sum w_i x_i
$$

其中就是把$log(p)$ 作为 $x_i$，把真实数值 $Y$作为权重

‍

#### 4.模型的训练

训练的流程:  
1.实例化模型，设置模型为训练模式  
2.实例化优化器类，实例化损失函数  
 3.获取,遍dataloader4,梯度为0  
5.进行向前计算  
6.计算损失  
7,反向传播  
8.更新参数

‍

```python
mnist_net = MnistNet()
optimizer = optim.Adam(mnist_net.parameters(),lr=0.001)
def train(epoch):
	mode = True 
	mnist_net.train(mode = mode ) # 模型设置为训练模型

	train_dataloader = get_dataloader(train=mode) # 获取训练数据集
	for idx,(data,target) in enumerate(train_dataloader):
		optimizer.zero_grad() # 梯度设定为0 
		output

```

‍

#### 5.模型的保存和加载

```python
for idx%100 == 0 #
torch.save(mnist_net.state_dict(), "" )
```

googleColab

Windows 开启 OpenSSH 和 远程服务 和 Frp服务

服务器开发

pytorch-手写数字识别

Windows 开启 OpenSSH 和远程服务和 Frp服务