Bash Command

find . -type f -name *vocab* 

scp local_file_dir usename@ip_address:remote_dir

Scp vocabulary.json yaxiwang@cluster.eng.uts.edu.au:~/Data/

scp yaxiwang@cluster.eng.uts.edu.au:~/Data/Flickr30k/data/f30k_precomp_vocab.json ./   

While true
do
	free -h > memory.out
	sleep 1
done:

ulimit -a

du -sh * | sort -nr

  Find ./ -name'*.log' -print0 | xargs -0 rm -f

  Find / -name *.jpg -type f -print | xargs tar -cvzf images.tar.gz

  ls . *.jpg | xargs -n1 -i cp {} /external-hard_drive/dir

  ls . *.jpg | xargs -n1 -I {} cp {} /external-hard_driver/dir

  Find . -type f -print | xargs grep 'test-word'

  tmux new -s session
  Thus kill-session -t 会话名称

  tmux ls #列出所有会话 第一列名称，第二列窗口编号
  tmux a #进入最近的会话
  Tmux a -t 会话名 #进入指定的会话
  Windows/command 键 + 上/下箭头 #上/下翻

  c #创建新窗口,
  p #切换到上一个window
  n #切换到下一个window
  w #查看所有窗口
  “ #横分当前面板
  % #竖分当前面板
  方向键/o #在分割的面板之间切换, 安住ctrl + b o，切换面板
  , #修改窗口名称
  ？#查看所有命令
  d #刮起当前会话
  s #查看所有会话
  $ #修改会话名称
  q #显示面板号，快速输入面板号可以选择相应面板
  & #关闭当前窗口
  x #关闭当前面板
  f #在当前窗口打开的所有文件中进行搜索
  d #暂时离开当前session
  ; #切换到最后一个使用的面板
  l #切换到最后一个使用的窗口
  z #在最大化和初始之前切换  

 :m，ns/\<string\>//gn#统计m-n行中字符串string出现的次数
 :%s/string//gn#统计当前编辑的文件中string出现的次数

 :%s/old/new/g #直接将旧字符串替换为新字符串
 :%s/old/new/gc #替换每次需要你确认

:line_num1, line_num2 </> #按下enter即可向左/右缩进一个tab
#第二中方法
进入visual模式，选中要缩进的行shift + </> 向左/右缩进一个tab

#多窗口编辑
Ctrl w + | #水平最大化当前窗口
Ctrl w + _ #垂直最大化当前窗口
Ctrl w + = #将所有窗口设置为同等大小

  Cat file | grep -I 字符串 | wc -l
  grep (-rinc) 字符串（可以是正则表达式） filename #查找包含字符串的行

 grep '字符串' ./ -Rnl #参数R表示便利所有子目录，n显示匹配的行号，l表示显示文件名称，加会覆盖n的效果不会显示行，只会显示文件名称，所以有l参数时可以去掉n
 grep -v '字符串' ./ -Rl # 表示不包含字符串的文件
 #查找多个字符串
 grep '字符串1' ./ -R | grep '字符串2' ./ -Rl

 zc #折叠
 zC #对所在范围内的嵌套的折叠点进行折叠
 zo #展开折叠
 zO #对所在范围内的嵌套的折叠点进行展开
 [z #到当前折叠点的开始出
  z] #到当前折叠点的开始出
 zj #向下移动到下一个折叠处的开始
 zk #向上移动前一折叠的结束
 za #折叠打开和关闭之间切换
 zM #全文折叠
 zR #全部打开折叠
 zd #删除光标下的折叠
 zD #删除光标下的折叠以及嵌套的折叠

 wc -lw filename #查看文件有多少行（l）和字数（w）

 head -n line_num file_name #查看文件的前几行
 tail -n line_num file_name #查看文件的后几行
 Ls -Slh | head -n 5 #只显示结果的前5个
Grep 'Image to text' train.log | head -n 4 #显示前4个带有‘Image to text’字符串的行

 #!/usr/bin/expect
  set timeout 30
  spawn ssh -l username ip_adress
  expect "*password:"
  send "your password"
  interact

 chmod +x filename.sh

 ./filename.sh

 aria2c -c url #-c表示断点续传, 注意是aria2c

sudo apt-get install axel

--max-speed=2 / -s x #指定最大的下载速度，单位为bite
--num-connections=x / -n x #指定最大的链接线程数为axel
--output=x / -o x #下载下来的文件重新命名为x
--search=x / -s=x #使用文件搜索引擎来找找文件镜像 （不太懂）
--no-proxy / -N #不使用代理服务器下载文件
--verbose  #输出更多的状态信息
--quiet -q #不想标准输出输输出信息
--header=x / -H x #添加HTTP的头域
--alternate -a #显示进度条
--user-agent=x / -U x #指定user agent
--help -h #显示一些帮助信息
--version / -V #显示版本信息

 wget -c -t 0 -O new_name.tar.gz http://www.cnscn.org/old_name.tar.gz 

wget [参数列表] [目标软件、网页的网址]

-V,–version 显示软件版本号然后退出；
-h,–help显示软件帮助信息；
-e,–execute=COMMAND 执行一个 “.wgetrc”命令

-o,–output-file=FILE 将软件输出信息保存到文件；
-a,–append-output=FILE将软件输出信息追加到文件；
-d,–debug显示输出信息；
-q,–quiet 不显示输出信息；
-i,–input-file=FILE 从文件中取得URL；

-t,–tries=NUMBER 是否下载次数（0表示无穷次）
-O –output-document=FILE下载文件保存为别的文件名
-nc, –no-clobber 不要覆盖已经存在的文件
-N,–timestamping只下载比本地新的文件
-T,–timeout=SECONDS 设置超时时间
-Y,–proxy=on/off 关闭代理

-nd,–no-directories 不建立目录
-x,–force-directories 强制建立目录

–http-user=USER设置HTTP用户
–http-passwd=PASS设置HTTP密码
–proxy-user=USER设置代理用户
–proxy-passwd=PASS设置代理密码

-r,–recursive 下载整个网站、目录（小心使用）
-l,–level=NUMBER 下载层次

-A,–accept=LIST 可以接受的文件类型
-R,–reject=LIST拒绝接受的文件类型
-D,–domains=LIST可以接受的域名
–exclude-domains=LIST拒绝的域名
-L,–relative 下载关联链接
–follow-ftp 只下载FTP链接
-H,–span-hosts 可以下载外面的主机
-I,–include-directories=LIST允许的目录
-X,–exclude-directories=LIST 拒绝的目录

原文：https://blog.csdn.net/richardysteven/article/details/4565931 

pytorch数据交互准备-挂载
sudo nvidia-docker run --ipc=host -it -v /media/tensorflow/1412C30112C2E738:/home/wangyx --name wangyx_docker ufoym/deepo bash
or
sudo nvidia-docker run -it -v --shm-size /home/smiles/jhy:/home/jhy -name jhy_deepo ufoym/deepo bash

挂载
sudo nvidia-docker run -it -v /media/smiles/OS1/jhy/:/home/jhy --name jhy_deepo d35aa33f77cb bash
启动
sudo nvidia-docker start -i jhy_deepo
删除
sudo docker container rm jhy_deepo / docker rm 容器id（docker ps -a查看容器id，如果docker正在运行，加上-f选项参数，强制移除）
查看容器
sudo docker ps -a

查看本地有哪些可用的镜像
docker images

删除镜像
docker rm -r id or name

查看image 有多大
docker system df -v | grep my_env

在HUB中搜索可用的镜像
docker search image_name (caffe for example)

拉取HUB中的镜像到本地
docker pull image_name (mtngld/caffe-gpu, for example)
Docker查看要拉取的镜像版本：https://hub.docker.com/r/mapler/caffe-py3/tags?page=1&ordering=last_updated

重新开启一个容器，与原先不同步：
nvidia-docker exec -it wangyx /bin/bash/ 

nvidia-docker run -itd --shm-size 64G --name wangyx -v /data1/wangyx:/home/wangyx -p 3316:22 pytorch/pytorch(本地镜像：docker images查看本地存在哪些镜像)

#假设你的一个容器环境名字为：yaxiong
step 1: 打包
docker commit yaxiong my_env:v1

step 2:将该环境保存在为文件
docker save -o my_env.tar my_env:v1

Step 3: 加载镜像
docker load -i my_env.tar

Step 4:依托该镜像，建立容器
Nvidia-docker run -it -name yaxiong -p 5019:5019 -v

unzip -d dir file.zip

tar -zxvf ./tarfile.tar -C adir
tar -zcvf ./tarfilename.tar ./adir # 压缩

#-----------------------------------
tar 解压缩命令 
tar 
-c: 建立压缩档案 
-x：解压 
-t：查看内容 
-r：向压缩归档文件末尾追加文件 
-u：更新原压缩包中的文件 
这五个是独立的命令，压缩解压都要用到其中一个，可以和别的命令连用但只能用其中一个。下面的参数是根据需要在压缩或解压档案时可选的。 
-z：有gzip属性的 
-j：有bz2属性的 
-Z：有compress属性的 
-v：显示所有过程 
-f 指定压缩文件文件名称
-O：将文件解开到标准输

import pub

#在任何想调试的地方
pdb.set_trace()

vim ~/.tmux.conf
#输入
unbind C-b
set -g prefix C-a
 
bind C-a send-prefix
 
bind r source-file ~/.tmux.conf

set nocompatible
set number
syntax on
set autoindent
set smartindent
set tabstop=4
set shiftwidth=4
set hlsearch
set softtabstop=4
set tabstop=4
set shiftwidth=4
set expandtab=4

set showmatch
filetype on
set ruler

set incsearch
set cursorcolumn
hi cursorcolumn cterm=none ctermbg=black ctermfg=green
autocmd WinEnter * setlocal cursorline
autocmd WinLeave * setlocal nocursorline
highlight CursorColumn guibg=#303000 ctermbg=10
set cursorline
set scrolloff=5
hi cursorline cterm=none term=none
autocmd WinEnter * setlocal cursorline
autocmd WinLeave * setlocal nocursorline
highlight CursorLine guibg=#303000 ctermfg=White ctermbg=Black
hi Search term=standout ctermfg=0 ctermbg=3

set nocompatible       " be iMproved, required
filetype off         " required

" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" let Vundle manage Vundle, required
Plugin 'VundleVim/Vundle.vim'
Plugin 'Valloric/YCM'
Plugin 'skywind3000/asyncrun'
Plugin 'vim-scripts/zoomwin'
" Keep Plugin commands between vundle#begin/end.
" 安装其它插件
" All of your Plugins must be added before the following line
Plugin 'preservim/nerdtree'
call vundle#end()      " required
filetype plugin indent on  " required

let g:ycm_global_ycm_extra_conf = '/root/.vim/bundle/YCM/.ycm_extra_conf.py'
"开启基于tag的补全，可以在这之后添加需要的标签路径
""let g:ycm_collect_identifiers_from_tags_files = 1
""开启语义补全
let g:ycm_seed_identifiers_with_syntax = 1
"在接受补全后不分裂出一个窗口显示接受的项
""set completeopt-=preview
""不显示开启vim时检查ycm_extra_conf文件的信息
let g:ycm_confirm_extra_conf=0
"每次重新生成匹配项，禁止缓存匹配项
""let g:ycm_cache_omnifunc=0
""在注释中也可以补全
let g:ycm_complete_in_comments=1
"输入第一个字符就开始补全
""let g:ycm_min_num_of_chars_for_completion=1
""不查询ultisnips提供的代码模板补全，如果需要，设置成1即可
let g:ycm_use_ultisnips_completer=0

let g:ycm_show_diagnostics_ui = 0
let g:ycm_server_log_level = 'info'
let g:ycm_min_num_identifier_candidate_chars = 2
let g:ycm_collect_identifiers_from_comments_and_strings = 1
let g:ycm_complete_in_strings=1
let g:ycm_key_invoke_completion = '<c-z>'

noremap <c-z> <NOP>

"let g:ycm_semantic_triggers =  {
"                   \ 'c,cpp,python,java,go,erlang,perl': ['re!\w{2}'],
"            \ 'cs,lua,javascript': ['re!\w{2}'],
"            \ }

map <F3> :NERDTree<cr>
map <F2> :AsyncRun
map <F1> :copen<cr>
map <F4> :ZoomWin<cr>

##与YCM等的安装配合使用
#---------------------------------------------------------
#使用map设置快捷键
map <F8> gt #f8映射到gt， 打开的多标签中进入下一个标签
map <F7> gT #f7映射为gT，打开的多标签汇总进入上一个标签
map n :bn<cr> #n映射为normal模式下的":bn+enter"，多文件中操作红移动到下一个
Map p :bp<cr> #p映射为normal模式下的 “:bp+enter”,多文件操作中的移动到上一个文件
Unman gt #取消对gt的绑定

<k0> - <k9> 小键盘 0 到 9 
<S-...> Shift＋键 
<C-...> Control＋键 
<M-...> Alt＋键 或 meta＋键 
<A-...> 同 <M-...> 
<Esc> Escape 键 
<Up> 光标上移键 
<Space> 插入空格 
<Tab> 插入Tab 
<CR> 等于<Enter>

Pip install scipy==1.1.0
Pip install pillow==6.0.0

ctrl+w 删除最后一个词
Ctrl + xx 在行首和光标之间快速切换
ctrl + y 粘贴之间的删除的东西
ctrl+u 删除从光标处到行开头的内容
ctrl+k 删除光标到行末尾的内容
ctrl+e 定位光标到末尾
ctrl+a 定位光标到开头

Alt + 方向左右键 向/前后移动一个字
ctrl + _ 撤销之间的操作
alt+. 环形遍历之前的命令
alt+# 另当前的行失效，将跳过键入的命令，让你重新输入


history 查看历史命令
!! 运行上一个命令
history | grep your_prefix
会出来历史命令序号
!!序号  #可以重新运行代码

w/uptime  查看机器u已经运行了多少天
～/.bash_profile 其中可以写当你登录机器的时候要运行的命令，如希望登录的时候链接某个docker，则写入Nvidia-docker attach wangyfian2
alias 使用其创建快捷键，例如list ll='ls -latr'
#自定义传入参数
alias hist='history | grep $1' #~/.bash_profile, $1表示第一个参数

Brew install tmate

Ssh-keygen -t rsa #一路按enter 生成文件id_rsa （～/.ssh/id_rsa）

#新建 /root/.ssh/authorized_keys
将step2中的id-rsa文件中的所有内容粘贴到 authorized_keys中并保存

Chmod 600 /root/.ssh/authorized_keys
Chmod 700 /root/.ssh

tmate

Public key (permission denied)

:set ts=4
:set noexpandtab
:%retab!

:set ts=4
:set expand tab
:%retab!

Import os

Os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
0---输出所有信息
1---屏蔽通知信息
2---屏蔽通知信息和警告信息
3---屏蔽通知信息，警告信息和报错信息

pip install numpy --upgrade

Export PATH=/usr/local/nvidia/bin:$PATH

import zmail
#发送带附件的邮件
def send_zmail(path):
  #path is the attachment path
  mail_content = {'subject':'a subject string',
                 'content_text': 'a content string',
                  'attachments':path}
  server = zmail.server('senderxxx@qq.com', '授权码')
#这里的授权吗不是邮箱密码，而是打开发送邮箱pop3/SMTP服务时给的授权码,小号授权码是：rtztpbqrnyqmcjjd
#牛小号：授权码：fmzpsgtqoajhbbcg
server.seed_mail(['targetxxx@qq.com'], mail_content)

Import zmail
server = zmail.server('xxxxxxx@qq.com', '授权码')
mail = server.get_latest()#得到最新的邮件
attachment = mail['attachments']#得到邮件的附件
name, content = attachment[0]# 分别得到邮件的名称和内容
with open(name, 'wb') as f:
     f.write(content)

1,open:打开文件、目录或者执行程序，相当于图形界面下的双击操作
open my.docx#将会使用默认关联程序打开
选项-e: 强制在TextEdit中编辑次文件

2，pbcopy和pbpaste：命令行与剪切板，等同于鼠标的复制粘贴操作
ls . | pdcopy #复制当前文件夹下的所有文件
Pbpaste < test.file #将文件的内容复制到剪切板
pbpaste > test.file1 #将剪切板上的内容粘贴进文件里

3，say命令：让Mac说话
say 'All works is done!'

4, mdfind命令：spotlight的命令行模式
mdfind -onlyin ~/Document essay #在document中寻找essay文件

convert 1.jpg 2.png #转换图像格式
Convert 1.gif 2.bmp #
#改变图像尺寸
convert -resize 1024x768 1.jpg 2.jpg
#比例放缩 
Convert -resize %50 1.jpg 2.jpg 
#旋转图像
Convert -rotate 1.jpg 2.jpg
#批量处理-重新转换
for %f in (*.jpg) do convert “%f” “%~nf.png”
#全部进行缩放
for %f in (*.png) do convert “%f” -sample 80×40 “%~nf_sample.png”

sudo apt-get install autoconf
git clone https://github.com/universal-ctags/ctags.git
cd ctats
./autogen.sh
./configure
make
sudo make install

1)配置vim
打开～/.vimrc键入
Set tags=tags;
Set autochdir

2)使用在需要使用使用ctags的文件夹下，首先使用ctags -R .生成tags文件，之后进入vim
即可使用，常用快捷键
Ctrl + ] 找到光标出变量/函数定义的地方
Ctrl + T 回到跳转之前的地方
Ctrl + O 退回原来的地方
[I 全局查找光标出的变量，全局指在当前文件夹中的所有文件爱你中国呢查找
[i 局部查找变量，当前文件中查找
]i 类似上条命令，从光标出向下开始查找
[{ / [( 转到匹配的上一个中括号/圆括号
[} / [) 转到匹配的下一个中括号/圆括号
{/} 转到上/下一个空行
u 更新taglist，用于更改了代码之后更新
[[ 跳到前一个文件
]] 跳到后一个文件
*/# 转到光标出单词下一次/上一次出现的地方
gd 查找光标出的局部变量

#第一种是用file命令
file im.png
#第二种是安装imagemagic
Sudo apt-get install imagemagic
identify im.jpg #使用identify查看信息

readlink -f dir/file_path

ln 源文件路径 硬连接文件路径 #建立硬连接
ln -s 源文件路径 硬文件路径 #建立软连接

#例子，假设安装了g++-7与g++-8, 配置默认的g++通过建立软连接
ln -s /usr/bin/g++7 /usr/bin/g++ #配置默认为g++-7,g++-8同理

#查看软连接的指向
ls -al softlink

#使用的格式为:
at 参数 时间
#常用参数
-v 显示任务将被执行的时间
-c 打印任务内容

#一个简单例子
at 5pm+3days #三天之后的下午五点（没有pm/am，默认为24小时制）
/bin/ls  #执行ls命令
<EOT> #ctrl +d自动出现<EOT>, 完成任务定制

at now+40 minutes #40分钟之后，关键字有minutes, hours, days, weeks
at 4:00 #今天四点执行，如果过了明天执行
At 16:00 tomorrow #明天下午四点执行, today也是个关键字
at 15:00 2019-03-11 #具体日期具体时间，绝对日期

#查询已经定时的任务
atq #查询，会给出id号

#删除已经提交的定时任务
atrm id

#查询任务内容
at -c id

dircolors -p | sed 's/;42/;01/' > ~/.dircolors
source ~/.bashrc

#解决方案：加入路径，重新编译
#step 1
#修改CMakelist.txt,加入：
INCLUDE_DIRECTORIES("PATH_OF_THE_H_HFILE")

#step 2:
 用新的CMakeList重新编译，build， install即可

Rsync -avprvz -e 'ssh -p 36396' --progress file.zip yaxiong@ip:/home/

#剪切视频,从第一分31秒开始，剪切1分钟
ffmpeg -ss 00:01:31 -I input.mp4 -t 00:01:00 -c:v copy -c:a copy output.mp4

#改变视频尺寸,将分辨率改为720x1280 （高x宽）
ffmpeg -I input.mp4 -s 720x1280 -c:a copy output.mp4

#压缩mp4文件
ffmpeg -i input.mp4 -vcodec h264 -acodec mp3 out.mp4 #会过滤掉声音
ffmpeg -i input.np4 -vcodec h264 -acodec aac output.mp4 #保留声音

Cd upload #cd the dir that your file saved
Git init
Git lfs install
Git lfs track
Git commit -m 'pre'
Git remote add origin https:github. (github仓库地址链接)
git push origin master
Git add *
Git commit -m 'git LFS commt'
Git push origin master

Step1: 从官网安装，成功的案例是通过runfile local安装（run）
Step2: 系统变量倒入：
    export PATH=/usr/local/cuda-11.7/bin:$PATH
    export LD_LIBRARY_PATH="/usr/local/cuda-11.7/lib64/":$LD_LIBRARY_PATH

conda remove -n tensorflow --all
Conda activate name#激活环境
conda deactivate #退出环境
conda info --env #列出所有的环境
conda info  #查看基本信息配置，例如安装源

scp ./yalexwang_workstation/  webdev@100.115.156.103:haoyang/title_image_matching/yalexwang_workstation/ (如果拷贝是文件夹，scp之后加 -r即可)

 Scp !(*.new) yaxiwang@cluster.eng.uts.edu.au:~/Data/

 rsync -av -e ssh --include='*.new' ./vgg16/ yaxiwang@cluster.eng.uts.edu.au:~/Data/TBIRDataSet/NUS-Wide/vgg16/
#与sshpass结合使用可以避免输入密码,-p选项输入密码 -f指定文件读取密码
sshpass -p wangyifan123456 rsync -avP ./* wangyifan@10.20.108.16:/home/wangyifan/   

nltk.download('stopwords')
之后就可以导入停用词（列表）
from nltk.corpus import stopwords

stop_word = stopswords.words('english')#列表，里面是一些引文单词如‘me’, 'againse'等

command 1> out.file 2>&1 （简写 command>out.file 2>&1）

nohup command > &(nohup command 2>&1 &)
nohup python train.py >train.log 2>&1 &

nohup python -u train.py>nohup.log 2>&1 & #-u表示不启用缓冲

ps ux | grep 运行的程序名称（如 train.py）/ps ef | grep 运行的程序名称

kill -9 进程id

sz file-name

ls | wc -w

ls -Slh(r) 

pkill -9 program_id (pkill -9 python 杀死所有python进程)

du -h flick30k_image/

 'ascii' codec can't decode byte 0xe4 in position 24: ordinal not in range(128)

pickle.load(open(filename, 'rb'), encoding = 'bytes')

sorted_list = sorted(dict_name.items(), key = lambda x:x[1], reverse  = True)#由大到小排序

/usr/bin/zip: Argument list too long

ls | grep 关键字| xargs -n 10 zip zipfile.zip

print('\r finished percent: %f'%(counter/length * 100), end = '', flush = True)

import sys
sys.stdout.write('\rfinished percent %f '%(counter / length *100))
Sys.flush()

unsupported pickle protocol: 3

pickle.dump(data, open(file_pth, 'wb'), protocol = 2)

import cv2

cap = cv2.VideoCapture(url_string)
ret, img = cap.read()

from skimage import io

image = io.imread(url)
#save the image
io.imsave('test.jpg', image)

import urllib

# 网络上图片的地址
img_src = 'https://img-my.csdn.net/uploads/201212/25/1356422284_1112.jpg'

# 将远程数据下载到本地，第二个参数就是要保存到本地的文件名
urllib.urlretrieve(img_src,'D:/1.jpg')

import cv2

cv2.puttext(image_data, text_string, position, fontFace, fontcolor, thickness, linetype)

a_dict = {'a':1, 'b':2}
f = open(file_path, 'w')
dict_str = pickle.dumps(a_dict)
f.write('f')
f.close()

f = open(file_path , 'r')
content = f.read()
content_list = content.split('.')
a_data = pickle.loads(content_list[0] + '.')
f.close()

if '、' in string:
		....

#-*-coding:utf8-*

unicode_str = str.decode('utf-8')
# PIL图片上打印汉字
draw = ImageDraw.Draw(pilimg) # 图片上打印
font = ImageFont.truetype("*.ttf", fontsize) # 参数1：字体文件路径，参数2：字体大小
draw.text((x, y), unicode_str, (0, 0, 0), font=font) 参数1：左上角坐标，参数2：字符串，参数3：字的颜色，参数4：字体

string = '??????'
s = string.decode('utf-8').encode('utf-8')
print(s)#将会是中文

:vsplit fiile_name.py
#多文件编辑
Ctrl+^ 两者之间切换
:bn/bp 切换到下一个/上一个
:ls 查看所有打开的文件
:close 关闭当前面板
#多标签操作
:tabnew/tabe + 文件名 开起新tab打开文件
:tabc/o 关闭当前tab/所有其他tab
:qa 退出所有的tab，到bash中
:tabn/p 下一个/上一个tab
gt/gT 直接可以在tab之间切换

:tabs 查看所有打开的tab
ctrl+s 停止向屏幕输出
ctrl+q 恢复向屏幕输出

 conda install cudatoolkit
 conda install cudnn

 conda install tensorflow-gpu

  def count():
       path = './510_loose_true.xls'
       work_book = xlrd.open_workbook(path, formatting_info = 1)
       sheets = work_book.sheet_names()
       sheet = work_book.sheet_by_index(0)
  
       rows, cols = sheet.nrows, sheet.ncols
 
      posi_count = 0
      nega_count = 0
      img_list = []
      for row in range(rows):
          for col in range(3, cols):
              xfx = sheet.cell_xf_index(row, col)
              xf = work_book.xf_list[xfx]
              bgx = xf.background.pattern_colour_index
              value = sheet.cell(row, col).value
              if bgx == 17:
                  posi_count += 1
                  img_list.append(value)
              if bgx == 10:
                  nega_count += 1
                  img_list.append(value)
 
      img_set = set(img_list)
      print('total image: %d'%len(img_list))
      print('different images: %d'%len(img_set))
      print('negative images: %d'%nega_count)
      print('positive iamges: %d'%posi_count)
      print('validate: %d'%(nega_count + posi_count))

 conda remove -n tensorflow0 --all

Array = np.random.rand(224,224,3)
Image = Image.fromarray(array.astyep(np.uint8))
``

### Image.open()错误：IOError：image file truncated 
``` bash
From PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES=True

vim ~/.bash_profile
#在bash_profile加入
LD_LIBRARY_PATH=/home/yaxiwang/anaconda/lib:$LD_LIBRARY_PATH
export LD_LIBRARY_PATH两行
#最后要生效
source ~/.bash_profile

pip install --force-reinstall scipy --ignore-installed

pip install --force-reinstall scipy --ignore-installed

vim ~/.bash_profile
#在打开的文件中加入
export PATH="/users/wang/anaconda2/bin":$PATH

tailf nohup.out

vim /etc/profile插入
export PATH=$PATH:/data/cuda-8.0/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/data/cuda-10.0/lib64
export LIBRARY_PATH=$LIBRARY_PATH:/data/cuda-10.0/lib64
#最后,使之生效
source /etc/profile

#用clearndata来过滤指定的程序，ps ef 也可以换成ps ux
for i in `ps -ef|grep cleardata |awk '{print $2}' `; do kill -9 $i ; done;

import numpy as np

Path = 'train.npy'
data = np.load(path, mmap_mode = 'r')#

Rsync -avP * wangyifan@:/home/wangyifan/part_images
#过滤文件夹
rsync -avP ATTNGANW ATTNGAN_AUTO/ --exclude ATTNGANW/fea_save #注意第一个源文件夹没有/ 第二个目的文件夹有/
#-a 表示拷贝本地文件
#-v verbose 详细模式输出
#-P 相当于--partial 保留那些没有传输完成的文件，可以加快后续的传输

#其他常见的命令如下：
-v, --verbose 详细模式输出
-q, --quiet 精简输出模式
-c, --checksum 打开校验开关，强制对文件传输进行校验
-a, --archive 归档模式，表示以递归方式传输文件，并保持所有文件属性，等于-rlptgoD
-r, --recursive 对子目录以递归模式处理
-R, --relative 使用相对路径信息
-b, --backup 创建备份，也就是对于目的已经存在有同样的文件名时，将老的文件重新命名为~filename。可以使用--suffix选项来指定不同的备份文件前缀。
--backup-dir 将备份文件(如~filename)存放在在目录下。
-suffix=SUFFIX 定义备份文件前缀
-u, --update 仅仅进行更新，也就是跳过所有已经存在于DST，并且文件时间晚于要备份的文件。(不覆盖更新的文件)
-l, --links 保留软链结
-L, --copy-links 想对待常规文件一样处理软链结
--copy-unsafe-links 仅仅拷贝指向SRC路径目录树以外的链结
--safe-links 忽略指向SRC路径目录树以外的链结
-H, --hard-links 保留硬链结
-p, --perms 保持文件权限
-o, --owner 保持文件属主信息
-g, --group 保持文件属组信息
-D, --devices 保持设备文件信息
-t, --times 保持文件时间信息
-S, --sparse 对稀疏文件进行特殊处理以节省DST的空间
-n, --dry-run现实哪些文件将被传输
-W, --whole-file 拷贝文件，不进行增量检测
-x, --one-file-system 不要跨越文件系统边界
-B, --block-size=SIZE 检验算法使用的块尺寸，默认是700字节
-e, --rsh=COMMAND 指定使用rsh、ssh方式进行数据同步
--rsync-path=PATH 指定远程服务器上的rsync命令所在路径信息
-C, --cvs-exclude 使用和CVS一样的方法自动忽略文件，用来排除那些不希望传输的文件
--existing 仅仅更新那些已经存在于DST的文件，而不备份那些新创建的文件
--delete 删除那些DST中SRC没有的文件
--delete-excluded 同样删除接收端那些被该选项指定排除的文件
--delete-after 传输结束以后再删除
--ignore-errors 及时出现IO错误也进行删除
--max-delete=NUM 最多删除NUM个文件
--partial 保留那些因故没有完全传输的文件，以是加快随后的再次传输
--force 强制删除目录，即使不为空
--numeric-ids 不将数字的用户和组ID匹配为用户名和组名
--timeout=TIME IP超时时间，单位为秒
-I, --ignore-times 不跳过那些有同样的时间和长度的文件
--size-only 当决定是否要备份文件时，仅仅察看文件大小而不考虑文件时间
--modify-window=NUM 决定文件是否时间相同时使用的时间戳窗口，默认为0
-I 为所有更新输出一个更改摘要
-T --temp-dir=DIR 在DIR中创建临时文件
--compare-dest=DIR 同样比较DIR中的文件来决定是否需要备份
-P 等同于 --partial
--progress 显示备份过程
-z, --compress 对备份的文件在传输时进行压缩处理
--exclude=PATTERN 指定排除不需要传输的文件模式
--include=PATTERN 指定不排除而需要传输的文件模式
--exclude-from=FILE 排除FILE中指定模式的文件
--include-from=FILE 不排除FILE指定模式匹配的文件
--version 打印版本信息
--address 绑定到特定的地址
--config=FILE 指定其他的配置文件，不使用默认的rsyncd.conf文件
--port=PORT 指定其他的rsync服务端口
--blocking-io 对远程shell使用阻塞IO
-stats 给出某些文件的传输状态
--progress 在传输时现实传输过程
--log-format=formAT 指定日志文件格式
--password-file=FILE 从FILE中得到密码
--bwlimit=KBPS 限制I/O带宽，KBytes per second
-h, --help 显示帮助信息

### tmux配置前缀为ctrl+a 
退出tmux
``` bash
Step 1:
Vim ~/.tmux.conf
Step 2:在文件中输入
set -g prefix C-a
Unbind C-b

tar -zxvf name.tar -C ./your_dir

Tar -zcvf name.tar ./you_dir

ps auxw --sort=%cpu  #cpu使用排行
ps auxw --sort=%MEM  #内存使用排行

PATH="/home/yxwang/anaconda3/envs/tensorflow/bin/":$PATH

Conda create -p /ssd/yuxiong/.conda/envs/tensorflow python=3.6
#激活
Source activate /ssd/yuxiong/.conda/envs/tensorflow

#设置环境变量
``` bash
Export CONDA_PKGS_DIRS=/ssd/yuxiong/conda/pags/

Sudo chown 1002:1002 /ssd/yuxiong/conda/pkgs

Import numpy as np

export PATH="/ssd/yuxiong/.conda/envs/tensorflow/bin":$PATH
iexport PATH="/ssd/yuxiong/.conda/envs/tensorflow/lib/python3.6/site-packages":$PATH

Conda install cudatoolkit=9.0
Conda install cudnn=7.1.2

.bashrc: 打开新的终端的时候回执行该文件中的命令和配置
.bash_profile:登陆机器的时候执行，且只执行一次
.profile: 该文件和.login,一起起到了bash_profile的作用,
有时候在bash_profile配置的命令在登录时不起作用，这时可以在./profile中进行配置，例如nvidia-docker attach wangyx

PATH:可执行文件存放目录
LIBRARY_PATH：程序编译期间查找动态链接库时，查找共享库的路径
LD_LIBRARY_PATH：程序的加载运行期间查找动态链接库时，除了系统默认路径之外的其他路径

/usr/local:软件安装的系统级目录,相当于windows下的C:/Windows
/opt: 用户级的附件安装目录，用于安装附件的软件
/usr/bin:常用命令的目录
/usr/local/bin、/bin、/usr/local/bin：常用的所有命令的文件
/usr/sbin: 不是必要的系统管理目录
/usr/include：C语言的头文件路径，
/usr/lib：程序不变的数据文件，包括一些site-wide配置文件
/var:系统一般运行时要改变的数据文件，每个系统都是特定的

import tqdm 
from tqdm import trange

#索引便利
for I in trange(100):
   Pass

#职别便利列表
For item in tqdm.tqdm(a_list/iterator):
   pass

useradd wangyx #添加用户名
passwd wangyx #为用户设置密码
Mkdir /home/wangyx #穿件home目录
sudo chown -R linchao:linchao /home/linchao #将目录权限付给用户
useradd -d /home/wangyx wangyx #给用户增加用户目录
Userdel -r wangyx #删除用户

#增加用户的sudo权限
sudo usermod -aG sudo wangyx
#查看用户是否有sudo权限
groups yaxiong
#列出所有具有sodu权限的用户
getent group sudo

#===========================================#
#简易版本，用户不存在运行
sudo useradd -s /bin/bash -d /home/vivek/ -m -G sudo vivek  
-G 分组为sudo，即给予sodu权限，如果添加简单用户，-G sudo去掉即可 

apt-get install ca-certificates

#第一个表示多少位有效数字，第二个整数控制精度即小数点保留位数，前面的0， 1表示位置对应
print('{0:4.2f}--{1:8.4f}'.fomrat(prection, recall)) 

A = 2
B = 3
print(f'A:{A}， B:{B}, A/B:{A/B:.4f}')
#注意括号内不能使用反斜杠\
print(f'His name is {\'Tom\'}')#错误
print(f"His name is {'Tom'}")#使用不同的引号
Str = f'{ {A} }'#插入大括号

#运行命令
tmux -S ~/.tmsock new -ADsCyg
#tmux -a时任然会报错，解决方案在～/.bashrc中加入,并source
alias tmux='tmux -S ~/.tmsock new -ADsCyg'

#step1: add following command in ~/.bashrc
export TMUX_TMPDIR=~/.tmux/tmp

#step2:create folder & change to write mode
mkdir -p ~/.tmux/tmp
Chmod 777 -R ~/.tmux/tmp

#step3: source/reload the bashrc file
source ~/.bashrc

#step4: re-run the tmux, and it would be work normally
tmux

step 1: sudo rm /etc/apt/sources.list.d/cuda*
sudo apt remove nvidia-cuda-toolkit

step 2: sudo apt remove nvidia-*

step 3: sudo apt update

step 4: sudo apt-key adv --fetch-keys  http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64/7fa2af80.pub

step 5: sudo bash -c 'echo "deb http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1604/x86_64 /" > /etc/apt/sources.list.d/cuda.list'

step 6: sudo apt update

step7: sudo apt install cuda-10-2 #此步骤更新cuda和对应的driver

step 1: in overleaf, choose the submit --> arxiv->download the zip file (would auto deal with some dir problems)(texStudio打开文件并编译)
step 2: in main.tex, if you use the hyperref like '\usepackage{options ... }[hyperref]' change to
\usepackage{hyperref}
\hypersetup{colorlinks, allcolors=black} 
step 3: build a new file named ref.bbl(名称尽量和主.tex文件名相同，例如tmi_main.tex==>tmi_main.bbl) and cut the content from \begin{thebibliography}[1] to \end{thebibliograph}(包含环境变量), ie, all references
step 4: delete the content mentioned in step3 and add the following contents in its original place:
\nocite{*} #注意不是notice
\input{tmi_main.bbl}
step 5: notice the dir problems, if your project under name 'tcyb', the image path, 'tcyb/first_show.png' should change to 'first_show.png' 

#会议版本
step 2和step 4也是必须的

grep -rn "nibabel" * #递归查找所有目录下包含“nibabel“的文件

Opencv读取的图片的通道0-2对应的BGR颜色, 取值范围0-255， 数据类型numpy.ndarry
matplotlib.image.imread读入的图片是RGB颜色,取之范围0-255， 数据类型numpy.ndarray
scripy.misc.imread/scipy.ndimage.imread 读取的图像为RGB，范围0-255， 数据类型numpy.ndarray
Pillow(PIL)读取图像对象，供后续处理
skimage.io.imread通道顺序RGB，取值范围0-255， 数据类型numpy.ndarray

import cv2
#save the image, img是一个四通道ndarray
Cv2.imwrite('test.png', img, [int(cv2.IMWRITE_PNG_COMPRESSION), 9])
#读取图片
Im = cv2.imread(path, cv2.IMREAD_UNCHANGED)

#解决方案
Pip uninstall tensorboard-plugin-wit==1.6.0.post3

From skimage.segmentation import mark_boundaries, find_boundaries
#mark_boundaries:根据区域的label画出边界
#image_array:image data 0-255
#sp_arry: label data int
Out = mark_boundaries(image_array, sp_array)
Cv2.imwrite('vis.png', out*255)

#find_boundaries:根据label显示出边界（1表示边界）
#output the boundary pixel
Out = find_boundaries(sp_arr)

git clone --recursive https://github.com/NVIDIA/apex.git
cd apex
pip install . #注意点号
#最好的安装是，cuda11报错未安装成功,cuda10成功：
pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" ./

#note:可能安装之后：import apex报错module not found, 解决
#
Import sys
sys.path.append('/home/yaxiong/apex')

#代码示例
import os
from datetime import datetime
import argparse
import torch.multiprocessing as mp
import torchvision
import torchvision.transforms as transforms
import torch
import torch.nn as nn
import torch.distributed as dist
from apex.parallel import DistributedDataParallel as DDP
from apex import amp

class ConvNet(nn.Module):
    def __init__(self, num_classes=10):
        super(ConvNet, self).__init__()
        self.layer1 = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=5, stride=1, padding=2),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
                
        self.layer2 = nn.Sequential(
            nn.Conv2d(16, 32, kernel_size=5, stride=1, padding=2),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2))
        self.fc = nn.Linear(7*7*32, num_classes)

    def forward(self, x):
        out = self.layer1(x)
        out = self.layer2(out)
        out = out.reshape(out.size(0), -1)
        out = self.fc(out)
        return out


def train(gpu, args):
    #计算传入的gpu在总共gpu的顺序号，如果只是一个机器，就是gpu的id
    ##
    rank = args.nr * args.gpus + gpu                              
    #初始化方式为env://, 需要设置四个环境变量：MASTER_PORT, MASTER_ADDR, WORD_SIZE, RANK
    #前两个已设置，后两个作为参数传入
    dist.init_process_group(                                   
        backend='nccl',                                         
        init_method='env://',                                   
        world_size=args.world_size,                              
        rank=rank                                               
    )
    ##
    torch.manual_seed(0)
    model = ConvNet()
    torch.cuda.set_device(gpu)
    model.cuda(gpu)
    batch_size = 100
    # define loss function (criterion) and optimizer
    criterion = nn.CrossEntropyLoss().cuda(gpu)
    optimizer = torch.optim.SGD(model.parameters(), 1e-4)

    ##	
    #如果模型中有batchnorm，使用同步batchnorm以获得更好的结果
    model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)      

    #包装模型，
    model = nn.parallel.DistributedDataParallel(model,
        device_ids=[gpu])

    #-------如果要同时分布式训练并且使用fp16，上面两句需要替换为（后续loss反向也需要改动)----------#
    model = apex.parallel.convert_syncbn_model(model)
    model, optimizer = amp.initialize(model, optimizer, opt_level='O1')
    model = DDP(model)
    #-------------------------------------------------------------#     
    ##
    
    # Data loading code
    train_dataset = torchvision.datasets.MNIST(root='./data',
        train=True,
        transform=transforms.ToTensor(),
        download=True)

   ##
   #负责给各个gpu切分数据
    train_sampler = torch.utils.data.distributed.DistributedSampler(
        train_dataset,
        num_replicas=args.world_size,
        rank=rank
    )
    ##
    
   #dataloader中shuffle必须为false，指定sampler为分配的sampler
   train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
        batch_size=batch_size,
        shuffle=False,
        num_workers=2,                                                                                                                                                                                 
        pin_memory=True, sampler=train_sampler)

    start = datetime.now()
    total_step = len(train_loader)
    for epoch in range(args.epochs):
        for i, (images, labels) in enumerate(train_loader):
            images = images.cuda(non_blocking=True)
            labels = labels.cuda(non_blocking=True)
            outputs = model(images)
            loss = criterion(outputs, labels)

            optimizer.zero_grad()
            loss.backward()
	    #-----如果使用fp16，需要loss.backward替换为：----------------#
	    with amp.scale_loss(loss, optimizer) as scaled_loss:
                scaled_loss.backward()
            #-------------------------------------------------------#

            optimizer.step()
            if (i + 1) % 100 == 0 and gpu == 0:
                print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(
                epoch + 1,
                args.epochs,
                i + 1,
                total_step,
                loss.item())
                )

    if gpu == 0:
        print("Training complete in: " + str(datetime.now() - start))

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-n', '--nodes', default=1, type=int, metavar='N')
    parser.add_argument('-g', '--gpus', default=1, type=int,
                       help='number of gpus per node')
    parser.add_argument('-nr', '--nr', default=0, type=int,
                       help='ranking within the nodes')
    parser.add_argument('--epochs', default=200, type=int, metavar='N',
                       help='number of total epochs to run')
    args = parser.parse_args()
    
    #step 1:设置控制主机的地址，如果为本地主机，即设置为127.0.0.1，并设置端口
    args.world_size = args.gpus * args.nodes
    ##
    os.environ['MASTER_ADDR'] = '127.0.0.1'
    os.environ['MASTER_PORT'] = '8888' 
    #mp的作用是启动该节点的所有进程，每个节点都会运行train函数，其中i从0-args.gpus-1(节点机器的总共可用的gpu数量）
    #即函数是将程序按照GPU id进行部署到每一个gpu上
    mp.spawn(train, nprocs=args.gpus, args=(args,))
    ##
    train(0, args)

if __name__ == '__main__':
    main()

#===============命令行中输入命令开始训练======================#
CUDA_VISIBLE_DEVICES=1,2 python pytorch_dist.py -n 1 -g 2 -nr 0

validate_loss = loss(input, target)
validate_loss = reduce_tensor(validate_loss)

def reduce_tensor(tensor, world_size=2):
    dist.barrier()
    dist.all_reduce(tensor, op=torch.distributed.ReduceOp.SUM)#或者op=dist.reduce_op.SUM
    tensor =  tensor / world_size
    
    return tensor

#step 1:首先安装pudb
pip install pudb

#step 2:在程序中
Import pub.remote import set_trace
#在想要走停住的地方插入
set_trace() #或者设置窗口大小set_trace(term_size=(80, 24))

#step 3:打开另一个终端窗口输入
telnet into 127.0.0.1 6899.

#重要的快捷键
ctrl + x 进入交互模式，类似pdb，但是上下箭头被占用, 再次ctrl +x 推出交互模式
Ctrl + p 进行设置，包括设置主题
？ 帮助

 cmake -DCMAKE_CXX_FLAGS='-std=c++11' ..

#修改cudnn.h中的函数

template <typename Dtype>
inline void setConvolutionDesc(cudnnConvolutionDescriptor_t* conv,
    cudnnTensorDescriptor_t bottom, cudnnFilterDescriptor_t filter,
    int pad_h, int pad_w, int stride_h, int stride_w) {
  CUDNN_CHECK(cudnnSetConvolution2dDescriptor(*conv,
      pad_h, pad_w, stride_h, stride_w, 1, 1, CUDNN_CROSS_CORRELATION));
}

#改为
template <typename Dtype>
inline void setConvolutionDesc(cudnnConvolutionDescriptor_t* conv,
    cudnnTensorDescriptor_t bottom, cudnnFilterDescriptor_t filter,
    int pad_h, int pad_w, int stride_h, int stride_w) {
 
#if CUDNN_VERSION_MIN(6, 0, 0)
	CUDNN_CHECK(cudnnSetConvolution2dDescriptor(*conv,
		pad_h, pad_w, stride_h, stride_w, 1, 1, CUDNN_CROSS_CORRELATION,
		dataType<Dtype>::type));
#else
	CUDNN_CHECK(cudnnSetConvolution2dDescriptor(*conv,
		pad_h, pad_w, stride_h, stride_w, 1, 1, CUDNN_CROSS_CORRELATION));
#endif
}

#在库中搜索安装包
Pip/apt search opencv-python

#列出已经安装的包
Pip list | grep opencv-python

#显示已经安装包的信息, 包括版本号,安装位置
pip/apt show  opencv-python

Import os

all_pathes = []
for root, dirs, files in os.walk(os.path.abspath(split)):
   for file in files:
   all_pathes.append(os.path.join(root, file))

all_pathes =[item for item in all_pathes if '.jpg' in item]

1，安装Vundle
mkdir -p ~/.vim/bundle
git clone https://github.com/VundleVim/Vundle.vim.git ~/.vim/bundle/Vundle.vim

2，打开.vimrc添加如下内容
set nocompatible       " be iMproved, required
filetype off         " required
 
" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" let Vundle manage Vundle, required
Plugin 'VundleVim/Vundle.vim'
 
" Keep Plugin commands between vundle#begin/end.
" 安装其它插件
 
" All of your Plugins must be added before the following line
call vundle#end()      " required
filetype plugin indent on  " required

3，安装NERDTree
git clone https://github.com/preservim/nerdtree.git ~/.vim/bundle/nerdtree

4，打开vimrc在call vundle#end()语句之前添加内容：
Plugin 'preservim/nerdtree'

Vim打开文件，命令行下输入：NERDTree即可使用

1，首先安装依赖库
sudo apt-get install build-essential cmake python-dev python3-dev

2，安装YouCompeleteMe，首先下载源码到指定的目录
git clone https://github.com/Valloric/YouCompleteMe.git ~/.vim/bundle/YCM

3，获取相关依赖
git submodule update --init --recursive

4，安装YCM的语言依赖
apt install mono-complete golang nodejs default-jdk npm

5，编译,在YCM目录下，运行,all表示为所有的语言安装依赖
./install.py --all
如果安装总是不成功，尝试：
/usr/bin/python3 install.py

6，配置vimrc文件，打开vimrc文件
在call vundle#begin() 和call vundle#end()之间插入：
Plugin 'Valloric/YCM'

7，在filetype plugin indent on  "" required之后输入
let g:ycm_global_ycm_extra_conf = '/root/.vim/bundle/YCM/.ycm_extra_conf.py'
""开启基于tag的补全，可以在这之后添加需要的标签路径
""let g:ycm_collect_identifiers_from_tags_files = 1
""开启语义补全
let g:ycm_seed_identifiers_with_syntax = 1
""在接受补全后不分裂出一个窗口显示接受的项
""set completeopt-=preview
""不显示开启vim时检查ycm_extra_conf文件的信息
let g:ycm_confirm_extra_conf=0
""每次重新生成匹配项，禁止缓存匹配项
""let g:ycm_cache_omnifunc=0
""在注释中也可以补全
let g:ycm_complete_in_comments=1
""输入第一个字符就开始补全
""let g:ycm_min_num_of_chars_for_completion=1
""不查询ultisnips提供的代码模板补全，如果需要，设置成1即可
let g:ycm_use_ultisnips_completer=0

""下面代码加上感觉最开的打开文件的时候，补全会变慢，不知道具体的功能
let g:ycm_show_diagnostics_ui = 0
let g:ycm_server_log_level = 'info'
let g:ycm_min_num_identifier_candidate_chars = 2
let g:ycm_collect_identifiers_from_comments_and_strings = 1
let g:ycm_complete_in_strings=1
let g:ycm_key_invoke_completion = '<c-z>'

noremap <c-z> <NOP>

""导致变慢的原因是这个命令
let g:ycm_semantic_triggers =  {
                \ 'c,cpp,python,java,go,erlang,perl': ['re!\w{2}'],
            \ 'cs,lua,javascript': ['re!\w{2}'],
            \ }


##====== 可能遇到的错误==================
1，执行以上步骤之后，打开vim，报错
The ycmd server SHUT DOWN (restart with :YcmRestartServer). Unexpected exit code 1. Type ':YcmToggleLogs ycmd_57346_stderr_2hrqlh43.log' to check the logs.

解决方案：
a 在YCM目录下，输入
cat PYTHON_USED_DURING_BUILDING
b,上述命令输出一个python路径，为YouCompleteMe所执行的python环境，假设输出为/usr/bin/python3
/usr/bin/python3 install.py

2，提示vim版本过低，不支持YouCompleteMe
YouCompleteMe unavailable: requires Vim 8.1.2269+.

解决方案：安装最新版的vim，依次执行
add-apt-repository ppa:jonathonf/vim 
apt update 
apt install vim 

3，提示gcc版本过低： Your C++ compiler does NOT fully support C++17

解决方案：升级gcc，依次执行
apt-get install g++-8
update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-7 700 --slave /usr/bin/g++ g++ /usr/bin/g++-7
update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-8 800 --slave /usr/bin/g++ g++ /usr/bin/g++-8

cd ~/.vim/bundle
git clone https://github.com/skywind3000/asyncrun.vim asyncrun

Plugin 'skywind3000/asyncrun' (较老版本的Plugin==>Bundle)

map <F1> :copen<cr> #打开quick fix窗口
map <F2> :AsyncRun  #注意最后有一个空格

cd ~/.vimrc/bundle
git clone https://github.com/vim-scripts/ZoomWin zoomwin

Plugin 'vim-scripts/zoomwin'

map <F4> :ZoomWin<cr> #利用F4在最大化当前窗口与返回

step 1: 安装rtorrent
sudo apt-get install rtorrent

step 2：进入环境
rtorrent

step 3: 会车即可，load.normal> 并粘贴.torrent文件的 url

step 4: Down/Up 键按住选择要下载的文件（* 符号指示）

step 5: ctrl +S开始下载
   ctrl + D 停止下载
   ctrl + Q 退出rtorrent

#linux: telnet
telnet 192.168.1.102 3306

#Mac
nc -vz -w 2 192.168.1.104 3306

windows下得下载tcping: https://blog.csdn.net/qq_35487165/article/details/89458003

Sudo apt-get install nvidia-container-runtime

python3 -m IPython notebook filename.ipynb

pip config list

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple gevent #指定清华源下载安装

mkdir ~/.pip
vim ~/.pip/pip.conf
#在pip.conf中写入
[global]
index-url = http://pypi.douban.com/simple
[install]
trusted-host=pypi.douban.com #http-com中间内容，将永久使用豆瓣源

wget http://ftp.debian.org/debian/pool/main/f/freeglut/freeglut3_2.8.1-3_amd64.deb
dpkg -i thewebpackage

#1, 在服务器上安装showdata
pip install showdata

#2, 在想查看的文件夹下，运行
showdata server -p 8000 -h 0.0.0.0
 
该命令会打印对应的查看地址，一般是服务器的IP和设置的端口号

#3，在本地浏览器输入上面的 地址即可查看
更多流程可以查看 https://github.com/silverbulletmdc/showdata

1，进入Zerotier 官网注册账号(谷歌账号直接登录即可)：https://my.zerotier.com/

2，登录，点击create a  network, 记录下Network ID

3，在你要穿透的内网机器上安装客户端，以linux系统为例，执行命令：
   curl -s https://install.zerotier.com | sudo bash

4，本地机器启动服务： sudo /usr/sbin/zerotier-one -d
   这步可能报错：fatal error: cannot bind to local control interface port 9993
   解决方案：step 1: systemctl stop zerotier-one （stop/Restart重新启动  start也是一个选项） step 2: sudo /usr/sbin/zerotier-one -d

5, 接入ID： sudo /usr/sbin/zerotier-cli join 网络ID

6，去zerotier 网站上，会显示member接入

7， Physical IP就是地址, 任意一台机器上  ssh  配置的时候机器用户名@Physical IP即可链接

sudo mkdir /your/new/path/anaconda3

sudo chown $USER:$USER /your/new/path/anaconda3

sudo rsync -aXS $HOME/anaconda3/. /your/new/path/anaconda3/.

mv $HOME/anaconda3 $HOME/anaconda3_back

ln -s /your/new/path/anaconda3 $HOME/anaconda3

rm -rf $HOME/anaconda3_back

#step 1: 安装samba
sudo apt-get install samba

#step 2: 创建共享目录
mkdir /home/hfut/smbshare
sudo chmod 777 /home/yaxiong/smbshare

#step 3: 设置密码,运行并连续输入两次密码
sudo smbpasswd -a yaxiong

#step 4: 修改samba配置文件
sudo vim /etc/samba/smb.conf
#再最后加入
[share]
path = /home/yaxiong/smbshare
public = yes
writable = yes
valid users = yaxiong
create mask = 0644
force create mode = 0644
directory mask = 0755
force directory mode = 0755
available = yes

#(1) [share]表示共享文件夹的别名，之后将直接使用这个别名
#(2) force create mode 与 force directory mode的设置是因为Windows下与Linux下文件和文件夹的默认权限不同造成的，Windows下新建的文件是可执行的，必须强制设定其文件权限。
#(3) valid users 设置为你当前的Linux用户名，例如我的是yaxiong，因为第一次打开共享文件夹时，需要验证权限。

#step 5: 启动sama服务器
sudo systemctl start smbd

#step 6: 测试是否共享成功
sudo apt-get install smbclient 
smbclient -L //localhost/share
//还记得吗？share为2.3中设置的共享文件夹的别名
//如果共享成功，将要求输入之前设置的密码

1，cmd+r ->输入control->打开控制面板

2，控制面板->程序->启动或关闭windows功能->勾选SMB 1.0/CIFS 文件共享知识

3，点击用户账户->管理windows凭据->增加windows凭据->输入IP 用户名以及密码

4，打开文件管理器->此电脑->三个点(...)->映射网络驱动器->文件夹：\\ip\share  即可连接

安装多版本cuda，cuda都是同样的装
0，准备步骤，安装显卡驱动，已安装可跳过
sudo add-apt-repository ppa:graphics-drivers/ppa #将GPU驱动仓库加入系统
ubuntu-drivers devices #checkGPU和可用的驱动
sudo ubuntu-drivers install #安装
nvidia-detector/nvidia-smi  #测试是否成功

1，前往https://developer.nvidia.com/cuda-toolkit-archive，下载对应的CUDA版本，以11.8为例

2，最后安装方式，选择runfile (local)，并下载
wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda_11.8.0_520.61.05_linux.runsudo 
sh cuda_11.8.0_520.61.05_linux.run

3，安装时，不要选择 CUDA driver选项（取消 x号）

4，安装cuDNN加速库
前往 https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/linux-x86_64/，下载CUDA 11.8对应的版本

5，解压cudnn压缩包
tar -xvf cudnn-linux-x86_64-9.1.0.70_cuda11-archive.tar.xz

6，复制对应的文件到cuda tookit文件
cd cudnn-linux-x86_64-9.1.0.70_cuda11-archive/
sudo cp include/cudnn*.h /usr/local/cuda-11.8/include
sudo cp lib64/libcudnn* /usr/local/cuda-11.8/lib64

7，并赋予读取权限：
sudo chmod a+r /usr/local/cuda-11.8/include/cudnn*.h /usr/local/cuda-11.8/lib64/libcudnn*
sudo chmod a+r /usr/local/cuda-12.1/include/cudnn*.h /usr/local/cuda-12.1/lib64/libcudnn*

8，切换到安装的版本
vim ~/.bashrc
写入：
PATH=/usr/local/cuda-11.8/bin:$PATH
LD_LIBRARY_PATH=/usr/local/cuda-11.8/extras/CUPTI/lib64:$LD_LIBRARY_PATH
LD_LIBRARY_PATH=/usr/local/cuda-11.8/lib64:$LD_LIBRARY_PATH

source ~/.bashrc

9,多版本切换
 多版本之前切换
1，删除原有的cuda软连接
rm -rf /usr/local/cuda

2, sudo ln -s /usr/local/cuda-11.8/ /usr/local/cuda
nvcc -V

alias hs='func() { history | grep $1;}; func' 

#terminal中，筛选python程序
hs python 

原因是内存不够

1， 安装dkms
sudo apt-get install dkms

2, 查看之前坏了的驱动版本
ls /usr.src | grep nvidia

3, 重新生成驱动模块
sudo dkms install -m nvidia -v 550.90.07

4, 禁止内核自动更新
sudo nvidia-smi -pm 1

sudo nvidia-persistenced --persistence-mode

from nltk.corpus import workout
def get_wordnet_pos(treebank_tag):
    if treebank_tag.startswith('J'):
        return wordnet.ADJ
    elif treebank_tag.startswith('V'):
        return wordnet.VERB
    elif treebank_tag.startswith('N'):
        return wordnet.NOUN
    elif treebank_tag.startswith('R'):
        return wordnet.ADV
    else:
        return None

import nltk
from nltk.stem import WordNetLemmatizer
test_word = 'working'
word, word_pos = nltk.pos_tag([test_word])
wordnet_pos = get_wordnet_pos(word_pos) or word net.NOUN
lemmatizer = WordNetLemmatizer()
lemmatize.lemmatize(test_word, pos = wordnet_pos)#the output will be working

Np.vstack([a_vec, b_vec])#纵向
Np。hstack([a_vec, b_vec]#横向

import threading

#申明类
Class fea_read_load(threading.Thread):
	def __init__(self,func, para):
		threading.Thread.__init__(self)
		self.para = para
		self.func = func
		self.result = self.func(self.para)
	def get_result(self):
		return self.result

#调用过程
def main():
	for query in querys
		fea_t = fea_read_load(load_vis_fea, query)#其中laod_vis_fea是一个函数，query是参数
		fea_t.start()#开启线程
		fea_t.join()#等待线程结束
		#结束之后才能获取结果
		fea_dict = fea_t.get_result()#获得读区额特征字典

vgg=models.vgg16(pretrained=True)
children=vgg.classifie.children()
*obtain the layer that want to be saved *
removed=list(vgg.classifier.children())[:-1]
model.classifier=torch.nn.Sequential(*removed)
*then, add the new fc layer*
vgg.add_module('fc', torch.nn.Linear(4096, out_num))

vgg16=models.vgg16(pretrained=True)
class MyNET(nn.Module):
    def __init__(self):
        super(NET, self).__init__()
        self.features=vgg16.features()
        self.fc=vgg16.classifier()
    def forward(self, x):
        x=self.features(x)
        x=self.fc(x)
        return x

f = open(file, 'r')
line = f.readline()
we can direcyly print the string, if line is encoded by Ascii, the output will be chinese
print(line)

t1=torch.eye(3)
convert t1 to ByteTensor
t1_byte = t1.type(tf.ByteTensor)

output_packed = model.lstm(packed)

output_unpacked = rnn.pad_packed_squeeze(output_packed[0])

device-side assert triggered

  Loss = torch.nn.BCEWithLogitsLoss()
  #或者
  loss = torch.nn.BCELoss()

 #错误做法：
 out = model(input)
 out = out.cpu()
 save_list.append(out)
 #正确做法
 out = model(input)
 out = out.cpu().detach().numpy()/out.data.cpu().numpy()
 save_list.append(out)

  import multiprocess
  
  P1 = multiprocess.Process(target=Function1, arg s=(input,))
  P2 = multiprocess.Process(target = Function2, args=(input2,))

  p1.start()
  p2.start()

  p1.join()
  p2.join()

import json
import urllib#python 3使用urllib.request
import os
import sys
import multiprocessing as multiprocess
from threading import Thread
import threading

image_save_pth = './images/'
if not os.path.exists(image_save_pth):
    os.mkdir(image_save_pth)
def download_image(data_lines, start_index, end_index, split):
    #if split.startswith('test'):
    #    split = split+'all'
     
    all_data_lines = data_lines[start_index:end_index]
    count = 0.0
    thread_name = threading.current_thread().name
    print(thread_name + ' is downloading images...')
    length = len(all_data_lines)
    for i in range(0, length):
        line = all_data_lines[i]
        tmp_dict = json.loads(line)
        url = tmp_dict['url']
        img_id = tmp_dict['img_id']
        if os.path.exists(image_save_pth + str(img_id) + '.jpg'):
            continue

        flag = True
        while flag:
            try:
		#python 3使用urllib.request.urlretrieve(~,~)
                out = urllib.urlretrieve(url, image_save_pth + str(img_id) + '.jpg')
                flag = False
            except:
                flag = True
        #sys.stdout.write('[%d/%d]-th in [%s], [%f] percent is finished!\r'%(i+1, length, split, (i*1.0 + 1) / length *100))
        #sys.stdout.flush()
    
def main():
    #data_split = ['train', 'dev', 'test']
    #for item in data_split:
    #download_image(item)
    #p = multiprocess.Process(target = download_image, args = ('train',))
    #p.start()
    #p.join()
    split = 'train'
    path = '/Users/wang/SCAN/data/coco_precomp/' + split + '_data_coco.json'
    data_lines = open(path).readlines()

    num_thread = 100
    all_length = len(data_lines)
    step = all_length // num_thread
    start_index = 0
    end_index = step
    t = []
    count = 1
    while end_index != all_length:
        thread = Thread(target = download_image, args = (data_lines,start_index, end_index, split), name = 'Thread ' + str(count))
        t.append(thread)
        start_index=end_index
        end_index = min(start_index + step, all_length)
        count += 1

    for th in t:
        th.start()
    for th in t:
        th.join()


if __name__ == '__main__':
    main()

from joblib import Parallel, delayed
import math

def my_fun(i):

    return math.sqrt(ii*2)

#Parallel和delayed配合使用进行多线程
#n_jobs设置多少个并行线程
Parallel(n_jobs=2)(delayed(my_fun)(i) for i in range(num))

 import numpy as np
 string = '1 2 3 6'
 arr = np.fromstring(string, dtype = int, sep = ' ')

dataloader_train = data.DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=2)
改为：
dataloader_train = data.DataLoader(train_dataset, batch_size=64, shuffle=True)

#使用多gpu训练
net = my_model()
net = torch.nn.DataParallel(net, device_ids=[0,1,2,3])
net = net.cuda()

#模型的保存与load--方法1:保存的时候做处理
由于被DataParallel是一个新的对象，所以保存的时候需要，直接提取出state_dict保存
torch.save(net.module.state_dict(), path)#load的时候直接按照单gpu的来训练

#方法2:load的时候做处理
1), 利用torch.nn.DataParallel包起来进行训练的模型在，载入的时候也要使用DataParallel封装，因为经过封装之后的参数字典中的key多出了一个module前缀：
``` bash
net = my_model()
net = torch.nn.DataParallel(net)
net.load_state_dict(torch.load(path))

from functools import partial
import pickle
pickle.load = partial(pickle.load, encoding="latin1")
pickle.Unpickler = partial(pickle.Unpickler, encoding="latin1")

 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                   std=[0.229, 0.224, 0.225])

with torch.autograd.detect_anomaly():                                              │
	out = model(input)
	optizer.zero_grad()
	loss. =Loss(out,target)
        Loss.backward()
        optimizer.step()

Apt-get install update
apt-get install -y libsm6 libxext6 libxrender-dev
Pip install opencv-python

Pip install opencv-python-headless
#if you need, also install the contrib
Pip install opencv-contrib-python-headless

#step 1
1. sudo apt-get install cmake
2. sudo apt-get install python-devel numpy
3. sudo apt-get install gcc gcc-c++

#Step 2
1.sudo apt-get install gtk2-devel
2. sudo apt-get install libv4l-devel
3. sudo apt-get install ffmpeg-devel
4. sudo apt-get install gstreamer-plugins-base-devel

#step 3
git clone https://github.com/opencv/opencv.git

#step 4
1. cd ~/opencv
2. mkdir build
3. cd build

#step 5
1. cmake ../
2. make
3. sudo make install

#======安装boost==========
sudo apt-get install libboost-all-dev

from torch.optim import lr_scheduler

optimiser = torch.optim.Adam(net.parameters(), lr = 0.005)
Scheduler = lr_scheduler.StepLR(optimizer, 10, 0.1)#没10轮学习率乘以1

for n in range(epochs):
    scheduler.step()
    .....

def adjust_learning_rate(opt, optimizer, epoch):
     """Sets the learning rate to the initial LR
        decayed by 10 every 30 epochs"""
     lr = opt.learning_rate * (0.1   (epoch // opt.lr_update))
     for param_group in optimizer.param_groups:
         param_group['lr'] = lr

random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic=True #使用确定性卷积,会极大的降低速度
torch.backends.cudnn.benchmark =True #自动搜索最快的操作，用于提速

dataset = tf.data.TFRecordDataset(files=[your_data_path])
dataset = dataset.cache()

Import torchvision.models as models
From torch vision.models.resnet import model_urls

model_urls['resnet152'] = model_urls['resnet152'].replace('https://', 'http://')
Resnet152 = models.renset152(pertrained=True)

Import re
#返回在super_string中sub_string 的下标
Index = [m.start() for m inre.finditer(sub_string, super_string)]

Import glob
all_images = glob.glob(r'.A/*/*.jpg')#得到所有文件的路径

Out = map(lambda x:x*2, [1,3,5,7])#每个元素翻倍
Out = map(lambda x, y: x+y, [1,3,5], [2,4,6])#对应元素相加

Out = filter(lambda x:x.startswith('wang'), ['wang', 'wangyx', 'yaxiong'])

Import matplotlib.pyplot as plt
Import senborn as sns
Import numpy as np

mat = np.random.rand(16,16)
ax = sns.heatmap(mat, camp ='rainbow')#cmap设置色系，可以参考https://blog.csdn.net/weixin_39777626/article/details/95892284
#保存热力图
ax.figure.savefig('hmx.png', transparent=True, bbox_inches='tight')

#只保存图，去除边框

plt.imshow()
plt.axis('off')#去掉坐标系
plt.savefig('test.png', bbox_inches='tight', pad_inches=0.0)

Import matplotlib.pyplot as pat
styles = pet.style.available #所有的画图风格，其中第22， 24比较好看，是一个列表，
plt.style.use(styles[args.style])#应用风格，对所有的绘图
fig = plt.figure()
ax1 = plt.subplot(2,1,1)
#设置不显示上方和右边的边界
#ax1.spines['right'].set_visible(False)
#ax1.spines['left'].set_visible(False)
ax1.set_title('Discriminator Loss')#设置子图的标题
posi_d, = plt.plot(np.arange(len(loss_d)), np.array(posi_loss_d), label='Dis-NRSC', color='r    ')
our_d, = plt.plot(np.arange(len(loss_d)), np.array(loss_d), label='Dis-RSC',color = 'g')
plt.legend(handles =[posi_d, our_d],loc='best',facecolor='blue')#加图例
plt.grid()
#plt.xlabel('epoch')
#plt.ylabel('loss')
ax1.set_xlabel('epochs',fontsize=12)#设置坐标轴的名称，字体大小
ax1.set_ylable('Gen loss',fontsize=12)#设置坐标轴的名称，字体大小
plt.savefig('test.png')#保存图片

#绘制第二个子图，类似
ax2=plt.subplot(2,1,2)
ax2.set_title('Generator Loss')
posi_g, = plt.plot(np.arange(len(loss_d)), np.array(posi_loss_g),label = 'Gen-NRSC', color='    r')
our_g, = plt.plot(np.arange(len(loss_d)), np.array(loss_g), label = 'GEN_RSC', color = 'g')
plt.legend(handles =[posi_g, our_g],loc='best',facecolor='blue')
plt.grid()
ax2.set_xlabel('epochs', fontsize=12)
ax2.set_ylabel('Gen loss', fontsize=12)

#bbox_inches='tight'去除坐标轴所占用的空间
#dpi用来控制分辨率，600是很高的分辨率
#pad_inches=0.0 重点，去除占用的白边
plt.savefig('test.png', bbox_inches='tight',dpi=600,pad_inches=0.0)

#作为函数的装饰器进行使用
Import pysnooper
@pysnooper.snoop()
def func():
   ...

主要参数：
输出到调试信息到文件中：pysnooper.snoop('debug.log')
Prefix参数给函数命名，让挑食信息更加清晰:pysnooper.snoop(prefix='my_fun')
watch/watch_explode:查看参数的值/展开所有的值：pysnooper.snoop(watch='var1')，查看多个参数设置为watch=('var1','var2')
Depth:设置出打印的代码行数，默认为1:pysnooper.snoop(depth=2)

import fire

def print_fun(path):
    print(path)

def add_fun(a,b):
    return a+b

#默认将所有的函数都进行了打包
fire.Fire()

#---------------------------------
在命令行中运行时需要指定使用哪个函数：
python test.py print_fun --path  'a path string'#也可以不要参数--path
或者 python test.py add_fun --a 2 --b 3 #同样的也可以不要参数--a and --b 值按照顺序分配

#------------------------------
也可以在py文件中指定打包哪个函数
fire.Fire(print_fun)
#则在命令行中不需要传递函数参数
python test.py --path 'a path string' 

pip install cython
pip. Install pycocotools

#两种都是对象在前，文件在后
json.dump(object, open('files.json', 'w'))
pickle.dump(object, open('files.pkl', 'wb'))

1 在github上新建一个项目AINet
2 在要操作的文件夹下输入如下的命令
  a git init (初始化，令git管理改文件夹)
  b git add .(将当前文件夹下的所有文件加入本地仓库，如果只是想加入某个文件，将.换成文件名称)
  c git commit -m 'AINet code-Official'
  d git remote add origin https://github.com/wangyxxjtu/AINet.git (将本地仓库与远程仓库进行关联)
  e git push -u origin master (上传项目到github)

1，建立远端连接，并改动文件，如果项目只从github上通过git clone 命令下载下来的，第一步可以省略
git remote add origin git@github.com:wangyxxjtu/JHR.git

2, 添加改动的文件或者文件夹到仓库
git add file_name(dir_name/)

3, 提交改动
git commit -m '提示信息'

4, 执行提交的改动
git push origin master

git rm file_name #删除文件,文件夹加r
git commit -m '...' #提交改动
git push origin master #执行改动

git status

git reset --hard HEAD^ #回退到上个版本
git reset --hard HEAD^^ #回退到上上个版本
git reset --hard HEAD~10 #回退到之前10个版本
git reset --hard commit-id #回到提交ID的版本
git log --graph / git log --stat #查看提交历史和commit-id

git reflog #可以看到命令的log，从中可以查看进入的commit-id历史

git diff HEAD -- main.py

git checkout main.py

git reset main.py

git log --follow main.oy #查看文件的版本历史
git whatchanged main.py #查看文件每次提交的修改历史
git log -p main.py #查看文件每次的不同
git blame main.py #显示文件什么时候被什么人修改过
Git diff #显示暂存区和工作区的差异
git show --name-only commit-id #显示某次提交发生变化的文件名
git show commit-id #显示某次提交数据和内容的变化
git show commit-id1 commit-id2 #显示两次提交内容的差异
git diff HEAD #显示工作区和最新一次提交的差异

step 1： 安装java 1.8或者更高版本
step 2: 下载[holer软件](https://link.zhihu.com/?target=https%3A//github.com/wisdom-projects/holer/tree/master/Binary/Java)
Step 3: 解压zip文件，并修改配置文件：hole-client/conf/holer.conf
设置HOLER_ACCESS_KEY如下：
HOLER_ACCESS_KEY=HOLER_CLIENT-2F8D8B78B3C2A0AE
HOLER_SERVER_HOST=holer.org
上面的holder_access_Key,参照下表设置：
访问密钥	                             访问域名	           公网地址	 本地地址	    使用场景
HOLER_CLIENT-2F8D8B78B3C2A0AE	holer65530.wdom.net	holer.org:65530	127.0.0.1:8080	WEB
HOLER_CLIENT-3C07CDFD1BF99BF2	holer65531.wdom.net	holer.org:65531	127.0.0.1:8088	WEB
HOLER_CLIENT-2A623FCB6E2A7D1D	holer65532.wdom.net	holer.org:65532	127.0.0.1:80	WEB
HOLER_CLIENT-AF3E6391525F70E4	             N/A	holer.org:65533	127.0.0.1:3389	远程桌面
HOLER_CLIENT-822404317F9D8ADD	             N/A	holer.org:65534	127.0.0.1:22	SSH
HOLER_CLIENT-27DD1389DF1D4DBC	             N/A	holer.org:65535	127.0.0.1:3306	数据库
我们启动的网址和端口，为127.0.0.1和8080所以使用第一个密钥
step 4:启动服务
Cd holer-client/bin
bash startup.sh(停止为bash shutdown.sh)
如果为windows直接点击startup.bat/shutdown.bat

class Data_Prefetcher():
     def __init__(self, loader):
         self.loader = iter(loader)
         self.dataloader = loader
         self.stream = torch.cuda.Stream()
         #self.fetch_next()

     def fetch_next(self):
         try:
             self.batch_data = next(self.loader) #imgs是一个字典形式
         except StopIteration:
             self.batch_data = None
             self.loader = iter(self.dataloader) #如果迭代器到头了重新开始
             return

         with torch.cuda.stream(self.stream):
             for item in self.imgs:
                 self.batch_data[item] = self.batch_data[item].cuda(non_blocking=True)

	      #如果不是字典，直接是tensor，直接self.img = self.img.cuda(non_blocking=True)
         return self.batch_data

dataloader = DataLoader(dataset= ...) #定义你的dataloader
data_prefetcher = Data_Prefetcher(dataloaader)
for epoch in range(epochs):
	batch_data = data_prefetcher.fetch_next()
	while batch_data is not None:
		images = batch_data['imgs']
 		labels = batch_data['labels']
		......

		batch_data = data_prefetcher.fetch_next()

from tensorflow.python import pywrap_tensorflow
from resnet_v2 import resnet_v2_152, resnet_arg_scope
slim = tf.contrib.slim
def load_checkpoint(path='./resnet_v2_152.ckpt', sess=None):
    reader = pywrap_tensorflow.NewCheckpointReader(path)
    saved_vars = reader.get_variable_to_shape_map()
    variables = tf.trainable_variables()
    count =0
    hit_list = []
    if sess is None:
        sess = tf.get_default_session()#传入自己的sess，自己网络所在图
    vars_to_restore = []
    for v in variables:
        v_name = v.name[:-2] if v.name.endswith(':0') else v.name
        for k in sorted(saved_vars):
            k_name = k[:-2] if k.endswith(':0') else k
            if v_name.replace('cpu_variables/','') == k_name:#名称匹配来赋值
                #print(v_name, k_name)
                count += 1
                hit_list.append(v.name)
                para = reader.get_tensor(k)
                vars_to_restore.append(v.assign(para))

    sess.run(vars_to_restore)
    #saved_names = sorted(list(saved_vars.keys()))
    #filter = [item for item in saved_names if 'conv1' in item]
    print(count, len(hit_list))
if __name__ == '__main__':
    input = tf.placeholder(tf.float32, [6, 128,128,3])
    input_arr = np.random.rand(6,128,128,3)
    #使用该var_scope和类别数设置为1001是必须的
    arg_scope = resnet_arg_scope()#官方的设定的一些参数，包括卷积的参数配置    
    with slim.arg_scope(arg_scope):
      output, end_points = resnet_v2_152(input, 1001, is_training=False)

    load_checkpoint()    
    sess = tf.InteractiveSession()

    sess.run(tf.global_variables_initializer())
    out_arr = sess.run(output, feed_dict={input:input_arr})
    print('Done')

#定义数据扩充的参数
aug_args = dict(
rotation_range=90.,
width_shift_range=0.4,
height_shift_range=0.4,
zoom_range=0.5, horizontal_flip=True, vertical_flip=True)
#利用参数分别定义image_generator
imDataGen = ImageDataGenerator( aug_args)
maskDataGen = ImageDataGenerator( aug_args)
maskDataGen1 = ImageDataGenerator( aug_args)
maskDataGen2 = ImageDataGenerator( aug_args)
maskDataGen3 = ImageDataGenerator( aug_args)
#如果imageDataGenerator中制定了normalization或者白化参数，则需要进行fit
#imDataGen.fit(im_train, augment=True, seed=random_seed)
#maskDataGen.fit(mask_train, augment=True, seed=random_seed)

#接下来只需要进行在generator中制定seed就可以同步的变换
image_generator = imDataGen.flow(x=im_train, seed=random_seed, shuffle=True, batch_size=batchnum)
mask_generator = maskDataGen.flow(x=mask_train, seed=random_seed, shuffle=True, batch_size=batchnum)
mask_generator1 = maskDataGen.flow(x=mask_train1, seed=random_seed, shuffle=True, batch_size=batchnum)
mask_generator2 = maskDataGen.flow(x=mask_train2, seed=random_seed, shuffle=True, batch_size=batchnum)
mask_generator3 = maskDataGen.flow(x=mask_train3, seed=random_seed, shuffle=True, batch_size=batchnum)

#如果网络有多个输出，也需要再次封装为Geneartor
def multi_output_generator(image_generator, mask_generator1, mask_generator2, mask_generator3, mask_generator4):
     while True:
         im = image_generator.next()
         gt1 = mask_generator1.next()
         gt2 = mask_generator2.next()
         gt3 = mask_generator3.next()
         gt4 = mask_generator4.next()

         yield im, [gt1, gt2, gt3, gt4]

final_train_generator = multi_output_generator(image_generator, mask_generator1, mask_generator2, mask_generator3, mask_generator)
#将最后封装好的generator传入fit_generator函数中进行训练
hist = model.fit_generator(final_train_generator, steps_per_epoch=len(train_index)//batchnum,
shuffle=True, epochs=epochnum,validation_data=[im_val, [mask_val1, mask_val2, mask_val3, mask_val]], callbacks=[checkpoint])
h = hist.history

import keras.layers as KL
From losses import My_Loss
From keras import Model
#step1:写好损失函数并利用Lamdab进行封装
my_loss = KL.Lambda(lambda x:My_Loss(*x), name='my_loss')([input1, input2, input3])
#step2:正常定义模型，output中需要输出my_loss
model= Model(input=[input1, ....], output=[output1, ...., my_loss])
#step3:得到loss的输出并加入到模型的loss之中去
loss = model.get_layer('my_loss').output
model.add_loss(loss)
#step4:loss的对应输出定义为None
losses={'out1_name':loss_fun, ...., 'my_loss':None}
weights={'out1_name':1, ..., 'my_loss':1}
最后进行模型compile即可完成
model.compile(optimizer=opt, loss=loss, loss_weights=loss_weights,metrics=[losses.dsc])

import random
import numpy as np
...
def getitem():
    img = ....
    Mask = ...
    
    seed = np.random.randint(123456)
    random.seed(seed)
    img = self.transform(img)
    
    #再次设置transofrm
    random.seed(seed)
    Mask = self.transform(mask)
...

#model.compile之后
print(model.non_trainable_weights)

Pip install -r tb-nightly
Pip install -r future

A, 下载该文件
wget https://raw.githubusercontent.com/tensorflow/tensorboard/master/tensorboard/tools/diagnose_tensorboard.py 

B, 运行
python diagnose_tensorboard.py

C, 遵照指示进行fix，一般得卸载一些东西并安装tensorflow

A, 在服务器上启动tensorboard
tensorboard --logdir=./logs --port 6006

B, 在本地进行端口映射(可以加f选项后台运行)
ssh -NL localhost:6006:localhost:6006 user@remote

N: no remote commands
L machine1:portA : machine2:portB: forward machine2:portB to machine1:portA

#查看哪些进程在使用指定端口:
lsof  -ti:6006

#释放指定端口
lsof -ti:6006 | xargs kill 9

#磁盘占用
sudo iotop

# 不能直接tf.random.shuffle(tensor) shape: bs x height x width x channel
Out = tf.gather(tensor, tf.random.shuffle(tf.range(bs)))

#pip install imutils
#翻转30度并且超过边界的进行裁剪
im = cv2,imread(im_path) #im shape:256x256x3
im_rotate = imutils.rotate(im,30)

#翻转30度并且保留全图的内容，不进行裁剪
im_rotate_bound = imutils.im_rotate(im, 30)

Import nibble as nib
From nilearn import plotting
#1读取数据
data = nib.load(nii_path)
data_arr = np.array(data.get_fdata(), np.uint8)

#2显示图像直接传送路径即可
plotting.plot_img(path)

from PIL import Image
#open and image or generate an image from array
im=Image.fromarray(label_array, mode='P') #mode可以为'P'或者'L'

#定义colormap,数据有四个不同的label，则需定义4x3长度的list，每连续三个元素定义为一个颜色
#也可以从一个具有调色板的图像中得到color_map:
#color_map = im.getpalette()
color_map = [255,0,0,  0,255,0,  0,0,255,  128,0,128]
im.putpalette(color_map)

im.save('test.png')

Import torch.nn.Functional as F
Input = [0.2,0.3,0.4,0.2]
Target = [0.3,0.4,0.1,0.2]

Kl = F.kl_div(input.log(), target， reduction='mean') #input需要log，而不是直接传进去

# reduction='mean'，所有元素求平均，等价于：
kl = torch.mean(input * torch.log(input / (target+1e-10) + 1e-10))
#reduction='batchmean',bachsize求平均，为KL散度的严格定义，等价于
Kl = torch.sum(input * torch.log(input / (target+1e-10) + 1e-10)) / batch_size 

torch.exp(value).clamp(min=1e-8,max=1e15),

from PIL import Image
Im = Image.fromarray(data.astype(np.uint16)).save('16bit.png')
#读取时使用
im_r = cv2.imread('16bit.png', cv2.IMREAD_ANYDEPTH) #后面的参数很重要

Import numpy as np
Data = np.random.rand(3,4)
Ele, count = np.unique(Data, return_counts=True)
bd_index = np.argsort(count)
#the maximum ele
Ele[bd_index[-1]]

PackageNotFoundError: Package not found: '' Dependencies missing in current linux-64 channels:
  - pytorch 0.4.1* -> mkl >=2018
  - pytorch 0.4.1* -> python >=3.7,<3.8.0a0
  - pytorch 0.4.1* -> cudatoolkit 9.*

conda config --add channels conda-forge

Mat = np.random.rand(3,4)
most_freq_ele = max(set(mat.flatten().tolist()), key=seg_labels.count)

import pandas as pd
csv_data = pd.read_csv(path1, sep='\t')
#csv_data的基础属性包括values, index, columns和dtypes
csv_data.
Values: 获取元素
Index: 获取属性
column:获取列名
Types: 获取类型
Ndim： 获取维度
shape: 数据形状

#对数据的访问
#取出某列
Age = csv_data['Age']

#取出某行
Out = csv_data[:][I:i+1]

#取出多行多列
Out = csv_data['age','year'][:3]

#更方便的是利用iloc/loc函数进行数据读取,
# iloc第二维度中填列索引，loc中填列名称
DataFrame.loc[行索引条件/名称，列索引名称]
DataFrame.iloc[行索引位置，列索引位置]
#例子
Out = csv_data.iloc[:10, 2] #前10行，2列数据
Out2 = csv_data.loc[:10, 'age'] #钱10行，age列数据
#根据条件过滤
Out = csv_data.loc[csv_data['age']>10, 'age']

#访问任意数据
Out = csv_data.loc[:10, ['age','year']]

#取出制定行制定列数据
Out = csv.loc[2, ['age']]
Out = csv.iloc[2, [0]]

#删除列数据
Out = csv_data.drop(['age'], axis=1)
#删除全部为nan的行
Out = csv_data.dropna(axis=0, how='all') #how='any' 删除某一元素为nan的行


#这里
out = csv.iloc[2, [1]]索引出来的是序列化的数据，而
csv.iloc[2,1]直接是对应的位置的值，等于out[0]

#DataFrame对某列进行操作
Data1 = csv_data.age.apply(lambda x:int(x))

#匹配字典
#dict中村的事age:year, 映射过后age列和自动中对应age对应起来
csv_data['age'] = csv_data['year'].map(a_dict)

#一般读如的age是字符串，我们需要转换为数字
#首先处理‘uknown’数字（或者其他类型）
csv_data = csv_data.replace({'unknown':'0.0'})
#应用函数
csv_data1 = csv_data.age.apply(lambda x:int(x))
csv_data['age'] = csv_data1

#按照列进行排序
out. = csv_data.sort_values(by=['age'], ascending=False)
#也可以按照双列进行排序
Out = csv_dta.sort_values(by=['age','height'], ascending=[False, True])
#排序完还想调整索引号为升序，
csv_data.reset_index()
#恢复原来的排序
Out = out.sord_index()
#如果不想删除原索引号，值增加一列新索引，则:
csv_data.reset_index()

sudo apt-get install freeglut3
sudo apt-get install freeglut3-dev
Sudo apt-get install python-poengl # 不确定是否有用

xvfb-run -a python script.py

export MESA_GL_VERSION_OVERRIDE=3.3 #

import trimesh
mesh = trimmest.load('my_obj.pbj')
mesh.show()

#=====================
“鼠标单击拖动”旋转视图
*`ctl鼠标单击拖动`平移视图
*鼠标滚轮放大
*`z`返回基本视图
*`w'切换线框模式
*`c`切换背面剔除
*`g`切换XY网格，将Z设置为最低点
*`a`可以在三种状态之间切换XYZ-RGB轴标记：关，在世界帧或每帧
*`f`在全屏和窗口模式之间切换
*`m`最大化窗口
*`q`关闭窗口wf

for layer_name, layer in net._modules.item():
     setattr(net, layer_name, layer.eval())
     Out = getattr(net, layer_name)

python -m wandb login

import torch
import decord

#！ /bin/sh

Cd ~

Mkdir shell_tut

Cd sheel_tut

For ((I=0;i<10;i++)): do
	touch test_$I.txt
done

name='yaxiwang' #注意等号不能有空格
name=‘yaxiongwang‘ #重定义变量

Name='yaxionwang'
echo $Name

name=='yaxiongwang'
str="Hello. I know you are \"#name\"! \n"

   name=='yaxiongwang'
   greeting="hello, "$name" !"
   greeting="hello, ${name} !"

  String = 'abdc'
  Echo ${#string}
  #提取子串
  echo ${string:1:4}
  #查找字符串
  echo ‘expr index "$string" bd’ #输出2，找出单词bd在单词string中的位置

if condition
then 
	command 1
        Command 2
else
	command 1
	command 2
	command 3
fi

#另一种形式是
for var in item1, item2, item3....itemn
do
	cmd 1
	cmd 2
done

#也可以是c风格的for
for ((exp1; exp2; exp3))
do
	cmds
done

while condition
do
	cmds
done

#无限循环可以写作
while true或者while ：

-ne 不等于
-eq 等于
-le 小于等于
-l 小于
-ge 大于等于
-g 大于
== 字符串比较

count =1
while [ $count -le 5]
do
	cmd 1
	count=$[ $count+1 ]
done

array=(a b c d)
array[0]#索引数组

find dir '*' -exec scp -r {} yaxiwang@cluster.eng.uts.edu.au:~/Data/ \;

 word_vec_pth="/Volumes/Untitled/TBIRDataSet/NUS-WIDE/word_vec_stanford/"
  tags_pth="./tags_filtered.txt"
 
  cat $tags_pth | while read line #一行一行读取文件
  do
      tmp_line=${word_vec_pth}${line}.txt
      if [ ! -f $tmp_line ];then #判断文件是否存在
             echo 1
     else
	     #传入参数和后面的对应
             ./scp_expect.sh "$tmp_line" "yaxiwang@cluster.eng.uts.edu.au:~/Data/word_vec_s    tanford/"
 1            echo successfully transfer
      fi
 done

 #!/usr/bin/expect
 set content [lindex $argv 0] #将传入的第一个参数命名为content
 set dest [lindex $argv 1] 
 spawn scp $content $dest
 expect "*passward:"
 send "wang\$764113779\r"
 expect eof

［#!/usr/bin/expect］ 这一行告诉操作系统脚本里的代码使用那一个shell来执行。这里的expect其实和linux下的bash、windows下的cmd是一类东西。 注意：这一行需要在脚本的第一行。

spawn              调用要执行的命令,相当于开启一个线程
expect               只有spawn执行的命令的执行结果才被expect捕捉到，主要包括标准输入的提示信息、eof和timeout。等待命令提示信息的出现，也就是捕捉用户输入的提示：
send                 发送需要交互的值，替代了用户手动输入内容
set                    设置变量值
interact             执行完成后保持交互状态，把控制权交给控制台，这个时候就可以手工操作了。如果没有这一句登录完成后会退出，而不是留在远程终端上。
expect eof        这个一定要加，与spawn对应表示捕获终端输出信息终止，类似于if....endif

1, 注册cpolar账号： https://www.cpolar.com/

2, ubuntu上安装cpolar客户端
（国内安装）curl -L https://www.cpolar.com/static/downloads/install-release-cpolar.sh | sudo bash
（国外安装）curl -sL https://git.io/cpolar | sudo bash

3，查看版本信息确认安装成功
cpolar version

4，进行token认证
前往你的cplar主页，在主页右侧有验证一栏，点击即可看到token，复制然后
cpolar authtoken xxxxxxxxxxxxxxxxxx

5，配置cpolar开机自启动
sudo systemctl enable cpolar

6，启动服务
sudo systemctl start cpolar

7，查看cpolar守护进程状态
sudo systemctl status cpolar

第二行显示 Active: active (running)说明服务器启动成功

8，获取ssh公网地址
在内网机器上打开：http://localhost:9200/  ，通过cploar账号登陆，左侧栏-》状态-〉在线隧道列表
Ssh那一栏的第二列，即为tcp://公网地址：端口
在外网机器上输入：ssh 内网机器用户名称@公网地址 -p 端口 输入密码即可登录
注意：ssh公网地址是tcp：//之后的地址，不需要携带tcp://