log以2为底（x+1）的对数函数 步骤越详细越好 必要时请注明原因 谢谢_百度知道
log以2为底（x+1）的对数函数 步骤越详细越好 必要时请注明原因 谢谢
log以2为底（x+1）的对数函数
步骤越详细越好
必要时请注明原因
答题抽奖
首次认真答题后
即可获得3次抽奖机会，100%中奖。
换底公式x*lg3/lg2=1x=lg2/lg3所以x=log3(2)
x的取值范围是多少
采纳率：81%
来自团队：
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。噢哦，这个页面找不到了
下载作业帮可以找到更多答案log以2为底2x＋1的对数的图像。怎么画，求图！_百度知道
log以2为底2x＋1的对数的图像。怎么画，求图！
log以0.5为底2x－3的对数图像你会吗
你是学生？
上海政法学院
2的2x次方＝12怎么解方程
我不玩微信。。
还是那个号，你加我时写下备注
采纳率：54%
为您推荐：
其他类似问题
对数的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。登录网易通行证
使用网易通行证(含网易邮箱)帐号登录
提交您的投诉或建议
视频画面花屏
视/音频不同步
播放不流畅
分享给朋友:
扫描分享给微信好友和朋友圈
扫一扫分享给微信好友和朋友圈
通过代码可以让这个视频在其它地方上播放！
复制FLASH代码
复制HTML代码
复制页面地址
使用公开课APP下载视频
扫描二维码 手机继续看
扫描二维码在手机上继续观看，
还可分享给您的好友。
没有公开课客户端？
登录后才能查看我的笔记
暂时没有笔记!
确定删除笔记？
即将播放下一集，请您保存当前的笔记哦！
对字幕纠错要登录哦！
内容不能少于3个字
7x=14这一类线性方程的解法。两侧同时除以x项系数即可。这一节还讲了多个例子，并深通俗地进行了讲解。
3x+5=17这类线性方程的解法。两侧同时减去5，然后得到上一节中的方程求解。这一节还讲了多个例子，并深通俗地进行了讲解。
2x+3=5x-2这类线性方程的解法。需要同时加2，然后得到上一节中的方程求解。这一节还讲了多个例子，并深通俗地进行了讲解。
3/x=5这类，形如分式的方程的求法。这类方程本质上仍然是线性方程。这一节还讲了多个例子，并深通俗地进行了讲解。
如3x+2&1这类不等式的求法，这类不等式同线性方程求法一样，只是需要注意两侧同时乘以或除以负数时，不等号要改变。这一节还讲了多个例子，并深通俗地进行了讲解。
6 直线绘图
直线方程的一般表示为y=mx+b。一元线性方程，在坐标系中的几何表示为直线同x轴交点，即y=0。这一节讲解直线的绘图方法，图解对代数问题非常重要。这一节还讲了多个例子，并深通俗地进行了讲解。
7 斜率及y轴截距程序演示
这一节用可汗网站上的一个自主开发程序演示了斜率m变化，和y轴截距b变化时，直线所产生的变化。让学生对直线方程y=mx+b有更深刻的认识。
8 斜率求法
已知两点(x1,y1)和(x2,y2)，连接两点的直线，斜率m为(y2-y1)/(x2-x1)，或者说Δy/Δx。这一节就是以多个例题通俗讲解这一内容。
9 y轴截距求法
求出斜率后，通过将其中任意一点代入已知斜率的直线方程，就能求出y轴截距。这一节就是以多个例题通俗讲解这一内容。
10 直线方程
斜率m和y轴截距b求出后，直线方程y=mx+b就能求出。这一节就是以多个例题通俗讲解这一内容。
11 直线方程(续)
这一节是上一节的延续，继续通过多个例题通俗讲解并教熟练掌握直线方程求法。
12 直线方程程序演示
这一节使用可汗网站上的自主开发程序演示直线方程的变化，并同之前讲的直线方程求法综合起来。进一步加深学生对直线方程的认识。
已知4次考试后，平均分为84分，第5次要考多少分，才能让平均分达到88分？通过这样的问题讲解平均值，关键是代数在其中的运用。
14 整数求和
5个连续整数之和为200，那么其中最小的整数是多少？通过这样的问题，这一节讲解了整数求和的问题，关键还是代数的运用。
40的15%是多少？多少的15%是40？这两个题千万别搞混。这一节讲百分比问题，关键还是代数的运用。如何设未知数，如何解方程。
16 百分比增长
股市中价格会增长或减少，你在股市中的钱也会增值或缩水，具体怎么通过百分比来计算呢？这就是这一节的内容。
17 打折问题
水果店今天水果优惠30%，买6个12.60美元。明天不打折，我还要按原价买2个，那需要多少钱？这是一个百分数问题，也是一个代数问题，如何列方程求解就是这一节的内容。
18 更多百分数问题
股市今天上涨15%，明天下跌15%，你股市中的钱是涨是跌还是没变？这一节中将揭开答案。这一节还有其它一些百分数问题，帮助更深刻认识百分数。
y＝ax＋b，y＝cx＋d是两条直线方程，将其联立就是一个线性方程组。解线性方程组的本质就是求直线交点。这一节通过多个例子讲解这一问题。
农场的马和狗之比，班上的男女生之比，这就是比率。这一节讲了比率的表示，以及基本运算方法。举了一些通俗易懂的例子。
班上有55名学生，男女的比率是4：7，然后班上要新来多少女生，才能让男女比变成1：2？这是一个比率问题，同时是一个代数问题，这类问题就是这一节的主题。
苹果和橘子之比为5：8，拿走15个苹果，比率变成1：4，拿走苹果后总共有多少水果？这是一个比率问题，同时是一个代数问题，这类问题就是这一节的主题。
苹果和橘子之比为5：8，拿走15个苹果，比率变成1：4，拿走苹果后总共有多少水果？还是这个题，为了让大家跟深刻理解，这一节用了与上一节截然不同的方法，这种方法显然更加有效。
这一节依然是比率的代数问题，使用列方程组的方法比一般代数方法更直观明了，观看这一节之后，对比率的求法会更清晰。
比率问题稍微变化一下，形式可以非常多样，这一节又深入浅出地讲了一些比率问题，加深对比率的认识。
4年后，阿里的年龄将是今天的3倍，问阿里今年多少岁？这类问题是这一节的主题，关键还是在于列方程解题这种代数应用。
萨尔曼108岁，乔纳森24岁，多少年后萨尔曼是乔纳森年龄的4倍？这类问题是这一节的主题，关键还是在于列方程解题这种代数应用。
现在塔鲁什年龄是阿尔曼的5倍，85年前塔鲁什年龄是阿尔曼的10倍，问现在阿尔曼多大年纪？这类问题是这一节的主题，关键还是在于列方程解题这种代数应用。
（x＋2）（x＋3）怎么求，想想A（x＋3）就清楚了，可以将x＋2看作A。这类问题是这一节的主题，这一节还讲了其它几个例子。
x²＋6x＋8＝0怎么求，因式分解为（x＋A）（x＋B）＝0，然后x＝－A或x＝－B，具体求法这一节给出了一种需要练习的方法，具体原因还需要后面视频来了解。
i不是实数，它是比π、e这些更难懂，更奇妙的数。定义为根号－1。这一节求出i的0次方、1次方、2次方、3次方、4次方…并找出这些次幂的规律所在。
i的任意次方，在1、i、－1、－i之间循环。根据这个规律i的7321次方等于多少呢？这一节讲了很多这样的例子。
[第33课]i等于根号-1
很多人说i不能定义为－1的算术平方根，因为－1＝i·i＝根号－1乘以根号－1等于根号（－1·（－1））＝根号1＝1。－1＝1显然矛盾。这是为什么呢？这就是这一节的主题。
复数也就是实数和虚数复合在一起的数，形如a＋bi，其中a和b都是实数。a称作复数的实部、bi称作复数的虚部。两个复数相加、相减、相乘如何求解是这一节的主题。
这一节仍然讲复数，是上一节的延续。这一节主要关注复数除法，复数除法比实数除法复杂得多。并需要引入共轭复数的概念。这一节会给出例子。
之前学习过使用因式分解解二次方程Ax²＋Bx＋C＝0。这一节引入公式法解二次方程，这才是二次方程的一般方法。然后举出了一些公式法解方程的例子。
这一解还是讲解二次公式【－B±根号（B²－4AC）】／（2A），这是二次方程中最重要的公式。这一节继续举了一些例子，便于大家更好掌握二次公式。
（x＋a）²＝x²＋2ax＋a²，这个式子是配方的基础。配方也就是将任意一个二次方程，配成（x＋a）²＝b的形式，然后两侧同时开方求解。这是二次方程解法的基础，也是原理。这一节举了几个通俗的例子。
二次公式【－B±根号（B²－4AC）】／（2A），这是二次方程的一般解法。这一节通过上一节讲的配方，证明了二次公式是怎么来的。
Ax²＋Bx＋C＜0或Ax²＋Bx＋C＞0这样的不等式，解法基于对应二次方程Ax²＋Bx＋C＝0，先求出方程两根，然后根据不等式关系求解。这一节举了几个深入浅出的例子。
这一节是上一节的延续，继续讲二次不等式。不同的是，这一节引入图解，让学生更直观地感受为什么二次不等式的解是那样。这一节举了几个深入浅出的例子。
这一节讲函数的概念，说明其实函数就是黑箱，往其中输入一个内容，它会经过黑箱操作，输出一个内容。还讲到了函数的几种特殊用途。
f（x）＝x²＋1，g（x）＝2x＋f（x－3），h（x）＝5x，求h（g（3））。这一类问题就是这一解的函数问题，主要落脚于数例，帮助更好理解函数的概念。
这一节继续讲函数例题，通过图像定义了一个函数，然后和其它代数式定义的函数结合，讲解一些例题。
函数概念难懂且类型丰富，所以函数例题越多越有助于理解。这一节继续讲函数例题：f（g（x））＝（2倍根号（x＾2＋1）－1）／（根号（x＾2＋1）＋1），而f（x）＝（2x－1）／（x＋1），求g（x）。
函数的定义域，也就是让函数有定义的所有x的集合。比如f（x）＝1／x时，定义域为｛x∈R|x≠0｝；比如根式下为非负数，这些。这一节详细讲解了一些例题。
这一节开始证明对数的第一个性质，即logA＋logB＝logAB。对数的本质也就是求幂中的指数，同底两式相乘，底数不变，指数相加，这一指数性质，表示在对数中就是logA＋logB＝logAB。这一节给出了详细的证明。
这一节证明对数的另外两个性质，AlogB＝log（B＾A）和logA－logB＝log（A／B）。对数的本质也就是求幂中的指数，同底两式相乘，底数不变，指数相加。鉴于此，这一节给出了对数性质的详细证明。
这一节证明对数的另外一个性质，log＿A（B）＝（log＿x（B））／（log＿x（A））。对数的本质也就是求幂中的指数，同底两式相乘，底数不变，指数相加。鉴于此，这一节给出了对数性质的详细证明。
8x³－7x²＋10x－5除以2x＋1怎么算？这一节通过一个例子讲解多项式除法的运算，指出它同整数除法的相似之处。讲清楚了这种除法的具体意义。
圆锥曲线也就是圆、椭圆、抛物线、双曲线的统称。为什么这么叫，这些曲线之间有什么关联呢？这一节通过图像直观讲解了这些问题。
圆的方程是x²＋y²＝r²，其中r为半径。平移之后圆的方程为（x－a）²＋（x－b）²＝r²，圆心的坐标是（a，b）。这一节从图像平移的观点解释了这个内容。
椭圆方程为x²／a²＋y²／b²＝1，其中a为x半轴长、b为y半轴长。圆是椭圆的特例。这一节讲解了椭圆的方程，以及平移等问题，以及其它基础性内容。
双曲线方程为x²／a²－y²／b²＝1或－x²／a²＋y²／b²＝1，可能是上下开口，也可能是左右开口。这一节讲解了渐近线的求法，以及判别开口方向的直观方法。
双曲线方程为x²／a²－y²／b²＝1或－x²／a²＋y²／b²＝1，可能是上下开口，也可能是左右开口。这一节主要是通过一个特定的双曲线例子，讲解了上一节所使用的方法。
这一节讲双曲线平移后的绘图方法，首先求平移后的中心位置，然后作渐近线，然后确定开口方向，然后绘图。这一节仍然是通过实例讲解。
9x²+4y²+54x-8y+49=0是哪种圆锥曲线的方程？这一节讲了快速辨别圆锥曲线种类的办法，同时讲了如何化成标准形式以及如何绘图。
4y²-50x=25x²+16y+109是哪种圆锥曲线的方程？这一节以此为例讲了双曲线的辨别方法，同时讲了如何化成标准形式以及如何绘图。
x²+y²-2x+4y=4是哪种圆锥曲线的方程？2x²+y+12x+16=0又是哪种圆锥曲线的方程？这一节以此为例讲了圆和抛物线的辨别方法，同时讲了如何化成标准形式以及如何绘图。
椭圆的定义是，到两定点距离之和等于常值的所有点的轨迹；两定点称为焦点，关于椭圆中心对称。x²/a²+y²/b²=1，a&b时，半焦距c=根号(a²-b²)。涉及到焦点之后，圆锥曲线才逐渐体现出了特殊之处和奇妙之处。
双曲线的定义是，到两定点距离之差的绝对值等于常值的所有点的轨迹；这两定点称为焦点，关于双曲线中心对称。x²/a²-y²/b²=1时，半焦距c=根号(a²+b²)。涉及到焦点之后，圆锥曲线才逐渐体现出了特殊之处和奇妙之处。
通过双曲线定义：到两定点距离之差的绝对值等于常值的所有点的轨迹；经过复杂的代数运算，这一节证明出了半焦距c=根号(a2+b2)这一公式。
部分分式展开，又叫部分分式分解。如(x+3)/(x2-3x-40)分成2/13/(x+5)和11/13/(x-8)的形式，这在未来微积分中求积分和求解微分方程等地方非常有用。
这一节讲另一种类型的部分分式展开，例：(10x2+12x+20)/(x3-8)=7/(x-2)+(3x+4)/(x2+2x+4)，待定系数时分母为n次，分子需要是n-1次。这在未来微积分中求积分和求解微分方程等地方非常有用。
这一节讲另一种类型的部分分式展开，例：(6x2-19x+15)/[(x-1)(x-2)2]。分母中有重复因式。其待定形式为A/(x-1)+B/(x-2)+C/(x-2)2。这在未来微积分中求积分和求解微分方程等地方非常有用。
抛物线是到焦点和准线等距的所有点的轨迹；任意取直线y=k，焦点(a,b)，这一节证明了任意满足到焦点和准线等距的点(x,y)，轨迹是一条抛物线。
这一节讲，已知抛物线的情况下，如何求焦点坐标和准线方程。对于抛物线y-y1=A(x-x1)2，顶点为(x1,y1)，焦点横坐标同顶点一样，纵坐标比顶点纵坐标高出1/(4A)，准线位置比顶点纵坐标低1/(4A)。
安和贝蒂骑自行车同时出发，安从A出发，贝蒂从B出发，相向而行，两人都是恒定速度，30分钟后相遇。相遇后两人继续向前骑行。安花20分钟到达B，问多少分钟后，贝蒂到达A。
一位女人沿铁路骑车去上班，时速6公里，每天在道口正好被同向火车追上。某日，女人晚出50分钟，被火车追上时，离道口还有6公里。问之后火车需要多少分钟到达道口。
两火车A和B轨道平行，以恒定速度形式。A长200米，B长400米。同向行驶时，A追上B（A头追上B尾部）到A完全超过B（A尾部超过B头部）需要15秒；相向行驶时，A与B头部相遇到两者尾部完全驶离需要5秒。问两车的速度。
爱丽丝、比尔、切尔西站在同一路线上，爱丽丝前面100米是比尔，比尔前面300米是切尔西，三人朝着同一方向前进。6分钟后，爱丽丝追上比尔，又过了6分钟，她追上切尔西。问比尔需要多久追上切尔西。
贝夫4点上火车，6点火车到站。她丈夫开车来接她，正好6点到火车站，开车速度不变。接到后立刻反方向回家。一天，她早一个小时上火车，5点就到火车站，但丈夫还是照常出来接她，她到站见丈夫没来就先往回走。中途碰到丈夫，然后一起回家，这一天回家比平时早了20分钟。问贝夫走了多久。
军官骑马从队列最后到最前，然后又从队列最前回到最后，骑马速度是步行的3倍，队列是100米长。问军官回到队列末尾时，队伍行进了多远。
这一节讲分式不等式，形如(x-1)/(x+2)&0，它有两种解法，这一节详细讲解两种解法，以及考虑方法。解出来结果是x&1或x&-2。
这一节讲分式不等式，形如(x-3)/(x+4)≥2。比起上一节，大于变成了大于等于，而且不等式右侧不为0。这一节对这种题目进行了详细讲解。
假设f(x)=ax3+bx2+cx+d，已知有零点(-1,0)和(2,0)，y轴截点为(0,-2)，求a+b+c+d。这个题其实有无穷多种情况，课堂最后绘图证明了这一点。
住房抵押贷款是每个人都要经历的事物，一般是查表来看每个月的还款额是多少。那么这下面的数学运算是怎样的呢？其实并不复杂，这一节课将教你如何计算。
函数是一种映射，将输入值映射为输出值。那反向的逆操作，将原来的输入值映射回输入值，这就是逆函数。视频中介绍了函数及其逆函数关于y=x的对称关系。
例题：求f(x)=-x+4和g(x)=-2x-1的逆函数。求逆函数大体思路是这样的：原函数表示为y等于x的表达式，进行代数运算，用y表示出x 得到逆函数，然后把自变量由y改成x。
例题：f(x)=(x+2)2+1，其中x≥-2。求其逆函数。求逆函数大体思路是这样的：原函数表示为y等于x的表达式，进行代数运算，用y表示出x 得到逆函数，然后把自变量由y改成x。
例题：函数f(x)=(x-1)2-2，其中x≤1。求其逆函数。求逆函数大体思路是这样的：原函数表示为y等于x的表达式，进行代数运算，用y表示出x 得到逆函数，然后把自变量由y改成x。
若两个量的变化关系符合其中一个量是另一个量乘以一个常数，则称两者是成正比，即y=kx。若两个量的变化关系符合其中一个量是另一个量的倒数乘以一个常数，则称两者是成反比，即y=k/x。
这一节是正比关系和反比关系的应用部分。课上举出了各种关系式，然后判别关系式是正比关系、反比关系、或既非正比也非反比。
奇函数为f(-x)=-f(x)的函数，它关于原点对称，比如y=x3就是奇函数；偶函数是为f(-x)=f(x)的函数，它关于y轴对称，比如y=x2就是偶函数。这一节告诉大家如何判断函数的奇偶性。
这一节探究了函数奇偶性称呼的来源，这同奇数或偶数的称谓之间有什么关系呢？关键在于幂函数y=xⁿ上，这一节将清楚讲解这一知识点。
除了加减乘除之外，我们还可以定义自己的运算，这也是题目中经常出现的考点。比如定义x☆y=5x-y，a◇b=a/(a+b)，问-1◇(0☆5)。
数学归纳法的一般步骤是：首先证明基本情况；然后假设n=k时成立，再证明n=k+1的情况也成立。这一节通过计算1+2+…+n之和，来演示数学归纳法。
设S(n)=1+2+…+n，即所有小于等于n的正整数之和。上一节用归纳法证明了S(n)=n(n+1)/2。这一节继续讲这个问题，给出了不用归纳法的简单代数证明。
9支记号笔价格11.50美元，问7支笔的价格是多少钱。7个苹果价格是5美元，8美元能买多少苹果。5个人吃的蛋糕需要2个蛋，15个人吃的需要多少鸡蛋。这些关于比例的问题就是这一节的主题。
所有循环小数都可以化成分数形式，那7.7777…化成分数是多少呢？1.2222…化成分数又是多少呢？这就是这一节的主题。
所有循环小数都可以化成分数形式，这一节接着上一节，讲解了循环位数不止一位的循环小数，比如0.36(36循环)，0.714(14循环)，3.257(257循环)。
学校：可汗学院
讲师：Salman Khan
授课语言：英文
类型：数学 可汗学院
课程简介：这是为没有代数基础的学生准备的代数课程，包含方程及求解、不等式求解、作图、百分比、比值问题、因式分解、虚数和复数、二次方程、二次不等式、函数、对数及运算、圆锥曲线的坐标运算(椭圆、双曲线、抛物线)、分式、应用问题等内容。视频由可汗学院免费提供，详见：（All Khan Academy materials are available for free at ）
扫描左侧二维码下载客户端深度学习与自然语言处理(4)_斯坦福cs224d大作业测验1与解答
深度学习与自然语言处理(4)_斯坦福cs224d 大作业测验1与解答
作业内容翻译：@胡杨(superhy199148@hotmail com) && @胥可(feitongxiaoke@gmail com)
解答与编排：寒小阳 && 龙心尘
时间：2016年6月
深度学习与自然语言处理(4)_斯坦福cs224d 大作业测验1与解答
前面一个接一个的Lecture，看得老衲自己也是一脸懵逼，不过你以为你做一个安安静静的美男子(总感觉有勇气做deep learning的女生也是一条汉纸)就能在Stanford这样的学校顺利毕业啦?图样图森破，除掉极高的内容学习梯度，这种顶尖大学的作业和考试一样会让你突(tong)飞(bu)猛(yu)进(sheng)。
说起来，怎么也是堂堂斯坦福的课，这种最看重前言研究在实际工业应用的学校，一定是理论和应用并进，对动手能力要求极强的，于是乎，我们把作业和小测验(MD你这也敢叫小测验!!)也扒过来，整理整理，让大家都来体验体验。反正博主君自己每次折腾完这些大学的assignment之后，都会感慨一句，“还好不生在水生火热的万恶资本主义国家，才能让我大学和研究僧顺利毕业(什么?phd?呵呵…博主是渣渣，智商常年处于欠费状态，我就不参与你们高端人士的趴体了)”。
不能再BB了，直接开始做作业考试吧…
1 Softmax (10 分)
(part a) (5分)
证明针对任何输入向量x和常数c，softmax函数的输出不会随着输入向量偏移(也就是常数c)而改变。即：
softmax(x)=softmax(x+c)
其中x+c就是给x每一个元素加上常数c。注意：
softmax(x)i=exi&jexj
提示：在实际应用中，经常会用到这个性质。为了稳定地计算softmax概率，我们会选择c=?maxixi。(即将x的每个元素减去最大的那个元素)。
博主：熬过了高中，居然又看见证明了，也是惊(ri)喜(le)万(gou)分(le)，答案拿来!!!
证明，针对所有维度1&i&dim(x)：
(softmax(x+c))i=exp(xi+c)&dim(x)j=1exp(xj+c)=exp(c)exp(xi)exp(c)&dim(x)j=1exp(xj)=exp(xi)&dim(x)j=1exp(xj)=(softmax(x))i
(part b) (5 分)
已知一个N行d列的输入矩阵，计算每一行的softmax概率。在q1_softmax.py中写出你的实现过程，并使用python q1_softmax.py执行。
要求：你所写的代码应该尽可能的有效并以向量化的形式来实现。非向量化的实现将不会得到满分。
博主：简直要哭晕在厕所了，当年毕业设计也是加论文一星期都可以写完的节奏，这里一个5分的作业，还这么多要求…社会主义好…答案拿来!!!
import numpy as np
def softmax(x):
Softmax 函数
assert len(x.shape) & 1, "Softmax的得分向量要求维度高于1"
x -= np.max(x, axis=1, keepdims=True)
x = np.exp(x) / np.sum(np.exp(x), axis=1, keepdims=True)
2 神经网络基础(30分)
(part a) (3 分)
推导sigmoid函数的导数，并且只以sigmoid函数值的形式写出来(导数的表达式里只包含&(x)，不包含x)。证明针对这个问题没必要单独考虑x。方便回忆：下面给出sigmoid函数形式：
&(x)=11+e?x
旁白：我年纪轻轻干嘛要走上深度学习这条不归路，真是生无所恋了。
答案：&'(x)=&(x)(1?&(x))。
(part b) (3 分)
当使用交叉熵损失来作为评价标准时,推导出损失函数以softmax为预测结果的输入向量&的梯度。注意，
CE(y,y^)=?&iyilog(y^i)
其中y是一个one-hot向量，y^是所有类别的预测出的概率向量。(提示：你需要考虑y的许多元素为0，并且假设y仅有第k个类别是1)
答案：?CE(y,y^)?&=y^?y
或者等价于下面表达式，其中假设k是正确的类别
?CE(y,y^)?&={y^i?1,i=ky^i,otherwise
(part c) (6 分)
推导出单隐层神经网络关于输入x的梯度(也就是推导出?J?x，其中J是神经网络的损失函数)。这个神经网络在隐层和输出层采用了sigmoid激活函数，y是one-hot编码向量，使用了交叉熵损失。(使用&'(x) 作为sigmoid梯度，并且你可以任意为推导过中的中间变量命名)
前向传播方程如下：
h=sigmoid(xW1+b1)y^=softmax(hW2+b2)
在问题中，我们假设输入向量(隐层变量和输出概率)始终是一个行向量。此处我们约定，当我们说要对向量使用sigmoid函数时，也就是说要对向量每一个元素使用sigmoid函数。Wi和bi(其中i=1，2)分别是两层的权重和偏移。
旁白：好好的100分总分，硬要被你这么5分6分地拆，人家5分6分是一道选择题，你特么是一整个毕业设计!!好吧，不哭，跪着也要把题目做完，代码写完。哎，博主还是太年轻，要多学习啊。
答案：令 z2=hW2+b2， z1=xW1+b1x，于是可得：
&1=?CE?z2=y^?y&2=?CE?h=&1?z2?h=&1WT2&3=?CEz1=&2?h?z1=&2&&&(z1)?CE?x=&3?z1?x=&3WT
(part d) (2 分)
上面所说的这个神经网络有多少个参数?我们可以假设输入是Dx维，输出是Dy，隐层单元有H个。
旁白：还有part d!!!
答案: (Dx+1)?H+(H+1)?Dy.
(part e) (4 分) 在q2_sigmoid.py中补充写出sigmoid激活函数的和求它的梯度的对应代码。并使用python q2_sigmoid.py进行测试，同样的，测试用例有可能不太详尽，因此尽量检查下自己的代码。
旁白：如果博主没有阵亡，就在走向阵亡的路上…
def sigmoid_grad(f):
计算Sigmoid的梯度
#好在我有numpy
f = f * ( 1 - f )
(part f) (4 分)
为了方便debugging，我们需要写一个梯度检查器。在q2_gradcheck.py中补充出来，使用python q2_gradcheck.py测试自己的代码。
旁白：做到昏天黑地，睡一觉起来又是一条好汉…
def gradcheck_naive(f, x):
对一个函数f求梯度的梯度检验
- f 输入x，然后输出loss和梯度的函数
- x 就是输入咯
rndstate = random.getstate()
random.setstate(rndstate)
fx, grad = f(x)
# 遍历x的每一维
it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
while not it.finished:
ix = it.multi_index
old_val = x[ix]
x[ix] = old_val - h
random.setstate(rndstate)
( fxh1, _ ) = f(x)
x[ix] = old_val + h
random.setstate(rndstate)
( fxh2, _ ) = f(x)
numgrad = (fxh2 - fxh1)/(2*h)
x[ix] = old_val
# 比对梯度
reldiff = abs(numgrad - grad[ix]) / max(1, abs(numgrad), abs(grad[ix]))
if reldiff & 1e-5:
print "Gradient check failed."
print "First gradient error found at index %s" % str(ix)
print "Your gradient: %f \t Numerical gradient: %f" % (grad[ix], numgrad)
it.iternext() # Step to next dimension
print "Gradient check passed!"
(part g) (8 分)
现在，在q2 neural.py中，写出只有一个隐层且激活函数为sigmoid的神经网络前向和后向传播代码。使用python q2_neural.py测试自己的代码。
旁白：一入DL深似海…
def forward_backward_prop(data, labels, params, verbose = False):
2个隐层的神经网络的前向运算和反向传播
if len(data.shape) &= 2:
(N, _) = data.shape
### 展开每一层神经网络的参数
W1 = np.reshape(params[t:t+dimensions[0]*dimensions[1]], (dimensions[0], dimensions[1]))
t += dimensions[0]*dimensions[1]
b1 = np.reshape(params[t:t+dimensions[1]], (1, dimensions[1]))
t += dimensions[1]
W2 = np.reshape(params[t:t+dimensions[1]*dimensions[2]], (dimensions[1], dimensions[2]))
t += dimensions[1]*dimensions[2]
b2 = np.reshape(params[t:t+dimensions[2]], (1, dimensions[2]))
### 前向运算
# 第一个隐层做内积
a1 = sigmoid(data.dot(W1) + b1)
# 第二个隐层做内积
a2 = softmax(a1.dot(W2) + b2)
cost = - np.sum(np.log(a2[labels == 1]))/N
### 反向传播
# Calculate analytic gradient for the cross entropy loss function
grad_a2 = ( a2 - labels ) / N
# Backpropagate through the second latent layer
gradW2 = np.dot( a1.T, grad_a2 )
gradb2 = np.sum( grad_a2, axis=0, keepdims=True )
# Backpropagate through the first latent layer
grad_a1 = np.dot( grad_a2, W2.T ) * sigmoid_grad(a1)
gradW1 = np.dot( data.T, grad_a1 )
gradb1 = np.sum( grad_a1, axis=0, keepdims=True )
if verbose: # Verbose mode for logging information
print "W1 shape: {}".format( str(W1.shape) )
print "W1 gradient shape: {}".format( str(gradW1.shape) )
print "b1 shape: {}".format( str(b1.shape) )
print "b1 gradient shape: {}".format( str(gradb1.shape) )
### 梯度拼起来
grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), gradW2.flatten(), gradb2.flatten()))
return cost, grad
3 word2vec(40分+5附加分)
(part a) (3分)
假设你得到一个关联到中心词c的预测词向量&c，并且这个词向量使用skip-gram方法生成，预测词使用的是softmax预测函数，它能够在word2vec模型中被找到。
y^o=p(o|c)=exp(&?o&c)&&Ww=1exp(&?w&c)(4)
式中，w代表第w个词，&w(w=1,…,W)是词库中全体词汇的输出词向量。假设为交叉熵损失函数，且词o是被预测的词汇(noe-hot/独热模型的标记向量中第o个元素为1)，求解预测词向量 &c的所对应的梯度。
提示：问题2中的标记法将有助于此问题的解答。比如：设y^为各个词汇使用softmax函数预测得到的向量，y为期望词向量，而损失函数可以表示为：
Jsoftmax?CE(o,&c,U)=CE(y,y^)(5)
其中，U=[&1,&2,…,&W]是全体输出向量形成的矩阵，确保你已经规定好你的向量和矩阵的方向。
旁边：是的，旁白我已经不知道写什么了，感谢党感谢祖国吧。
解答：设y^为词汇softmax预测结果的列向量，y是同样形为列向量的独热标签，那么有：
?J?&c=UT(y^?y).
或者等同于：
?J?&c=?&i+&w=1Wyw^&w
(part b) (3分)
条件仍然如前一题所描述，求解输出词向量&w的梯度(包括&o在内)
旁白：我还是安安静静在天朝搬砖吧
?J?U=&c(y^?y)?
或者等同于：
?J?&w={(yw^?1)&c,yw^,w=ootherwise
(part c) (6分)
仍然延续(part a)和(part b)，假设我们使用为预测的向量&c使用负采样损失的计算方式，并且设定期望输出词为o。假设获得了K个负样例(词)，并且被记为1,…,K，分别作为这些样例的标签(o?1,…,K)。那么，对于一个给定的词o，将其输出向量记作&o。这里，负采样损失函数如下：
Jneg?sample(o,&c,U)=?log(&(&?o&c))?&k=1Klog(&(?&?k&c))(6)
其中，&(?)为sigmoid激活函数。
当你完成上述操作之后，尝试简要描述这个损失函数比softmax-CE损失函数计算更为有效的原因(你可以给出递增式的学习率，即，给出softmax-CE损失函数的计算时间除以负采样损失函数的计算时间的结果)。
注释：由于我们打算计算目标函数的最小值而不是最大值，这里提到的损失函数与Mikolov等人最先在原版论文中描述的正好相反。
旁白：突然想起来，小时候好焦虑，长大后到底去清华还是去北大，后来发现多虑了。我想如果当初走了狗屎运进了贵T大贵P大，也一定完不成学业。
?J?&c?J?&o?J?&k=(&(&?o&c)?1)&o?&k=1K(&(?&?k&c)?1)&k=(&(&?o&c)?1)&c=?(&(?&?k&c)?1)&c,forallk=1,2,…,K
(part d) (8分)
试得到由skip-gram和CBOW算法分别算出的全部词向量的梯度，前提步骤和词内容集合[wordc-m,…,wordc-1,wordc,wordc+1,…,wordc+m]都已给出，其中，m是窗口的大小。将词wordk的输入和输出词向量分别记为&k和&k。
提示：可以随意使用函数F(o,&c)(其中o代表词汇)作为这一部分中Jsoftmax?CE(o,&c,…)或Jneg?sample(o,&c,…)损失函数的占位符——你将在编程部分看到一个非常有用的抽象类，那意味着你的解决方法可以用这样的形式表达：?F(o,&c)?…
回忆skip-gram算法，以c为中心周边内容的损失值计算如下：
Jskip?gram(wordc?m…c+m)=&?m&j&m,j&0F(wc+j,&c)(7)
其中，wc+j代表距离中心词的第j个词。
CBOW略有不同，不同于使用&c作为预测向量，我们以&^为底，在CBOW中(一个小小的变体)，我们计算上下文输入词向量的和:
&^=&?m&j&m,j&0&c+j(8)
于是，CBOW的损失函数定义为：
JCBOW(wordc?m…c+m)=F(wc,&^)(9)
注释：为了符合&^在诸如代码部分中的各种表达规范，在skip-gram方法中，令：&^=&c。
旁白：我诚实一点，这个部分真的是翻了课件抄下来的。
解答：为了表达得更为清晰，我们将词库中全部词汇的全部输出向量集合记作U，给定一个损失函数F，我们可以很容易获得以下引出结果：
?F(wi,&^)?U 和?F(wi,&^)?&^
对于skip-gram方法，一个内容窗口的损失梯度为：
?Jskip?gram(wordc?m,…,c+m)?U?Jskip?gram(wordc?m,…,c+m)?&c?Jskip?gram(wordc?m,…,c+m)?&j=&?m&j&m,j&0?F(wc+j,&c)?U,=&?m&j&m,j&0?F(wc+j,&c)?&c=0,forallj&c.
同样地，对于CBOW则有：
?JCBOW(wordc?m,…,c+m)?U?JCBOW(wordc?m,…,c+m)?&j?JCBOW(wordc?m,…,c+m)?&j=?F(wc,&^)?U,(usingthedefinitionof&^intheproblem)=?F(wc,&^)?&^,forallj&{c?m,…,c?1,c+1,…,c+m}=0,forallj?{c?m,…,c?1,c+1,…,c+m}
(part e) (12分)
在这一部分，你将实现word2vec模型，并且使用随机梯度下降方法(SGD)训练属于你自己的词向量。首先，在代码q3_word2vec.py中编写一个辅助函数对矩阵中的每一行进行归一化。同样在这个文件中，完成对softmax、负采样损失函数以及梯度计算函数的实现。然后，完成面向skip-gram的梯度损失函数。当你完成这些的时候，使用命令：python q3_word2vec.py对编写的程序进行测试。
注释：如果你选择不去实现CBOW(h部分)，只需简单地删除对NotImplementedError错误的捕获即可完成你的测试。
旁白：前方高能预警，代码量爆炸了!
import numpy as np
import random
from q1_softmax import softmax
from q2_gradcheck import gradcheck_naive
from q2_sigmoid import sigmoid, sigmoid_grad
def normalizeRows(x):
行归一化函数
N = x.shape[0]
x /= np.sqrt(np.sum(x**2, axis=1)).reshape((N,1)) + 1e-30
def test_normalize_rows():
print "Testing normalizeRows..."
x = normalizeRows(np.array([[3.0,4.0],[1, 2]]))
# 结果应该是 [[0.6, 0.8], [0.4]]
assert (np.amax(np.fabs(x - np.array([[0.6,0.8],[0..]]))) &= 1e-6)
def softmaxCostAndGradient(predicted, target, outputVectors, dataset):
word2vec的Softmax损失函数
# - predicted: 预测词向量的numpy数组
# - target: 目标词的下标
# - outputVectors: 所有token的"output"向量(行形式)
# - dataset: 用来做负例采样的，这里其实没用着
# - cost: 输出的互熵损失
# - gradPred: the gradient with respect to the predicted word
# - grad: the gradient with respect to all the other word
probabilities = softmax(predicted.dot(outputVectors.T))
cost = -np.log(probabilities[target])
delta = probabilities
delta[target] -= 1
N = delta.shape[0]
D = predicted.shape[0]
grad = delta.reshape((N,1)) * predicted.reshape((1,D))
gradPred = (delta.reshape((1,N)).dot(outputVectors)).flatten()
return cost, gradPred, grad
def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,
Word2vec模型负例采样后的损失函数和梯度
grad = np.zeros(outputVectors.shape)
gradPred = np.zeros(predicted.shape)
indices = [target]
for k in xrange(K):
newidx = dataset.sampleTokenIdx()
while newidx == target:
newidx = dataset.sampleTokenIdx()
indices += [newidx]
labels = np.array([1] + [-1 for k in xrange(K)])
vecs = outputVectors[indices,:]
t = sigmoid(vecs.dot(predicted) * labels)
cost = -np.sum(np.log(t))
delta = labels * (t - 1)
gradPred = delta.reshape((1,K+1)).dot(vecs).flatten()
gradtemp = delta.reshape((K+1,1)).dot(predicted.reshape(
(1,predicted.shape[0])))
for k in xrange(K+1):
grad[indices[k]] += gradtemp[k,:]
t = sigmoid(predicted.dot(outputVectors[target,:]))
cost = -np.log(t)
delta = t - 1
gradPred += delta * outputVectors[target, :]
grad[target, :] += delta * predicted
for k in xrange(K):
idx = dataset.sampleTokenIdx()
t = sigmoid(-predicted.dot(outputVectors[idx,:]))
cost += -np.log(t)
delta = 1 - t
gradPred += delta * outputVectors[idx, :]
grad[idx, :] += delta * predicted
return cost, gradPred, grad
def skipgram(currentWord, C, contextWords, tokens, inputVectors, outputVectors,
dataset, word2vecCostAndGradient = softmaxCostAndGradient):
""" Skip-gram model in word2vec """
# skip-gram模型的实现
# - currrentWord: 当前中心词所对应的串
# - C: 上下文大小(词窗大小)
# - contextWords: 最多2*C个词
# - tokens: 对应词向量中词下标的字典
# - inputVectors: "input" word vectors (as rows) for all tokens
# - outputVectors: "output" word vectors (as rows) for all tokens
# - word2vecCostAndGradient: the cost and gradient function for a prediction vector given the target word vectors, could be one of the two cost functions you implemented above
# - cost: skip-gram模型算得的损失值
# - grad: 词向量对应的梯度
currentI = tokens[currentWord]
predicted = inputVectors[currentI, :]
cost = 0.0
gradIn = np.zeros(inputVectors.shape)
gradOut = np.zeros(outputVectors.shape)
for cwd in contextWords:
idx = tokens[cwd]
cc, gp, gg = word2vecCostAndGradient(predicted, idx, outputVectors, dataset)
cost += cc
gradOut += gg
gradIn[currentI, :] += gp
return cost, gradIn, gradOut
def word2vec_sgd_wrapper(word2vecModel, tokens, wordVectors, dataset, C, word2vecCostAndGradient = softmaxCostAndGradient):
batchsize = 50
cost = 0.0
grad = np.zeros(wordVectors.shape)
N = wordVectors.shape[0]
inputVectors = wordVectors[:N/2,:]
outputVectors = wordVectors[N/2:,:]
for i in xrange(batchsize):
C1 = random.randint(1,C)
centerword, context = dataset.getRandomContext(C1)
if word2vecModel == skipgram:
c, gin, gout = word2vecModel(centerword, C1, context, tokens, inputVectors, outputVectors, dataset, word2vecCostAndGradient)
cost += c / batchsize / denom
grad[:N/2, :] += gin / batchsize / denom
grad[N/2:, :] += gout / batchsize / denom
return cost, grad
def test_word2vec():
# Interface to the dataset for negative sampling
dataset = type('dummy', (), {})()
def dummySampleTokenIdx():
return random.randint(0, 4)
def getRandomContext(C):
tokens = ["a", "b", "c", "d", "e"]
return tokens[random.randint(0,4)], [tokens[random.randint(0,4)] \
for i in xrange(2*C)]
dataset.sampleTokenIdx = dummySampleTokenIdx
dataset.getRandomContext = getRandomContext
random.seed(31415)
np.random.seed(9265)
dummy_vectors = normalizeRows(np.random.randn(10,3))
dummy_tokens = dict([("a",0), ("b",1), ("c",2),("d",3),("e",4)])
print "==== Gradient check for skip-gram ===="
gradcheck_naive(lambda vec: word2vec_sgd_wrapper(skipgram, dummy_tokens, vec, dataset, 5), dummy_vectors)
gradcheck_naive(lambda vec: word2vec_sgd_wrapper(skipgram, dummy_tokens, vec, dataset, 5, negSamplingCostAndGradient), dummy_vectors)
print "\n==== Gradient check for CBOW ===="
gradcheck_naive(lambda vec: word2vec_sgd_wrapper(cbow, dummy_tokens, vec, dataset, 5), dummy_vectors)
gradcheck_naive(lambda vec: word2vec_sgd_wrapper(cbow, dummy_tokens, vec, dataset, 5, negSamplingCostAndGradient), dummy_vectors)
print "\n=== Results ==="
print skipgram("c", 3, ["a", "b", "e", "d", "b", "c"], dummy_tokens, dummy_vectors[:5,:], dummy_vectors[5:,:], dataset)
print skipgram("c", 1, ["a", "b"], dummy_tokens, dummy_vectors[:5,:], dummy_vectors[5:,:], dataset, negSamplingCostAndGradient)
print cbow("a", 2, ["a", "b", "c", "a"], dummy_tokens, dummy_vectors[:5,:], dummy_vectors[5:,:], dataset)
print cbow("a", 2, ["a", "b", "a", "c"], dummy_tokens, dummy_vectors[:5,:], dummy_vectors[5:,:], dataset, negSamplingCostAndGradient)
if __name__ == "__main__":
test_normalize_rows()
test_word2vec()
(f) (4分) 在代码q3_sgd.py中完成对随即梯度下降优化函数的实现。并且在该代码中运行测试你的实现。
旁白：想到这篇文章有可能会被无数可以智商碾压我的大神看到，就脸一阵发烫。
# 实现随机梯度下降
# 随机梯度下降每1000轮，就保存一下现在训练得到的参数
SAVE_PARAMS_EVERY = 1000
import glob
import os.path as op
import cPickle as pickle
import sys
def load_saved_params():
载入之前的参数以免从头开始训练
for f in glob.glob("saved_params_*.npy"):
iter = int(op.splitext(op.basename(f))[0].split("_")[2])
if (iter & st):
if st & 0:
with open("saved_params_%d.npy" % st, "r") as f:
params = pickle.load(f)
state = pickle.load(f)
return st, params, state
return st, None, None
def save_params(iter, params):
with open("saved_params_%d.npy" % iter, "w") as f:
pickle.dump(params, f)
pickle.dump(random.getstate(), f)
def sgd(f, x0, step, iterations, postprocessing = None, useSaved = False, PRINT_EVERY=10, ANNEAL_EVERY = 20000):
""" 随机梯度下降 """
###########################################################
# - f: 需要最优化的函数
# - x0: SGD的初始值
# - step: SGD的步长
# - iterations: 总得迭代次数
# - postprocessing: 参数后处理(比如word2vec里需要对词向量做归一化处理)
# - PRINT_EVERY: 指明多少次迭代以后输出一下状态
# - x: SGD完成后的输出参数 #
###########################################################
if useSaved:
start_iter, oldx, state = load_saved_params()
if start_iter & 0:
step *= 0.5 ** (start_iter / ANNEAL_EVERY)
random.setstate(state)
start_iter = 0
if not postprocessing:
postprocessing = lambda x: x
expcost = None
for iter in xrange(start_iter + 1, iterations + 1):
cost, grad = f(x)
x = x - step * grad
x = postprocessing(x)
if iter % PRINT_EVERY == 0:
print "Iter#{}, cost={}".format(iter, cost)
sys.stdout.flush()
if iter % SAVE_PARAMS_EVERY == 0 and useSaved:
save_params(iter, x)
if iter % ANNEAL_EVERY == 0:
step *= 0.5
(part g) (4分)
开始秀啦!现在我们将要载入真实的数据并使用你已经实现的手段训练词向量!我们将使用Stanford Sentiment Treebank (SST)数据集来进行词向量的训练，之后将他们应用到情感分析任务中去。在这一部分中，无需再编写更多的代码;只需要运行命令python q3 run.py即可。
注释：训练过程所占用的时间可能会很长，这取决于你所实现的程序的效率(一个拥有优异效率的实现程序大约需要占用1个小时)。努力去接近这个目标!
当脚本编写完成，需要完成对词向量的可视化显示。相应的结果同样被保存下来，如项目目录中的图片q3 word_vectors.png所示。包括在你作业中绘制的坐标图。简明解释最多三个句子在你的坐标图中的显示状况。
(part h) 附加题(5分)
在代码q3_word2vec.py中完成对CBOW的实现。注释：这部分内容是可选的，但是在d部分中关于CBOW的梯度推导在这里并不适用!
def cbow(currentWord, C, contextWords, tokens, inputVectors, outputVectors,
dataset, word2vecCostAndGradient = softmaxCostAndGradient):
word2vec的CBOW模型
gradIn = np.zeros(inputVectors.shape)
gradOut = np.zeros(outputVectors.shape)
D = inputVectors.shape[1]
predicted = np.zeros((D,))
indices = [tokens[cwd] for cwd in contextWords]
for idx in indices:
predicted += inputVectors[idx, :]
cost, gp, gradOut = word2vecCostAndGradient(predicted, tokens[currentWord], outputVectors, dataset)
gradIn = np.zeros(inputVectors.shape)
for idx in indices:
gradIn[idx, :] += gp
return cost, gradIn, gradOut
4 情感分析(20分)
现在，随着词向量的训练，我们准备展示一个简单的情感分析案例。随着词向量的训练，我们准备展示一个简单的情感分析。对于每条Stanford Sentiment Treebank数据集中的句子，将句子中全体词向量的平均值算作其特征值，并试图预测所提句子中的情感层次。短语的情感层次使用真实数值在原始数据集中表示，并被我们用以下5个类别来表示：
“超级消极”，“比较消极”，“中立”，“积极”，“非常积极”
对其分别进行从0到4的编码。在这一部分，你将学习用SGD来训练一个softmax回归机，并且通过不断地训练/调试验证来提高回归机的泛化能力。
(part a)(10分)
实现一个句子的特征生成器和softmax回归机。在代码q4_softmaxreg.py中完成对这个任务的实现，并运行命令python q4_ softmaxreg.py，对刚才完成的功能函数进行调试。
import numpy as np
import random
from cs224d.data_utils import *
from q1_softmax import softmax
from q2_gradcheck import gradcheck_naive
from q3_sgd import load_saved_params
def getSentenceFeature(tokens, wordVectors, sentence):
简单粗暴的处理方式，直接对句子的所有词向量求平均做为情感分析的输入
# - tokens: a dictionary that maps words to their indices in the word vector list
# - wordVectors: word vectors (each row) for all tokens
# - sentence: a list of words in the sentence of interest
# - sentVector: feature vector for the sentence
sentVector = np.zeros((wordVectors.shape[1],))
indices = [tokens[word] for word in sentence]
sentVector = np.mean(wordVectors[indices, :], axis=0)
return sentVector
def softmaxRegression(features, labels, weights, regularization = 0.0, nopredictions = False):
""" Softmax Regression """
# 完成加正则化的softmax回归
# - features: feature vectors, each row is a feature vector
# - labels: labels corresponding to the feature vectors
# - weights: weights of the regressor
# - regularization: L2 regularization constant
# - cost: cost of the regressor
# - grad: gradient of the regressor cost with respect to its weights
# - pred: label predictions of the regressor (you might find np.argmax helpful)
prob = softmax(features.dot(weights))
if len(features.shape) & 1:
N = features.shape[0]
# A vectorized implementation of 1/N * sum(cross_entropy(x_i, y_i)) + 1/2*|w|^2
cost = np.sum(-np.log(prob[range(N), labels])) / N
cost += 0.5 * regularization * np.sum(weights ** 2)
grad = np.array(prob)
grad[range(N), labels] -= 1.0
grad = features.T.dot(grad) / N
grad += regularization * weights
pred = np.argmax(prob, axis=1)
pred = np.argmax(prob)
if nopredictions:
return cost, grad
return cost, grad, pred
def accuracy(y, yhat):
""" Precision for classifier """
assert(y.shape == yhat.shape)
return np.sum(y == yhat) * 100.0 / y.size
def softmax_wrapper(features, labels, weights, regularization = 0.0):
cost, grad, _ = softmaxRegression(features, labels, weights,
regularization)
return cost, grad
def sanity_check():
Run python q4_softmaxreg.py.
random.seed(314159)
np.random.seed(265)
dataset = StanfordSentiment()
tokens = dataset.tokens()
nWords = len(tokens)
_, wordVectors0, _ = load_saved_params()
wordVectors = (wordVectors0[:nWords,:] + wordVectors0[nWords:,:])
dimVectors = wordVectors.shape[1]
dummy_weights = 0.1 * np.random.randn(dimVectors, 5)
dummy_features = np.zeros((10, dimVectors))
dummy_labels = np.zeros((10,), dtype=np.int32)
for i in xrange(10):
words, dummy_labels[i] = dataset.getRandomTrainSentence()
dummy_features[i, :] = getSentenceFeature(tokens, wordVectors, words)
print "==== Gradient check for softmax regression ===="
gradcheck_naive(lambda weights: softmaxRegression(dummy_features,
dummy_labels, weights, 1.0, nopredictions = True), dummy_weights)
print "\n=== Results ==="
print softmaxRegression(dummy_features, dummy_labels, dummy_weights, 1.0)
if __name__ == "__main__":
sanity_check()
(part b)(2分)
解释当分类语料少于三句时为什么要引入正则化(实际上在大多数机器学习任务都这样)。
解答：为了避免训练集的过拟合以及对未知数据集的适应力不佳现象。
(part c)(4分)
在q4 sentiment.py中完成超参数的实现代码从而获取“最佳”的惩罚因子。你是如何选择的?报告你的训练、调试和测试精度，在最多一个句子中校正你的超参数选定方法。 注释：在开发中应该获取至少30%的准确率。
解答：参考值为1e-4，在调试、开发和测试过程中准确率分别为29.1%，31.4%和27.6%
import numpy as np
import matplotlib.pyplot as plt
from cs224d.data_utils import *
from q3_sgd import load_saved_params, sgd
from q4_softmaxreg import softmaxRegression, getSentenceFeature, accuracy, softmax_wrapper
# 试试不同的正则化系数，选最好的
REGULARIZATION = [0.0, 0.003, 0.3, 0.001, 0.003, 0.01]
# 载入数据集
dataset = StanfordSentiment()
tokens = dataset.tokens()
nWords = len(tokens)
# 载入预训练好的词向量
_, wordVectors0, _ = load_saved_params()
wordVectors = (wordVectors0[:nWords,:] + wordVectors0[nWords:,:])
dimVectors = wordVectors.shape[1]
# 载入训练集
trainset = dataset.getTrainSentences()
nTrain = len(trainset)
trainFeatures = np.zeros((nTrain, dimVectors))
trainLabels = np.zeros((nTrain,), dtype=np.int32)
for i in xrange(nTrain):
words, trainLabels[i] = trainset[i]
trainFeatures[i, :] = getSentenceFeature(tokens, wordVectors, words)
# 准备好训练集的特征
devset = dataset.getDevSentences()
nDev = len(devset)
devFeatures = np.zeros((nDev, dimVectors))
devLabels = np.zeros((nDev,), dtype=np.int32)
for i in xrange(nDev):
words, devLabels[i] = devset[i]
devFeatures[i, :] = getSentenceFeature(tokens, wordVectors, words)
# 尝试不同的正则化系数
results = []
for regularization in REGULARIZATION:
random.seed(3141)
np.random.seed(59265)
weights = np.random.randn(dimVectors, 5)
print "Training for reg=%f" % regularization
# batch optimization
weights = sgd(lambda weights: softmax_wrapper(trainFeatures, trainLabels,
weights, regularization), weights, 3.0, 10000, PRINT_EVERY=100)
# 训练集上测效果
_, _, pred = softmaxRegression(trainFeatures, trainLabels, weights)
trainAccuracy = accuracy(trainLabels, pred)
print "Train accuracy (%%): %f" % trainAccuracy
# dev集合上看效果
_, _, pred = softmaxRegression(devFeatures, devLabels, weights)
devAccuracy = accuracy(devLabels, pred)
print "Dev accuracy (%%): %f" % devAccuracy
# 保存结果权重
results.append({
"reg" : regularization,
"weights" : weights,
"train" : trainAccuracy,
"dev" : devAccuracy})
# 输出准确率
print "=== Recap ==="
print "Reg\t\tTrain\t\tDev"
for result in results:
print "%E\t%f\t%f" % (
result["reg"],
result["train"],
result["dev"])
# 选最好的正则化系数
BEST_REGULARIZATION = None
BEST_WEIGHTS = None
best_dev = 0
for result in results:
if result["dev"] & best_dev:
best_dev = result["dev"]
BEST_REGULARIZATION = result["reg"]
BEST_WEIGHTS = result["weights"]
# Test your findings on the test set
testset = dataset.getTestSentences()
nTest = len(testset)
testFeatures = np.zeros((nTest, dimVectors))
testLabels = np.zeros((nTest,), dtype=np.int32)
for i in xrange(nTest):
words, testLabels[i] = testset[i]
testFeatures[i, :] = getSentenceFeature(tokens, wordVectors, words)
_, _, pred = softmaxRegression(testFeatures, testLabels, BEST_WEIGHTS)
print "Best regularization value: %E" % BEST_REGULARIZATION
print "Test accuracy (%%): %f" % accuracy(testLabels, pred)
# 画出正则化和准确率的关系
plt.plot(REGULARIZATION, [x["train"] for x in results])
plt.plot(REGULARIZATION, [x["dev"] for x in results])
plt.xscale('log')
plt.xlabel("regularization")
plt.ylabel("accuracy")
plt.legend(['train', 'dev'], loc='upper left')
plt.savefig("q4_reg_v_acc.png")
plt.show()
(d)(4分)绘出在训练和开发过程中的分类准确率，并在x轴使用对数刻度来对正则化值进行相关设置。这应该自动化的进行。包括在你作业中详细展示的坐标图q4_reg_acc.png。简明解释最多三个句子在此坐标图中的显示情况。
红黑联盟&版权所有
Copyright&& 2017
All rights reserved.}