毕设_毕设选题 - CSDN
精华内容
参与话题
  • 计算机专业毕设

    2020-07-27 23:32:16
    计算机专业一些毕业设计和论文,里面内容带有代码,供参考。
  • 大学生 计算机 毕业设计 xx管理系统 毕设(1)

    千次阅读 多人点赞 2019-01-21 22:26:09
    计算机专业的毕设,尤其是计科专业,总是脱离不开的简单题目就是xx管理系统,学生宿舍管理系统,仓库管理系统,超市销售管理系统,宠物医院挂号系统,会员卡管理系统,人才管理系统,图书管理系统,社区物业管理系统...

    xx管理系统

    计算机专业的毕设,尤其是计科专业,总是脱离不开的简单题目就是xx管理系统,学生宿舍管理系统,仓库管理系统,超市销售管理系统,宠物医院挂号系统,会员卡管理系统,人才管理系统,图书管理系统,社区物业管理系统,教学信息管理系统等等题目。都9102年了,我相信大部分学校老师给出的依然是这些题目。

    本科生的毕设

    大学生本科毕设还停留在xx管理系统的阶段也是学科教学与学生能力所限,毕竟不用统计大家也清楚身边学计算机的恐怕至少五成是不想编程的。于是出现了很多买毕设的情况,导致我也心痒痒想做这种xx管理系统来收点外快

    但是跑到淘宝一看,开个这种店的何止成百上千,而且手握几百个已经开发好的程序随便一改就拿来卖了

    自己也不善于言辞和沟通,开个店也没有那么多各种项目的积累,又不想跑去给学弟学妹们说给我钱我给你们做毕设吧(当年也是菜鸡,不然真就帮同学做了,室友花了八百买了个辣鸡,还有个女同学花了三千连论文都买了,这钱真是好挣)

    这次开个坑写个专题帮计算机专业的同学脱离毕设的苦海吧。从这个专题写下去,我的目标是,一能学到实际开发的知识(从零教起,从什么都不懂学起);二是能从中懂得这个世界的运行规律(毫不夸张,能在后面讲清楚互联网背后的运作规律是这个系列的另一个目标)

    本系列的计划

    就从做一个管理系统开始写,从基本的工具教起,用2019年还不过时的框架。可能会写的比较慢,也可能会弃坑。
    首先然我们摒弃jsp,.net这些十年前的工具。从流行的前后端分离,vue的前端+spring boot的后端,开始学起吧。
    本次依托于开源的框架,renren-fast,搭建起来的初步展示效果可以参考官方demo,用户名密码admin/admin。
    前端的git地址https://github.com/renrenio/renren-fast-vue,后端的git地址https://gitee.com/renrenio/renren-fast
    这个框架集成了几个常用的工具类框架可以省掉很多事情,并且使用了目前流行的前后端分离的模式和开发框架,十分适合拿来做一个xx管理系统

    那从哪里开始学起呢?

    从最基础的开始学起,对于大部分同学来说,可能看着文档把这个有源码的工程跑起来都是一件很困难的事情。
    所以从开发工具和环境准备开始教起。
    环境准备:
    jdk 1.8
    MySQL
    npm
    git(可选)

    开发工具:
    IDEA
    visual studio code
    Navicat for MySQL (可选)

    我们一个一个开始讲起,jdk,本科阶段肯定大部分学校还是会开设Java相关的课程,有的是大一作为基础编程语言学的,也有的大二大三再补得Java编程,总而言之如果连装Java,配环境变量都没搞过的话。。。还是出门不要说自己学计算机的吧。
    MySQL作为一个开源的数据库,虽然后来被收购了,开源的改名MariaDB了,但是本质还是没变的嘛,就是个传统关系型数据库。
    npm就是搞前端才需要的咯。node.js就是运行在服务端的 JavaScript,npm是一个包管理工具,相当于Java工程的maven。
    git是用来做代码管理的,如果GitHub都没听说过,那出门也别说自己学计算机的。。。

    下面三个工具,idea是最好用的Java IDE,不想用换eclipse也行,visual studio code拿来写前端足够了,换webstorm也行。最后那个数据库管理工具,SQLyog或者别的啥也都可以。

    当然你要是真的什么都不会也没关系,安装包和安装文档我打包放在qq群里了,群号972611583
    也可扫码入群在这里插入图片描述

    展开全文
  • 本课程演示的是一套基于SSM框架实现的在线商城系统,主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 1. 包含:项目源码、项目文档、数据库脚本、软件工具等所有资料 2. 手把手...
  • 本课程演示的是一套基于JavaWeb实现的健身房管理系统,主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 1. 包含:项目源码、项目文档、数据库脚本、软件工具等所有资料 2. 手把手的...
  • 本科游戏设计毕设经历

    千次阅读 2020-08-13 18:45:13
    大学毕设经历   以前其实还没听说过本科毕设有多难,研究生和博士生到是知道难度有些大,在网上听很多人说本科的毕业设计很水,虽然目前为止我还没有答辩,还有一周,但是就我的毕设经历来讲,我觉得本科毕设真的...

    文章目录


    提供了必设源码:https://github.com/abcnull/IndependentPlaneGame
    欢迎大家 star 和 fork

      以前其实还没听说过本科毕设有多难,研究生和博士生到是知道难度有些大,在网上听很多人说本科的毕业设计很水,虽然目前为止我还没有答辩,还有一周,但是就我的毕设经历来讲,我觉得本科毕设真的不简单,也许是网友们实力太强或者是大学检查的很水,或者说我的实力太差了。
      我的毕设是做个游戏APP,起初我本来选题是连连看APP游戏设计,但是后来遇到一点事情说题目重复了要求更换,于是我在4月初的时候去换题目,结果是换成的俄罗斯方块游戏改进也重复了,我便在导师的要求下换了一个类似于“雷霆战机”那样的飞行射击类游戏APP,当时学校没什么事情,我就一直呆在家里,从四月份开始,要知道5月初就要中期检查了,5月中旬还要论文检查之类的,5月底要答辩了,所以说我做这个APP游戏还是时间很紧迫的,所以这段时间一直没有更新CSDN博客,时间都去做毕设了,今天开始的后几天可以连续写博客了。其实我以前只学过一点Android开发,而且忘了很多,Android游戏以前都没做过。
      这次的游戏APP题目是飞机游戏APP设计与实现,幸好我在寒假的时候没有太松懈,复习了Android的一些内容,学习了View的相关知识,还看了网上对于俄罗斯方块的实现(虽然忘了),同时仔细看了安卓游戏从零开始的入门,看了不少东西,对做这么一个题目也不能说完全没有信息。后来我在网上也查过许多的资料,终于在4月快结束的时候基本把项目弄好了。使用的是eclipse,View框架,因为我以前一直用eclipse没用过Android Studio,而且我也没系统的学习过一些游戏引擎,所以只能用View来做游戏,而且View足够用了,虽然逻辑部分可能很复杂。
      还记得我4月份在家做毕业设计,几乎连续12天早上睡醒就直接打开电脑码代码做毕业设计,就这样一直做,做到晚上11点多便去睡觉,除了上厕所偶尔出个门,连吃饭都是在电脑前。4月底终于把项目基本完成,后来我在5月份的时候给项目添加了许多新的功能,而且在5月份前几天先去给另一个老师进行中期检查,老师估计只看了不到一分钟,他直接看了在我手机上运行的游戏的效果,稍微问了几点问题,然后就行了,感觉中期检查好水啊~。当时中期检查我还担心看不看论文,因为我还没写论文,不过幸好中期检查根本不看论文。后来的几天我把论文补上了,一开时论文的格式问题非常让人头痛,什么设置页眉页脚,还有许多需要注意到的格式问题,我调了很久,我还记得我写了2天2夜,包括调整格式,写论文,修改论文,查重等,偶,对了忘了提及了,在写论文前,我添加了许多新功能。论文一开始写了2w多字,然后去查重,发现22%,这个在我意料之外,因为都是我自己写的,竟然这么多重复,后来我把很多句子改的比较刁钻,再一查16%,我还不满意,再改再去查只有5%了。后来我那论文给到时检查,结果导师说不合格,我其实一开始还信心满满的,结果像被破了一票冷的冷水,是我的行间距有问题,再加上由于我过于追求重复率低使得我改的某些句子有点读的不通顺。后来我只得再修改,现在把句子改通顺了,但是改的只剩下1w7的字了,查重是15%,接下来我尽量想办法改到10%以内。导师说10%以内会比较稳。
      现在我谈谈我的项目实现功能,这是一个飞行射击游戏,里头的图片我是从百度图片里头搞的,然后用美图秀秀来抠图(美图秀秀学了半天),游戏进入的界面我后来美化了一下也变得好看了,图片都是从网上弄得然后自己修改。游戏可以设置游戏难度,可以设置音乐,可以查看作者,可以查看玩法,进入游戏,你可以触屏移动控制战斗机,战斗机会一直发射子弹,默认是黄色单发子弹,游戏中有黄色的小敌机,绿色的中敌机,红色的大敌机还有章鱼一样的老板敌机,老板敌机可以发射火球来攻击战斗机,当然老板敌机比较难出现,它是每隔一定时间才会出现,并且界面上只能有一个老板敌机。在游戏中玩家可以获得5中道具,其中有3种是子弹道具,这些子弹道具都是蓝色子弹,子弹道具分别有双发的子弹道具,战斗机为不发射子弹的子弹道具,战斗机两侧发射子弹的子弹道具,还有炸弹道具和生命值恢复道具,在屏幕上点击两下,界面上所有的敌方单位都会爆炸,战斗机最初有3条生命,战斗机每被击中就会变白几帧,每次接收到回血道具就会变绿几帧。音乐是循环播放的,只有背景音乐,没有特效音乐。我还记得当时选音乐时候选了很久,想选一首好听的同时又比较适合的。游戏可以暂停可以重新开始,还可以查看FPS,我是小米5,可以发现非常稳定的维持在60帧/s。
      项目的一些部分是怎么实现的呢?我大致讲一下,因为我在其他博客中会写一点。项目主要是通过View来代表整个游戏界面,在onDraw()中绘制游戏界面,每执行一次绘制其实就是一帧画面,有postinvalidate()方法可以重绘,这个只要在必要时候写就行了。因为手机绘制一帧的画面是非常快的,只要能保证你会的每一帧中图片的位置都不同就行了,在游戏中有许多精灵对象,游戏分三种状态,我只要在游戏进行态时候,执行某一精灵对象的绘制方法,代表该精灵在这一帧中绘制出来了,其实精灵的绘制方法就是安卓graphics包下的drawBitmap之类的方法,将位图绘制在界面上即可,那有人会问,你怎么改变每一帧精灵的位置呢,其实精灵的绘制方法不是直接写drawBitmap之类的,而是分为三个方法,第一个方法负责移动精灵位置,第二个方法负责绘制精灵位置,第三个方法负责检查销毁之类的即可。在游戏进行态的时候,只要战斗机没有被销毁(因为我是根据战斗机是否被销毁来判定游戏是否在结束态),那么最后在执行postinvalidate()方法实现重绘,只要在游戏进行态,就会不断的循环。其中有许多的特殊功能,还不是很好说清楚,一些经验和特殊功能我会在其他博文中写清楚。
      我这个人有点强迫症,有点完美主义,做的不好就非常不安心。接下来的数天我还要改论文,项目做得是差不多了,我也的确做的很累了。项目以后再做些其他的游戏出来,就是通过这次毕设,使我对游戏制作变得非常感兴趣,有时间去学习一下unity3d,再去做做游戏。
      这次毕业设计真的是一个很难得的经历,确实学习到了不少东西。由于我非常怕遗忘,而且我认为经验非常重要,于是写下这篇博文给大家分享我的毕设经历。我码字太快了,一下子就码到这里来,可能有很多错别字还有语句不通的问题,希望提醒(#.#)。

    展开全文
  • 毕设

    2018-06-04 16:05:28
    推荐大家一个靠谱的论文检测平台。重复的部分有详细出处以及具体修改意见,能直接在文章上做修改,全部改完一键下载就搞定了。怕麻烦的话,还能用它自带的降重功能。哦对了,他们现在正在做毕业季活动, 赠送很多...
    推荐大家一个靠谱的论文检测平台。重复的部分有详细出处以及具体修改意见,能直接在文章上做修改,全部改完一键下载就搞定了。怕麻烦的话,还能用它自带的降重功能。哦对了,他们现在正在做毕业季活动, 赠送很多免费字数,可以说是十分划算了!地址是:http://www.paperpass.com/
    展开全文
  • 毕设日志(一)

    千次阅读 2019-03-09 13:12:21
    首先,毕设的大致方向是深度强化学习。具体内容未知。 Q1:我现在的任务是什么? A1:(1)掌握相关的知识,如深度强化学习,图像处理等等,(2)学习相关的论文并复现。 Q2:我现在具体在做什么? A2:了解强化...

    2019.3.5

    现在开始准备做本科毕业设计,将每天的安排和进度记录下来,督促自己。
    首先,毕设的大致方向是深度强化学习。具体内容未知。

    Q1:我现在的任务是什么?
    A1:(1)掌握相关的知识,如深度强化学习,图像处理等等,(2)学习相关的论文并复现。

    Q2:我现在具体在做什么?
    A2:了解强化学习,并用python实现一些小例子。

    Q-learning算法

    Q-Learning别人的代码:
    来自 https://www.cnblogs.com/hhh5460/p/10134018.html

    '''
    -o---T
    # T 就是宝藏的位置, o 是探索者的位置
    '''
    # 作者: hhh5460
    # 时间:20181217
    
    import pandas as pd
    import random
    import time
    
    
    epsilon = 0.9   # 贪婪度 greedy
    alpha = 0.4     # 学习率
    gamma = 0.9     # 奖励递减值
    
    states = range(6)           # 状态集。从0到5
    actions = ['left', 'right'] # 动作集。也可添加动作'none',表示停留
    rewards = [0,0,0,0,0,1]     # 奖励集。只有最后的宝藏所在位置才有奖励1,其他皆为0
    
    q_table = pd.DataFrame(data=[[0 for _ in actions] for _ in states],
                           index=states, columns=actions)
                           
    
    def update_env(state):
        '''更新环境,并打印'''
        global states
        
        env = list('-----T') # 环境,就是这样一个字符串(list)!!
        if state != states[-1]:
            env[state] = 'o'
        print('\r{}'.format(''.join(env)), end='')
        time.sleep(0.1)
                           
    def get_next_state(state, action):
        '''对状态执行动作后,得到下一状态'''
        global states
        
        # l,r,n = -1,+1,0
        if action == 'right' and state != states[-1]: # 除非最后一个状态(位置),向右就+1
            next_state = state + 1
        elif action == 'left' and state != states[0]: # 除非最前一个状态(位置),向左就-1
            next_state = state -1
        else:
            next_state = state
        return next_state
                           
    def get_valid_actions(state):
        '''取当前状态下的合法动作集合,与reward无关!'''
        global actions # ['left', 'right']
        
        valid_actions = set(actions)
        if state == states[-1]:             # 最后一个状态(位置),则
            valid_actions -= set(['right']) # 不能向右
        if state == states[0]:              # 最前一个状态(位置),则
            valid_actions -= set(['left'])  # 不能向左
        return list(valid_actions)
        
    for i in range(13):
        #current_state = random.choice(states)
        current_state = 0
        
        update_env(current_state) # 环境相关
        total_steps = 0           # 环境相关
        
        while current_state != states[-1]:
            if (random.uniform(0,1) > epsilon) or ((q_table.ix[current_state] == 0).all()):  # 探索
                current_action = random.choice(get_valid_actions(current_state))
            else:
                current_action = q_table.ix[current_state].idxmax() # 利用(贪婪)
    
            next_state = get_next_state(current_state, current_action)
            next_state_q_values = q_table.ix[next_state, get_valid_actions(next_state)]
            q_table.ix[current_state, current_action] += alpha * (rewards[next_state] + gamma * next_state_q_values.max() - q_table.ix[current_state, current_action])
            current_state = next_state
            
            update_env(current_state) # 环境相关
            total_steps += 1          # 环境相关
            
        print('\rEpisode {}: total_steps = {}'.format(i, total_steps), end='') # 环境相关
        time.sleep(2)                                                          # 环境相关
        print('\r                                ', end='')                    # 环境相关
            
    print('\nq_table:')
    print(q_table)
    

    先看懂别人的代码,了解一下强化学习。
    这段代码比较简单,

    例子的环境是一个一维世界,在世界的右边有宝藏,探索者只要得到宝藏尝到了甜头,以后就记住了得到宝藏的方法,这就是他用强化学习所学习到的行为。
    Q-learning 是一种记录行为值 (Q value) 的方法,每种在一定状态的行为都会有一个值 Q(s, a),就是说 行为 a 在 s 状态的值是 Q(s, a)。s 在上面的探索者游戏中,就是 o 所在的地点了。而每一个地点探索者都能做出两个行为 left/right,这就是探索者的所有可行的 a 啦。

    Q-learning算法的关键在于Q值的更新。

    用的是时间差分方法

    时间差分方法

    这里看了好多遍,做下整理。
    假设有两种状态 s1,s2, 两种行为a1,a2。

    Q a1 a2
    s1 0 1
    s2 0 2

    无论在s1还是在s2中,a2的奖励都要比a1要高。
    当处于状态s1时,大概率选择行为a2。假设s1选择a2之后就到了s2,如何更新Q(s1,a2)的值?

    Q(s2, a2) 的值比 Q(s2, a1) 的大,所以我们把大的值乘上一个衰减值 gamma (比如0.9) 并加上到达 s2 时所获取的奖励 R(eward),奖励R是自己设计的
    将这个作为我现实中 Q(s1, a2) 的值,之前是根据 Q 表估计 Q(s1, a2) 的值。
    所以有了现实和估计值,我们就能更新Q(s1, a2),根据估计与现实的差距,将这个差距乘以一个学习效率 alpha 累加上旧的 Q(s1, a2) 的值,变成新的值。

    Q learning 的重点就是在 Q(s1, a2) 现实中,也包含了一个 Q(s2) 的最大估计值,
    将对下一步的衰减的最大估计和当前所得到的奖励当成这一步的现实。

    最后总结这套算法中一些参数的意义。

    1. Epsilon Greedy 是用在决策上的一种策略,比如 epsilon = 0.9 时, 就说明有 90% 的情况我会按照 Q 表的最优值选择行为,10% 的时间使用随机选行为,这样做的目的是让其有机会跳出局部最优。

    2. alpha是学习率,来决定这次的误差有多少要被学习的,alpha是一个小于1 的数。

    3. gamma 是对未来 reward 的衰减值。

    结合了蒙特卡罗的采样方法和动态规划方法的bootstrapping(利用后继状态的值函数估计当前值函数)使得他可以适用于model-free的算法并且是单步更新,速度更快。值函数计算方式如下

    V(s)←V(s)+α(Rt+1+γV(s′)−V(s))

    其中Rt+1+γV(s′) 被称为TD目标,δt=Rt+1+γV(s′)−V(s)δt​=Rt+1​+γV(s′)−V(s) 称为TD偏差。

    具体介绍:https://zhuanlan.zhihu.com/p/25913410

    2019.3.6

    迷宫

    今天学习一下 pyqt5 的作图,然后根据 https://www.cnblogs.com/hhh5460/p/10145797.html 的代码自己用pyqt5做一个迷宫。初步构思是用三个类,迷宫图形,Q-learning算法和main主程序。

    一步一步来。

    借鉴了这位博主 https://www.cnblogs.com/hhh5460/p/10145797.html 的文章,我用pyqt5重做了一下,样子跟他差不多

    在这里插入图片描述
    接下来要完成的是
    1)玩家的移动,也就是红色圆圈的移动,要用到self.update()函数
    2)Q-Learning算法,能不能写一个效率较高的算法?加一点自己的理解,比如终点在玩家的左下方,我可不可以让玩家在没有头绪的时候,也就是Q值都差不多的时候给他一点明确的方向?这样做有没有副作用?

    2019.3.7

    大致完成了,还有一点小问题。
    我把迷宫改了一下

    在这里插入图片描述

    游戏分为两个阶段:learn 和 play。这两个阶段都在另一个线程里完成,与主界面分离,每次执行一步就返回一个消息 msg,主界面每次接受信号就刷新界面,红色小球移动一格。

    部分代码:
    maze_graph.py

    import sys
    from PyQt5 import QtCore
    from PyQt5.QtWidgets import QWidget, QApplication
    from PyQt5.QtGui import QPainter, QColor, QBrush, QPen, QFont
    from PyQt5.QtCore import Qt, QThread, pyqtSignal
    import time
    from gl import *
    from maze_Q_learning import Agent
    
    
    class Example(QWidget):
        def __init__(self):
            super().__init__()
            self.initUI()
    
        def initUI(self):
            self.setGeometry(300, 300, W, H)
            self.setWindowTitle("maze")
            self.search_imfomation_from_maze()
    
            self.learning = TrainModel()
            self.learning._signal.connect(self.callbacklog)
            self.learning.start()
    
            self.show()
    
        def paintEvent(self, e):
            qp = QPainter()
            qp.begin(self)
            self.drawLines(qp)
            self.drawTrap(qp)
            self.drawTreasure(qp)
            self.drawStartEnd(qp)
            self.drawPlayer(qp)
            qp.end()
    
        def search_imfomation_from_maze(self):
            self.traps_location = []
            self.treasure_locations = []
            for i in range(MAZE_H):
                for j in range(MAZE_W):
                    if MAZE[i][j] == 1:
                        self.traps_location.append([i, j])
                    elif MAZE[i][j] == 2:
                        self.treasure_locations.append([i, j])
                    elif MAZE[i][j] == -1:
                        self.start = [i, j]
                    elif MAZE[i][j] == 3:
                        self.end = [i, j]
            self.state = self.start[:]
    
        def drawLines(self, qp):
            pen = QPen(Qt.black, 1, Qt.SolidLine)
            qp.setPen(pen)
            for c in range(0, W, UNIT):
                qp.drawLine(c, 0, c, H)
            for r in range(0, H, UNIT):
                qp.drawLine(0, r, W, r)
    
        def drawTrap(self, qp):
            pen = QPen(Qt.white, 1, Qt.SolidLine)
            qp.setPen(pen)
            qp.setBrush(QColor(800, 0, 0))
            for trap in self.traps_location:
                qp.drawRect(PADDING + UNIT * trap[1], PADDING + UNIT * trap[0], UNIT - PADDING * 2,
                            UNIT - PADDING * 2)  ##(起点坐标,终点坐标,长,宽)
    
        def drawTreasure(self, qp):
            pen = QPen(Qt.white, 1, Qt.SolidLine)
            qp.setPen(pen)
            qp.setBrush(QColor(220, 250, 0))
            for treasure in self.treasure_locations:
                qp.drawRect(PADDING + UNIT * treasure[1], PADDING + UNIT * treasure[0], UNIT - PADDING * 2,
                            UNIT - PADDING * 2)  ##(起点坐标,终点坐标,长,宽)
    
        def drawStartEnd(self, qp):
            qp.setPen(QColor(800, 0, 0))
            qp.setFont(QFont("Decorative", 10))
            qp.drawText(PADDING + UNIT * self.start[1], PADDING + UNIT * self.start[0], UNIT - PADDING * 2,
                        UNIT - PADDING * 2, Qt.AlignCenter, '起点')
            qp.drawText(PADDING + UNIT * self.end[1], PADDING + UNIT * self.end[0], UNIT - PADDING * 2,
                        UNIT - PADDING * 2, Qt.AlignCenter, '终点')
    
        def drawPlayer(self, qp):
            pen = QPen(Qt.white, 2, Qt.SolidLine)
            qp.setPen(pen)
            qp.setBrush(QColor(255, 0, 0))
            qp.drawEllipse(PADDING + UNIT * self.state[1], PADDING + UNIT * self.state[0], UNIT - PADDING * 2,
                           UNIT - PADDING * 2)
    
        def callbacklog(self, msg):
            self.state[0] = msg // MAZE_W
            self.state[1] = msg % MAZE_W
            # print("state", self.state)
            # print("------------------------------")
            self.update()
    
    
    class TrainModel(QThread):
        _signal = pyqtSignal(int)
        agent = Agent()
    
        def __int__(self):
            super(TrainModel, self).__init__()
    
        def run(self):
            print("--------Learning---------")
            for i in range(40000):
                self.agent.learn_step_by_step()
                msg = self.agent.return_msg
                self._signal.emit(msg)
                # time.sleep(0.2)
    
            print("--------Playing----------")
            for i in range(50):
                time.sleep(1)  # stop for watching
                if i == 0: # restart
                    self.agent.learn_step_by_step(epsilon=1, start_=True)
                else:
                    self.agent.learn_step_by_step(epsilon=1)
                msg = self.agent.return_msg
                self._signal.emit(msg)
    
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        ex = Example()
        sys.exit(app.exec_())
    

    gl.py

    import pandas as pd
    
    """
        Only need to change these constant
    """
    
    UNIT = 40  # pixels
    PADDING = 5
    MAZE_H = 9  # grid height
    MAZE_W = 12  # grid width
    H = MAZE_H * UNIT + 1  # height
    W = MAZE_W * UNIT + 1  # weight
    
    STATES = range(MAZE_H * MAZE_W)
    ACTIONS = list('udlr')
    # MAZE = [[-1, 1, 1, 0, 0, 0, ],
    #         [0, 1, 0, 0, 1, 0, ],
    #         [0, 1, 0, 1, 0, 0, ],
    #         [0, 0, 0, 1, 0, 0, ],
    #         [0, 1, 0, 1, 2, 0, ],
    #         [0, 0, 0, 1, 0, 3, ]]
    
    MAZE = [[-1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0],
            [0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1],
            [0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0],
            [0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0],
            [0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0],
            [1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0],
            [0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0],
            [1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0],
            [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 3], ]
    
    REWARDS = {
        -1: 0,
        0: 0,
        1: -10,
        2: 2,
        3: 20}
    #  -1:start
    #  0: path
    #  1:trap  -10point
    #  2:treasure   2point
    #  3:end    20point
    
    Q_TABLE = pd.DataFrame(data=[[0 for _ in ACTIONS] for _ in STATES],
                           index=STATES,
    

    学习的时候我设定的步数是40000,epsilon=0.7,学习完以后根据Q表策略进行游戏,看看在50步以内能不能完成,此时epsilon=1。

    结果还可以,小球在play的时候可以以最短路径到达终点。我做这个只是方便自己理解Q-learning,包括Q值的更新和参数对它的影响,这些可以比较直观的看出来。但是还有些问题。

    1)我发现奖惩的数值对游戏的影响特别大,这在设计其他的东西时也要注意。

    2)还有,Q-learning是一种model-free(不用学习环境模型)的基于off-policy(学习过程中执行的策略与值估计使用的策略不一样)的temporal difference(TD)方法。而我的代码只是在线学习,并没有将策略存储到本地,学习时随机选择策略。这就导致很可能会陷入局部最优解。就像我一开始加入奖励区域时,小球会不断地进出奖励区域,从而陷入死循环。

    3)这是第一行12个小格子的Q值

                 u          d          l          r
    0     0.000000   5.261027   0.000000  -6.254604
    1     0.000000  -6.244355   4.639746  -7.812449
    2     0.000000  -5.921415  -6.853677   6.729724
    3     0.000000   6.470706  -4.861265   7.546971
    4     0.000000  -3.667872   6.746933   7.944251
    5     0.000000  -2.672183   6.776512   8.362396
    6     0.000000   8.802530   7.364814  -0.158281
    7     0.000000  -5.032490   2.276062  11.366744
    8     0.000000  10.487153   0.417934  11.974739
    9     0.000000   2.338169  11.146606  12.604988
    10    0.000000  13.268409  11.828161  10.586115
    11    0.000000  -0.490233  12.289693   0.000000
    

    可以发现有陷阱的那一个方向的值基本都是负的,但是往回走的值仅仅比正确方向的值略小,说明在学习的时候走了很多弯路,浪费了很多时间。

    Q1:接下来要做什么?
    A1:学习DQN,改进程序。具体要做的是:复习tensorflow,神经网络,将算法改成离线学习,优化算法提高效率,最主要的是将效率数值化,怎么评估他的学习速度。

    2019.3.8

    先复习tensorflow基础

    从官网 http://www.tensorfly.cn/tfdoc/get_started/basic_usage.html 上了解到:

    TensorFlow

    使用 TensorFlow, 你必须明白 TensorFlow:

    使用图 (graph) 来表示计算任务.
    在被称之为 会话 (Session) 的上下文 (context) 中执行图.
    使用 tensor 表示数据.
    通过 变量 (Variable) 维护状态.
    使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据.
    

    综述

    TensorFlow 是一个编程系统, 使用来表示计算任务. 图中的节点被称之为 op (operation 的缩写). 一个 op 获得 0 个或多个 Tensor, 执行计算, 产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组. 例如, 你可以将一小组图像集表示为一个四维浮点数数组, 这四个维度分别是 [batch, height, width, channels].

    一个 TensorFlow 图描述了计算的过程. 为了进行计算, 图必须在 会话 里被启动. 会话 将图的 op 分发到诸如 CPU 或 GPU 之类的 设备 上, 同时提供执行 op 的方法. 这些方法执行后, 将产生的 tensor 返回. 在 Python 语言中, 返回的 tensor 是 numpy ndarray 对象; 在 C 和 C++ 语言中, 返回的 tensor 是 tensorflow::Tensor 实例.

    构建图

    import tensorflow as tf
    
    # 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点
    # 加到默认图中.
    #
    # 构造器的返回值代表该常量 op 的返回值.
    matrix1 = tf.constant([[3., 3.]])
    
    # 创建另外一个常量 op, 产生一个 2x1 矩阵.
    matrix2 = tf.constant([[2.],[2.]])
    
    # 创建一个矩阵乘法 matmul op , 把 'matrix1' 和 'matrix2' 作为输入.
    # 返回值 'product' 代表矩阵乘法的结果.
    product = tf.matmul(matrix1, matrix2)
    

    启动图

    # 启动默认图.
    sess = tf.Session()
    
    # 调用 sess 的 'run()' 方法来执行矩阵乘法 op, 传入 'product' 作为该方法的参数. 
    # 上面提到, 'product' 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回
    # 矩阵乘法 op 的输出.
    #
    # 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.
    # 
    # 函数调用 'run(product)' 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.
    #
    # 返回值 'result' 是一个 numpy `ndarray` 对象.
    result = sess.run(product)
    print(result)
    # ==> [[ 12.]]
    
    # 任务完成, 关闭会话.
    sess.close()
    

    Session 对象在使用完后需要关闭以释放资源. 除了显式调用 close 外, 也可以使用 “with” 代码块 来自动完成关闭动作.

    with tf.Session() as sess:
      result = sess.run([product])
      print result
    

    变量

    Variables for more details. 变量维护图执行过程中的状态信息. 下面的例子演示了如何使用变量实现一个简单的计数器. 参见 变量 章节了解更多细节.

    # 创建一个变量, 初始化为标量 0.
    state = tf.Variable(0, name="counter")
    
    # 创建一个 op, 其作用是使 state 增加 1
    
    one = tf.constant(1)
    new_value = tf.add(state, one)
    update = tf.assign(state, new_value)
    
    # 启动图后, 变量必须先经过`初始化` (init) op 初始化,
    # 首先必须增加一个`初始化` op 到图中.
    init_op = tf.initialize_all_variables()
    
    # 启动图, 运行 op
    with tf.Session() as sess:
      # 运行 'init' op
      sess.run(init_op)
      # 打印 'state' 的初始值
      print(sess.run(state))
      # 运行 op, 更新 'state', 并打印 'state'
      for _ in range(3):
        sess.run(update)
        print(sess.run(state))
    
    # 输出:
    
    # 0
    # 1
    # 2
    # 3
    

    Fetch

    为了取回操作的输出内容, 可以在使用 Session 对象的 run() 调用 执行图时, 传入一些 tensor, 这些 tensor 会帮助你取回结果. 在之前的例子里, 我们只取回了单个节点 state, 但是你也可以取回多个 tensor:

    input1 = tf.constant(3.0)
    input2 = tf.constant(2.0)
    input3 = tf.constant(5.0)
    intermed = tf.add(input2, input3)
    mul = tf.mul(input1, intermed)
    
    with tf.Session():
      result = sess.run([mul, intermed])
      print result
    
    # 输出:
    # [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]
    

    Feed

    上述示例在计算图中引入了 tensor, 以常量或变量的形式存储. TensorFlow 还提供了 feed 机制, 该机制 可以临时替代图中的任意操作中的 tensor 可以对图中任何操作提交补丁, 直接插入一个 tensor.

    feed 使用一个 tensor 值临时替换一个操作的输出结果. 你可以提供 feed 数据作为 run() 调用的参数. feed 只在调用它的方法内有效, 方法结束, feed 就会消失. 最常见的用例是将某些特殊的操作指定为 “feed” 操作, 标记的方法是使用 tf.placeholder() 为这些操作创建占位符.

    
    input1 = tf.placeholder(tf.types.float32)
    input2 = tf.placeholder(tf.types.float32)
    output = tf.mul(input1, input2)
    
    with tf.Session() as sess:
      print(sess.run([output], feed_dict={input1:[7.], input2:[2.]}))
    
    # 输出:
    # [array([ 14.], dtype=float32)]
    

    看完基础待会再看CNN。

    头疼,还是keras简单。。

    学习一下 交叉熵损失函数 ,这个看到过很多次了

    交叉熵

    先记住公式:L=−[ylog y^+(1−y)log (1−y^)]

    查了一些资料,发现还是从 信息论的角度去理解比较好
    资料来源:https://blog.csdn.net/weixin_37567451/article/details/80895309

    主要搞清楚两个问题:

    1. 什么是交叉熵?
    2. 为什么要用交叉熵?

    交叉熵原来是用来估算平均编码长度的。给定两个概率分布p和q,通过q来表示p的交叉熵为:
    在这里插入图片描述
    什么意思?它刻画的是通过概率分布q来表达概率分布p的困难程度,p代表正确答案,q代表的是预测值,交叉熵越小,两个概率的分布越接近。

    而神经网络模型的最后通常会经过一个 Sigmoid 函数,输出一个概率值。

    Sigmoid 函数图形如下所示:

    在这里插入图片描述
    这样就把神经网络的输出也变成了一个概率分布,从而可以通过交叉熵来计算预测的概率分布和真实答案的概率分布之间的距离了。

    举个例子,假设有一个3分类问题,某个样例的正确答案是(1,0,0),这个模型经过softmax回归之后的预测答案是(0.5,0.4,0.1),那么预测和正确答案之间的交叉熵为:

    在这里插入图片描述
    如果另一个模型的预测是(0.8,0.1,0.1),那么这个预测值和真实值之间的交叉熵是:

    在这里插入图片描述

    为什么要用交叉熵来做损失函数,不用MSE(Mean Squared Error)?

    先记住结论:只有当损失函数为凸函数时,梯度下降算法才能保证达到全局最优解,MSE的损失函数是非凸函数,在分类问题中,并不是一个好的损失函数。相对MSE而言,交叉熵曲线整体呈单调性,损失越大,梯度越大。便于梯度下降反向传播,利于优化。所以一般针对分类问题采用交叉熵作为损失函数。

    TensorFlow实现交叉熵

    cross_entropy=-tf.reduce_mean(y_*tf.log(tf.clip_by_value(y,1e-10,1.0)))
    

    其中y_就代表p,也就是正确结果(或者说标签),y代表q,也就是预测结果(或者说实际输出)。

    这里的tf.reduce_mean()是求一个平均值,具体是这样的:

    1. tf.reduce_mean(x):就是求所有元素的平均值;

    2. tf.reduce_mean(x,0):就是求维度为0的平均值,也就是求列平均;

    3. tf.reduce_mean(x,1):就是求维度为1的平均值,也就是求行平均。

    这里的tf.clip_by_value(v,a,b):表示把v限制在a~b的范围内,小于a的让它等于a,大于b的让它等于b.

    因为交叉熵一般会与softmax回归一起使用,所以TensorFlow对这两个功能进行了同一封装,并提供了tf.nn.softmax_cross_entropy_with_logits函数。比如可以直接通过以下代码实现了sotfmax回归之后的交叉熵损失函数:

    cross_entropy=tf.nn.sparse_sotfmax_cross_entropy_with_logits(label=y_,logits=y)
    

    再问几个问题

    1. 激活函数的作用?
    2. 为什么要用sigmoid函数作为激活函数?
    3. 还有什么激活函数?

    如果不用: 每一层输出都是上层输入的线性函数,无论神经网络有多少层,输出都是输入的线性组合

    如果用: 激活函数给神经元引入了非线性因素,使得神经网络可以任意逼近任何非线性函数,这样神经网络就可以应用到众多的非线性模型中。

    sigmoid

    优点:

    1. sigmoid函数也叫 Logistic 函数,用于隐层神经元输出,取值范围为(0,1),它可以将一个实数映射到(0,1)的区间,可以用来做二分类。
    2. 在特征相差比较复杂或是相差不是特别大时效果比较好。

    缺点

    1. 激活函数计算量大,反向传播求误差梯度时,求导涉及除法
    2. 反向传播时,很容易就会出现梯度消失的情况,从而无法完成深层网络的训练
    3. Sigmoids函数饱和且kill掉梯度。
    4. Sigmoids函数收敛缓慢。

    为何会出现梯度消失?:

    反向传播算法中,要对激活函数求导,sigmoid 的导数表达式为:

    在这里插入图片描述
    sigmoid 原函数及导数图形如下:

    在这里插入图片描述导数从 0 开始很快就又趋近于 0 了,易造成梯度消失现象。

    除此之外,还有 ReLU,softmax 等等激活函数。

    展开全文
  • 毕设问题汇总

    千次阅读 2019-05-14 20:13:28
            我毕业设计做的是芯片引脚缺陷检测,用的是halcon+MFC,...这里主要将我做的毕设的过程,以及在这过程中遇到的问题记录下来,留作以后参考,也算是经验的积累。 描述一:在检测引脚平...
  • unity游戏毕设

    千次阅读 2017-10-10 15:06:12
    想做一个赛车游戏,在这里记录unity的学习资料,以便查寻。
  • 毕设选题深度学习

    千次阅读 2017-12-17 00:49:17
    MARK
  • 毕设论文阶段总结

    千次阅读 2019-02-26 21:09:11
    毕设论文总结
  • 毕设题目——个性化推荐系统

    千次阅读 2010-01-12 19:53:00
    导师今天把题目发过来了,个性化推荐系统。听说实验室在这方面已经有很长时间的积累了,今年还有一篇个性化推荐的论文被CIKM录用为长文。希望我能做出点儿对得起人的东西。
  • 很不错的ppt模板,毕设答辩用

    千次下载 热门讨论 2020-06-30 23:30:33
    适合中期答辩用的,效果不错,简单简洁,都是优秀
  • 慎选算法类毕设

    千次阅读 2019-04-24 23:21:50
    别说了都是泪,查重很难过的 推荐大家一个靠谱的论文检测平台。重复的部分有详细出处以及具体修改意见,能直接在文章上做修改,全部改完一键下载就搞定了。怕麻烦的话,还能用它自带的降重功能。...
  • 如果毕设挂了

    千次阅读 2005-06-02 13:53:00
    注册费1700试读费1700毕设18*66=1200一共4600
  • Android毕设

    千次阅读 2019-04-30 15:48:34
    1. 基于MVC的设计 Android studio开发 2. Android Material Design风格 3. GreenDao本地数据,实现数据的增删查改 4. Tablayout+ViewPager实现首页切换 5. RecycleView用于显示列表 6. Intent跳转传参 ...
  • 一个社区app应用,从程序员角度说,开发前需要准备什么呀?例如,程序框架需要怎么做啊?
  • 以设带学
  • 今天在实现温湿度提取的过程中,在这个小车搭载摄像头识别的毕业设计中,遇到了Python中 字符串 “0” 与 数字0区别,决定把这个区别给他搞清楚,于是写了这篇文章。 董付国老师的教程 Python编程一定要注意的那些...
  • 这个月应该是可以完成的,加油!
1 2 3 4 5 ... 20
收藏数 25,383
精华内容 10,153
关键字:

毕设