CUDA可用，共有 1 个GPU设备可用。





当前使用的GPU设备索引：0

当前使用的GPU设备名称：NVIDIA T1000

GPU显存总量：4.00 GB

已使用的GPU显存：0.00 GB

剩余GPU显存：4.00 GB

PyTorch版本：1.10.1+cu102

```python
import torch
# 检查CUDA是否可用
cuda_available = torch.cuda.is_available()
if cuda_available:
    # 获取GPU设备数量
    num_gpu = torch.cuda.device_count()
    # 获取当前使用的GPU索引
    current_gpu_index = torch.cuda.current_device()
    # 获取当前GPU的名称
    current_gpu_name = torch.cuda.get_device_name(current_gpu_index)
    # 获取GPU显存的总量和已使用量
    total_memory = torch.cuda.get_device_properties(current_gpu_index).total_memory / (1024 ** 3)  # 显存总量(GB)
    used_memory = torch.cuda.memory_allocated(current_gpu_index) / (1024 ** 3)  # 已使用显存(GB)
    free_memory = total_memory - used_memory  # 剩余显存(GB)
    print(f"CUDA可用，共有 {num_gpu} 个GPU设备可用。")
    print(f"当前使用的GPU设备索引：{current_gpu_index}")
    print(f"当前使用的GPU设备名称：{current_gpu_name}")
    print(f"GPU显存总量：{total_memory:.2f} GB")
    print(f"已使用的GPU显存：{used_memory:.2f} GB")
    print(f"剩余GPU显存：{free_memory:.2f} GB")
else:
    print("CUDA不可用。")
# 检查PyTorch版本
print(f"PyTorch版本：{torch.__version__}")
import torch
print(f"CUDA版本：{torch.version.cuda}")
```


windows先装显卡驱动，再装CUDA10.2，最后装了pytorch。

pip install torch==1.10.1+cu102 torchvision==0.13.1+cu102 torchaudio==0.12.1 --extra-index-url https://download.pytorch.org/whl/cu102


![在这里插入图片描述](/static/img/images/03938.png)



```python
import torch
import os
import subprocess

def check_gpu_availability():
    print("==== Checking GPU Availability ====")
    if torch.cuda.is_available():
        print(f"GPU is available. Number of GPUs: {torch.cuda.device_count()}")
        for i in range(torch.cuda.device_count()):
            print(f"GPU {i}: {torch.cuda.get_device_name(i)}")
    else:
        print("No GPU available. Please check your hardware or drivers.")
        return False
    return True

def check_cuda_and_cudnn():
    print("\n==== Checking CUDA and cuDNN Availability ====")
    if torch.cuda.is_available():
        print(f"CUDA version: {torch.version.cuda}")
        print(f"cuDNN version: {torch.backends.cudnn.version()}")
        print(f"cuDNN enabled: {torch.backends.cudnn.enabled}")
    else:
        print("CUDA or cuDNN not available. Please check the installation.")

def test_gpu_computation():
    print("\n==== Testing Simple Computation on GPU ====")
    try:
        
        device = torch.device("cuda:2")
        a = torch.randn(50, 50, device=device)
        b = torch.randn(50, 50, device=device)
        c = torch.matmul(a, b)
        print("Matrix multiplication on GPU successful.")
    except Exception as e:
        print(f"Error during computation on GPU: {e}")

def check_gpu_memory():
    print("\n==== Checking GPU Memory Usage ====")
    try:
        gpu_memory = torch.cuda.memory_summary()
        print(gpu_memory)
    except Exception as e:
        print(f"Error retrieving GPU memory info: {e}")

def run_nvidia_smi():
    print("\n==== Running nvidia-smi Command ====")
    try:
        # Run the nvidia-smi command and capture the output
        result = subprocess.run(["nvidia-smi"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
        if result.returncode == 0:
            print(result.stdout)
        else:
            print(f"Error running nvidia-smi: {result.stderr}")
    except Exception as e:
        print(f"Error running nvidia-smi command: {e}")

def main():
    print("==== Starting GPU Health Check ====")
    
    # Step 1: Check GPU availability
    if not check_gpu_availability():
        return
    
    # Step 2: Check CUDA and cuDNN versions
    check_cuda_and_cudnn()
    
    # Step 3: Test GPU computation
    test_gpu_computation()
    
    # Step 4: Check GPU memory usage
    check_gpu_memory()
    
    # Step 5: Run nvidia-smi to check GPU status
    run_nvidia_smi()
    
    print("\n==== GPU Health Check Completed ====")

if __name__ == "__main__":
    main()

```

【Python】pytorch，CUDA是否可用，查看显卡显存剩余容量

# conda





```c
conda config --set ssl_verify no
conda config --set proxy_servers.http <VPN 服务器地址>:<VPN 服务器端口>
conda config --set proxy_servers.https <VPN 服务器地址>:<VPN 服务器端口>
```


```c
conda install <package_name>
```


# pip

```c
pip --proxy <VPN 服务器地址>:<VPN 服务器端口> install requests
```

example.


```c
 pip install --proxy http://127.0.0.1:10809 -r req.txt
```

给conda、pip提提速，给他一个vpn，还世界清静

# 环境





```shell
pip install jupyter 
```

# 使用

在你想访问的目录下执行：


```c
jupyter notebook --ip=0.0.0.0
```

jupyter 给出提示：

```c
[I 2023-07-28 14:32:43.589 ServerApp] Package notebook took 0.0000s to import
[I 2023-07-28 14:32:43.597 ServerApp] Package jupyter_lsp took 0.0081s to import
[W 2023-07-28 14:32:43.597 ServerApp] A `_jupyter_server_extension_points` function was not found in jupyter_lsp. Instead, a `_jupyter_server_extension_paths` function was found and will be used for now. This function name will be deprecated in future releases of Jupyter Server.
[I 2023-07-28 14:32:43.601 ServerApp] Package jupyter_server_terminals took 0.0034s to import
[I 2023-07-28 14:32:43.601 ServerApp] Package jupyterlab took 0.0000s to import
[I 2023-07-28 14:32:43.639 ServerApp] Package notebook_shim took 0.0000s to import
[W 2023-07-28 14:32:43.640 ServerApp] A `_jupyter_server_extension_points` function was not found in notebook_shim. Instead, a `_jupyter_server_extension_paths` function was found and will be used for now. This function name will be deprecated in future releases of Jupyter Server.
[I 2023-07-28 14:32:43.640 ServerApp] jupyter_lsp | extension was successfully linked.
[I 2023-07-28 14:32:43.643 ServerApp] jupyter_server_terminals | extension was successfully linked.
[I 2023-07-28 14:32:43.647 ServerApp] jupyterlab | extension was successfully linked.
[I 2023-07-28 14:32:43.651 ServerApp] notebook | extension was successfully linked.
[I 2023-07-28 14:32:43.654 ServerApp] Writing Jupyter server cookie secret to /home/xd/.local/share/jupyter/runtime/jupyter_cookie_secret
[I 2023-07-28 14:32:43.827 ServerApp] notebook_shim | extension was successfully linked.
[I 2023-07-28 14:32:43.930 ServerApp] notebook_shim | extension was successfully loaded.
[I 2023-07-28 14:32:43.932 ServerApp] jupyter_lsp | extension was successfully loaded.
[I 2023-07-28 14:32:43.933 ServerApp] jupyter_server_terminals | extension was successfully loaded.
[I 2023-07-28 14:32:43.934 LabApp] JupyterLab extension loaded from /ssd/xd/miniconda3/envs/py38_diffusers_1/lib/python3.8/site-packages/jupyterlab
[I 2023-07-28 14:32:43.934 LabApp] JupyterLab application directory is /ssd/xd/miniconda3/envs/py38_diffusers_1/share/jupyter/lab
[I 2023-07-28 14:32:43.935 LabApp] Extension Manager is 'pypi'.
[I 2023-07-28 14:32:43.937 ServerApp] jupyterlab | extension was successfully loaded.
[I 2023-07-28 14:32:43.939 ServerApp] notebook | extension was successfully loaded.
[I 2023-07-28 14:32:43.939 ServerApp] Serving notebooks from local directory: /ssd/xd/workplace
[I 2023-07-28 14:32:43.939 ServerApp] Jupyter Server 2.7.0 is running at:
[I 2023-07-28 14:32:43.939 ServerApp] http://gpu20:8888/tree?token=490e738359e9e3a73247822c61620bacdfcae0038a9a721e
[I 2023-07-28 14:32:43.939 ServerApp]     http://127.0.0.1:8888/tree?token=490e738359e9e3a73247822c61620bacdfcae0038a9a721e
[I 2023-07-28 14:32:43.939 ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[W 2023-07-28 14:32:43.948 ServerApp] No web browser found: Error('could not locate runnable browser').
```


记住这提示里的token：

490e738359e9e3a73247822c61620bacdfcae0038a9a721e

# 访问

windows电脑浏览器访问：

http://101.20.31.20:8888


默认端口8888，前面的ip需要填写你Linux服务器的IP。

【Python】jupyter Linux服务器使用

基础环境：





```c
sudo apt-get install ffmpeg
```


# m4a


要将M4A文件转换为MP3文件，你可以使用Python中的第三方库`pydub`。`pydub`使得音频处理变得非常简单。在开始之前，请确保你已经安装了`pydub`库，如果没有，可以通过以下命令安装：

```bash
pip install pydub
```

接下来，你可以使用以下代码将M4A文件转换为MP3文件：

```python
from pydub import AudioSegment
def m4a_to_mp3(m4a_file, mp3_file):
    # Load the M4A file
    audio = AudioSegment.from_file(m4a_file, format="m4a")
    # Export the audio as MP3
    audio.export(mp3_file, format="mp3")
if __name__ == "__main__":
    input_m4a_file = "input_file.m4a"   # Replace with the path to your M4A file
    output_mp3_file = "output_file.mp3" # Replace with the desired output MP3 file path
    m4a_to_mp3(input_m4a_file, output_mp3_file)
```

将上述代码中的`input_m4a_file`替换为你要转换的M4A文件路径，`output_mp3_file`替换为你希望输出的MP3文件路径。然后运行代码，它将加载M4A文件并将其转换为MP3格式。请注意，转换过程可能需要一些时间，具体取决于文件大小和你的计算机性能。

提醒：在进行音频格式的转换时，请遵守相关版权法规和使用规定，确保你有权处理和使用这些文件。




# aac

要将AAC文件转换为MP3文件，你可以使用Python中的`pydub`库，它提供了一个简单的方法来进行音频格式转换。在开始之前，请确保已经安装了`pydub`库，如果没有，可以通过以下命令安装：

```bash
pip install pydub
```

接下来，你可以使用以下代码将AAC文件转换为MP3文件：

```python
from pydub import AudioSegment
def aac_to_mp3(aac_file, mp3_file):
    # Load the AAC file
    audio = AudioSegment.from_file(aac_file, format="aac")
    # Export the audio as MP3
    audio.export(mp3_file, format="mp3")
if __name__ == "__main__":
    input_aac_file = "input_file.aac"   # Replace with the path to your AAC file
    output_mp3_file = "output_file.mp3" # Replace with the desired output MP3 file path
    aac_to_mp3(input_aac_file, output_mp3_file)
```

将上述代码中的`input_aac_file`替换为你要转换的AAC文件路径，`output_mp3_file`替换为你希望输出的MP3文件路径。然后运行代码，它将加载AAC文件并将其转换为MP3格式。请注意，转换过程可能需要一些时间，具体取决于文件大小和你的计算机性能。

同样地，在进行音频格式的转换时，请确保你有权处理和使用这些文件，遵守相关版权法规和使用规定。

【Python】将M4A\AAC录音文件转换为MP3文件

Python代码：




```powershell
import os
def split_file(input_file, output_dir, chunk_size):
    with open(input_file, 'rb') as f:
        index = 0
        while True:
            chunk = f.read(chunk_size)
            if not chunk:
                break
            output_file = os.path.join(output_dir, f'chunk_{index}.dat')
            with open(output_file, 'wb') as out:
                out.write(chunk)
            index += 1
def merge_files(input_dir, output_file):
    files = os.listdir(input_dir)
    files.sort()
    with open(output_file, 'wb') as out:
        for file_name in files:
            file_path = os.path.join(input_dir, file_name)
            with open(file_path, 'rb') as f:
                chunk = f.read()
                out.write(chunk)
# 切分大文件
split_file('big_file.dat', 'output_dir', 10 * 1024 * 1024)  # 每个小文件大小为10GB
# 合并小文件
merge_files('output_dir', 'merged_file.dat')
```