精华内容
下载资源
问答
  • 具有神经网络数据库系统的自调整性能
  • 数据库 五大图数据库 TigerGraph Neo4j Neptune JanusGraph ArangoDB elasticsearch redis 端口:6379 postgreSQL 端口:5432 hadoop hive spark flink

    图数据库

    五大图数据库
    TigerGraph
    Neo4j
    Neptune
    JanusGraph
    ArangoDB

    elasticsearch

    redis
    端口:6379

    postgreSQL
    端口:5432

    hadoop
    hive
    spark
    flink

    展开全文
  • 基于网络上的BP神经网络进行改编,里面有对mnist数据库的读取和特征提取,为C++写成的源代码形式,对神经网络和手写体数字识别有一定启发作用。
  • 语音识别是一门交叉学科。近二十年来,语音识别技术取得显著进步,开始从实验室走向市场。人们预计,未来10年内,语音识别技术将进入工业、家电、通信、汽车电子、医疗、家庭服务、消费电子产品等各个领域。...
  • 发育离体的神经网络的电活动对于理解神经信息处理和存储的一般特性具有巨大的意义。 此外,网络活动模式的复杂性和多样性使它们成为开发新颖的计算模型和评估算法的理想人选。 但是,很少有数据库关注开发过程中不断...
  • 我们训练了一个大型的深度卷积神经网络,来将在ImageNet LSVRC-2010 大赛中的120万张高清图像分为1000 个不同的类别。对测试数据,我们得到了top-1 误差率37.5%,以及top-5 误差率17.0%,这个效果比之前最顶尖的都...
  • 神经网络与ORCAL数据库相结合的实现。PDF版
  • 讨论了数据库中的知识发现的基本技术,提出了一种适用于数据挖掘的神经网络方法,并给出了神经网络数据挖掘系统的构造过程,应用结果表明该方法是可行有效的,并对该方法进行了深入的讨论。
  • 评述了利用神经网络数据库中进行规则发现的几种方法,采用权值组合算法提取规则;利用模糊推理神经网络,采用CamDelta算法提取模糊规则;基于从数据中提取模糊控制规则;利用生长自组织映射神经网络,采用分级聚类...
  • 单层感知器神经网络matlab代码在MATLAB中使用神经网络进行MNIST数据库手写体检测 由J.Barhydt 1 华盛顿大学华盛顿州西雅图市98195 概述: 对于涉及不可思议的大型数据集的机器学习任务,神经网络(NNs)的使用已变得...
  • 相关的包weka.jar,weka-src.jar,libsvm.jar.wlsvm.jar可以在以下链接下载 /s/1kTHW3un文档来自于网络搜索 在Eclipse项目中导入weka包本文中使用BP神经网络的算法只用添加weka.jar即可若要使用libsvm
  • mnist神经网络 mnist-neural-network实现了一个神经网络来识别手写数字。 我使用来训练网络。 安装及使用 我们可以使用make实用程序来安装软件: $ cd implementation && make 安装后,我们可以执行以下软件: $ ...
  • 双流卷积神经网络我最初是在做行为识别的时候接触到的,双流指的是时间流和空间流,再具体一点就是,时间流指的是对光流图片进行卷积处理,然后空间流指的是对RGB图片进行卷积处理,然后进行融合操作。这样往往比...

    本文所有代码已经放在GitHub上https://github.com/zhuzhuxia1994/CK-TensorFlow

    双流卷积神经网络我最初是在做行为识别的时候接触到的,双流指的是时间流和空间流,再具体一点就是,时间流指的是对光流图片进行卷积处理,然后空间流指的是对RGB图片进行卷积处理,然后进行融合操作。这样往往比单纯对RGB图片进行卷积效果好,特别是在视频行为识别等方面,因为引入了时间信息。话不多说,放上代码及讲解。

    以下代码是对表情识别CK+数据库进行实验,CK=数据库的地址如下http://www.consortium.ri.cmu.edu/ckagree/ 需要填写信息,如果有同学需要可以在博客下面留言,我会放上百度云地址~(先赞再跟我要哦,不然不理你,嘿嘿嘿害羞害羞

     import tensorflow as tf
    
    #%%
    def inference(s_images,T_images, batch_size, n_classes):
        '''Build the model
        Args:
            images: image batch, 4D tensor, tf.float32, [batch_size, width, height, channels]
        Returns:
            output tensor with the computed logits, float, [batch_size, n_classes]
        '''
        #conv1, shape = [kernel size, kernel size, channels, kernel numbers]
        
        # one stream space
        with tf.variable_scope('s_conv1') as scope:
            weights = tf.get_variable('weights', 
                                      shape = [3,3,3, 16],
                                      dtype = tf.float32, 
                                      initializer=tf.truncated_normal_initializer(stddev=0.1,dtype=tf.float32))
            biases = tf.get_variable('biases', 
                                     shape=[16],
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            conv = tf.nn.conv2d(s_images, weights, strides=[1,1,1,1], padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases)
            s_conv1 = tf.nn.relu(pre_activation, name= scope.name)
        
        #pool1 and norm1   
        with tf.variable_scope('s_pooling1_lrn') as scope:
            pool1 = tf.nn.max_pool(s_conv1, ksize=[1,3,3,1],strides=[1,2,2,1],
                                   padding='SAME', name='s_pooling1')
            norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                              beta=0.75,name='s_norm1')
        
        #conv2
        with tf.variable_scope('s_conv2') as scope:
            weights = tf.get_variable('weights',
                                      shape=[3,3,16,16],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.1,dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[16], 
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            conv = tf.nn.conv2d(norm1, weights, strides=[1,1,1,1],padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases)
            s_conv2 = tf.nn.relu(pre_activation, name='s_conv2')
        
        
        #pool2 and norm2
        with tf.variable_scope('s_pooling2_lrn') as scope:
            norm2 = tf.nn.lrn(s_conv2, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                              beta=0.75,name='s_norm2')
            pool2 = tf.nn.max_pool(norm2, ksize=[1,3,3,1], strides=[1,1,1,1],
                                   padding='SAME',name='s_pooling2')
        
        
        #local3
        with tf.variable_scope('s_local3') as scope:
            reshape = tf.reshape(pool2, shape=[batch_size, -1])
            dim = reshape.get_shape()[1].value
            weights = tf.get_variable('weights',
                                      shape=[dim,128],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[128],
                                     dtype=tf.float32, 
                                     initializer=tf.constant_initializer(0.1))
            s_local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)    
        
        #local4
        #with tf.variable_scope('s_local4') as scope:
        #    weights = tf.get_variable('weights',
        #                              shape=[128,128],
        #                              dtype=tf.float32, 
        #                              initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
        #    biases = tf.get_variable('biases',
        #                             shape=[128],
        #                             dtype=tf.float32,
        #                             initializer=tf.constant_initializer(0.1))
        #    local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name='s_local4')
    
    
        # another stream temporal
        with tf.variable_scope('T_conv1') as scope:
            weights = tf.get_variable('weights', 
                                      shape = [3,3,3, 16],
                                      dtype = tf.float32, 
                                      initializer=tf.truncated_normal_initializer(stddev=0.1,dtype=tf.float32))
            biases = tf.get_variable('biases', 
                                     shape=[16],
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            conv = tf.nn.conv2d(T_images, weights, strides=[1,1,1,1], padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases)
            T_conv1 = tf.nn.relu(pre_activation, name= scope.name)
        
        #pool1 and norm1   
        with tf.variable_scope('T_pooling1_lrn') as scope:
            pool1 = tf.nn.max_pool(T_conv1, ksize=[1,3,3,1],strides=[1,2,2,1],
                                   padding='SAME', name='T_pooling1')
            norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                              beta=0.75,name='T_norm1')
        
        #conv2
        with tf.variable_scope('T_conv2') as scope:
            weights = tf.get_variable('weights',
                                      shape=[3,3,16,16],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.1,dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[16], 
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            conv = tf.nn.conv2d(norm1, weights, strides=[1,1,1,1],padding='SAME')
            pre_activation = tf.nn.bias_add(conv, biases)
            T_conv2 = tf.nn.relu(pre_activation, name='T_conv2')
        
        
        #pool2 and norm2
        with tf.variable_scope('T_pooling2_lrn') as scope:
            norm2 = tf.nn.lrn(T_conv2, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                              beta=0.75,name='T_norm2')
            pool2 = tf.nn.max_pool(norm2, ksize=[1,3,3,1], strides=[1,1,1,1],
                                   padding='SAME',name='T_pooling2')
        
        
        #local3
        with tf.variable_scope('T_local3') as scope:
            reshape = tf.reshape(pool2, shape=[batch_size, -1])
            dim = reshape.get_shape()[1].value
            weights = tf.get_variable('weights',
                                      shape=[dim,128],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[128],
                                     dtype=tf.float32, 
                                     initializer=tf.constant_initializer(0.1))
            T_local3 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)    
    
        local3 = s_local3 + T_local3
        
        #local4
        with tf.variable_scope('local4') as scope:
            weights = tf.get_variable('weights',
                                      shape=[128,128],
                                      dtype=tf.float32, 
                                      initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
            biases = tf.get_variable('biases',
                                     shape=[128],
                                     dtype=tf.float32,
                                     initializer=tf.constant_initializer(0.1))
            local4 = tf.nn.relu(tf.matmul(local3, weights) + biases, name='local4')
    
         
            
        # softmax
        with tf.variable_scope('softmax_linear') as scope:
            weights = tf.get_variable('softmax_linear',
                                      shape=[128, n_classes],
                                      dtype=tf.float32,
                                      initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
            biases = tf.get_variable('biases', 
                                     shape=[n_classes],
                                     dtype=tf.float32, 
                                     initializer=tf.constant_initializer(0.1))
            softmax_linear = tf.add(tf.matmul(local4, weights), biases, name='softmax_linear')
        
        return softmax_linear
    
    #%%
    def losses(logits, labels):
        '''Compute loss from logits and labels
        Args:
            logits: logits tensor, float, [batch_size, n_classes]
            labels: label tensor, tf.int32, [batch_size]
            
        Returns:
            loss tensor of float type
        '''
        with tf.variable_scope('loss') as scope:
            cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits\
                            (logits=logits, labels=labels, name='xentropy_per_example')
            loss = tf.reduce_mean(cross_entropy, name='loss')
            tf.summary.scalar(scope.name+'/loss', loss)
        return loss
    
    #%%
    def trainning(loss, learning_rate):
        '''Training ops, the Op returned by this function is what must be passed to 
            'sess.run()' call to cause the model to train.
            
        Args:
            loss: loss tensor, from losses()
            
        Returns:
            train_op: The op for trainning
        '''
        with tf.name_scope('optimizer'):
            optimizer = tf.train.AdamOptimizer(learning_rate= learning_rate)
            global_step = tf.Variable(0, name='global_step', trainable=False)
            train_op = optimizer.minimize(loss, global_step= global_step)
        return train_op
    
    #%%
    def evaluation(logits, labels):
      """Evaluate the quality of the logits at predicting the label.
      Args:
        logits: Logits tensor, float - [batch_size, NUM_CLASSES].
        labels: Labels tensor, int32 - [batch_size], with values in the
          range [0, NUM_CLASSES).
      Returns:
        A scalar int32 tensor with the number of examples (out of batch_size)
        that were predicted correctly.
      """
      with tf.variable_scope('accuracy') as scope:
          correct = tf.nn.in_top_k(logits, labels, 1)
          correct = tf.cast(correct, tf.float16)
          accuracy = tf.reduce_mean(correct)
          #correct_prediction = tf.equal(tf.argmax(logits,1),tf.argmax(labels,1))
          #accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
          tf.summary.scalar(scope.name+'/accuracy', accuracy)
      return accuracy
    代码中写的S_conv等以S开头的是空间流,也就是对RGB进行训练,T_conv等以T开头的是时间流,对光流图片进行训练。并将结果在全连接层进行融合。以上代码是双流卷积模型的代码,其中的层数都可以修改。

    import tensorflow as tf 
    import numpy as np 
    import os
    
    
    #train_dir = '/home/hrz/projects/tensorflow/My-TensorFlow-tutorials/cats_vs_dogs/data/train/'
    
    def get_files(file_dir):
    
    
    	angry = []
    	label_angry = []
    	happy = []
    	label_happy = []
    	surprised = []
    	label_surprised = []
    	disgusted = []
    	label_disgusted = []
    	fearful = []
    	label_fearful = []
    	sadness = []
    	label_sadness = []
    	for sub_file_dir in os.listdir(file_dir):
    		if sub_file_dir == 'angry':
    			for name in os.listdir(file_dir+'/'+sub_file_dir):
    				angry.append(file_dir+'/'+sub_file_dir+'/'+name)
    				label_angry.append(0)
    		elif sub_file_dir == 'disgusted':
    			for name in os.listdir(file_dir+'/'+sub_file_dir):
    				disgusted.append(file_dir+'/'+sub_file_dir+'/'+name)
    				label_disgusted.append(1)
    		elif sub_file_dir == 'fearful':
    			for name in os.listdir(file_dir+'/'+sub_file_dir):
    				fearful.append(file_dir+'/'+sub_file_dir+'/'+name)
    				label_fearful.append(2)
    		elif sub_file_dir == 'happy':
    			for name in os.listdir(file_dir+'/'+sub_file_dir):
    				happy.append(file_dir+'/'+sub_file_dir+'/'+name)
    				label_happy.append(3)
    		elif sub_file_dir == 'sadness':
    			for name in os.listdir(file_dir+'/'+sub_file_dir):
    				sadness.append(file_dir+'/'+sub_file_dir+'/'+name)
    				label_sadness.append(4)
    		elif sub_file_dir == 'surprised':
    			for name in os.listdir(file_dir+'/'+sub_file_dir):
    				surprised.append(file_dir+'/'+sub_file_dir+'/'+name)
    				label_surprised.append(5)
    	print('Already!!',len(label_angry))
    
    
    	image_list = np.hstack((angry,disgusted,fearful,happy,sadness,surprised))
    	label_list = np.hstack((label_angry,label_disgusted,label_fearful,label_happy,label_sadness,label_surprised))
    	temp = np.array([image_list,label_list])
    	temp = temp.transpose()
    	np.random.shuffle(temp)
    
    	image_list = list(temp[:, 0])
    	label_list = list(temp[:, 1])
    	label_list = [int(i) for i in label_list]
        
        
    	return image_list, label_list
    
    
    def get_batch(image,label,image_W,image_H,batch_size,capacity):
    	'''
    	Args:
            image: list type
            label: list type
            image_W: image width
            image_H: image height
            batch_size: batch size
            capacity: the maximum elements in queue
        Returns:
            image_batch: 4D tensor [batch_size, width, height, 3], dtype=tf.float32
            label_batch: 1D tensor [batch_size], dtype=tf.int32
        '''
    
    	image = tf.cast(image,tf.string)
    	label = tf.cast(label,tf.int32)
    
    	input_queue = tf.train.slice_input_producer([image,label])
    	label = input_queue[1]
    	image_contents = tf.read_file(input_queue[0])
    	image = tf.image.decode_jpeg(image_contents,channels=3)
    
    	image = tf.image.resize_image_with_crop_or_pad(image,image_W,image_H)
    
    	image = tf.image.per_image_standardization(image)
    
    	image_batch,label_batch = tf.train.batch([image,label],
        											batch_size = batch_size,
        											num_threads = 64,
        											capacity = capacity)
    
    	label_batch = tf.reshape(label_batch,[batch_size])
    	image_batch = tf.cast(image_batch,tf.float32)
    
    	return image_batch,label_batch
    

    首先对数据库进行手动贴标签,获得image_list和label_list,是图片的路径以及所对应的标签信息。输入形式采用的是TensorFlow中的queue队列形式,对于较大规模的数据输入比较好使。不过要注意其中的tf.image.resize_image_with_crop_or_pad函数,这个函数其实是将图片的中间给截取出来,举个例子,原图尺寸为1080*1080,那使用这个函数想将图片变为256*256,实际的效果是抠出原图最中间的256*256的像素,而不是按比例缩小,所以如果同学们想换个数据库,可能就需要更换一个函数tf.resize_image,这个才是按比例缩放。get_batch函数就是将图片打包。

    import os
    import numpy as np
    import tensorflow as tf
    import input_data
    import model
    #%%
    
    N_CLASSES = 6
    IMG_W = 256  # resize the image, if the input image is too large, training will be very slow.
    IMG_H = 256
    BATCH_SIZE = 8
    CAPACITY = 10000
    MAX_STEP = 800 # with current parameters, it is suggested to use MAX_STEP>10k
    learning_rate = 0.0001 # with current parameters, it is suggested to use learning rate<0.0001
    
    
    #%%
    def run_training():
        
        # you need to change the directories to yours.
    	s_train_dir = '/home/hrz/projects/tensorflow/emotion/ck+/CK+YuanTu'
    	T_train_dir = '/home/hrz/projects/tensorflow/emotion/ck+/CK+X_mid'
    	logs_train_dir = '/home/hrz/projects/tensorflow/emotion/ck+'
    	s_train, s_train_label = input_data.get_files(s_train_dir)
    	s_train_batch, s_train_label_batch = input_data.get_batch(s_train,
                                                              s_train_label,
                                                              IMG_W,
                                                              IMG_H,
                                                              BATCH_SIZE, 
                                                              CAPACITY)   
    	T_train, T_train_label = input_data.get_files(T_train_dir)
        
    	T_train_batch, T_train_label_batch = input_data.get_batch(T_train,
                                                              T_train_label,
                                                              IMG_W,
                                                              IMG_H,
                                                              BATCH_SIZE, 
                                                              CAPACITY) 
    
    	train_logits = model.inference(s_train_batch,T_train_batch, BATCH_SIZE, N_CLASSES)
    	train_loss = model.losses(train_logits, s_train_label_batch)        
    	train_op = model.trainning(train_loss, learning_rate)
    	train__acc = model.evaluation(train_logits, s_train_label_batch)
           
    	summary_op = tf.summary.merge_all()  #汇总操作
    	sess = tf.Session()   #定义sess
    	train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph) #
    	saver = tf.train.Saver()    #保存操作
        
    	sess.run(tf.global_variables_initializer())#初始化所有变量
    	coord = tf.train.Coordinator() #设置多线程协调器
    	threads = tf.train.start_queue_runners(sess=sess, coord=coord) #开始Queue Runners(队列运行器)
        
        #开始训练过程
    	try:
    		for step in np.arange(MAX_STEP):
    			if coord.should_stop():
    					break
    			_, tra_loss, tra_acc = sess.run([train_op, train_loss, train__acc]) 
                   
    			if step % 50 == 0:
    				print('Step %d, train loss = %.2f, train accuracy = %.2f%%' %(step, tra_loss, tra_acc*100.0))
    				#运行汇总操作,写入汇总
    				summary_str = sess.run(summary_op)
    				train_writer.add_summary(summary_str, step)
                
    			if step % 800 == 0 or (step + 1) == MAX_STEP:
    				#保存当前模型和权重到 logs_train_dir,global_step为当前迭代次数
    				checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt')
    				saver.save(sess, checkpoint_path, global_step=step)
                    
    	except tf.errors.OutOfRangeError:
    		print('Done training -- epoch limit reached')
    	finally:
    		coord.request_stop()
            
    	coord.join(threads)
    	sess.close()
    run_training()
    上面就是训练的过程比较简单易懂,不再赘述,如果有问题可以问我,还有test.py没有贴出了,一并放在我的GitHub中,地址https://github.com/zhuzhuxia1994/CK-TensorFlow

    展开全文
  • **个人微信:934376935(阿秾)**欢迎大家随时骚扰我,我希望结交更多图数据库/图计算/图神经网络方面的人才以及关联技术人才。各类职位我都有 图论的历史 **第一阶段:**从1736年到19世纪中叶1736年,欧拉(L·...

    欢迎大家一起交流,本人对于图方面的做过一些市场洞察以及Mapping。

    图论的历史
    **第一阶段:**从1736年到19世纪中叶1736年,欧拉(L·Euler)研究哥尼斯堡城(Koni gsberg)的七桥问题发表了图论的首篇论文,被誉为图论之父1847年,德国数学家(G.R.kirchhoff)应用图的方法分析电网络,奠定了现代电网理论的基础。
    **第二阶段:**从19世纪中叶到1936年这一时期图论大量问题出现,诸如关于地图染色的四色问题,由“周游世界”游戏发展起来的哈密顿(W.Hamilton)问题等1936年匈牙利数学家柯尼希用德语编写了第一本图论专著《有限图与无限图的理论》,这是图论作为独立的数学分支形成的标志
    **第三阶段:**从1936年以后因为高速电子计算机的问世,以及网络理论的建立,现代图论已经成为了数学中的独立学科,衍生出如拓扑图论,随机图论等分支,也诞生出了一系列的图论学者。图论近些年在计算机流程图,通讯网络的设计分析等领域都有了丰富的应用
    图论中国近代史: 1982年,华东师范大学的李修睦教授。 他撰写了第一部中文图论书稿《图论导引》
    中国科学院数学研究所的吴文俊教授受惠特尼(图论研究者,创立拟阵论分支)的影响也展开了图论方面的深入研究
    到了二十世纪末, 涌现出了一大批国内数学家, 他们都对推动图论学科的发展做出了重要贡献, 如刘桂真、 刘彦佩等等。
    **21世纪的图论:**目前国内的图论研究者基本集中在各大高校以及研究所内,已经被划为独立学科进行研究包括各类应用场景以及学术理论研究各类应用场景,知识图谱,图计算,图引擎,图数据库等。
    上述内容借鉴过一些文章内容,但时间久远,有点找不到出处了。

    图计算相关技术的迅猛发展主要在社交应用兴起之后,也得益于云,分布式计算等技术的成熟

    相关技术人才主要分布在以下几类公司:
    1、具备自研能力的老牌IT厂商
    2、具备自研能力的互联网巨头
    3、具备相关技术研究院的学术机构
    4、积极开始应用相关产品的企业(不具备自研能力,但对业务应用场景比较了解)
    5、从第一第二第三类公司离职出来的创业人才
    6、开源社区(主要在海外,华人占比较少,)

    上述第一第二第三类公司相关的研发团队大多只有个位数的图计算/图数据库资深技术人才,其余多为不到5年研发及工程经验的工程师
    (国内外大大小小做图数据库的企业先不做赘述了)

    图计算目前相关技术的主要行业应用场景为:
    1、金融风控应用(传统金融机构及互联网金融)
    2、泛互联网应用(搜索引擎、推荐、用户分群、异常行为分析、舆情分析等)
    3、零售行业(以Walmart为例)
    4、城市工业等应用(电路、管道、交通网路等)
    5、企业IT应用(规划网络、分析故障、IT基础设施管理等)

    相关技术的技术应用场景为:

    1、知识图谱应用(存储、快速关联查询、知识梳理、学习路径识别及推荐)
    区块链、IOT等应用

    2、图计算等技术在知识图谱,IOT,区块链等技术领域的应用历史也是比较短,大部分在用开源的产品和工具,相关的软件公司会有技术比精通的工程师,能应用开源的产品工具构建解决方案,但还没发现有自研能力的公司(待挖掘)

    综上而言,图计算的人才市场依旧有非常广阔的挖掘空间,包括关系型数据库等关联系数的人才像图数据库领域的流动

    展开全文
  • 数据库读取数据训练神经网络

    千次阅读 2015-02-04 15:10:02
    由于数据列太多(504列),无法加载到txt和excel中,而且操作起来不方便,因此这里直接从数据库中加载数据 另外,对于数据库中一些连接和操作的语句,这里也记录下来,以后用起来方便些。就不用去代码中找了。 1、...

    由于数据列太多(504列),无法加载到txt和excel中,而且操作起来不方便,因此这里直接从数据库中加载数据

    另外,对于数据库中一些连接和操作的语句,这里也记录下来,以后用起来方便些。就不用去代码中找了。

    1、连接数据库

    在此之前,需要用odbc配置数据源,建立数据库,配置数据源即可。


    CDataBase* m_pDataBase; //定义
    m_pDataBase=new CDatabase(); //构造函数中
    
    m_pDataBase->Close();//析构函数中
    <span style="white-space:pre">	</span>delete m_pDataBase;
    
    #include "afxdb.h"  --数据库头文件不要忘记
    
    BOOL CChangeIdeaApp::PrepareDataBase()
    {	
    
    	BOOL bRet;
    	TRY
    	{
    		bRet=m_pDataBase->Open(NULL,FALSE,FALSE,_T("ODBC;DSN=ZKDB"));//;UID=sa;PWD=psdmaes
    	}
    	CATCH_ALL(e)
    	{
    		char MsgError[255];
    		e->GetErrorMessage(MsgError,255);
    		AfxMessageBox(MsgError);
    		delete m_pDataBase;
    		return FALSE;
    	}
    	END_CATCH_ALL
    	if(!bRet)
    	{
    		AfxMessageBox(_T("连接失败!"));
            delete m_pDataBase;
    		return FALSE;
    	}
    }
    
    这个例子是以前做的一个利用字库做idea的,这里重新拿出来

    2、读取数据

    这里是一个读取字库中记录的小程序,这里有一些随机读取的功能,可以用来做一般的模板使用

    int row=GetProfileInt("字库","行数",2358);
    	int col=GetProfileInt("字库","列数",10);
    
    	
    	CString OutContent="";
    	srand((int)time(0));
    	for(int i=0;i<4;i++)
    	{	
    		int r=rand()%row;//随机取行和列
    		int c=rand()%col;
    		char GetName[100];
    		SDWORD cbName;
    		c++;
    		c++;
    		char ss[1024];
    		HSTMT hStmt;
    		RETCODE retcode;
    		sprintf(ss,"select * from ZkTable where ROW=%d",r);
    		if(SQLAllocStmt(m_pDataBase->m_hdbc,&hStmt)!=SQL_SUCCESS) 
    		{
    			AfxMessageBox("SQLAllocStmt error !",MB_OK);
    			return FALSE;
    		}
    		retcode = SQLExecDirect(hStmt, (unsigned char *)ss, SQL_NTS); 
    		if((retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO)) 
    		{
    			SQLFreeStmt(hStmt,SQL_DROP);
    			AfxMessageBox("SQLExecDirect Error",MB_OK);
    			return FALSE;
    		}
    		while(retcode==SQL_SUCCESS)
    		{ 
    			retcode = SQLFetch(hStmt); 
    			if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
    			{
    				SQLGetData(hStmt, c, SQL_C_CHAR, &GetName[0], 256, &cbName); //c为第c列,从1开始,一些其他的格式见下表1
    				OutContent+=GetName;
    				break;
    			}
    			
    		}
    		SQLFreeStmt(hStmt,SQL_DROP);
    
    
    	}
    
    RecordContent=OutContent;	

     

    经过改进,完整的从数据库中读取数据成为矩阵的代码如下

    功能:从数据库中读取50行数据,共504列到矩阵中。

    对于这种矩阵类,我觉得还是很好用的,我应该掌握它。并让它成为自己的程序。

    bool CMatrix::LoadDataFromBase()
    {
    	CNNBPApp* pApp = (CNNBPApp*)AfxGetApp();
    	//设置矩阵的行列
    	m_nRow =50;
    	SetMatrixRowNumber(m_nRow);
    	m_nCol =504;
    	SetMatrixColNumber(m_nCol);
    
    	double GetValue;
    	SDWORD cbName;
    	char ss[1024];
    	CString OutContent="";
    	HSTMT hStmt;
    	RETCODE retcode;
    	sprintf(ss,"select * from aatest");
    	if(SQLAllocStmt(pApp->m_pDataBase->m_hdbc,&hStmt)!=SQL_SUCCESS) 
    	{
    		AfxMessageBox("SQLAllocStmt error !",MB_OK);
    		return FALSE;
    	}
    	retcode = SQLExecDirect(hStmt, (unsigned char *)ss, SQL_NTS); 
    	if((retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO)) 
    	{
    		SQLFreeStmt(hStmt,SQL_DROP);
    		AfxMessageBox("SQLExecDirect Error",MB_OK);
    		return FALSE;
    	}
    	int i=0;
    	while(retcode==SQL_SUCCESS)
    	{ 
    		retcode = SQLFetch(hStmt); 
    		if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO)
    		{
    			for(int j=1;j<=504;j++)
    			{	
    				SQLGetData(hStmt, j, SQL_C_DOUBLE, &GetValue, 256, &cbName); 	
    				m_pTMatrix [i][j-1] = GetValue;
    			}
    
    		}
    		i++;
    		if(i>=50)
    			break;
    		
    	}
    	SQLFreeStmt(hStmt,SQL_DROP);
    	
    }

    这里贴出来,以后找起来就方便了。

    表1 格式大全来源http://www.cnblogs.com/zhenjing/ 

    SQL类型

    C类型

    bit

    SQL_BIT

    SQL_C_BIT

    tinyint

    SQL_TINYINT

    SQL_C_STINYINT

    tinyint unsigned

    SQL_TINYINT

    SQL_C_UTINYINT

    bigint

    SQL_BIGINT

    SQL_C_SBIGINT

    bigint unsigned

    SQL_BIGINT

    SQL_C_UBIGINT

    long varbinary

    SQL_LONGVARBINARY

    SQL_C_BINARY

    blob

    SQL_LONGVARBINARY

    SQL_C_BINARY

    longblob

    SQL_LONGVARBINARY

    SQL_C_BINARY

    tinyblob

    SQL_LONGVARBINARY

    SQL_C_BINARY

    mediumblob

    SQL_LONGVARBINARY

    SQL_C_BINARY

    long varchar

    SQL_LONGVARCHAR

    SQL_C_CHAR

    text

    SQL_LONGVARCHAR

    SQL_C_CHAR

    mediumtext

    SQL_LONGVARCHAR

    SQL_C_CHAR

    char

    SQL_CHAR

    SQL_C_CHAR

    numeric

    SQL_NUMERIC

    SQL_C_CHAR

    decimal

    SQL_DECIMAL

    SQL_C_CHAR

    integer

    SQL_INTEGER

    SQL_C_SLONG

    integer unsigned

    SQL_INTEGER

    SQL_C_ULONG

    int

    SQL_INTEGER

    SQL_C_SLONG

    int unsigned

    SQL_INTEGER

    SQL_C_ULONG

    mediumint

    SQL_INTEGER

    SQL_C_SLONG

    mediumint unsigned

    SQL_INTEGER

    SQL_C_ULONG

    smallint

    SQL_SMALLINT

    SQL_C_SSHORT

    smallint unsigned

    SQL_SMALLINT

    SQL_C_USHORT

    real

    SQL_FLOAT

    SQL_C_DOUBLE

    double

    SQL_FLOAT

    SQL_C_DOUBLE

    float

    SQL_REAL

    SQL_C_FLOAT

    double precision

    SQL_DOUBLE

    SQL_C_DOUBLE

    date

    SQL_DATE

    SQL_C_DATE

    time

    SQL_TIME

    SQL_C_TIME

    year

    SQL_SMALLINT

    SQL_C_SHORT

    datetime

    SQL_TIMESTAMP

    SQL_C_TIMESTAMP

    timestamp

    SQL_TIMESTAMP

    SQL_C_TIMESTAMP

    text

    SQL_VARCHAR

    SQL_C_CHAR

    varchar

    SQL_VARCHAR

    SQL_C_CHAR

    enum

    SQL_VARCHAR

    SQL_C_CHAR

    set

    SQL_VARCHAR

    SQL_C_CHAR

    bit

    SQL_CHAR

    SQL_C_CHAR

    bool

    SQL_CHAR

    SQL_C_CHAR


    展开全文
  • 楼主自己改好的一个二分类卷积神经网络,识别率已经达到100%,用了900张train集,100张test集 现在我详细记录我的训练过程
  • neuro_net:用于从mnist数据库中识别手写数字的工作进度神经网络
  • 分类者Rede神经 Descrição 修改神经分类学分类法,在通用分类学基础上进行注册(1994年,欧洲联盟)。 每年至少获得5,000万美元的赔偿。 最小权重百分比->基线分类器= 0.7559(ZeroR)。 Resultados-Validaçã...
  • 卷积神经网络超详细介绍

    万次阅读 多人点赞 2018-09-19 10:16:59
    1、卷积神经网络的概念 2、 发展过程 3、如何利用CNN实现图像识别的任务 4、CNN的特征 5、CNN的求解 6、卷积神经网络注意事项 7、CNN发展综合介绍 8、LeNet-5结构分析 9、AlexNet 10、ZFNet 10.1 意义 ...
  • 本文中使用的weka版本为3.6版本,参阅的API也是3.6的 相关的包(weka.jar,weka-src.jar,...在Eclipse项目中导入weka包,本文中使用BP神经网络的算法,只用添加weka.jar即可,若要使用libsvm的算法,还需要添加libs
  • 多层感知机(MLP)(三层)(UCI乳腺癌数据库)(k折交叉验证)(反向传递)(机器学习,神经网络)
  • mnist2digits 这是一个关于如何使用神经网络对手写数字(MNIST 数据库)进行分类的小演示。 为了实现神经网络,我使用了 Neurolab。 为了速度和简单起见,我只对两个数字(1 和 8)进行分类。
  • BP神经网络

    2017-07-01 12:52:37
    BP神经网络实例资源
  • 与以下文章相关的Python脚本和CNN权重:“基于视频监视和卷积神经网络自动创建风暴影响数据库” 数据 两个站点上最佳模型的权重 这两个站点的最佳卷积神经网络的权重在这里可用:
  • Matlab与神经网络工具箱 Matlab 6.0有30个工具箱包,包括 控制系统工具箱(Control System Toolbox) 信号处理工具箱(Signal Processing toolbox) 系统辨识工具箱(System Identification toolbox) 鲁棒控制工具...
  • 使用tensorflow实现的单隐层bp神经网络识别mnist数据库
  • 数据库一共包括90段视频,这些视频分别是由9个人执行了10个不同的动作(bend, jack, jump, pjump, run, side, skip, walk, wave1,wave2)。视频的背景,视角以及摄像头都是静止的。而且该数据库提供标注好的前景...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,988
精华内容 18,795
关键字:

神经网络数据库