精华内容
下载资源
问答
  • 对于入门深度学习的同学开说,笔记本GPU性能太弱是一件非常让人头疼的事,而租用的gpu服务器又太贵,最近刚发现google提供的免费云平台,可供我们做训练网络服务器用,GPU型号为Tesla T4 ,性能也是不俗。...
  • C++服务器开发完整学习路线(含免费学习资料下载地址) 包含电子书和视频教程 非常好
  • 服务器上进行深度学习的入门教程

    千次阅读 多人点赞 2020-12-14 17:01:40
    主机那里填上服务器IP,下面填一下端口号,然后点击连接,之后会让你输入用户名密码,输入之后就可以进入啦 2.GPU状态 进入之后可能大家最想关注的就是GPU占用情况,可以使用一下两种命令来查看一下~ watch -n...

    1.远程登录

    Windows用户推荐使用Xshell

    主机那里填上服务器IP,下面填一下端口号,然后点击连接,之后会让你输入用户名密码,输入之后就可以进入啦

    2.GPU状态

    进入之后可能大家最想关注的就是GPU占用情况,可以使用一下两种命令来查看一下~

    watch -n 1 nvidia-smi

    或者

    watch --color -n 1 gpustat --color

    其中,--n是代表刷新时间,1就是每秒刷新一次;--color是加颜色好看一点QwQ,去掉也可以

    按ctrl+z可以退出哦~

    3.传输文件

    如果显卡有空闲,我们就可以准备跑代码啦

    不过首先需要把代码和数据集复制到服务器上。这里推荐使用Xftp,和Xshell一块下载就可以。

    在Xshell中点击这个按钮就可以传输文件了,界面十分友好,直接把Windows的文件拖过去就行了

    甚至可以像Windows一样操作Linux里的文件哦

    要想运行python文件,除了坏境外(服务器上要用Anaconda不然人多容易乱掉),还要把文件的访问权限更改一下,如果是小白没有特殊需求的话可以直接

    chmod 777 xxx.py

    777就是把权限拉满。如果有不希望其他人访问这个文件等其他需求,可以查一下linux文件访问权限的相关知识随意修改。

    嫌麻烦的话在Xftp中也是可以修改权限的

    4.运行代码

    在activate你自己的Anaconda环境并更改文件权限之后,使用

    python xxx.py

    即可运行代码。

    不过我们可能需要并行运行多种参数的代码

    在命令后面加上&即可让命令在后台执行。为了能看到训练日志,可以使用>将输出重定向到一个文件中(否则会直接打印到屏幕上)

    运行的时候代码中要调的参数用argparse(比较常见的东西,如果你读别人的代码的话几乎都是用这个的)

    比如要调整dropout参数和lr参数:

    python train.py --dropout=0.6 --lr=0.005 > log_001.txt &

    用jobs命令可以查看后台任务的运行状况(任务号、进程号、stopped、running等),在前台运行的程序用ctrl+z可以stop它并丢到后台,用bg [任务号] (不含方括号,介绍linux命令的文档都是这种格式哦)命令可以让stopped的任务继续在后台跑,用fg[任务号]命令可以让后台的任务来前台执行。

    为了防止忘记上面调了那些参数,可以把命令写成shell脚本,即创建一个xxx.sh文件,把上面的这条命令放进去,然后赋予文件权限后用 ./xxx.sh 即可

    还可以在y前面加上指令指定使用哪块GPU,比如

    CUDA_VISIBLE_DEVICES=0 python train.py --dropout=0.6 --lr=0.005 > log_001.txt &

    就是使用0号GPU

    注意:对于TensorFlow用 户而言,程序中新建Session时一定要设置gpu_options.allow_growth为True。否则 TensorFlow 会占用掉你选中显卡的所有显存

    有时候可能想要跑多个参数,可以把多个参数放到.sh文件中让它一个一个跑,然后就可以愉快地摸鱼去啦~

    5.tmux

    在正式运行代码之前,有必要介绍一下tmux。

    tmux是Terminal MultipleXer的缩写,意思是“终端复用器”,为什么要介绍它呢?

    要知道,我们的ssh连接在中断之后,其中的进程也会终止,也就是说我们跑一个代码要几天的话中间ssh连接断开了,这几天也就白跑了。

    一种方式是在命令前面加上 nohup 

    nohup python train.py --dropout=0.6 --lr=0.005 > log_001.txt &

    不过这样还不够方便,因为我希望实时知道每个代码运行到什么程度,比如创建多个窗口,让每个代码都在前台跑,我需要看的时候直接进入这个窗口就可以看到训练进度。而且当我们ssh连接断开时,这些窗口并不会关闭,代码还会继续跑!

    这就是tmux的用处!

    安装好tmux后,使用

    tmux new -s xxx

    创建一个名为xxx的会话(tmux session),之后就会进入一个tmux窗口,其左下角

    代表当前窗口的名称编号等信息

    按Ctrl+B,之后再按C即可创建一个新窗口

    上面的三个窗口中,2:bash有一个星号*, 代表当前的窗口是2

    按Ctrl+B,之后再按相应数字键即可切换到相应窗口(Linux中尽量不要按108键盘右面的键盘区数字可能会有问题)

    如果一次开9个以上窗口,就需要其他的方式切换了,不过开这么多窗口毕竟就不够方便了,也可以再新建一个会话

    使用Ctrl+B,再按D可以退出当前会话,或者输入tmux detach也可以退出(注意,用Ctrl+D会删除当前窗口,删掉就回不来了,不要搞混哦。只有一个窗口的时候会删掉会话)

    查看已有的session列表:

    tmux ls

    重新连接某个会话:

    tmux attach -t xxx
    上下分屏:Ctrl + B 再按 "
    左右分屏:Ctrl + B 再按 %
    切换分屏:Ctrl + B 再按 o
    

    将以下配置文件(文件名:.tmux.conf)添加到自己的目录下,并将tmux退出再重进,即可使用鼠标:

    # mouse mode on
    set-option -g mouse on
    

    还可以添加如下文件(.vimrc)让vim也更加好用:

    set nu
    syntax on
    set hlsearch
    set tabstop=4
    set showmatch
    set ruler
    set mouse=a
    set laststatus=2
    
    set statusline=%f         " Path to the file
    set statusline+=\ -\      " Separator
    set statusline+=FileType: " Label
    set statusline+=%y        " Filetype of the file
    set statusline+=\ \ \     " Separator
    set statusline+=%4l/%L    " Current line
    
    

    展开全文
  • 远程登陆服务器跑深度学习程序

    千次阅读 2020-06-13 11:28:42
    远程登陆服务器跑深度学习程序:在远程服务器上搭建跑程序的环境,然后把你想跑的程序及相关的文件传到远程服务器上,用命令行或者Pycharm或者Jupyter Notebook开始调试程序。也就是本机只是控制作用,程序的运行是...

    什么是远程登陆服务器跑深度学习程序:

    我最开始跑程序都在cpu或者谷歌云端,最近刚开始有gpu服务器,有空可以写一下谷歌云端跑程序教程,对于没有gpu服务器的可以考虑蹭谷歌云端的gpu,缺点就是非常不稳定,跑一个小网络可能要掉线三四次,很崩溃。
    远程登陆服务器跑深度学习程序:在远程服务器上搭建跑程序的环境,然后把你想跑的程序及相关的文件传到远程服务器上,用命令行或者Pycharm或者Jupyter Notebook开始调试程序。也就是本机只是控制作用,程序的运行是在服务器上,利用了服务器的gpu可以加快深度学习网络的训练。

    Ubuntu16.04添加新用户并授予管理员权限

    有root权限的用户

    远程连接服务器的方法:

    1.远程可视化控制软件TeamViewer

    直接傻瓜式安装使用即可,有时说连接错误,注册个用户登陆后会稳定很多

    2.SSH远程命令行控制

    3.推荐:远程命令行控制软件Xshell和远程传输文件软件Xftp

    Xshell和Xftp用校园邮箱注册是免费使用的
    Xshell和Xftp安装及使用软件B站教程

    Ubuntu16.04服务器远程安装Anaconda

    有用教程1
    附加:更改python环境变量后,最好重启一下服务器

    Anaconda ubuntu16.04 Cuda 8.0安装pytorch

    有用教程1
    已经安装了Cuda 8.0,命令行一直错写为conda install pytorch torchvision cuda8.0 -c pytorch
    应该是:conda install pytorch torchvision cuda80 -c pytorch

    可以用命令行在服务器上跑程序,这样改代码我不太习惯。我用了Pycharm远程连接服务器,或者jupyter notebook远程连接服务器,就是在本机上改的代码可以同步到服务器上。

    Pycharm远程连接服务器

    利用pycharm自带的远程访问功能

    Jupyter Notebook远程连接服务器

    利用jupyter notebook自带的远程访问功能
    其中打开jupyter_notebook_config.py用命令行:vim ./.jupyter/jupyter_notebook_config.py

    c.NotebookApp.ip = ‘*’
    c.NotebookApp.open_browser = False
    c.NotebookApp.port = 8888
    c.NotebookApp.password = ‘argon2: a r g o n 2 i d argon2id argon2idv=19 m = 10240 , t = 10 , p = 8 m=10240,t=10,p=8 m=10240,t=10,p=8YaMf/HFTexr8I2naS/gMpA$lil/xQYe/JOVjmHv7rXQVQ’

    VScode远程连接服务器

    VSCode 中利用 Remote SSH 连接远程服务器
    连接成功后会出现Open folder,打开需要的文件夹就行
    而且使用Terminal可以直接使用远程服务器的终端

    Anaconda ubuntu 安装caffe

    1.不同的深度学习框架最好还是不要混淆,所以在anaconda中新建一个caffe环境:
    conda create -n env_name python=X.X 创建python版本为X.X、名字为env_name的虚拟环境。env_name文件可以在Anaconda安装目录envs文件下找到。
    默认情况下只安装了一些必须的包,不会像我们安装anaconda时自动安装很多常用的包。要实现上面的功能,须在末尾加上‘anaconda’:conda create -n env_name python=X.X anaconda
    2.激活环境:conda activate caffe
    3.安装gpu版caffe:conda install -c defaults caffe-gpu
    4.验证:
    python
    import caffe

    PyTorch程序如何使用GPU加速

    已经配置好GPU环境了,在Pytorch程序中需要把数据,网络,与损失函数转换到GPU上
    有用教程1

    如果pytorch突然与cuda版本不符合了

    报错:The NVIDIA driver on your system is too old (found version 9000). Please update your GPU driver by downloading and installing a new version from the URL: http://www.nvidia.com/Download/index.aspx Alternatively, go to: https://pytorch.org to install a PyTorch version that has been compiled with your version of the CUDA driver.
    卸载pytoch重新安装

    展开全文
  • 搭建深度学习后台服务器

    千次阅读 2018-09-24 09:51:03
        本篇文章的原创为国外的一篇文章(一个可扩展的Keras深度学习REST API),链接为: ...我们的Keras深度学习REST API将能够批量处理图像,扩展到多台机器(包括多台web服务器和Redis实例),并在负载...

     

     

     

    本篇文章的原创为国外的一篇文章(一个可扩展的Keras深度学习REST API),链接为:

    https://www.pyimagesearch.com/2018/01/29/scalable-keras-deep-learning-rest-api/#

    我们的Keras深度学习REST API将能够批量处理图像,扩展到多台机器(包括多台web服务器和Redis实例),并在负载均衡器之后进行循环调度。

    为此,我们将使用:

    1. KerasRedis(内存数据结构存储)
    2. Flask (Python的微web框架)
    3. 消息队列和消息代理编程范例

    本篇文章的整体思路如下:

            我们将首先简要讨论Redis数据存储,以及如何使用它促进消息队列和消息代理。然后,我们将通过安装所需的Python包来配置Python开发环境,以构建我们的Keras深度学习REST API。一旦配置了开发环境,就可以使用Flask web框架实现实际的Keras深度学习REST API。在实现之后,我们将启动Redis和Flask服务器,然后使用cURL和Python向我们的深度学习API端点提交推理请求。最后,我们将以对构建自己的深度学习REST API时应该牢记的注意事项的简短讨论结束。

    第一部分:简要介绍Redis如何作为REST API消息代理/消息队列

                                                      

                                               图片1:Redis可以用作我们深度学习REST API的消息代理/消息队列

    Redis是内存中的数据存储。它不同于简单的键/值存储(比如memcached),因为它可以存储实际的数据结构。今天我们将使用Redis作为消息代理/消息队列。这包括:

    1. 在我们的机器上运行Redis
    2. 将数据(图像)按照队列的方式用Redis存储,并依次由我们的REST API处理
    3. 为新批输入图像循环访问Redis
    4. 对图像进行分类并将结果返回给客户端

    文章中对Redis官网有一个超链接(https://redis.io/topics/introduction),但是要翻出去,所以我就截图一个图片放上去仅供参考。

                                             

    第二部分:安装和配置Redis

    官网做法,linux系统的安装:

    自己的安装方法:

    conda install redis

    开启方式相同:

    resdis-server

    结果:

    测试和原文的命令一致。

    redis-cli ping

    第三部分:配置Python开发环境以构建Keras REST API

    文章中说需要创建新的虚拟环境来防止影响系统级别的python项目(但是我没有创建),但是还是需要安装rest api所需要依赖的包。以下为所需要的包。

    $ pip install numpy
    $ pip install scipy h5py
    $ pip install tensorflow # tensorflow-gpu for GPU machines
    $ pip install keras
    $ pip install flask gevent
    $ pip install imutils requests
    $ pip install redis
    $ pip install Pillow

    第四部分:实现可扩展的Keras REST API

    首先是Keras Redis Flask REST API数据流程图

    让我们开始构建我们的服务器脚本。为了方便起见,我在一个文件中实现了服务器,但是它可以按照您认为合适的方式模块化。为了获得最好的结果和避免复制/粘贴错误,我建议您使用本文的“下载”部分来获取相关的脚本和图像。:

    # import the necessary packages
    from keras.applications import ResNet50
    from keras.preprocessing.image import img_to_array
    from keras.applications import imagenet_utils
    from threading import Thread
    from PIL import Image
    import numpy as np
    import base64
    import flask
    import redis
    import uuid
    import time
    import json
    import sys
    import io

    为了简单起见,我们将在ImageNet数据集上使用ResNet预训练。我将指出在哪里可以用你自己的模型交换ResNet。flask模块包含flask库(用于构建web API)。redis模块将使我们能够与redis数据存储接口。从这里开始,让我们初始化将在run_keras_server.py中使用的常量.

    # initialize constants used to control image spatial dimensions and
    # data type
    IMAGE_WIDTH = 224
    IMAGE_HEIGHT = 224
    IMAGE_CHANS = 3
    IMAGE_DTYPE = "float32"
     
    # initialize constants used for server queuing
    IMAGE_QUEUE = "image_queue"
    BATCH_SIZE = 32
    SERVER_SLEEP = 0.25
    CLIENT_SLEEP = 0.25

    我们将向服务器传递float32图像,尺寸为224 x 224,包含3个通道。我们的服务器可以处理一个BATCH_SIZE = 32。如果您的生产系统上有GPU(s),那么您需要调优BATCH_SIZE以获得最佳性能。我发现将SERVER_SLEEP和CLIENT_SLEEP设置为0.25秒(服务器和客户端在再次轮询Redis之前分别暂停的时间)在大多数系统上都可以很好地工作。如果您正在构建一个生产系统,那么一定要调整这些常量。

    让我们启动我们的Flask app和Redis服务器:

    # initialize our Flask application, Redis server, and Keras model
    app = flask.Flask(__name__)
    db = redis.StrictRedis(host="localhost", port=6379, db=0)
    model = None

    在这里你可以看到启动Flask是多么容易。在运行这个服务器脚本之前,我假设Redis服务器正在运行(之前的redis-server)。我们的Python脚本连接到本地主机6379端口(Redis的默认主机和端口值)上的Redis存储。不要忘记将全局Keras模型初始化为None。接下来我们来处理图像的序列化:

    def base64_encode_image(a):
    	# base64 encode the input NumPy array
    	return base64.b64encode(a).decode("utf-8")
     
    def base64_decode_image(a, dtype, shape):
    	# if this is Python 3, we need the extra step of encoding the
    	# serialized NumPy string as a byte object
    	if sys.version_info.major == 3:
    		a = bytes(a, encoding="utf-8")
     
    	# convert the string to a NumPy array using the supplied data
    	# type and target shape
    	a = np.frombuffer(base64.decodestring(a), dtype=dtype)
    	a = a.reshape(shape)
     
    	# return the decoded image
    	return a

    Redis将充当服务器上的临时数据存储。图像将通过诸如cURL、Python脚本甚至是移动应用程序等各种方法进入服务器,而且,图像只能每隔一段时间(几个小时或几天)或者以很高的速率(每秒几次)进入服务器。我们需要把图像放在某个地方,因为它们在被处理前排队。我们的Redis存储将作为临时存储。

    为了将图像存储在Redis中,需要对它们进行序列化。由于图像只是数字数组,我们可以使用base64编码来序列化图像。使用base64编码还有一个额外的好处,即允许我们使用JSON存储图像的附加属性。

    base64_encode_image函数处理序列化。类似地,在通过模型传递图像之前,我们需要反序列化图像。这由base64_decode_image函数处理。

    预处理图片:

    def prepare_image(image, target):
    	# if the image mode is not RGB, convert it
    	if image.mode != "RGB":
    		image = image.convert("RGB")
     
    	# resize the input image and preprocess it
    	image = image.resize(target)
    	image = img_to_array(image)
    	image = np.expand_dims(image, axis=0)
    	image = imagenet_utils.preprocess_input(image)
     
    	# return the processed image
    	return image

    我已经定义了一个prepare_image函数,它使用Keras中的ResNet50实现对输入图像进行预处理,以便进行分类。在使用您自己的模型时,我建议修改此函数,以执行所需的预处理、缩放或规范化。

    从那里我们将定义我们的分类方法:

    def classify_process():
    	# load the pre-trained Keras model (here we are using a model
    	# pre-trained on ImageNet and provided by Keras, but you can
    	# substitute in your own networks just as easily)
    	print("* Loading model...")
    	model = ResNet50(weights="imagenet")
    	print("* Model loaded")

    classify_process函数将在它自己的线程中启动,我们将在下面的__main__中看到这一点。该函数将从Redis服务器轮询图像批次,对图像进行分类,并将结果返回给客户端。

    在model = ResNet50(weights="imagenet")这一行中,我将这个操作与终端打印消息连接起来——根据Keras模型的大小,加载是即时的,或者需要几秒钟。

    加载模型只在启动这个线程时发生一次——如果每次我们想要处理一个映像时都必须加载模型,那么速度会非常慢,而且由于内存耗尽可能导致服务器崩溃。

    加载模型后,这个线程将不断轮询新的图像,然后将它们分类(注意这部分代码应该时尚一部分的继续):

    	# continually poll for new images to classify
    	while True:
    		# attempt to grab a batch of images from the database, then
    		# initialize the image IDs and batch of images themselves
    		queue = db.lrange(IMAGE_QUEUE, 0, BATCH_SIZE - 1)  #第79行
    		imageIDs = []
    		batch = None
     
    		# loop over the queue
    		for q in queue:
    			# deserialize the object and obtain the input image
    			q = json.loads(q.decode("utf-8"))
    			image = base64_decode_image(q["image"], IMAGE_DTYPE,
    				(1, IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_CHANS))
     
    			# check to see if the batch list is None
    			if batch is None:
    				batch = image
     
    			# otherwise, stack the data
    			else:
    				batch = np.vstack([batch, image])
     
    			# update the list of image IDs
    			imageIDs.append(q["id"])

    在这里,我们首先使用Redis数据库的lrange函数从队列(第79行)中获取最多的BATCH_SIZE图像。

    从那里我们初始化imageIDs和批处理(第80和81行),并开始在第84行开始循环队列。

    在循环中,我们首先解码对象并将其反序列化为一个NumPy数组image(第86-88行)。

    接下来,在第90-96行中,我们将向批处理添加图像(或者如果批处理当前为None,我们将该批处理设置为当前图像)。

    我们还将图像的id附加到imageIDs(第99行)。

    让我们完成循环和函数:

    		# check to see if we need to process the batch
    		if len(imageIDs) > 0:                     # 第102行
    			# classify the batch
    			print("* Batch size: {}".format(batch.shape))
    			preds = model.predict(batch)
    			results = imagenet_utils.decode_predictions(preds)
     
    			# loop over the image IDs and their corresponding set of
    			# results from our model
    			for (imageID, resultSet) in zip(imageIDs, results):
    				# initialize the list of output predictions
    				output = []
     
    				# loop over the results and add them to the list of
    				# output predictions
    				for (imagenetID, label, prob) in resultSet:
    					r = {"label": label, "probability": float(prob)}
    					output.append(r)
     
    				# store the output predictions in the database, using
    				# the image ID as the key so we can fetch the results
    				db.set(imageID, json.dumps(output))        #第122行
     
    			# remove the set of images from our queue
    			db.ltrim(IMAGE_QUEUE, len(imageIDs), -1)
     
    		# sleep for a small amount
    		time.sleep(SERVER_SLEEP)

    在这个代码块中,我们检查批处理中是否有图像(第102行)。如果我们有一批图像,我们通过模型(第105行)对整个批进行预测。从那里,我们循环一个图像和相应的预测结果(110-122行)。这些行向输出列表追加标签和概率,然后使用imageID将输出存储在Redis数据库中(第116-122行)。

    我们使用第125行上的ltrim从队列中删除了刚刚分类的图像集。最后,我们将睡眠设置为SERVER_SLEEP时间并等待下一批图像进行分类。下面我们来处理/predict我们的REST API端点:

    @app.route("/predict", methods=["POST"])
    def predict():
    	# initialize the data dictionary that will be returned from the
    	# view
    	data = {"success": False}
     
    	# ensure an image was properly uploaded to our endpoint
    	if flask.request.method == "POST":
    		if flask.request.files.get("image"):
    			# read the image in PIL format and prepare it for
    			# classification
    			image = flask.request.files["image"].read()
    			image = Image.open(io.BytesIO(image))
    			image = prepare_image(image, (IMAGE_WIDTH, IMAGE_HEIGHT))
     
    			# ensure our NumPy array is C-contiguous as well,
    			# otherwise we won't be able to serialize it
    			image = image.copy(order="C")
     
    			# generate an ID for the classification then add the
    			# classification ID + image to the queue
    			k = str(uuid.uuid4())
    			d = {"id": k, "image": base64_encode_image(image)}
    			db.rpush(IMAGE_QUEUE, json.dumps(d))

    稍后您将看到,当我们发布到REST API时,我们将使用/predict端点。当然,我们的服务器可能有多个端点。我们使用@app。路由修饰符以第130行所示的格式在函数上方定义端点,以便Flask知道调用什么函数。我们可以很容易地得到另一个使用AlexNet而不是ResNet的端点,我们可以用类似的方式定义具有关联函数的端点。你懂的,但就我们今天的目的而言,我们只有一个端点叫做/predict。

    我们在第131行定义的predict方法将处理对服务器的POST请求。这个函数的目标是构建JSON数据,并将其发送回客户机。如果POST数据包含图像(第137和138行),我们将图像转换为PIL/Pillow格式,并对其进行预处理(第141-143行)。

    在开发这个脚本时,我花了大量时间调试我的序列化和反序列化函数,结果发现我需要第147行将数组转换为C-contiguous排序(您可以在这里了解更多)。老实说,这是一个相当大的麻烦事,但我希望它能帮助你站起来,快速跑。

    如果您想知道在第99行中提到的id,那么实际上是使用uuid(通用唯一标识符)在第151行生成的。我们使用UUID来防止hash/key冲突。

    接下来,我们将图像的id和base64编码附加到d字典中。使用rpush(第153行)将这个JSON数据推送到Redis db非常简单。

    让我们轮询服务器以返回预测:

    			# keep looping until our model server returns the output
    			# predictions
    			while True:
    				# attempt to grab the output predictions
    				output = db.get(k)
     
    				# check to see if our model has classified the input
    				# image
    				if output is not None:
     					# add the output predictions to our data
     					# dictionary so we can return it to the client
    					output = output.decode("utf-8")
    					data["predictions"] = json.loads(output)
     
    					# delete the result from the database and break
    					# from the polling loop
    					db.delete(k)
    					break
     
    				# sleep for a small amount to give the model a chance
    				# to classify the input image
    				time.sleep(CLIENT_SLEEP)
     
    			# indicate that the request was a success
    			data["success"] = True
     
    	# return the data dictionary as a JSON response
    	return flask.jsonify(data)

    我们将持续循环,直到模型服务器返回输出预测。我们开始一个无限循环,试图得到157-159条预测线。从这里,如果输出包含预测,我们将对结果进行反序列化,并将结果添加到将返回给客户机的数据中。我们还从db中删除了结果(因为我们已经从数据库中提取了结果,不再需要将它们存储在数据库中),并跳出了循环(第163-172行)。

    否则,我们没有任何预测,我们需要睡觉,继续投票(第176行)。如果我们到达第179行,我们已经成功地得到了我们的预测。在本例中,我们向客户机数据添加True的成功值(第179行)。注意:对于这个示例脚本,我没有在上面的循环中添加超时逻辑,这在理想情况下会为数据添加一个False的成功值。我将由您来处理和实现。最后我们称烧瓶。jsonify对数据,并将其返回给客户端(第182行)。这就完成了我们的预测函数。

    为了演示我们的Keras REST API,我们需要一个__main__函数来实际启动服务器:

    # if this is the main thread of execution first load the model and
    # then start the server
    if __name__ == "__main__":
    	# load the function used to classify input images in a *separate*
    	# thread than the one used for main classification
    	print("* Starting model service...")
    	t = Thread(target=classify_process, args=())
    	t.daemon = True
    	t.start()
     
    	# start the web server
    	print("* Starting web service...")
    	app.run()

    第186-196行定义了__main__函数,它将启动classify_process线程(第190-192行)并运行Flask应用程序(第196行)。

    第五部分:启动可伸缩的Keras REST API

    要测试我们的Keras深度学习REST API,请确保使用本文的“下载”部分下载源代码示例图像。从这里,让我们启动Redis服务器,如果它还没有运行:

    redis-server

    然后,在另一个终端中,让我们启动REST API Flask服务器:

    python run_keras_server.py 

    另外,我建议在向服务器提交请求之前,等待您的模型完全加载到内存中。现在我们可以继续使用cURL和Python测试服务器。

    第七部分:使用cURL访问Keras REST API

    使用cURL来测试我们的Keras REST API服务器。这是我的家庭小猎犬Jemma。根据我们的ResNet模型,她被归类为一只拥有94.6%自信的小猎犬。

    curl -X POST -F image=@jemma.png 'http://localhost:5000/predict'

    你会在你的终端收到JSON格式的预测:

    {
      "predictions": [
        {
          "label": "beagle", 
          "probability": 0.9461546540260315
        }, 
        {
          "label": "bluetick", 
          "probability": 0.031958919018507004
        }, 
        {
          "label": "redbone", 
          "probability": 0.006617196369916201
        }, 
        {
          "label": "Walker_hound", 
          "probability": 0.0033879687543958426
        }, 
        {
          "label": "Greater_Swiss_Mountain_dog", 
          "probability": 0.0025766862090677023
        }
      ], 
      "success": true
    }

    第六部分:使用Python向Keras REST API提交请求

    如您所见,使用cURL验证非常简单。现在,让我们构建一个Python脚本,该脚本将发布图像并以编程方式解析返回的JSON。

    让我们回顾一下simple_request.py

    # import the necessary packages
    import requests
     
    # initialize the Keras REST API endpoint URL along with the input
    # image path
    KERAS_REST_API_URL = "http://localhost:5000/predict"
    IMAGE_PATH = "jemma.png"

    我们在这个脚本中使用Python请求来处理向服务器提交数据。我们的服务器运行在本地主机上,可以通过端口5000访问端点/predict,这是KERAS_REST_API_URL变量(第6行)指定的。

    我们还定义了IMAGE_PATH(第7行)。png与我们的脚本在同一个目录中。如果您想测试其他图像,请确保指定到您的输入图像的完整路径。

    让我们加载图像并发送到服务器:

    # load the input image and construct the payload for the request
    image = open(IMAGE_PATH, "rb").read()
    payload = {"image": image}
     
    # submit the request
    r = requests.post(KERAS_REST_API_URL, files=payload).json()
     
    # ensure the request was sucessful
    if r["success"]:
    	# loop over the predictions and display them
    	for (i, result) in enumerate(r["predictions"]):
    		print("{}. {}: {:.4f}".format(i + 1, result["label"],
    			result["probability"]))
     
    # otherwise, the request failed
    else:
    	print("Request failed")

    我们在第10行以二进制模式读取图像并将其放入有效负载字典。负载通过请求发送到服务器。在第14行发布。如果我们得到一个成功消息,我们可以循环预测并将它们打印到终端。我使这个脚本很简单,但是如果你想变得更有趣,你也可以使用OpenCV在图像上绘制最高的预测文本。

    第七部分:运行简单的请求脚本

    编写脚本很容易。打开终端并执行以下命令(当然,前提是我们的Flask服务器和Redis服务器都在运行)。

    python simple_request.py

    使用Python以编程方式使用我们的Keras深度学习REST API的结果

    第八部分:扩展深度学习REST API时的注意事项

    如果您预期在深度学习REST API上有较长一段时间的高负载,那么您可能需要考虑一种负载平衡算法,例如循环调度,以帮助在多个GPU机器和Redis服务器之间平均分配请求。

    记住,Redis是内存中的数据存储,所以我们只能在队列中存储可用内存中的尽可能多的图像。

    使用float32数据类型的单个224 x 224 x 3图像将消耗602112字节的内存。

    假设一台内存为16GB的服务器,这意味着我们可以在队列中保存大约26500个图像,但在这一点上,我们可能希望添加更多的GPU服务器来更快地消耗队列。

    第九部分:然而,有一个微妙的问题。。。

    根据您如何部署深度学习REST API,将classify_process函数保持在与web API其余代码相同的文件中存在一个微妙的问题。大多数web服务器,包括Apache和nginx,都允许多个客户机线程。如果你保持classify_process在同一个文件中预测的观点,那么你可能加载多个模型,如果您的服务器软件认为有必要创建一个新线程来服务的客户机请求,每一个新线程,将会创建一个新视图,因此一种新的模式将被加载。

    解决方案是将classify_process转移到一个完全独立的进程中,然后与Flask web服务器和Redis服务器一起启动它。

     

    最后,本人这里有一些flask和rest api的视频讲解资源,需要的话可以联系我

    展开全文
  • 如何用云服务器进行深度学习

    万次阅读 多人点赞 2019-10-27 22:59:45
    本文将从购买GPU服务器、远程连接服务器、深度学习环境安装、用jupyter操控服务器等方面逐一讲解购买及使用GPU服务器的步骤。

    笔者网站:mwhitelab.com

    笔者公众号:技术杂学铺

    本文将从购买GPU服务器、远程连接服务器、深度学习环境安装、用jupyter操控服务器等方面逐一讲解购买及使用GPU服务器的步骤。

    免费在线jupyter可见在线jupyter平台推荐

    目录

    1. 服务器配置与购买

    2. 服务器连接

    3. 环境安装

    4. 用jupyter操控服务器

    录:使用密钥对


    1. 服务器配置与购买

    云服务器供应商有很多,本文以阿里云为例,在百度云、腾讯云、谷歌云等其他供应商购买服务器的步骤大同小异。

    进入阿里云官网

    阿里云官网

    登录(支付宝、淘宝账户均可登录)并先预充一百元。

    鼠标移动至右上角头像可见余额

    在导航栏中选择“产品”-“云计算基础”-“GPU云服务器”

    在云服务器界面选择“GN5(P100)购买”

    接下来,我们便跳转到了阿里云服务器购买界面。默认情况下,系统为我们推荐“包年包月”的计费方式。每月上千的GPU租赁费用对大部分用户来说过于昂贵,而且我们只是偶尔会使用GPU计算服务,以月为单位租赁服务器有点浪费。

    阿里云服务器购买界面

    除了包年包月,我们还可以选择“按量付费”或者“抢占式实例”。按量付费是以小时为单位进行计费,计算完毕后需手动关闭服务器以停止计费。“抢占式实例”也是按小时计费,价格随市场波动,出价高的一批用户获得GPU服务器的使用权。

    “抢占式实例”价格相对便宜,但当市场价格高于我们的出价时,我们的实例将会被释放,服务器将会被他人使用。不过使用“自动出价”可以让我们避免上述风险。

    按量付费实例停机后不收费,抢占式网络虽然便宜,但必须释放实例实例后才会停止收费。

    如果只是想体验一下,计费方式可选择“抢占式实例”。地域选择“华北5(呼和浩特)”会有优惠,价格大约在五到七块每小时(价格会随时间有些许波动)。读者若想以后长期间断使用服务器,一定要选“按量付费”,根据配置不同价格在八到十三块每小时。(实际费用以秒为单位进行计算)

    服务器规格选择“ecs.gn5-c8g1.2xlarge”,该规格有8个vCPU,60G内存,一块P100 GPU,440G存储空间(暂时存储),Intel Xeon E5-2682v4 CPU。配置足以满足绝大部分任务的需求了。

    接着,设置镜像。

    镜像推荐一:如下图进行配置。CentOS/Ubuntu16.04系统都支持“自动安装GPU驱动”(新手推荐使用Ubuntu16.04,遇到的坑会少一点),可免去之后安装GPU驱动的步骤。(若是使用Tensorflow,仍需要手动安装cuDNN)

    Tensorflow-GPU的底层支持一直在变。当前(2019年3月20号)Tensorflow-gpu版本要求CUDA版本要9.0(目前不支持9.1!)且Driver要384.x或更高版本。读者若是几年后看到该文章,请先查询tensorflow-gpu的GPU驱动版本要求。安装驱动版本不符无法运行tensorflow-gpu

    安装GPU驱动一定要符合tensorflow-gpu的驱动要求

    镜像推荐二:读者也可以选择使用“镜像市场”中的镜像。如下图中的镜像,已经预装了GPU驱动和tensorflow等框架。纯小白建议选择这个方法,此处就免去了文本第三步环境安装的过程

    存储选择默认设置。本地存储440G空间会随着我们的实例释放后消除。一般我们的代码都放在系统盘,40G的系统盘满足大部分AI比赛或项目的存储需求。若有额外需求,读者可适当增加数据盘。这里保持默认不更改。

    不更改存储设置

    完成上述配置后,点击“下一步:网络和安全组”该界面,我们不做任何更改

    值得注意的是“公网带宽”中的带宽大小是指流量留流出的带宽大小,计费0.8元/G也是计算流量留出的费用。我们使用服务器下载文件属于流量流入,与该“公网带宽”选择无关,且服务器下载文件免费

    不更改网络设置

    安全组默认也保持不变。确保22端口打开即可,我们之后会通过ssh的方式连接服务器。

    安全组,确保22端口打开

    点击“下一步:系统配置”。了解密钥的读者可在“登录凭证”选择“密钥对”的方式。不了解密钥的读者可选“自定义密码”(记住该密码,当我们登录服务器时,登录名为root,密码为此处设置的密码)。

    选择登录凭证

    完成后点击“确认订单”。确认界面如下:

    配置确认界面

    “保存为启动模板”可选可不选。保存模板后,当我们再次购买类似服务器时,可以使用模板中的服务器配置。(按量计费时,我们想停止计费,只需关停服务器,不用删除服务器。以后想用服务器,再次启动即可,无需再次配置并购买服务器。)

    另外,我们也可以设置自动释放的时间(谨慎操作,到达释放时间后,实例会被释放,数据及IP不会被保留)若读者对自己的使用时间没有把握,不建议设置“使用时限”。

    “使用时限”选项

    点击同意《云服务器 ECS 服务条款》服务协议。

    之后我们即可点击右下角的“创建实例”了。创建实例之后即开始计费,直到我们手动停止服务为止。

    另外,当不用服务器的时候,一定记得要停止服务!

    若使用按量计费,选择“停止”即可(下图绿色框),想用时选择“启动”即可。若使用抢占式实例,则需要选择“释放设置”了(下图红色框),因为抢占式实例停止服务器后仍旧计费。下次使用时需要重新配置服务器,包括各类环境。

    2. 服务器连接

    在控制台中我们可以看到我们正在运行的云服务器。记住我们服务器的公网IP地址

    这里笔者使用Xshell来连接远程服务器。打开Xshell,在菜单栏里选择“文件”-“新建”

    名称随意设置,“主机”为你购买的服务器的公网IP地址,协议SSH,端口22。

    完成上述内容后,点击确定即可。创建成功后,在界面左侧双击我们刚刚创建的“阿里云服务器”以连接服务器。

    第一次登陆会有一个SSH安全警告,选择“接收并保存”即可。

    之后便是用户登录,默认的用户名为root

    登录方式则与之前“登录凭证”相对应。密码登录或者密钥登录。

    接着,我们便成功以ssh的方式远程连接了阿里云服务器。

    3. 环境安装

    刚购买的云服务器只有最简单的一些配置。我们需要在此基础上安装一些深度学习需要的环境。

    3.1 安装GPU驱动、CUDA以及cuDNN

    安装GPU驱动、CUDA、cuDNN全是坑,不同环境下出现的问题千奇百怪,此处难以一一举出。读者若安装时出现问题请直接百度/google,网上必有解决方法(虽然可能也不靠谱)。

    Ubuntu出现的坑较少,此处以Ubuntu为例。

    3.1.1 安装GPU驱动

    在第一步配置服务器时若选择“自动安装GPU驱动”则可跳过这一步。

    英伟达驱动下载页面设置自己的配置,之后点击“SEARCH”

    接着进入信息确认界面,点击“DOWNLOAD”

    再之后,在如下界面,右键“AGREE&DOWNLOAD”,复制链接地址。

    返回服务器命令行,输入wget 地址

    本案例是 wget http://us.download.nvidia.com/tesla/384.183/NVIDIA-Linux-x86_64-384.183.run

    下载完后,执行如下代码以安装驱动

    sudo chmod  a+x NVIDIA-Linux-x86_64-384.183.run
    sudo ./NVIDIA-Linux-x86_64-384.183.run -no-x-check -no-nouveau-check -no-opengl-files 

    安装过程中会有窗口让你选择yes或者no,问你是否continue的时候选择yes(笔者没有遇到这个选择),其他时候选择no。

    若驱动安装成功,输入nvidia-smi即可查看GPU当前状态。

    3.1.2 安装CUDA以及cuDNN

    这里给出tensorflow官网上推荐的CUDA以及cuDNN安装代码

    sudo apt-key adv --fetch-keys http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/7fa2af80.pub
    wget http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/cuda-repo-ubuntu1604_9.1.85-1_amd64.deb
    sudo apt install ./cuda-repo-ubuntu1604_9.1.85-1_amd64.deb
    wget http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb
    sudo apt install ./nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb
    sudo apt update
    sudo apt install cuda9.0 cuda-cublas-9-0 cuda-cufft-9-0 cuda-curand-9-0  cuda-cusolver-9-0 cuda-cusparse-9-0 libcudnn7=7.2.1.38-1+cuda9.0 libnccl2=2.2.13-1+cuda9.0 cuda-command-line-tools-9-0
    

    3.1.3 手动安装cuDNN(使用pytorch可跳过)

    若3.1.2中成功安装CUDA但未成功安装cuDNN,此时则需要我们进行手动安装cuDNN了。这个步骤略微繁琐,需要用户前往

    https://developer.nvidia.com/rdp/cudnn-download

    注册账户后才会有权限下载文件,直接以wget的方式下载会被服务器拒绝。

    我们只能用本地电脑访问上述网站,注册账户,然后选择我们需要的cuDNN版本,先下载到本地。(选择for CUDA 9.0版的,下载cuDNN Library for Linux)

    接下来,我们需要将本地下好的文件传到远程的服务器上。但在这之前,我们需要先要将服务器允许传输文件的端口打开。

    在阿里云服务器管理界面,找到我们的服务器,选择“管理”

    在管理界面选择“本实例安全组”

    打开安全组界面后,在横向菜单栏中选择“安全组列表”,之后选择“配置规则”

    选择“快速创建规则”

    配置如下图,选择telnet(23)端口,授权对象填“0.0.0.0/0”。完成后,我们就可以从本地向服务器传输文件了。

    我们在服务器命令行上输入apt-get install -y lrzsz,安装一个便于我们文件传输的工具。

    命令行输入rz,会弹出一个窗口,找到我们之前下载的文件,选择“打开”。

    之后便会开始传输文件

    当文件传出完成后,我们先把文件重新命名为tgz格式。

    mv cudnn-9.0-linux-x64-v7.5.0.56.solitairetheme8 cudnn-9.0-linux-x64-v7.5.0.56.tgz

    解压该文件tar -xzvf cudnn-9.0-linux-x64-v7.5.0.56.tgz

    把解压出的这几个文件分别放到cudn安装的位置。

    值得注意的是,有的服务器cudn是安装在/usr/local/cuda下,笔者的服务器是安装在/usr/local/cuda-9.0下。读者应该先查看一下自己/usr/local/中cuda文件夹名是什么,再进行如下安装。

    依次将我们解压好的文件放入cudn的安装目录对于位置。(每行指令最后的“/”一定要有!)

    sudo cp cuda/include/cudnn.h /usr/local/cuda-9.0/include/
    sudo cp cuda/lib64/libcudnn* /usr/local/cuda-9.0/lib64/

    最后执行如下代码即可成功安装完cudnn

    sudo chmod a+r /usr/local/cuda-9.0/include/cudnn.h
    sudo chmod a+r /usr/local/cuda/lib64/libcudnn*

    输入cat /usr/local/cuda-9.0/include/cudnn.h | grep CUDNN_MAJOR -A 2 可检查安装是否成功(路径中cuda-9.0在某些服务器中应该为cuda)

    3.2 安装anaconda(可跳过)

    Anaconda是一个开源的Python发行版本,其包含了conda、Python等180多个科学包及其依赖项。

    3.2.1 下载并安装anaconda

    输入wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-4.4.0-Linux-x86_64.sh以下载anaconda文件(linux64位版)

    运行 bash 下载文件名.sh 来安装anaconda,这里是bash Anaconda3-4.4.0-Linux-x86_64.sh

    安装过程中一直回车。遇到问yes或no的问题,除了问是否安装vscode输入no,其他都输入yes。

    若遇见“bunzip2: command not found”报错执行yum install -y bzip2之后再执行bash 下载文件名.sh -u  (要加-u,-u的意思是重新安装,覆盖之前安装的内容)

    3.2.2 添加anaconda环境变量

    安装成功后,我们还要将anaconda添加到环境变量中。输入vim .bashrc 以用vim编辑器来编辑.bashrc文件。

    输入vim .bashrc

    注意,vim编辑器不是word文档!想要修改文件,我们要先按下“i”键切换到插入模式。按下i后,左下角会有“INSERT”显示,表示我们现在敲打键盘即可插入文字。

    我们在文件开头输入:

    #Anaconda
    export PATH=/home/用户名/anaconda3/bin:$PATH

    其中用户名在本案例中就是root,于是就应该输入:

    #Anaconda
    export PATH=/home/root/anaconda3/bin:$PATH

    按下Esc键,退出插入模式。依次按下”:”, “w”, “q”, 左下角应该显示如下图,之后“回车”,即可保存并关闭文件。

    输入source .bashrc 重新激活一下。此时输入which python即可发现当前使用的python是anaconda3中的。(/root/anaconda3/bin/python)

    若不行,则需重启服务器,再输入source .bashrc 重新激活。

    3.3 修改镜像源(可跳过)

    3.3.1 修改conda镜像

    conda默认的镜像源在国外,下载文件速度可能比较慢。我们需要将镜像源修改为国内的,下载速度会提高很多。

    输入如下命令修改conda的镜像源

    conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/free/  
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
    conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
    conda config --set show_channel_urls yes

    3.3.2 修改pip镜像源:

    (阿里云服务器的默认镜像都已使用阿里云的镜像,读者可跳过本步骤)

    输入mkdir .pip 创建.pip文件夹(有可能mkdir: cannot create directory ‘.pip’: File exists,表示已经有该文件了。)

    输入cd .pip 移动到.pip文件夹

    输入vim pip.conf,创建并修改pip.conf文件

    将该文件修改为如下内容(按下i进入插入模式,按下Esc退出插入模式,按下:wq并回车则保持并关闭文件):

    [global]
    
    index-url = https://pypi.tuna.tsinghua.edu.cn/simple

    3.4 anaconda环境管理(可跳过)

    anaconda可进行环境管理,可创建多个环境,不同环境内可安装不同的包。默认情况下,我们在base环境中。新建环境可用:

    conda create -n 环境名 python=python版本

    我们新建一个名字叫tensorflow的环境,这个环境的python版本是3.6则应该为:conda create -n tensorflow python=3.6。安装过程中会问我们是否执行Proceed ([y]/n)?,我们回复y。

    安装完新环境后,我们使用conda activate 环境名,即可从base环境切换到新环境。

    可见该环境是python3.6的,我们之后安装各类python包,import各类python包都是在该环境下进行。退出该环境可以输入conda deactivate,这样,我们就回到了base环境。

    3.5 安装深度学习框架

    3.5.1 机器学习函数库

    常用的机器学习包有numpy,pandas,matplotlib,sklearn等,其中有的包已经随anaconda一起安装好了,有的则没有(具体情况根据安装的anaconda版本而定)。尚未安装的需手动安装。

    使用 pip install 包名 即可。如:pip install pandas

    3.5.2 Tensorflow

    使用NVIDIA显卡运行Tensorflow-gpu需要除了要装驱动以外,还需要安装cuDNN。(见3.1)

    由于我们使用的是gpu版本,输入pip install tensorflow-gpu即可安装gpu版tensorflow。

    安装完后,检验一下我们的tensorflow是否安装成功。

    输入python,进入python执行界面。在该界面下输入import tensorflow as tf,不报错即代表安装成功。

    报FutureWarning不要紧,只要import tensorflow成功即可。

    安装gpu版tensorflow出错概率极高,各类问题请参见“3.6 安装tensorflow-gpu出错的各种可能”

    3.5.3 PyTorch

    PyTorch的官网上选择自己的服务器配置即可找到对应下载代码。

    我们输入 pip install torch 即可安装PyTorch

    输入python,进入python执行界面。在该界面下输入import torch ,不报错即代表安装成功。

    3.6 安装tensorflow-gpu出错的各种可能

    我们之前提到过,tensorflow对环境有比较严格的要求,如python版本只可为2.7、3.3-3.6,CUDA为9等等。

    3.6.1 python版本检查

    在命令行输入python -V(V要大写)查看python版本,若为版本不在2.7、3.3-3.6之间,请参照3.4 使用conda创建一个3.6python版本的环境,在该环境下安装并使用tensorflow。

    3.6.2 驱动以及CUDA版本检查

    输入nvidia-smi查看GPU状态,若报错,则要重新安装GPU驱动。见3.1.1

    查看CUDA版本:cat /usr/local/cuda/version.txt (cuda目录也可能为cuda-9.0等,可输入cat /usr/local/cuda-9.0/version.txt )若没有,则参见3.1.2

    查看cuDNN版本 cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2(cuda目录也可能为cuda-9.0,可输入cat /usr/local/cuda-9.0/include/cudnn.h | grep CUDNN_MAJOR -A 2)若没有,则参见3.1.3

    若CUDA和cuDNN的版本与tensorflow-gpu要求的版本不符,则需重新安装CUDA和cuDNN。

    3.6.3 安装指定tensorflow-gpu版本

    输入pip uninstall tensorflow-gpu即可卸载之前安装的tensorflow-gpu

    输入 pip install tensorflow-gpu==版本号 如pip install tensorflow-gpu==1.12.0 即可安装1.12.0版本的tensorflow。

    4. 用jupyter操控服务器

    我们可以通过xshell的隧道方式,让我们以本地浏览jupyter的方式控制远程服务器

    4.1 配置jupyter

    首先,在远程服务器上安装jupyter:pip install jupyter

    接着,输入jupyter notebook –generate-config –allow-root生成配置文件。

    我们输入python,进入python执行界面。输入:

    from notebook.auth import passwd
    passwd()

    之后系统会让我们输入并验证新密码,密码选一个好记的即可。输入完成后,系统会返回给我们一个加密的字符串,复制该字符串。

    按下ctrl+z返回命令行,输入vi ~/.jupyter/jupyter_notebook_config.py,以编辑该文件。

    按下”i”键进入插入模式,插入如下内容

    c.NotebookApp.ip='*'
    c.NotebookApp.password = u'之前的那串sha1字符串'
    c.NotebookApp.open_browser = False
    c.NotebookApp.port =8888 # 任意端口均可(只要不占用22,80等常用端口)

    按下‘Esc’退出插入模式,输入:wq回车以保持并关闭文件。

    此时,输入jupyter notebook –allow-root 服务器就在运行jupyter了,不过想要本地访问,我们还需要让阿里云打开8888端口

    4.2 开通服务器端口

    与3.1.3开通端口类似。在修改安全组规则界面(具体详情见3.1.3),我们选择“添加安全组规则”

    添加如下规则即可

    此时,访问我们服务器ip:8888 即可进入jupyter界面。密码输入我们在from notebook.auth import passwd; passwd() 时输入的密码。

    密码输入完成后,即可用jupyter的方式访问到我们的服务器了。

    4.3 隧道连接

    在Xshell界面左侧的会话管理器,选择属性

    点击“隧道”-“添加”

    输入如下信息,侦听端口任意,这里为5000;目标主机可以不用设置,目标端口是之前c.NotebookApp.port =8888设置的端口号。

    完成后点击确定。断开与服务器的连接并重连。

    此时运行jupyter后。我们可以以访问本地5000端口的形式访问远程服务器了。

     

    附录:使用密钥对

    在配置阿里云服务器时,在登陆凭证界面选择“新建密钥对”。

    我们创建一个密钥,并点击确定。此时我们会下载一个.pem文件

    下载的.pem文件为密钥(密钥请勿泄露,公钥随意,其他人知道你的公钥也无法伪造成你登录服务器)。

    以XShell为例,我们在菜单栏选择“工具”-“用户密钥管理者”

    在打开的“用户密钥”窗口,我们选择导入,导入之前的.pem文件

    导入成功后如下图。

    密钥相对于直接密码登录来说会安全很多。

    回到登陆凭证界面,选择我们之前创建的密钥对即可。

    展开全文
  • linux服务器配置深度学习环境

    千次阅读 2021-12-22 16:25:07
    自己服务器账号安装环境的顺序: 创新环境、新环境安装cuda、安装新环境cuda匹配的pytorch ...自己环境的cuda版本就要跟驱动版本匹配,比如我们服务器Driver Version: 450.119.03,那就是我们可以装这些 ...
  • 用途:跑深度学习,或者机器学习代码,训练数据 前言:  一台性能好一点的服务器可以缩短训练时间,提高工作效率,之前我用的那个电脑虽然有一张TITAN X GPU,但是CPU性能不行,数据量稍微大一点,就提示(core ...
  • 利用远程云服务器跑深度学习模型

    千次阅读 2020-03-16 18:06:47
    利用远程云服务器跑深度学习模型主要有三个问题需要解决。 一是深度学习环境的搭建,二是已搭建环境的保存,三是远程数据的传输。 深度学习环境的搭建 以阿里云为例,在购买服务器创建实例时,可以在镜像市场选择...
  • 服务器配置 方案一: 模块 型号 GPU 4 x Nvidia Tesla V100 GPU内存 32GB vCPU(核) 40 处理器 2.2 GHz主频的Intel Xeon E5-2650 v4(Broadwell)处理器 内存 220GB SSD云盘 4 x 960GB SSD ...
  • 深度学习服务器?深度了解一下!

    千次阅读 2021-06-19 23:20:28
    深度学习前言一、租服务器二、GPU和CPU三、普通显卡和Ti和TITAN总结 前言 我们在掌握了搭建深度学习模型后,就需要对模型进行训练并优化模型的参数,我们知道一个深度学习模型中需要对大量的参数进行计算和优化,...
  • 深度学习:GPU云服务器的租用

    万次阅读 多人点赞 2020-12-18 22:47:28
    本文是在笔者做深度学习相关研究的时候需要高算力GPU去运行代码因而选择去租借GPU云服务器,这里记下自己所接触的一些GPU服务器网站和使用技巧 一、推荐站点 1、极链AI云,首当其冲的一定是这家,这家是我用过认为...
  • 之所以需要租用aws是因为自己买不起服务器,周围又没有可用的服务器资源,听说aws是比较好的,所以就去试着用了一下,感觉还可以,自己用的过程中发现比较详细的介绍很少,所以结合自己这段时间使用的经验,和大家...
  • 服务器学习

    2012-11-05 12:05:56
    可以学习服务器的操作等相关内容,方便他人学习,仅上传供大家学习
  • 关于学习通访问,因为有火狐上的脚本可以使用,于是我想到利用我阿里云的服务器去访问学习通达到24小时挂机。但发现一旦我利用服务器去访问,验证码学习通不会显示。于是我改用学校系统转接入学习通。直接被拒绝403....
  • 如何搭建一台深度学习服务器

    万次阅读 2018-03-25 11:16:00
    到了深度学习的时代,前面那句话仍然是对的。 缘起 在2013年,MIT科技评论将深度学习列为当年十大科技突破之首。其原因在于,模型有其为庞大的网络结构,参数够多,学习能力够强,能配合大数据达到惊人的效果。...
  • 租用GPU服务器跑深度学习模型心得

    千次阅读 多人点赞 2021-01-05 15:34:16
    相信很多刚接触人工智能学习的人会遇到这个问题,当时用笔记本的CPU在跑一个Unet,19个epoch要跑半个小时,电脑内存也爆满。 先跑一个简单的网络试试看,比如Unet Unet代码可以在unet代码下载 用自己的轻薄本CPU...
  • 日常如果我们的个人电脑满足不了某些机器学习/深度学习程序运行需求的话,一般需要在实验室或者公司服务器上跑自己的代码,这里介绍一下如何在linux服务器上运行机器学习/深度学习python程序。 首先使用SecureCRT...
  • C++服务器开发完整学习路线

    千次阅读 多人点赞 2020-05-12 15:31:10
    C++服务器开发完整学习路线(含免费学习资料下载地址) 摘自:https://mp.weixin.qq.com/s/vkvQM8d78HBgJbUvY1KcLw 我看了下这里面高级阶段的nginx 容器我都接触过 原创 Buger 高并发学习社区 2019-06-04 视频...
  • 一开始肯定想着先去大厂看看,然后就去找了下阿里云的GPU服务器和机器学习平台的价格,然后。。 首先是GPU服务器,需要整月的租。因为我平时用到GPU进行计算的时候并不是很多,再加上这个价格也不便宜,然后环境之...
  • 使用云服务器搭建Linux学习环境

    千次阅读 2020-08-08 13:52:32
    一、开通云服务器 进入公有云提供商官网(示例:阿里云) 地址:www.aliyun.com或www.aliyun.com/minisite/goods?userCode=3satwfcw 已有阿里云账号的话,单击右上角“登录”按钮直接登录;没有阿里云账号的话,单击...
  • 注册进去的界面就是这样,可以看到现在可用的服务器的信息,按量使用就是按时计费,长期租用就是按天、周、月来租,2080ti一个月860,怎么划算看个人选择,如果不是需要一直占着服务器个人觉得按量使用还是可以的,...
  • GPU云服务器体验-深度学习模型训练

    万次阅读 2019-08-31 11:20:06
    您只需要专注于深度学习本身,无需安装任何深度学习环境,零设置开启您的深度学习之旅。 极客云,为深度学习而生,您只需简单几步操作即可测试和训练您的模型。 1.上传代码和训练集数据(不收费) 上传的数据将...
  • vscode远程连接深度学习服务器教程

    千次阅读 2019-11-07 18:44:23
    前言:在知乎还有csdn都尝试过配置远程连接服务器,配置过pycharm和vscode, pycharm配置最后还是有一点问题,没有办法同步到服务器,不知道具体哪里有问题,另外感觉pycharm很占内存,而且indexing的过程有点烦,...
  • 11月17日更新: 更多更新的内容和细节可以看我的知乎回答:学生党能去哪里租用便宜的gpu云服务器来进行深度学习计算? - 知乎 以下是原博客: 推荐一家国内平台:Featurize 前期比较和使用了国内主流的的平台如矩阵云...
  • 导师大手一挥给了块闲置的TitanX,加上毕业师兄留下的一台服务器级主机,花一天时间配了个深度学习环境出来。 实验室其他组有好几台这样的服务器。以前看人家测试代码都是自己电脑和服务器两头跑,心想这么搞看起来...
  • 实验室服务器学习总结

    千次阅读 2019-01-15 10:10:52
    最近产生了使用GPU服务器的需求。于是从准备期末前开始,经过多次麻烦和请教学长以及被期末耽搁了半...本文将学习过程中遇到的坑进行总结,以备不时之需。 主机OS:Windows 10 (PS:暂时不舍得清空windows重装Lin...
  • 深度学习如何在云服务器中搭建环境

    千次阅读 多人点赞 2019-04-28 20:52:55
    深度学习如何在云服务器中搭建环境 作者:Ruci 在深度学习中,难免会碰到电脑带不起的情况。这时,可以去网上购买云服务器使用。由于本人,在一次跑程序时,跑不起来。问向了导师,导师给我了一个云服务器。我看了一...
  • WebRTC学习进阶之路系列总目录:https://blog.csdn.net/xiaomucgwlmx/article/details/103204274 什么是信令 信令是协调通信的过程。为了使WebRTC应用程序能够建立一个“通话”,其客户需要交换以下信息: # ...
  • 自己动手打造深度学习服务器

    千次阅读 2018-07-23 08:07:59
    摘要: 本文介绍如何自己构建深度学习服务器 注意:本文主要关注服务器设置和与多个用户同时工作,部件组装和软件安装过程是Slav Ivanov关于创建自己的DL Box的文章的简化版本。 我刚刚开始阅读fast.ai课程的第1部分...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,081,993
精华内容 432,797
关键字:

有关服务器学习