复现Reasoning with Heterogeneous Graph Alignment for Video Question Answering

最新推荐文章于 2023-03-28 16:23:48 发布
最新推荐文章于 2023-03-28 16:23:48 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 论文 小白 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40459958/article/details/120671278
版权

tgif其实就是gif数据集，feat，vocabulary还有datasets获取参见https://github.com/fanchenyou/HME-VideoQA/tree/master/gif-qa

No module named ‘colorlog’
pip install colorlog

No module named ‘block’
pip install block.bootstrap.pytorch

ordinal not in range(128)
调了半天utf编码啥的都不行，结果全都改回去了反而就可以跑了

AttributeError: Can’t get attribute ‘_init_fn’ on <module ‘main’ (built-in)>
好像是多进程的什么问题
麻了，弃了
——————————————————————————
虽然跑不了，但姑且还是学一学吧
——————————————————————————
能跑了，就是有点慢，研究一下原理

+--------------+------------------+
|  Parameter   |      Value       |
+==============+==================+
| Ablation     | none             |有['none', 'gcn', 'global', 'local', 'only_local']这几种选项
+--------------+------------------+
| Batch size   | 128              |
+--------------+------------------+
| Birnn        | 0                |是否使用双向RNN
+--------------+------------------+
| Change lr    | none             |是否改变学习率，默认none即是不改变
+--------------+------------------+
| Checkpoint   | Count_4.092.pth  |saved_models\MMModel中存的预数据
+--------------+------------------+
| Cycle beta   | 0.010            |
+--------------+------------------+
| Dropout      | 0.300            |
+--------------+------------------+
| Fusion type  | coattn           |有['none', 'coattn', 'single_visual', 'single_semantic', 'coconcat','cosiamese']这几种选项
+--------------+------------------+
| Gcn layers   | 2                |+1，即默认GCN层数为3
+--------------+------------------+
| Hidden size  | 512              |
+--------------+------------------+
| Lr           | 0.000            |
+--------------+------------------+
| Lr list      | [10, 20, 30, 40] |
+--------------+------------------+
| Max epoch    | 100              |
+--------------+------------------+
| Max n videos | 100000           |
+--------------+------------------+
| Model        | 7                |
+--------------+------------------+
| Momentum     | 0.900            |
+--------------+------------------+
| Num workers  | 1                |
+--------------+------------------+
| Prefetch     | none             |有[none,nvidia, background]这几种选择，还有对应的nvidia_prefetcher，BackgroundGenerator类的调用
+--------------+------------------+
| Q max length | 35               |
+--------------+------------------+
| Rnn layers   | 1                |
+--------------+------------------+
| Save         | False            |是否保存模型，输入--save则为True
+--------------+------------------+
| Save adj     | False            |是否保存邻接矩阵，输入--save_adj则为True
+--------------+------------------+
| Save path    | ./saved_models/  |
+--------------+------------------+
| Server       | 1080ti           |有['780, 1080ti, 1080']这几种选择
+--------------+------------------+
| Task         | Count            |有[Count, Action, FrameQA, Trans]这几种选择
+--------------+------------------+
| Test         | False            |False即为训练，输入--test则为测试
+--------------+------------------+
| Tf layers    | 1                |
+--------------+------------------+
| Two loss     | 0                |
+--------------+------------------+
| V max length | 80               |
+--------------+------------------+
| Val ratio    | 0.100            |
+--------------+------------------+
| Weight decay | 0                |
+--------------+------------------+

补充

data_path    	|'/home/jp/data/tgif-qa/data'	|如果server是'780'则设置这一条，那么默认1080的话怎么办？下面还要用呢？
feat_dir     	| data_path+'feats'
vc_dir       	| data_path+'Vocabulary'
df_dir       	| data_path+'dataset'
model_name   	| 'Count'						|即task
pin_memory   	| False
dataset      	| 'tgif_qa'
log          	| './logs'
val_epoch_step	| 1
two_loss	    | False							|上面的two_loss大于0则设为True，否则为False
birnn		    | False							|同上
save_model_path | save_path + 'MMModel/'

通过data_utils的dataset创建两个TGIFQA类实例full_dataset（长为26839），test_dataset（长为3554），区别在于前者dataset_name=‘train’，后者为’test’
再通过torch.utils.data.random_split划分训练验证集，训练24156，验证2683，再通过torch.utils.data创建三个DataLoader类实例train_dataloader，val_dataloader，test_dataloader
补充

resnet_input_size	| 2048
c3d_input_size		| 4096
text_embed_size		| 300					|train_dataset.dataset.GLOVE_EMBEDDING_SIZE
answer_vocab_size	| None
word_matrix		   	| (2423, 300)的ndarray	|train_dataset.dataset.word_matrix
voc_len			  	| 2423

VOCABULARY_SIZE = train_dataset.dataset.n_words=2423

当前task为’Count’所以创建nn.MSELoss()均方误差的损失对象，并设定best_val_acc=-100

训练模型通过LSTMCrossCycleGCNDropout创建

for ii, data in enumerate(train_dataloader):

（看不太懂这个train_dataloader里面到底那个东西是数据信息，咋就摘出来ii和data了）
data是[128, 80, 2048]float32，[128, 80, 4096]float32，[128]int64，[128, 35]int64，[128]int64，[128]float326个tensor组成的list

当前change_lr为none所以创建如下优化器

Adam (
Parameter Group 0
    amsgrad: False
    betas: (0.9, 0.999)
    eps: 1e-08
    lr: 0.0001
    weight_decay: 0
)

LSTMCrossCycleGCNDropout(
读取train_dataloader
#sentence_inputs(batch_size, sentence_len, 1)
#video_inputs(batch_size, frame_num, video_feature)
当前task为'Count'所以首先执行forward_count
输入：
resnet_inputs	[128, 80, 2048]
c3d_inputs		[128, 80, 4096]
video_length	128
sentence_inputs	[128, 35]
question_length	128
answers			128
	#创建all_adj[128,115,115]
	#通过model_block得到out, adj
		 ###问题编码	输入
		 #			sentence_inputs	[128, 35]
		 #			question_length 128
		 (sentence_encoder): SentenceEncoderRNN(
			(embedding): Embedding(2423, 300, padding_idx=0)
			#得到embedded[128,35,300]
		    (dropout): Dropout(p=0.3, inplace=False)
		    (upcompress_embedding): Linear(in_features=300, out_features=512, bias=False)
		    (relu)
		    #[128,35,300]x[300,512]->[128,35,512]
		    if variable_lengths:
		    	nn.utils.rnn.pack_padded_sequence
		    	#输入：
		    	#	embedded		[128,35,300]
		    	#	input_lengths	128
		    	#输出：
		    	#	embedded：[1269,512],15,128,128 4个tensor组成的PackedSequence，
		    	#		有15个batch，batchsize有128,128,128,128,128,128,128, 128,107,60,35,20,16,6,1
		    (rnn): GRU(512, 512, batch_first=True, dropout=0.3)
		    #输入：embedded
		    #输出：
		    #	output：尺寸和batchsize同embedded的PackedSequence
		    #	hidden：[1, 128, 512]tensor
		    if variable_lengths:
		    	nn.utils.rnn.pad_packed_sequence
		    	#输入：output
		    	#输出：output[128, 15, 512]
		    #——————————————————————————————————————
		    if self.n_layers > 1 and self.bidirectional:
		    	(compress_output): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)→q_output
		    	(compress_hn_layers_bi): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)→s_hidden
		    elif self.n_layers > 1:
		    	(compress_hn_layers): Linear(in_features=512, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)→s_hidden
			elif self.bidirectional:
		    	(compress_output): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)→q_output
		    	(compress_hn_bi): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)→s_hidden
		    #————————————————————————————————
		)
		#输出：
		#	q_output[128, 15, 512]即上面的output
		#	s_hidden[1, 128, 512]即上面的hidden，再squeeze到s_last_hidden[128, 512]
		###视频编码
  		(compress_c3d): WeightDropLinear(in_features=4096, out_features=2048, bias=False)
  		#c3d_inputs[128, 80, 4096]x[4096,2048]->[128,80,2048]
  		(relu)
  		(video_fusion): WeightDropLinear(in_features=4096, out_features=2048, bias=False)
  		#c3d_inputs与resnet_inputs拼接
  		#[128, 80, 4096]x[4096,2048]->video_inputs[128,80,2048]
  		(relu)
  		(video_encoder): VideoEncoderRNN(
  		#输入：
  		#	video_inputs	[128,80,2048]
  		#	video_length	128
  			(project): Linear(in_features=2048, out_features=512, bias=False)
  			#[128,80,2048]x[2048,512]->embedded[128,80,512]
  			(relu)
		    (dropout): Dropout(p=0.3, inplace=False)
		    if variable_lengths:
		    	nn.utils.rnn.pack_padded_sequence
		    	#输入：
		    	#	embedded		[128,80,512]
		    	#	input_lengths	128
		    	#输出：
		    	#	embedded：[5311,512],80,128,128 4个tensor组成的PackedSequence，有80个batch
		    (rnn): GRU(512, 512, batch_first=True, dropout=0.3)
		    #输入：embedded
		    #输出：
		    #	output：尺寸和batchsize同embedded的PackedSequence
		    #	hidden：[1, 128, 512]tensor
		    if variable_lengths:
		    	nn.utils.rnn.pad_packed_sequence
		    	#输入：output
		    	#输出：output[128, 80, 512]
		    #——————————————————————————————————————
		    if self.n_layers > 1 and self.bidirectional:
		    	(compress_output): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)
		    	(compress_hn_layers_bi): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)
		    elif self.n_layers > 1:
		    	(compress_hn_layers): Linear(in_features=512, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)
			elif self.bidirectional:
		    	(compress_output): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)
		    	(compress_hn_bi): Linear(in_features=1024, out_features=512, bias=False)
		    	(relu)
		    	(dropout): Dropout(p=0.3, inplace=False)
		    #—————————————————————————————————————
		)
		#输出：
		#	v_output[128, 80, 512]即上面的output
		#	v_hidden[1, 128, 512]即上面的hidden，再squeeze到v_last_hidden[128, 512]
		if self.ablation != 'local':
			###视频问题融合
			if self.tf_layers != 0:
				(q_input_ln): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
			  	(v_input_ln): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
			  	#————————————————————————————
			  	###自注意力
			  	if 'self' in self.fusion_type:
			  		(q_selfattn): SelfAttention(
			  			(padding_mask_k)
			  			#(bs, q_len, v_len)
			  			(padding_mask_q)
			  			#(bs, v_len, q_len)
					    (encoder_layers): ModuleList(
					      SelfAttentionLayer(
					      	if attn_mask is None or softmax_mask is None:
						      	(padding_mask_k)
				  				(padding_mask_q)
				  			#三头
				  			(linear_k): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (linear_q): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (linear_v): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (softmax): Softmax(dim=-1)
					        (linear_final): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (layer_norm): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
					      )
					    )
					)
					(v_selfattn): SelfAttention(
					  	(padding_mask_k)
			  			(padding_mask_q)
					    (encoder_layers): ModuleList(
					      SelfAttentionLayer(
					      	if attn_mask is None or softmax_mask is None:
						      	(padding_mask_k)
				  				(padding_mask_q)
				  			#三头
				  			(linear_k): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (linear_q): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (linear_v): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (softmax): Softmax(dim=-1)
					        (linear_final): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (layer_norm): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
					      )
					    )
					)
				#——————————————————————————————————
				if 'coattn' in self.fusion_type:
					(co_attn): CoAttention(
					#输入：layernorm后的q_output,v_output
						(padding_mask_k)
							#fake_q[128,15,512]×v_output.T[128,512,80]->attn_mask[128,15,80]bool
			  			(padding_mask_q)
			  				#q_output[128,15,512]×fake_k.T[128,512,80]->softmax_mask[128,15,80]bool
			  			(padding_mask_k)
			  				#fake_q[128,80,512]×q_output.T[128,512,15]->attn_mask_[128,80,15]bool
			  			(padding_mask_q)
			  				#v_output[128,80,512]×fake_k.T[128,512,15]->softmax_mask_[128,80,15]bool
					    (encoder_layers): ModuleList(
					      CoAttentionLayer(
					      #输入：
					      #q_output,v_output,attn_mask,softmax_mask,attn_mask_,softmax_mask_
					      	#多头
					      	(linear_question): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (linear_video): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (linear_v_question): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (linear_v_video): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        #得到
					        #question_q	[128, 15, 512]
					        #video_k	[128, 80, 512]
					        #question	[128, 15, 512]
					        #video		[128, 80, 512]
					        #scale=512^(-1/2)
					        #question_q×video_k.T->attention_qv[128,15,80]
					        #attention_qv×scale再通过masked_fill(attn_mask,-np.inf)
					        (softmax): Softmax(dim=-1)
					        	#attention_qv再通过masked_fill(softmax_mask,0)
					        #video_k×question_q.T->attention_vq[128,80,15]
					        #attention_vq×scale再通过masked_fill(attn_mask_,-np.inf)
					        (softmax): Softmax(dim=-1)
					        	#attention_vq再通过masked_fill(softmax_mask_,0)
					        #attention_qv×v_output->output_qv[128,15,512]
					        (linear_final_qv): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (layer_norm_qv): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
					        	#output_qv+q_output做LayerNorm
					        #attention_vq×q_output->output_vq[128,15,512]
					        (linear_final_vq): WeightDropLinear(in_features=512, out_features=512, bias=False)
					        (layer_norm_vq): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
					        	#output_vq+v_output做LayerNorm
					      )
					    )
					  )
						  #输出：
						  #	q_output[128,15,512]
						  # v_output[128,80,512]
			###GCN
			(adj_learner): AdjLearner(
				#拼接q_output,v_output得到graph_nodes[128,95,512]
			    (edge_layer_1): Linear(in_features=512, out_features=512, bias=False)
			    (relu)
			    (edge_layer_2): Linear(in_features=512, out_features=512, bias=False)
			    (relu)
			    #[128,95,512]×[128,512,95]->adj[128,95,95]
			)
			#另外拼接q_output,v_output得到q_v_inputs[128,95,512]
			(gcn): GCN(
			#输入：q_v_inputs，adj
			#输出：q_v_output[128,95,512]
			    (layers): ModuleList(
			      (0): GraphConvolution(
			        (weight): Linear(in_features=512, out_features=512, bias=False)
			        (layer_norm): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
			        (relu)
			        (dropout): Dropout(p=0.3, inplace=False)
			      )
			      (1): GraphConvolution(
			        (weight): Linear(in_features=512, out_features=512, bias=False)
			        (layer_norm): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
			        (relu)
			        (dropout): Dropout(p=0.3, inplace=False)
			      )
			      (2): GraphConvolution(
			        (weight): Linear(in_features=512, out_features=512, bias=False)
			        (layer_norm): LayerNorm((512,), eps=1e-05, elementwise_affine=False)
			        (relu)
			        (dropout): Dropout(p=0.3, inplace=False)
			      )
			    )
			)
			###注意力池
			(gcn_atten_pool): Sequential(
			    (0): Linear(in_features=512, out_features=256, bias=True)
			    #[128,95,512]x[512,256]->[128,95,256]
			    (1): Tanh()
			    (2): Linear(in_features=256, out_features=1, bias=True)
			    #[128,95,256]x[256,1]->[128,95,1]
			    (3): Softmax(dim=-1)
			)
			#q_v_output[128,95,512]×local_attn[128,95,1]->[128,95,512]
			#再sum到local_out[128,512]
		if self.ablation != 'global':
			###全局融合
			(global_fusion): Block(	#block包里的功能
			#输入：
			#	s_last_hidden[128,512], v_last_hidden[128,512]
			    (linear0): Linear(in_features=512, out_features=1600, bias=True)
			    #[128,512]x[512,1600]->[128,1600]
			    (linear1): Linear(in_features=512, out_features=1600, bias=True)
			    #[128,512]x[512,1600]->[128,1600]
			    if self.dropout_input > 0:
			    	(dropout)
			    	(dropout)
		    	(get_chunks)
		    		#输入：	x0
		    		#		self.sizes_list：[80]*20	
		    		#输出：
		    		#	x0_chunks：通过对x0做narrow得到20个[128,80]的tensor组成的list	    		
		    	(get_chunks)
		    		#	x1_chunks：通过对x1做narrow得到20个[128,80]的tensor组成的list	
		    	#同步遍历x0_chunks和x1_chunks的20个tensor
				    (merge_linears0): ModuleList( #20层
				      (0): Linear(in_features=80, out_features=1200, bias=True)
				      #[128,80]x[80,1200]->[128,1200]
				    )
				    (merge_linears1): ModuleList( #20层
				      (0): Linear(in_features=80, out_features=1200, bias=True)
				    #[128,1200]x[128,1200]->[128,1200]
				    #再view成[128,15,80]
				    #再sum成z[128,80]
				    #z=relu(z)^(-1/2)-relu(-z)^(-1/2)
				    (normalize)
				#拼接成[128,1600]
			    )
			    (linear_out): Linear(in_features=1600, out_features=512, bias=True)
			    #[128,1600]×[1600,512]->global_out[128,512]
			)
			if self.ablation != 'local':
				(fusion): Block(
				#输入：
				#	global_out[128,512], local_out[128,512]
				    (linear0): Linear(in_features=512, out_features=1600, bias=True)
				    (linear1): Linear(in_features=512, out_features=1600, bias=True)
					    (merge_linears0): ModuleList(#20层
					      (0): Linear(in_features=80, out_features=1200, bias=True)
					    )
					    (merge_linears1): ModuleList(#20层
					      (0): Linear(in_features=80, out_features=1200, bias=True)
				    )
				    (linear_out): Linear(in_features=1600, out_features=1, bias=True)
				    #[128,1600]×[1600,1]->out[128,1]
	#输出：
	#	out[128,1]
	#	adj[128, 95, 95]
	#把adj放进all_adj（顶格放进前95位）
	#对out通过clamp到1到10（好像得到全是1啊？）
)
输出
out, predictions, answers, all_adj
用预测值out与标签answers做MSE损失
对每个batch做一次BP，总计是188个batch

每轮计算一个acc，比如18.935%，并计算本轮训练损失均值，比如5.758
然后又神秘的计算了一个所谓的真实损失，又拿所有预测结果和所有标签计算一次MSE，比如5.802

后面的验证测试集也是这样，既计算每batch的损失的均值和最终的acc，也要算一下真实损失（又不BP计算损失干啥，还能当性能指标的吗？）

Mighty_Crane
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TGIF-Release, 动态GIF描述数据集.zip
10-10
TGIF-Release, 动态GIF描述数据集 Tumblr ( TGIF )Tumblr ( TGIF ) 包含 100K 个动画GIF和 120K 个句子描述动画GIF的视觉内容。 gif动画已经从Tumblr收集，从randomly到6月之间随机选择发布的帖子。 我们在这个版本
《MUREL: Multimodal Relational Reasoning for Visual Question Answering》论文笔记
01-07
1. Abstract Attention 机制注重于视觉内容与问题的相关联系，但难以解决复杂的推理问题。为了解决这个问题，本文提出了 MUREL 架构模型，简单来说 MUREL ...MUREL 单元用于发掘 Question 和 Image region 间的细粒度关
ModuleNotFoundError: No module named ‘xxx‘可能的解决方案大全
热门推荐
Lucky小黄人的博客
08-29 29万+
"ModuleNotFoundError: No module named 'xxx'"这个报错是个非常常见的报错，几乎每个python程序员都遇到过，导致这个报错的原因也非常多，下面是我曾经遇到过的原因和解决方案 module包没安装 忘了import 没有__init__.py文件 package包的版本不对 自定义的包名与安装的包名相同，导致import包的时候导错了包 没设置PYTHO...
Python:No module named问题详解
qq_44683653的博客
06-20 1万+
这里写目录标题一、sys.path问题二、模块和包导入问题三、模块的__name__ 一、sys.path问题 二、模块和包导入问题 三、模块的__name__
已解决ModuleNotFoundError: No module named
03-28 12万+
ModuleNotFoundError通常是由于缺少相关的Python模块导致的。
解决ne module named ‘colour‘
qy_yyyyy的博客
06-12 2205
在sublime运行python3时 输入了 from colour import color 报错为： ne module named ‘colour’ 解决方法为： python3情况：在终端输入 pip3 install colour 后重启软件 python2情况：在终端输入 pip install colour
Reasoning With Neural Tensor Networks for Knowledge Base Completion-附件资源
03-02
Reasoning With Neural Tensor Networks for Knowledge Base Completion-附件资源
Graph-Based Representation and Reasoning
07-02
Graph-Based Representation and Reasoning， 24th International Conference on Conceptual Structures, ICCS 2019, Marburg, Germany, July 1–4, 2019, Proceedings
Reasoning With NTN for Knowledge Base Completion.zip
11-23
论文《Reasoning With Neural Tensor Networks for Knowledge Base Completion》原文及译文
ModuleNotFoundError: No module named ‘...’：报错解决方案
qq_41413211的博客
09-26 4万+
那要怎么知道正确的规范是什么？代码一开始是写import evaluate...，当改成from evaluate import inf时，可以看到系统提示Retina这个名字，于是改成上面打勾的格式，测试一下，果然没错。这个‘ ... ’就是包的名字，这时候可以在对应的环境里使用pip install安装对应的包，具体怎么安装参考我的环境配置博客。2.import时规范不对。1.module包没安装。
bootstrap.pytorch:用于启动深度学习项目的高级框架（轻巧，灵活，易于扩展）
05-03
bootstrap.pytorch是使用PyTorch进行深度学习的高级扩展。 它旨在通过提供针对您的数据集和模型的强大工作流程来加速研究项目和原型开发。 它是： 可扩展 模块化的 可共享的 可扩展的 简单 专为重现性而打造 易于记录和绘图 与许多其他应用bootstrap.pytorch不同， bootstrap.pytorch并不是pytorch的包装器，而是强大的扩展。 快速导览 要进行实验（培训+评估）： python -m bootstrap.run -o myproject/options/sgd.yaml 要显示来自yaml文件的已解析选项，请执行以下操作： python -m bootstrap.run -o myproject/options/sgd.yaml -h 进行实验将创建4个文件，这是的示例： 包含用于实验的选
python中的colorlog库使用详解
01-21
一. 描述 colorlog.ColoredFormatter是一个Python logging模块的格式化，用于在终端输出日志的颜色 二. 安装 pip install colorlog 三. 用法 import colorlog handler = colorlog.StreamHandler() handler.setFormatter(colorlog.ColoredFormatter( '%(log_color)s%(levelname)s:%(name)s:%(message)s')) logger = colorlog.getLogger('example') log
python导入模块出现ImportError: No module named '...'问题解决方法总结
weixin_40995629的博客
04-24 3万+
问题描述：在导入自己写的模块的时候，有时候会出现问题：ImportError: No module named 'xxx'，前人已经总结的方法如下：（1） 使用sys.path.append来添加路径, 具体如下：import syssys.path.append("/path/your/code")（2）使用PYTHONPATH环境变量（3）将py文件放到site-packages目录下（4）使...
命令行执行python文件显示ModuleNotFoundError: No module named ‘...‘解决办法
凡凡不知所错
02-15 4万+
在一个项目中如果我们使用类似pycharm这样的软件来写项目，项目中有些文件需要单独执行的时候，我们通常会使用软件自带的执行按钮来运行python脚本，但是有时候我们需要使用在命令行内敲击python run.py这样的方式来运行脚本，这时就会出现ModuleNotFoundError: No module named ‘…’ 这样的报错。 这样报错的原因是我们import模块的时候使用的是相对路...
No Module named block
Dabria1999的博客
04-07 1342
报错：No Module named block 源代码： from blcok import fusions 解决方法： pip install block.bootstrap.pytorch 或者 git clone https://github.com/Cadene/block.bootstrap.pytorch.git python setup.py install 解释： pytorch 中有一个模块block 参考链接 https://pypi.org/project/block.boot
pytorch踩坑（1）
feynman233的博客
11-29 424
RuntimeError: cuda runtime error (38) : no CUDA-capable device is detected at /pytorch/aten/src/THC/THCGeneral.cpp:74
python出现"No module named "XXX""的解决办法
ouening的博客
12-06 12万+
在使用wxPython的时候，已经下载安装了wxPython（只有python2版本的才有wxPython，python3版本是没有的），但是在import的时候出现了"No module named "wx""的错误提示，还有就是PIL 图像处理模块，虽然这个模块被Pillow替代了，但是我学习python所用一些书籍教程还是有用PIL的，安装之后也是出现”No module named “PIL
如何解决PyTorch中的No module named ‘pytorch_colors‘问题
surymy
08-14 3549
下载地址：https://pypi.org/project/ez_setup/#files pip install --target=/pytnon_list/zero_reference/ez_setup-0.9 setuptools
deep relational reasoning graph network for arbitrary shape text detection
最新发布
04-10
b'deep relational reasoning graph network for arbitrary shape text detection' 是一种深度关系推理图网络，用于任意形状的文本检测。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值