<!--{subtemplate common/header_common}-->	<!--{if $_GET['mod'] == 'viewthread' && !empty($_G['tid'])}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/thread-{$_G['tid']}-1-1.html" />
	<!--{elseif $_GET['mod'] == 'forumdisplay' && !empty($_G['fid'])}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/forum-{$_G['fid']}-1.html" />
	<!--{elseif $_GET['mod'] == 'guide'}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/guide/" />
	<!--{elseif $_G['basescript'] == 'forum' && (empty($_GET['mod']) || $_GET['mod'] == 'index')}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/" />
	<!--{/if}-->
	r`n`t<meta name="application-name" content="$_G['setting']['bbname']" />
	<meta name="msapplication-tooltip" content="$_G['setting']['bbname']" />
	<!--{if $_G['setting']['portalstatus']}--><meta name="msapplication-task" content="name=$_G['setting']['navs'][1]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['portal']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['portal'] : $_G[siteurl].'portal.php'};icon-uri={$_G[siteurl]}{IMGDIR}/portal.ico" /><!--{/if}-->
	<meta name="msapplication-task" content="name=$_G['setting']['navs'][2]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['forum']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['forum'] : $_G[siteurl].'forum.php'};icon-uri={$_G[siteurl]}{IMGDIR}/bbs.ico" />
	<!--{if $_G['setting']['groupstatus']}--><meta name="msapplication-task" content="name=$_G['setting']['navs'][3]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['group']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['group'] : $_G[siteurl].'group.php'};icon-uri={$_G[siteurl]}{IMGDIR}/group.ico" /><!--{/if}-->
	<!--{if helper_access::check_module('feed')}--><meta name="msapplication-task" content="name=$_G['setting']['navs'][4]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['home']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['home'] : $_G[siteurl].'home.php'};icon-uri={$_G[siteurl]}{IMGDIR}/home.ico" /><!--{/if}-->
	<!--{if $_G['basescript'] == 'forum' && $_G['setting']['archiver']}-->
		<link rel="archives" title="$_G['setting']['bbname']" href="{$_G[siteurl]}archiver/" />
	<!--{/if}-->
	<!--{if !empty($rsshead)}-->$rsshead<!--{/if}-->
	<!--{if widthauto()}-->
		<link rel="stylesheet" id="css_widthauto" type="text/css" href='{$_G['setting']['csspath']}{STYLEID}_widthauto.css?{VERHASH}' />
		<script type="text/javascript">HTMLNODE.className += ' widthauto'</script>
	<!--{/if}-->
	<!--{if $_G['basescript'] == 'forum' || $_G['basescript'] == 'group'}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}forum.js?{VERHASH}"></script>
	<!--{elseif $_G['basescript'] == 'home'}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}home.js?{VERHASH}"></script>
	<!--{elseif $_G['basescript'] == 'portal'}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}portal.js?{VERHASH}"></script>
	<!--{/if}-->
	<!--{if $_G['basescript'] != 'portal' && $_GET['diy'] == 'yes' && check_diy_perm($topic)}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}portal.js?{VERHASH}"></script>
	<!--{/if}-->
	<!--{if $_GET['diy'] == 'yes' && check_diy_perm($topic)}-->
		<link rel="stylesheet" type="text/css" id="diy_common" href="{$_G['setting']['csspath']}{STYLEID}_css_diy.css?{VERHASH}" />
	<!--{/if}-->
</head>

<body id="nv_{$_G[basescript]}" class="pg_{CURMODULE}{if $_G['basescript'] === 'portal' && CURMODULE === 'list' && !empty($cat)} {$cat['bodycss']}{/if}" onkeydown="if(event.keyCode==27) return false;">
	<div id="append_parent"></div><div id="ajaxwaitid"></div>
	<!--{if $_GET['diy'] == 'yes' && check_diy_perm($topic)}-->
		<!--{template common/header_diy}-->
	<!--{/if}-->
	<!--{if check_diy_perm($topic)}-->
		<!--{template common/header_diynav}-->
	<!--{/if}-->
	<!--{if CURMODULE == 'topic' && $topic && empty($topic['useheader']) && check_diy_perm($topic)}-->
		$diynav
	<!--{/if}-->
	<!--{if empty($topic) || $topic['useheader']}-->
		<!--{if $_G['setting']['mobile']['allowmobile'] && (!$_G['setting']['cacheindexlife'] && !$_G['setting']['cachethreadon'] || $_G['uid']) && ($_GET['diy'] != 'yes' || !$_GET['inajax']) && ($_G['mobile'] != '' && $_G['cookie']['mobile'] == '' && $_GET['mobile'] != 'no')}-->
			<div class="xi1 bm bm_c">
			    {lang your_mobile_browser}<a href="{$_G['siteurl']}forum.php?mobile=yes">{lang go_to_mobile}</a> <span class="xg1">|</span> <a href="$_G['setting']['mobile']['nomobileurl']">{lang to_be_continue}</a>
			</div>
		<!--{/if}-->
		<!--{if !empty($_G['setting']['shortcut']) && $_G['member'][credits] >= $_G['setting']['shortcut']}-->
			<div id="shortcut">
				<span><a href="javascript:;" id="shortcutcloseid" title="{lang close}">{lang close}</a></span>
				{lang shortcut_notice}
				<a href="javascript:;" id="shortcuttip">{lang shortcut_add}</a>

			</div>
			<script type="text/javascript">setTimeout(setShortcut, 2000);</script>
		<!--{/if}-->
		<div id="toptb" class="cl">
			<!--{hook/global_cpnav_top}-->
			<div class="wp">
				<div class="z">
					<!--{loop $_G['setting']['topnavs'][0] $nav}-->
						<!--{if is_array($nav) && $nav['available'] && (!$nav['level'] || ($nav['level'] == 1 && $_G['uid']) || ($nav['level'] == 2 && $_G['adminid'] > 0) || ($nav['level'] == 3 && $_G['adminid'] == 1))}-->$nav[code]<!--{/if}-->
					<!--{/loop}-->
					<!--{hook/global_cpnav_extra1}-->
				</div>
				<div class="y">
					<a id="switchblind" href="javascript:;" onclick="toggleBlind(this)" title="{lang switch_blind}" class="switchblind"></a>
					<!--{hook/global_cpnav_extra2}-->
					<!--{loop $_G['setting']['topnavs'][1] $nav}-->
						<!--{if is_array($nav) && $nav['available'] && (!$nav['level'] || ($nav['level'] == 1 && $_G['uid']) || ($nav['level'] == 2 && $_G['adminid'] > 0) || ($nav['level'] == 3 && $_G['adminid'] == 1))}-->$nav[code]<!--{/if}-->
					<!--{/loop}-->
					<!--{if empty($_G['disabledwidthauto']) && $_G['setting']['switchwidthauto']}-->
						<a href="javascript:;" id="switchwidth" onclick="widthauto(this)" title="{if widthauto()}{lang switch_narrow}{else}{lang switch_wide}{/if}" class="switchwidth"><!--{if widthauto()}-->{lang switch_narrow}<!--{else}-->{lang switch_wide}<!--{/if}--></a>
					<!--{/if}-->
					<!--{if $_G['uid'] && !empty($_G['style']['extstyle'])}--><a id="sslct" href="javascript:;" onmouseover="delayShow(this, function() {showMenu({'ctrlid':'sslct','pos':'34!'})});">{lang changestyle}</a><!--{/if}-->
					<!--{if check_diy_perm($topic)}-->
						$diynav
					<!--{/if}-->
				</div>
			</div>
		</div>

		<!--{if !IS_ROBOT}-->
			<!--{if $_G['uid'] && !$_G['setting']['bbclosed'] && empty($_G['member']['freeze']) && $_G['member']['groupid'] != 5}-->
			<ul id="myprompt_menu" class="p_pop" style="display: none;">
				<li><a href="home.php?mod=space&do=pm" id="pm_ntc" style="background-repeat: no-repeat; background-position: 0 50%;"><em class="prompt_news{if empty($_G[member][newpm])}_0{/if}"></em>{lang pm_center}</a></li>
				<!--{if $_G['setting']['followstatus']}-->
					<li><a href="home.php?mod=follow&do=follower"><em class="prompt_follower{if empty($_G[member][newprompt_num][follower])}_0{/if}"></em><!--{lang notice_interactive_follower}-->{if $_G[member][newprompt_num][follower]}($_G[member][newprompt_num][follower]){/if}</a></li>
					<!--{if $_G[member][newprompt] && $_G[member][newprompt_num][follow]}-->
						<li><a href="home.php?mod=follow"><em class="prompt_concern"></em><!--{lang notice_interactive_follow}-->($_G[member][newprompt_num][follow])</a></li>
					<!--{/if}-->
				<!--{/if}-->
				<!--{if $_G[member][newprompt]}-->
					<!--{loop $_G['member']['category_num'] $key $val}-->
						<li><a href="home.php?mod=space&do=notice&view=$key"><em class="notice_$key"></em><!--{echo lang('template', 'notice_'.$key)}-->(<span class="rq">$val</span>)</a></li>
					<!--{/loop}-->
				<!--{/if}-->
				<!--{if empty($_G['cookie']['ignore_notice'])}-->
					<li class="ignore_noticeli"><a href="javascript:;" onclick="setcookie('ignore_notice', 1);hideMenu('myprompt_menu')" title="{lang temporarily_to_remind}"><em class="ignore_notice"></em></a></li>
				<!--{/if}-->
			</ul>
			<!--{/if}-->
			<!--{if $_G['uid'] && !empty($_G['style']['extstyle'])}-->
				<div id="sslct_menu" class="cl p_pop" style="display: none;">
					<!--{if !$_G[style][defaultextstyle]}--><span class="sslct_btn" onclick="extstyle('')" title="{lang default}"><i></i></span><!--{/if}-->
					<!--{loop $_G['style']['extstyle'] $extstyle}-->
						<span class="sslct_btn" onclick="extstyle('$extstyle[0]')" title="$extstyle[1]"><i style='background:$extstyle[2]'></i></span>
					<!--{/loop}-->
				</div>
			<!--{/if}-->
			<!--{if $_G['uid']}-->
				<ul id="myitem_menu" class="p_pop" style="display: none;">
					<!--{if $_G['setting']['forumstatus']}--><li><a href="home.php?mod=space&do=thread&view=me">{lang mypost}</a></li><!--{/if}-->
					<!--{if $_G['setting']['favoritestatus']}--><li><a href="home.php?mod=space&do=favorite&view=me">{lang favorite}</a></li><!--{/if}-->
					<!--{if $_G['setting']['friendstatus']}--><li><a href="home.php?mod=space&do=friend">{lang friends}</a></li><!--{/if}-->
					<!--{hook/global_myitem_extra}-->
				</ul>
			<!--{/if}-->
			<!--{subtemplate common/header_qmenu}-->
		<!--{/if}-->

		<!--{ad/headerbanner/wp a_h}-->
		<div id="hd">
			<div class="wp">
				<div class="hdc cl">
					<!--{eval $mnid = getcurrentnav();}-->
					<h2><!--{if !isset($_G['setting']['navlogos'][$mnid])}--><a href="{if $_G['setting']['domain']['app']['default']}{$_G['scheme']}://{$_G['setting']['domain']['app']['default']}/{else}./{/if}" title="$_G['setting']['bbname']">{$_G['style']['boardlogo']}</a><!--{else}-->$_G['setting']['navlogos'][$mnid]<!--{/if}--></h2>
					<!--{template common/header_userstatus}-->
				</div>

				<div id="nv">
					<a href="javascript:;" id="qmenu" onmouseover="delayShow(this, function () {showMenu({'ctrlid':'qmenu','pos':'34!','ctrlclass':'a','duration':2});showForummenu($_G[fid]);})">{lang my_nav}</a>
					<ul>
						<!--{loop $_G['setting']['navs'] $nav}-->
							<!--{if is_array($nav) && $nav['available'] && (!$nav['level'] || ($nav['level'] == 1 && $_G['uid']) || ($nav['level'] == 2 && $_G['adminid'] > 0) || ($nav['level'] == 3 && $_G['adminid'] == 1))}--><li {if $mnid == $nav[navid] || substr($_SERVER['REQUEST_URI'], 1) == str_replace('./', '', $nav[filename])}class="a" {/if}$nav[nav]></li><!--{/if}-->
						<!--{/loop}-->
					</ul>
					<!--{hook/global_nav_extra}-->
				</div>
				<!--{if !empty($_G['setting']['plugins']['jsmenu'])}-->
					<ul class="p_pop h_pop" id="plugin_menu" style="display: none">
					<!--{loop $_G['setting']['plugins']['jsmenu'] $module}-->
						 <!--{if in_array($module['adminid'], array(0, -1)) || ($module['adminid'] && $_G['adminid'] > 0 && $module['adminid'] >= $_G['adminid'])}-->
						 <li>$module[url]</li>
						 <!--{/if}-->
					<!--{/loop}-->
					</ul>
				<!--{/if}-->
				$_G[setting][menunavs]
				<div id="mu" class="cl">
				<!--{if $_G['setting']['subnavs']}-->
					<!--{loop $_G[setting][subnavs] $navid $subnav}-->
						<!--{if $_G['setting']['navsubhover'] || $mnid == $navid}-->
						<ul class="cl {if $mnid == $navid}current{/if}" id="snav_$navid"{if $mnid != $navid} style="display:none"{/if}>
						$subnav
						</ul>
						<!--{/if}-->
					<!--{/loop}-->
				<!--{/if}-->
				</div>
				<!--{ad/subnavbanner/a_mu}-->
				<!--{subtemplate common/pubsearchform}-->
			</div>
		</div>

		<!--{hook/global_header}-->
	<!--{/if}-->

	<div id="wp" class="wp">

qidao123.com ToB IT社区-企服评测·应用市场»论坛 › 中间件 › 中间件 › 在WSL2-Ubuntu中安装CUDA12.8、cuDNN、Anaconda、Pytorc ...
返回列表 发新帖

在WSL2-Ubuntu中安装CUDA12.8、cuDNN、Anaconda、Pytorch并验证安装

[复制链接]
发表于 2025-3-31 14:34:30 | 显示全部楼层 |阅读模式
#记录工作
提示：整个过程最好先开启体系代理，也可以用镜像源，确保有官方发布的最新特性和官方库的完整和兼容性支持。
 期间下载会特殊慢，必要在体系上先开启代理，然后WSL设置里打开网络模式“Mirrored”,以设置WSL自动使用主机上的代理网络。
   【WLS2怎么设置网络自动代理 - CSDN App】https://blog.csdn.net/u014451778/article/details/146073726?sharetype=blog&shareId=146073726&sharerefer=APP&sharesource=u014451778&sharefrom=link
   
一、起首要先确保——windows体系中要精确安装了以下组件：

（一）显卡驱动；

   下载 NVIDIA 官方驱动 | NVIDIA
  （二）Microsoft Visual Studio；

   下载 Visual Studio Tools - 免费安装 Windows、Mac、Linux
  （三）CUDA；

   CUDA Toolkit 12.8 Downloads | NVIDIA Developer
  （四）cuDNN；

   CUDA Toolkit 12.8 Downloads | NVIDIA Developer
  （五）精确安装WSL2-Ubuntu版本

要正常安装WSL2-Ubuntu版本，安装成功后打开ubuntu界面输出如下界面：
   安装 WSL | Microsoft Learn
  


该版本默认是安装的WSL2-Ubuntu 24.04版本 ，也可以选择其他的ubuntu版本举行安装。
 
 
二、在WSL2-Ubuntu体系中安装CUDA、cuDNN、Anaconda

在windows体系中精确安装完必要组件后，然后才是在WSL2-Ubuntu中按照顺序安装 CUDA、cuDNN、Anaconda。
打开WSL2-Ubuntu，先安装CUDA、再安装cuDNN、末了是Anaconda（管理假造环境）
只要windows体系配置好了显卡驱动，在WSL2中一样平常不必再另外安装linux驱动了。
在安装前可以在WSL2-Ubuntu中使用以下下令举行验证与显卡的通讯和驱动调用的情况：
  1. nvidia-smi
复制代码

 
（一）安装CUDA

打开CUDA官方网址<发起“deb(network)”方式较为省事>，完整复制全部下令粘贴进WSL2-Ubuntu终端中按回车键运行。
   CUDA Toolkit 12.8 Downloads | NVIDIA Developer
  选项如图所示：
固然，也可以选WSL-Ubuntu这个选项更把稳。

  1. wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
  2. sudo dpkg -i cuda-keyring_1.1-1_all.deb
  3. sudo apt-get update
  4. sudo apt-get -y install cuda-toolkit-12-8
复制代码
 
1、复制图片/官网下边的全部下令，粘贴到WSL2-Ubuntu终端窗口中，按ENTER键（回车键）运行 


2、过程中会要求输入密码，输入ubuntu密码即可。


3、执行下令后会自动举行下载和安装： 



 
4、安装竣事后举行环境变量的编辑：

 a）我们可以按照下面的步调来永久添加环境变量：

检查安装是否成功在配置环境变量之前，先确认 CUDA 是否精确安装。运行以下下令：ls /usr/local/cuda-12.8/bin/
在 WSL2-Ubuntu 体系中，CUDA 12.8 通常安装在/usr/local/cuda-12.8目录下，这个目录包含了 CUDA 相关的各种组件，如 bin（包含可执行文件，比如 nvcc 编译器就在这里面）、lib64（包含库文件）、include（包含头文件） 等。如果在安装过程中没有指定其他特殊路径，这就是默认的安装位置。我们可以通过以下下令来验证：
  1. ls /usr/local/cuda-12.8
复制代码
  如果安装成功，我们会看到nvcc等工具的列表。如果没有看到这些文件，大概必要重新检查安装步调。

从我执行 ls /usr/local/cuda-12.8 后的输出结果来看，CUDA 12.8 似乎已经成功安装到了 /usr/local/cuda-12.8 目录下。
接下来，我们必要将 /usr/local/cuda-12.8/bin 目录添加到体系的 PATH 环境变量中，以便体系能够找到 nvcc 等下令。

b） 配置环境变量环境变量的配置必要根据你的体系类型（Bash 或 Zsh）来操作。
 确认当前使用的 Shell
起首，确认你当前使用的 Shell 是 Bash 照旧 Zsh。
我们可以通过以下下令检察：
  1. echo $SHELL
复制代码
• 如果输出是   /bin/bash  ，则使用 Bash。
• 如果输出是   /bin/zsh  ，则使用 Zsh。

c）编辑环境变量配置文件
 
以下是常见的配置方法：
对于 Bash 用户
编辑   ~/.bashrc   文件，
  1. nano ~/.bashrc
复制代码
添加以下内容： 
  1. export PATH=/usr/local/cuda-12.8/bin:$PATH
  2. export LD_LIBRARY_PATH=/usr/local/cuda-12.8/lib64:$LD_LIBRARY_PATH
复制代码
• 按下   Ctrl + X  ，然后按   Y   确认保存，末了按   Enter   完成退出。 
保存文件后，运行以下下令使变量生效：
  1. source ~/.bashrc
复制代码
对于 Zsh 用户
编辑   ~/.zshrc   文件，
  1. nano ~/.bashrc
复制代码
添加雷同的内容 : 
  1. export PATH=/usr/local/cuda-12.8/bin:$PATH
  2. export LD_LIBRARY_PATH=/usr/local/cuda-12.8/lib64:$LD_LIBRARY_PATH
复制代码
保存文件后，运行以下下令使变量生效（选其一）：
  1. source ~/.bashrc   # 如果是 Bash 用户
  2. source ~/.zshrc    # 如果是 Zsh 用户
复制代码
 5. 验证环境变量

配置完成后，运行以下下令验证：
  1. echo $PATH
复制代码
 6. 测试   nvcc  

运行   nvcc -V  或nvcc --version
，检查输出是否精确。
  1. nvcc -V
复制代码
或者： 
  1. nvcc --version
复制代码
 
如果配置精确，你会看到类似以下的输出：
 
  1. love@AI:~$ ls /usr/local/cuda-12.8DOCS      README  compute-sanitizer  extras  include  libnvvp           nvml  share  targets  version.jsonEULA.txt  bin     doc                gds     lib64    nsightee_plugins  nvvm  src    toolslove@AI:~$ echo $SHELL/bin/bashlove@AI:~$ nano ~/.bashrc
  2. love@AI:~$ source ~/.bashrclove@AI:~$ nvcc -Vnvcc: NVIDIA (R) Cuda compiler driverCopyright (c) 2005-2025 NVIDIA CorporationBuilt on Wed_Jan_15_19:20:09_PST_2025Cuda compilation tools, release 12.8, V12.8.61Build cuda_12.8.r12.8/compiler.35404655_0love@AI:~$
复制代码
 

至此，CUDA算是安装成功并得到验证。
 
7.驱动步伐安装步伐（发起）


在官方CUDA安装下令下方，有以下下令选项，强烈发起在验证完CUDA安装精确后，再次运行以下下令（任选其一）以确保安装步伐的未来兼容性。
NVIDIA 驱动步伐说明（选择一个选项）
 要安装 open kernel module 风格：
  1. sudo apt-get install -y nvidia-open
复制代码
要安装旧版内核模块风格：
  1. sudo apt-get install -y cuda-drivers
复制代码

 NVIDIA 驱动步伐提供了两种内核模块风格：open kernel module（开源内核模块）和旧版内核模块（proprietary kernel module，专有内核模块）。这两种风格的告急区别在于它们的允许证类型、支持的功能和兼容性。

open kernel module 风格
• 允许证：开源，通常采用 MIT/GPLv2 允许证。
• 支持的 GPU 架构：支持 Turing 及以后的 GPU 架构。
• 支持的功能：支持大多数 Linux GPU 驱动步伐的功能，包罗 CUDA、Vulkan、OpenGL、OptiX 和 X11。此外，尚有一些功能是仅 open kernel modules 支持的，比方 NVIDIA Confidential Computing、Magnum IO GPUDirect Storage(GDS)、Heterogeneous Memory Management(HMM)、CPU affinity for GPU fault handlers 和 DMABUF support for CUDA allocations。
• 兼容性：大概不支持所有旧版专有内核模块支持的特性，比方 NVIDIA virtual GPU(vGPU)、G-Sync on notebooks 和 Preserving video memory across power management events。

 
旧版内核模块风格
• 允许证：专有，由 NVIDIA 提供。
• 支持的 GPU 架构：支持 Maxwell、Pascal、Volta、Turing 和之后的 GPU 架构。
• 支持的功能：支持所有 NVIDIA GPU 驱动步伐的功能，包罗那些大概在 open kernel modules 中尚未支持的特性。
• 兼容性：通常更稳固，特殊是在支持较旧的硬件和特定的企业级应用场景中。

新手用户保举
对于新手用户，保举安装open kernel module 风格的驱动步伐，原因如下：
• 开源：更透明，社区支持更广泛。
• 更新：通常包含最新的功能和改进。
• 兼容性：对于大多数现代应用和游戏来说，open kernel modules 提供的兼容性已经足够。
然而，如果你有特定的需求，比如必要使用专有驱动步伐中特有的功能，或者你的硬件较旧，大概必要旧版内核模块风格。
在安装驱动步伐之前，发起先阅读 NVIDIA 的官方文档，相识不同风格的具体区别和保举使用场景。此外，确保我们的体系满足安装要求，并按照官方指南举行操作，以制止潜伏的兼容性问题。
 
 
 
（二）安装cuDNN

打开CUDA官方网址<发起“deb(network)”方式较为省事>，完整复制全部下令粘贴进WSL2-Ubuntu终端中按回车键运行。
   cuDNN 9.8.0 Downloads | NVIDIA Developer
   选项如图所示：

  1. wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-keyring_1.1-1_all.deb
  2. sudo dpkg -i cuda-keyring_1.1-1_all.deb
  3. sudo apt-get update
  4. sudo apt-get -y install cudnn
复制代码
 
1、复制图片/官网下边的全部下令，粘贴到WSL2-Ubuntu终端窗口中，按ENTER键运行


2、执行下令后会自动举行下载和安装：


 

3、暂时性地验证 cuDNN 安装

此时，暂时性地验证 cuDNN 安装是否成功可以通过以下方法：
检查文件路径的方法
cuDNN 的库文件通常会被安装到`/usr/lib/x86_64-linux-gnu`或`/usr/local/cuda/lib64`目录下。你可以通过以下下令检查这些文件是否存在：
  1. ls /usr/lib/x86_64-linux-gnu/libcudnn*
复制代码
 输出应该如下所示：
  1. love@AI:~$ ls /usr/lib/x86_64-linux-gnu/libcudnn*
  2. /usr/lib/x86_64-linux-gnu/libcudnn.so
  3. /usr/lib/x86_64-linux-gnu/libcudnn.so.9
  4. /usr/lib/x86_64-linux-gnu/libcudnn.so.9.8.0
  5. /usr/lib/x86_64-linux-gnu/libcudnn_adv.so
  6. /usr/lib/x86_64-linux-gnu/libcudnn_adv.so.9
  7. /usr/lib/x86_64-linux-gnu/libcudnn_adv.so.9.8.0
  8. /usr/lib/x86_64-linux-gnu/libcudnn_adv_static.a
  9. /usr/lib/x86_64-linux-gnu/libcudnn_adv_static_v9.a
  10. /usr/lib/x86_64-linux-gnu/libcudnn_cnn.so
  11. /usr/lib/x86_64-linux-gnu/libcudnn_cnn.so.9
  12. /usr/lib/x86_64-linux-gnu/libcudnn_cnn.so.9.8.0
  13. /usr/lib/x86_64-linux-gnu/libcudnn_cnn_static.a
  14. /usr/lib/x86_64-linux-gnu/libcudnn_cnn_static_v9.a
  15. /usr/lib/x86_64-linux-gnu/libcudnn_engines_precompiled.so
  16. /usr/lib/x86_64-linux-gnu/libcudnn_engines_precompiled.so.9
  17. /usr/lib/x86_64-linux-gnu/libcudnn_engines_precompiled.so.9.8.0
  18. /usr/lib/x86_64-linux-gnu/libcudnn_engines_precompiled_static.a
  19. /usr/lib/x86_64-linux-gnu/libcudnn_engines_precompiled_static_v9.a
  20. /usr/lib/x86_64-linux-gnu/libcudnn_engines_runtime_compiled.so
  21. /usr/lib/x86_64-linux-gnu/libcudnn_engines_runtime_compiled.so.9
  22. /usr/lib/x86_64-linux-gnu/libcudnn_engines_runtime_compiled.so.9.8.0
  23. /usr/lib/x86_64-linux-gnu/libcudnn_engines_runtime_compiled_static.a
  24. /usr/lib/x86_64-linux-gnu/libcudnn_engines_runtime_compiled_static_v9.a
  25. /usr/lib/x86_64-linux-gnu/libcudnn_graph.so
  26. /usr/lib/x86_64-linux-gnu/libcudnn_graph.so.9
  27. /usr/lib/x86_64-linux-gnu/libcudnn_graph.so.9.8.0
  28. /usr/lib/x86_64-linux-gnu/libcudnn_graph_static.a
  29. /usr/lib/x86_64-linux-gnu/libcudnn_graph_static_v9.a
  30. /usr/lib/x86_64-linux-gnu/libcudnn_heuristic.so
  31. /usr/lib/x86_64-linux-gnu/libcudnn_heuristic.so.9
  32. /usr/lib/x86_64-linux-gnu/libcudnn_heuristic.so.9.8.0
  33. /usr/lib/x86_64-linux-gnu/libcudnn_heuristic_static.a
  34. /usr/lib/x86_64-linux-gnu/libcudnn_heuristic_static_v9.a
  35. /usr/lib/x86_64-linux-gnu/libcudnn_ops.so
  36. /usr/lib/x86_64-linux-gnu/libcudnn_ops.so.9
  37. /usr/lib/x86_64-linux-gnu/libcudnn_ops.so.9.8.0
  38. /usr/lib/x86_64-linux-gnu/libcudnn_ops_static.a
  39. /usr/lib/x86_64-linux-gnu/libcudnn_ops_static_v9.a
复制代码
从我的提供的输出结果来看，cuDNN 库文件已经成功安装在`/usr/lib/x86_64-linux-gnu`目录下，而不是`/usr/local/cuda/lib64`。这说明 cuDNN 的安装路径是精确的，并且体系已经精确配置了相关的库文件。

以下是验证结果解释：
• cuDNN 库文件存在：
• 我已经找到了多个 cuDNN 的动态链接库（如`libcudnn.so`、`libcudnn.so.9`、`libcudnn.so.9.8.0`）和静态库（如`libcudnn_adv_static.a`、`libcudnn_cnn_static_v9.a`等）。
• 这些文件的存在表明 cuDNN 已精确安装。

• CUDA 目录下没有 cuDNN 文件：
• `/usr/local/cuda/lib64`目录下没有找到 cuDNN 文件，这是由于 cuDNN 的安装路径是`/usr/lib/x86_64-linux-gnu`，而不是`/usr/local/cuda`。
• 这是正常的，由于 cuDNN 的安装路径通常由体系包管理器（如`apt`）决定，而不是手动安装到 CUDA 的目录下。
小结：从我的输出结果来看，cuDNN 已精确安装在   /usr/lib/x86_64-linux-gnu   目录下。
 
接下来我们将通过安装Anaconda之后，在与体系隔离的假造环境中安装Pytorch来完全地验证CUDA和cuDNN的安装是否精确。

 
（三）安装Anaconda

通过查询，截止2025年03月06日，最新版本Anaconda完整文件名为：Anaconda3-2024.10-1-Linux-x86_64.sh
1、通过以下下令下载和安装：

复制下令粘贴到WSL2-Ubuntu终端窗口中，按ENTER键运行
  1. wget -P /tmp https://repo.anaconda.com/archive/Anaconda3-2024.10-1-Linux-x86_64.sh # 下载anaconda安装包至 /tmp 目录下
  2. bash /tmp/Anaconda3-2024.10-1-Linux-x86_64.sh # 安装anaconda
复制代码

2、执行下令后会自动举行下载完成后会进入安装步调： 

此时要点击ENTER键后不停按着不松开，来翻页阅读安装前协议

 继续按着ENTER键不松手，直到出现输入框才停止

不停按到出现输入框，按多了也没关系，不输入就不能继续
 用键盘手动输入“yes”，之后按ENTER回车键确认输入。然后进入到下边这个界面：
这会会询问安装位置，默认不修改则继续按一次ENTER键确认使用默认安装路径：

之后安装会询问:是否要集成到shell当中，自动进入默认假造环境？ 

发起输入“yes”
 

此时安装完成。
发起关闭终端，然后重新打开，看看是否自动进入默认的conda的base假造环境了： 
 可以看到重新打开WSL2-Ubuntu终端后已自动激活base默认的Anaconda假造环境了。
 

3、验证Anaconda的安装

验证 Conda 安装是否成功可以通过以下几种方法。这些方法可以帮助你确认 Conda 是否精确安装，并且能够正常运行。

方法 1：检查 Conda 版本
运行以下下令来检查 Conda 的版本号。如果 Conda 安装成功，它会表现当前的版本信息：
  1. conda --version
复制代码

如果输出类似以下内容，则说明 Conda 安装成功：

 

如果没有输出，或者提示`conda: command not found`，则说明 Conda 没有精确安装，或者其路径没有被添加到体系的环境变量中。

方法 2：检查 Conda 环境
运行以下下令来检察当前的 Conda 环境列表：
  1. conda env list
复制代码

如果 Conda 安装成功，你会看到类似以下的输出，列出所有已创建的 Conda 环境：


 
方法 3：创建并激活新的 Conda 环境
你可以创建一个新的 Conda 环境并激活它，以验证 Conda 的功能是否正常：

• 创建新的环境：
  1. conda create -n testenv python=3.9
复制代码
 
• 激活环境：
  1. conda activate testenv
复制代码
 
• 检查当前环境：
  1. conda info --envs
复制代码

如果输出表现当前激活的环境是`testenv`，则说明 Conda 正常工作：

# conda environments:
#
base                     /home/love/miniconda3
testenv               *  /home/love/miniconda3/envs/testenv
```
方法 4：安装并验证 Python 包
在激活的 Conda 环境中，安装一个常用的 Python 包（如`numpy`），并验证其是否正常工作：

• 安装包：
  1.  conda install numpy
复制代码
 
• 验证安装：
  1.  python -c "import numpy; print(numpy.__version__)"
复制代码

如果输出表现了`numpy`的版本号（比方`1.23.4`），则说明 Conda 和 Python 环境正常工作。

方法 5：检查 Conda 配置
运行以下下令来检查 Conda 的配置信息：
  1. conda config --show
复制代码
 

这将表现 Conda 的配置文件路径、默认环境路径、通道（channels）等信息。如果输出正常，说明 Conda 的配置文件没有问题。

方法 6：检查 Conda 的初始化
如果你在安装 Conda 后没有运行初始化下令，大概会导致`conda`下令无法正常使用。运行以下下令来初始化 Conda：
  1. conda init
复制代码

然后重新打开终端窗口，再次运行`conda --version`来验证。
  1. conda --version
复制代码

小结
通过以上方法，你可以全面验证 Conda 是否精确安装并正常工作。如果在验证过程中遇到问题，请检查以下内容：
• 确保 Conda 的安装路径已添加到体系的环境变量中。
• 确保 Conda 初始化完成。
• 如果仍然有问题，可以尝试重新安装 Conda。
 
 
三、安装Pytorch并验证CUDA12.8、cuDNN、Anaconda、Pytorch的安装

（一）安装Pytorch


我们就用默认的base环境来安装torch举行验证WSL2-Ubuntu的整个深度学习环境的搭建是否成功

如今CUDA12.8版本还不支持conda下令安装，以后torch官方会更新出conda包，我们就先用官方给的pip下令安装Preview (Nightly)版：
 
  1. pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu128
复制代码

 过一会后安装完成：

 接下来我们将用这个告急的深度学习库来验证之前的所有安装。
 
（二）用Pytorch并验证CUDA12.8、cuDNN、Anaconda、Pytorch的安装
先关闭WSL2-Ubuntu终端后，重新打开WSL2-Ubuntu终端；
在WSL2-Ubuntu终端内输入“python”并回车调起python：
  1. python
复制代码
 

复制以下整段代理粘贴后按ENTER回车键支持验证：
  1. import torch  # 导入 PyTorch 库
  3. print("PyTorch 版本：", torch.__version__)  # 打印 PyTorch 的版本号
  5. # 检查 CUDA 是否可用，并设置设备（"cuda:0" 或 "cpu"）
  6. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  7. print("设备：", device)  # 打印当前使用的设备
  8. print("CUDA 可用：", torch.cuda.is_available())  # 打印 CUDA 是否可用
  9. print("cuDNN 已启用：", torch.backends.cudnn.enabled)  # 打印 cuDNN 是否已启用
  11. # 打印 PyTorch 支持的 CUDA 和 cuDNN 版本
  12. print("支持的 CUDA 版本：", torch.version.cuda)
  13. print("cuDNN 版本：", torch.backends.cudnn.version())
  15. # 创建两个随机张量（默认在 CPU 上）
  16. x = torch.rand(5, 3)
  17. y = torch.rand(5, 3)
  19. # 将张量移动到指定设备（CPU 或 GPU）
  20. x = x.to(device)
  21. y = y.to(device)
  23. # 对张量进行逐元素相加
  24. z = x + y
  26. # 打印结果
  27. print("张量 z 的值：")
  28. print(z)  # 输出张量 z 的内容
复制代码
 如果输出如下，则表明CUDA12.8、cuDNN、Anaconda、Pytorch全部安装成功！

从上边的输出来看，你已经成功地在 Python 中导入了 PyTorch，并且确认了 CUDA 和 cuDNN 的可用性。你的代码运行正常，并且 PyTorch 正在使用 GPU（`cuda:0`）举行计算。以下是对代码和输出的总结：
  1. (base) love@AI:~$ python
  2. Python 3.12.7 | packaged by Anaconda, Inc. | (main, Oct  4 2024, 13:27:36) [GCC 11.2.0] on linux
  3. Type "help", "copyright", "credits" or "license" for more information.
  4. >>> import torch  # 导入 PyTorch 库
  5. "PyTorch 版本：", torch.__version__)  # 打印 PyTorch 的版本号
  7. # 检查 CUDA 是否可用，并设置设备（"cuda:0" 或 "cpu"）
  8. device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  9. print("设备：", device)  # 打印当前使用的设备
  10. print("CUDA 可用：", torch.cuda.is_available())  # 打印 CUDA 是否可用
  11. print("cuDNN 已启用：", torch.backends.cudnn.enabled)  # 打印 cuDNN 是否已启用
  13. # 打印 PyTorch 支持的 CUDA 和 cuDNN 版本
  14. print("支持的 CUDA 版本：", torch.version.cuda)
  15. print("cuDNN 版本：", torch.backends.cudnn.version())
  17. # 创建两个随机张量（默认在 CPU 上）
  18. x = torch.rand(5, 3)
  19. y = torch.rand(5, 3)
  21. # 将张量移动到指定设备（CPU 或 GPU）
  22. x = x.to(device)
  23. y = y.to(device)
  25. # 对张量进行逐元素相加
  26. z = x + y
  28. # 打印结果
  29. print("张量 z 的值：")
  30. print(z)  # 输出张量 z 的内容>>>
  31. >>> print("PyTorch 版本：", torch.__version__)  # 打印 PyTorch 的版本号
  32. PyTorch 版本： 2.7.0.dev20250306+cu128
  33. >>>
  34. >>> # 检查 CUDA 是否可用，并设置设备（"cuda:0" 或 "cpu"）
  35. >>> device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  36. >>> print("设备：", device)  # 打印当前使用的设备
  37. 设备： cuda:0
  38. >>> print("CUDA 可用：", torch.cuda.is_available())  # 打印 CUDA 是否可用
  39. CUDA 可用： True
  40. >>> print("cuDNN 已启用：", torch.backends.cudnn.enabled)  # 打印 cuDNN 是否已启用
  41. cuDNN 已启用： True
  42. >>>
  43. >>> # 打印 PyTorch 支持的 CUDA 和 cuDNN 版本
  44. >>> print("支持的 CUDA 版本：", torch.version.cuda)
  45. 支持的 CUDA 版本： 12.8
  46. >>> print("cuDNN 版本：", torch.backends.cudnn.version())
  47. cuDNN 版本： 90701
  48. >>>
  49. >>> # 创建两个随机张量（默认在 CPU 上）
  50. >>> x = torch.rand(5, 3)
  51. >>> y = torch.rand(5, 3)
  52. >>>
  53. >>> # 将张量移动到指定设备（CPU 或 GPU）
  54. >>> x = x.to(device)
  55. >>> y = y.to(device)
  56. >>>
  57. >>> # 对张量进行逐元素相加
  58. >>> z = x + y
  59. >>>
  60. >>> # 打印结果
  61. >>> print("张量 z 的值：")
  62. 张量 z 的值：
  63. >>> print(z)  # 输出张量 z 的内容
  64. tensor([[0.8231, 0.9657, 1.3131],
  65.         [0.8789, 1.4404, 0.8304],
  66.         [0.8528, 1.3328, 1.9110],
  67.         [1.0722, 0.6289, 1.4093],
  68.         [1.1559, 0.8878, 0.5438]], device='cuda:0')
  69. >>>
复制代码

---
代码运行结果：
PyTorch 版本： 2.7.0.dev20250306+cu128
装备： cuda:0
CUDA 可用： True
cuDNN 已启用： True
支持的 CUDA 版本： 12.8
cuDNN 版本： 90701
---
关键信息：
• PyTorch 版本：`2.7.0.dev20250306+cu128`
• 这是一个开发版本（`dev`），并且是针对 CUDA 12.8 的版本。

• 装备：`cuda:0`
• 表示 PyTorch 已成功检测到 GPU，并将使用第一个 GPU 装备。

• CUDA 和 cuDNN：
• CUDA 可用：`True`，表示体系支持 CUDA，PyTorch 可以利用 GPU 加速。
• cuDNN 已启用：`True`，表示 cuDNN 已启用，这有助于进一步加速深度学习任务。
• 支持的 CUDA 版本：`12.8`，表示 PyTorch 支持 CUDA 12.8。
• cuDNN 版本：`90701`（即 cuDNN 9.7.1）。

---
如果我们遇到任何问题（比方 CUDA 不可用），请确保：
• 检查 GPU 驱动和 CUDA 安装：
• GPU 驱动是最新的。
• 安装了精确版本的 CUDA 和 cuDNN。
• PyTorch 版本与 CUDA 版本兼容。

---
   【Windows 11 中摆设 Linux 项目 - CSDN App】https://blog.csdn.net/u014451778/article/details/144777265?sharetype=blog&shareId=144777265&sharerefer=APP&sharesource=u014451778&sharefrom=link
  
至此，在Windosw体系上的WSL2-Ubuntu深度学习环境配置完成，可以在Windosw体系上优雅地借助Windosw的易用性和Linux体系的高效性举行项目摆设和开发调试了。
 
 
 
 
 
 

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

登录后关闭弹窗

登录参与点评抽奖  加入IT实名职场社区
去登录

QQ|手机版|qidao123.com IT社区;IT企服评测▪应用市场 ( 浙ICP备20004199|浙ICP备20004199号 )|网站地图

GMT+8, 2026-10-2 02:43 , Processed in 0.074274 second(s), 6 queries , Redis On.

Powered by Discuz! X3.5 Licensed

© 2001-2026 Discuz! Team.

快速回复 返回顶部 返回列表