-
Notifications
You must be signed in to change notification settings - Fork 0
/
index.html
2561 lines (1830 loc) · 110 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!doctype html>
<html class="no-js" lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>
星晨入梦
</title>
<link href="atom.xml" rel="alternate" title="星晨入梦" type="application/atom+xml">
<link rel="stylesheet" href="asset/css/foundation.min.css" />
<link rel="stylesheet" href="asset/css/docs.css" />
<script src="asset/js/vendor/modernizr.js"></script>
<script src="asset/js/vendor/jquery.js"></script>
<script src="asset/highlightjs/highlight.pack.js"></script>
<link href="asset/highlightjs/styles/github.css" media="screen, projection" rel="stylesheet" type="text/css">
<script>hljs.initHighlightingOnLoad();</script>
<script type="text/javascript">
function before_search(){
var searchVal = 'site:blog.cxstars.com ' + document.getElementById('search_input').value;
document.getElementById('search_q').value = searchVal;
return true;
}
</script>
</head>
<body class="antialiased hide-extras">
<div class="marketing off-canvas-wrap" data-offcanvas>
<div class="inner-wrap">
<nav class="top-bar docs-bar hide-for-small" data-topbar>
<section class="top-bar-section">
<div class="row">
<div style="position: relative;width:100%;"><div style="position: absolute; width:100%;">
<ul id="main-menu" class="left">
<li id=""><a target="_self" href="index.html">Home</a></li>
<li id=""><a target="_self" href="archives.html">Archives</a></li>
<li id=""><a target="_self" href="about.html">About</a></li>
</ul>
<ul class="right" id="search-wrap">
<li>
<form target="_blank" onsubmit="return before_search();" action="http://google.com/search" method="get">
<input type="hidden" id="search_q" name="q" value="" />
<input tabindex="1" type="search" id="search_input" placeholder="Search"/>
</form>
</li>
</ul>
</div></div>
</div>
</section>
</nav>
<nav class="tab-bar show-for-small">
<a href="javascript:void(0)" class="left-off-canvas-toggle menu-icon">
<span> 星晨入梦</span>
</a>
</nav>
<aside class="left-off-canvas-menu">
<ul class="off-canvas-list">
<li><a target="_self" href="index.html">Home</a></li>
<li><a target="_self" href="archives.html">Archives</a></li>
<li><a target="_self" href="about.html">About</a></li>
<li><label>Categories</label></li>
<li><a href="ml.html">ml</a></li>
<li><a href="MySQL.html">MySQL</a></li>
<li><a href="python.html">python</a></li>
<li><a href="nginx.html">nginx</a></li>
<li><a href="golang.html">golang</a></li>
<li><a href="book.html">book</a></li>
<li><a href="arch.html">arch</a></li>
<li><a href="redis.html">redis</a></li>
<li><a href="life.html">life</a></li>
<li><a href="php.html">php</a></li>
</ul>
</aside>
<a class="exit-off-canvas" href="#"></a>
<section id="main-content" role="main" class="scroll-container">
<script type="text/javascript">
$(function(){
$('#menu_item_index').addClass('is_active');
});
</script>
<div class="row">
<div class="large-8 medium-8 columns">
<div class="markdown-body home-categories">
<div class="article">
<a class="clearlink" href="14900171104128.html">
<h1>TensorFlow安装</h1>
<div class="a-content">
<div class="a-content-text">
<h3 id="toc_0">决定你的tensorflow类型</h3>
<p>选择一种最适合你的tensorflow进行安装:<br/>
* 只支持CPU.<br/>
* 不仅支持CPU,还支持GPU.需要硬件支持<strong>NVIDIA CUDA GPU</strong></p>
<p><em>只有集显的我默默流泪,需要的朋友请自取<a href="http://docs.nvidia.com/cuda/cuda-installation-guide-mac-os-x">NVIDIA's documentation</a></em></p>
<h3 id="toc_1">tensorflow的安装方式</h3>
<ul>
<li>virtualenv</li>
<li>"native" pip</li>
<li>Docker</li>
<li>from source</li>
</ul>
<h5 id="toc_2">virtualenv(官方推荐)</h5>
<ul>
<li>开启shell</li>
<li>安装<em>pip</em>和<em>virtualenv</em> </li>
</ul>
<pre><code class="language-shell"> $ sudo easy_install pip
$ sudo pip install --upgrade virtualenv
</code></pre>
<ul>
<li>创建虚拟环境</li>
</ul>
<p><code>$ virtualenv --system-site-packages targetDirectory</code></p>
<p>注:当前目录为<code>~/tensorflow</code></p>
<ul>
<li>激活环境</li>
</ul>
<pre><code class="language-shell"> $ source ~/tensorflow/bin/activate # If using bash, sh, ksh, or zsh
$ source ~/tensorflow/bin/activate.csh # If using csh or tcsh
</code></pre>
<p>正确显示如下:</p>
<pre><code> (tensorflow)$
</code></pre>
<ul>
<li>安装tensorflow(pip >= 8.1)</li>
</ul>
<pre><code class="language-shell"> $ pip install --upgrade tensorflow # for Python 2.7
$ pip3 install --upgrade tensorflow # for Python 3.n
$ pip install --upgrade tensorflow-gpu # for Python 2.7 and GPU
$ pip3 install --upgrade tensorflow-gpu # for Python 3.n and GPU
</code></pre>
<ul>
<li>修复激活失败(安装正确请跳过)</li>
</ul>
<pre><code class="language-shell"> $ pip install --upgrade TF_BINARY_URL # Python 2.7
$ pip3 install --upgrade TF_BINARY_URL # Python 3.N
</code></pre>
<ul>
<li>mac,python 3.4</li>
</ul>
<pre><code class="language-shell"> $ pip3 install --upgrade \
https://storage.googleapis.com/tensorflow/mac/cpu/tensorflow-1.0.1-py3-none-any.whl
</code></pre>
<p>上面的url需要export到环境</p>
<h6 id="toc_3">使用</h6>
<ul>
<li>选择使用的shell类型</li>
</ul>
<pre><code class="language-shell">$ source ~/tensorflow/bin/activate # bash, sh, ksh, or zsh
$ source ~/tensorflow/bin/activate.csh # csh or tcsh
</code></pre>
<ul>
<li>暂停tensorflow virtualenv</li>
</ul>
<p><code>(tensorflow)$ deactivate</code></p>
<ul>
<li>删除tensorflow virtualenv</li>
</ul>
<p><code>(tensorflow)$ deactivate</code></p>
<h5 id="toc_4">pip安装</h5>
<p>tip:需要pip version >= 8.1</p>
<ul>
<li>升级pip命令</li>
</ul>
<pre><code class="language-shell">$ sudo easy_install --upgrade pip
$ sudo easy_install --upgrade six
</code></pre>
<ul>
<li>安装tensorflow</li>
</ul>
<pre><code class="language-shell"> $ pip install tensorflow # Python 2.7; CPU support (no GPU support)
$ pip3 install tensorflow # Python 3.n; CPU support (no GPU support)
$ pip install tensorflow-gpu # Python 2.7; GPU support
$ pip3 install tensorflow-gpu # Python 3.n; GPU support
</code></pre>
<ul>
<li>卸载tensorflow</li>
</ul>
<pre><code class="language-shell">$ pip uninstall tensorflow
$ pip3 uninstall tensorflow
</code></pre>
<h5 id="toc_5">docker安装</h5>
<ul>
<li>拉取镜像</li>
</ul>
<pre><code class="language-shell">docker pull gcr.io/tensorflow/tensorflow
docker pull gcr.io/tensorflow/tensorflow:latest-devel
</code></pre>
<h3 id="toc_6">测试</h3>
<h5 id="toc_7">pip安装测试</h5>
<pre><code class="language-shell">star@starMBP:~/Documents/web$ python
Python 3.6.0 (default, Mar 4 2017, 12:32:34)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import tensorflow as tf
>>> a = tf.constant([1.0,2.0],name="a")
>>> b = tf.constant([2.0,3.0],name="b")
>>> result = a+b
>>> sess = tf.Session()
>>> sess.run(result)
array([ 3., 5.], dtype=float32)
</code></pre>
<p>如上ok.</p>
<h5 id="toc_8">virtualenv安装测试</h5>
<pre><code class="language-shell">[root@VM_10_16_centos tensorflow]# virtualenv --system-site-packages test1
New python executable in /data/tensorflow/test1/bin/python
Installing setuptools, pip, wheel...^@^@cdone.
[root@VM_10_16_centos tensorflow]# source ./test1/bin/activate
(test1) [root@VM_10_16_centos tensorflow]# pip install --upgrade tensorflow
Collecting tensorflow
Downloading tensorflow-1.0.1-cp27-cp27mu-manylinux1_x86_64.whl (44.1MB)
0% |▎ | 307kB 8.6kB/s eta 1:25:1
</code></pre>
<p>慢慢等吧,也ok的.</p>
</div>
</div>
</a>
<div class="read-more clearfix">
<div class="more-left left">
<span class="date">2017/3/20 21:38 下午</span>
<span>posted in </span>
<span class="posted-in"><a href='ml.html'>ml</a></span>
</div>
<div class="more-right right">
<span class="comments">
<a class="ds-thread-count" data-thread-key="14900171104128.html" data-count-type="comments" href="14900171104128.html#ds-thread"></a>
</span>
</div>
</div>
</div><!-- article -->
<div class="article">
<a class="clearlink" href="14899316488389.html">
<h1>一篇上了头条的文章感想</h1>
<div class="a-content">
<div class="a-content-text">
<h3 id="toc_0">起因</h3>
<p><a href="http://blog.cxstars.com/14893113007289.html">PHP PDO深入探索</a>这篇文章很意外的上了开发头条,只是因为我很意外的在头条上建了一个独家号,然后又很意外的写那篇文章(只是因为我想试试新买的机械键盘手感Orz...),然后又很意外的觉得还行便分享到了上面提到的那个意外的独家号,最后竟然意外的上了开发者头条精选.</p>
<h3 id="toc_1">带来的一点点改变</h3>
<ul>
<li><p><em>带来了一条评论</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899323375273.jpg" alt="带来了一条评论"/></p></li>
<li><p><em>带来了三个关注者</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899323936505.jpg" alt="带来了三个关注者"/></p></li>
<li><p><em>在头条上有20个点赞(唔,算上自己的)和74个收藏</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899327323387.jpg" alt="在头条上有20个点赞(唔,算上自己的)和74个收藏"/></p></li>
<li><p><em>在头条上的阅读量高达3780</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899328025473.jpg" alt="我大PHPer还是很多的"/></p></li>
<li><p><em>给我那个一天几乎没人访问的小站带来了许多顾客</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899322023669.jpg" alt="给我那个一天几乎没人访问的小站带来了许多顾客"/></p></li>
<li><p><em>继而被各网站收录</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899330640882.jpg" alt="PHP PDO深入探索 - 推酷"/></p></li>
</ul>
<p><img src="http://bimg.cxstars.com/2017-03-19-14899331792181.jpg" alt=""/></p>
<ul>
<li><p><em>搜了下反链,意外的看到了以前的WP博客截图</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899333673163.jpg" alt="2013-5-24"/></p></li>
<li><p><em>还有一个意外的发现,写的workflow被library io收录了</em><br/>
<img src="http://bimg.cxstars.com/2017-03-19-14899335791384.jpg" alt="library"/></p></li>
</ul>
<h3 id="toc_2">感想</h3>
<p>今天虽然很WTF的一天,车子被撞得拖去了4S店,老爸的泡脚盆漏电闪火花,但是所幸人都没有事情.虽然不是很开心,但是还好翻了翻这篇文章的所带来的一小点成就感也就平复了.(唔,我就是这么容易满足).</p>
<p>希望以后能写得更有用的东西,<strong>不求能够被记住,但是只要能够被记录,我就已经感到满足了</strong>.有3个朋友订阅了独立号,得对这三个朋友负责,尽量抽空写点有用的东西.(虽然他们不一定看,我知道的.0 0.)但还是希望自己能够做点有用的事,即能帮到别人.<strong>这就是我所理解的开源精神.</strong></p>
<p><strong>如果你看了这篇文章,谢谢你,如果没有人看到,那就谢谢努力的自己.噢,对了,谢谢头条君.</strong></p>
</div>
</div>
</a>
<div class="read-more clearfix">
<div class="more-left left">
<span class="date">2017/3/19 21:54 下午</span>
<span>posted in </span>
<span class="posted-in"><a href='life.html'>life</a></span>
</div>
<div class="more-right right">
<span class="comments">
<a class="ds-thread-count" data-thread-key="14899316488389.html" data-count-type="comments" href="14899316488389.html#ds-thread"></a>
</span>
</div>
</div>
</div><!-- article -->
<div class="article">
<a class="clearlink" href="14897253436771.html">
<h1>How to Chose A Restful Api Http Status Code</h1>
<div class="a-content">
<div class="a-content-text">
<h3 id="toc_0">Pre Knowledge</h3>
<p><a href="httpstatuses.com">httpstatuses.com</a><br/>
<a href="https://tools.ietf.org/html/rfc7231">RFC 7231</a><br/>
<strong>这个好玩且形象</strong><a href="https://http.cat/">https://http.cat/</a></p>
<h3 id="toc_1">Start</h3>
<p><img src="http://bimg.cxstars.com/2017-03-17-start.png" alt="start"/></p>
<h3 id="toc_2">Description</h3>
<p><img src="http://bimg.cxstars.com/2017-03-17-HTTP-Status-Codes-Key.png" alt="HTTP-Status-Codes-Key"/></p>
<h3 id="toc_3">2XX & 3XX</h3>
<p><img src="http://bimg.cxstars.com/2017-03-17-2_3.png" alt="2_3"/></p>
<h3 id="toc_4">4XX</h3>
<p><img src="http://bimg.cxstars.com/2017-03-17-HTTP-4XX-Status-Codes.png" alt="HTTP-4XX-Status-Codes"/></p>
<h3 id="toc_5">5XX</h3>
<p><img src="http://bimg.cxstars.com/2017-03-17-HTTP-5XX-Status-Codes.png" alt="HTTP-5XX-Status-Codes"/></p>
<h3 id="toc_6">扩展</h3>
<p><a href="https://dev.twitter.com/overview/api/response-codes">twitter的错误码</a><br/>
<a href="https://developers.facebook.com/docs/graph-api/using-graph-api">facebook的错误码</a></p>
<h3 id="toc_7">End</h3>
<p><em><a href="http://racksburg.com/choosing-an-http-status-code/">原文链接</a></em></p>
</div>
</div>
</a>
<div class="read-more clearfix">
<div class="more-left left">
<span class="date">2017/3/17 12:35 下午</span>
<span>posted in </span>
<span class="posted-in"><a href='arch.html'>arch</a></span>
</div>
<div class="more-right right">
<span class="comments">
<a class="ds-thread-count" data-thread-key="14897253436771.html" data-count-type="comments" href="14897253436771.html#ds-thread"></a>
</span>
</div>
</div>
</div><!-- article -->
<div class="article">
<a class="clearlink" href="14894790545658.html">
<h1>设计模式原则</h1>
<div class="a-content">
<div class="a-content-text">
<h4 id="toc_0">什么是设计模式</h4>
<p>设计模式是个很值得思考且需要思考很深的事.<br/>
Just Do it.</p>
<h4 id="toc_1">六大原则</h4>
<ul>
<li>单一职责原则=>Single Responsibility Principle=>SRP</li>
</ul>
<blockquote>
<p>一个类只干这件事且只有这个类也只干这件事,俗语:一夫一妻制</p>
</blockquote>
<ul>
<li>里氏替换原则=>Liskov Substitution Principle=>LSP</li>
</ul>
<blockquote>
<p>基类出现的地方都可以完美使用其子类替换,俗语:养子防老or上阵父子兵</p>
</blockquote>
<ul>
<li>依赖倒置原则=>Dependence Inversion Principle=>DIP</li>
</ul>
<blockquote>
<p>所有的实现都应该依赖于约束,无约束的实现是不可控的,其中的约束就是interface,多约束就是多接口实现,俗语:依法治国,一国两治(多约束,手动点赞)每个地方都会有地方性治安条例,在各地具体的标准/实施不一样,但是各地所解决的问题是同一个.</p>
</blockquote>
<ul>
<li>接口隔离原则=>Interface Segregation Principle=>ISP</li>
</ul>
<blockquote>
<p>所有的接口都是有针对性,所要解决的问题是单一的,因为可以多实现,提高内聚性.举个栗子:国家是无数个小家组成的,家庭有收入,支出,那么收入和支出就是不同的接口,而每个家庭都必须要实现.俗语:条条大路通罗马.</p>
</blockquote>
<ul>
<li>迪米特法则=>Law of Demeter=>LoD</li>
</ul>
<blockquote>
<p>低耦合，高内聚是程序设计的最终目标,低耦合就是此法则的目标,通过减少依赖或者无感知依赖达到.俗语:知其然,不知其所以然.你只要知要这个类有了它所需要的依赖,而不需要知道它怎么有的.</p>
</blockquote>
<ul>
<li>开闭原则=>Open Close Principle=>OCP</li>
</ul>
<blockquote>
<p>关闭修改,开放扩展.业务的变化是一定的,但是类的修改却不是一定的,需要类在设计的时候就有横向扩展性.俗语:宪法补充案.</p>
</blockquote>
<h4 id="toc_2">原则总结</h4>
<p>具体的实现类是单一目标的,实现类能完美替换基类,类是实现的接口约束,接口约束同样也是单一目标的,约束的实现中需要借助其他约束时,在其初始化的同时注入约束的实现(其实就是依赖注入),每个约束的划分清晰,无强交集.</p>
<p>(以上总结以六大原则顺序而来,实质我觉得是反向的.先定义好合适约束,也就是interface需要实现的方法,以满足开闭原则.在interface或者class中使用依赖注入,以满足迪米特原则.在第一步设计约束的时候,同时也要满足接口隔离原则.class会实现所有需要实现的interface中的方法,这就是依赖倒置原则.class可以继承另一个class,继承者可以完美替换父类.每个类的实现都应该是单一需求或者功能)</p>
</div>
</div>
</a>
<div class="read-more clearfix">
<div class="more-left left">
<span class="date">2017/3/14 16:10 下午</span>
<span>posted in </span>
<span class="posted-in"><a href='arch.html'>arch</a></span>
</div>
<div class="more-right right">
<span class="comments">
<a class="ds-thread-count" data-thread-key="14894790545658.html" data-count-type="comments" href="14894790545658.html#ds-thread"></a>
</span>
</div>
</div>
</div><!-- article -->
<div class="article">
<a class="clearlink" href="14893113007289.html">
<h1>PHP PDO深入探索</h1>
<div class="a-content">
<div class="a-content-text">
<h2 id="toc_0">引子</h2>
<blockquote>
<p>学而时习之.用了这么多年的PDO,就知道预处理和参数绑定,但是对于其具体实现并没有进行深入了解.今天好奇心大发了,习MySQL PDO吧. </p>
</blockquote>
<h2 id="toc_1">官释</h2>
<p>很多更成熟的数据库都支持预处理语句的概念。什么是预处理语句？可以把它看作是想要运行的 SQL 的一种编译过的模板，它可以使用变量参数进行定制。预处理语句可以带来两大好处：</p>
<ul>
<li>查询仅需解析（或预处理）一次，但可以用相同或不同的参数执行多次。当查询准备好后，数据库将分析、编译和优化执行该查询的计划。对于复杂的查询，此过程要花费较长的时间，如果需要以不同参数多次重复相同的查询，那么该过程将大大降低应用程序的速度。通过使用预处理语句，可以避免重复分析/编译/优化周期。简言之，预处理语句占用更少的资源，因而运行得更快。</li>
<li>提供给预处理语句的参数不需要用引号括起来，驱动程序会自动处理。如果应用程序只使用预处理语句，可以确保不会发生SQL 注入。（然而，如果查询的其他部分是由未转义的输入来构建的，则仍存在 SQL 注入的风险）。
预处理语句如此有用，以至于它们唯一的特性是在驱动程序不支持的时PDO 将模拟处理。这样可以确保不管数据库是否具有这样的功能，都可以确保应用程序可以用相同的数据访问模式。</li>
</ul>
<p><em>PS:存储过程会稍有特殊,具体请看:<a href="http://php.net/manual/zh/pdo.prepared-statements.php">http://php.net/manual/zh/pdo.prepared-statements.php</a></em></p>
<h2 id="toc_2">上下而求索</h2>
<p>其实细心的会发现官释有句很特别的话[<strong>以至于它们唯一的特性是在驱动程序不支持的时PDO将模拟处理</strong>].<br/>
驱动程序,模拟处理?<br/>
直接上代码吧.</p>
<p>1.模拟处理</p>
<pre><code class="language-php"><?php
$pdo = new PDO("mysql:host=127.0.0.1;dbname=words;charset=utf8","root","password");
$st = $pdo->prepare("SELECT `words`.* FROM `words` WHERE word = ? ORDER BY `id` DESC LIMIT 10 OFFSET 0");
$word = 'charm';
$st->bindParam(1,$word);
$st->execute();
$data = $st->fetchAll();
</code></pre>
<p>运行后使用<code>wireshark</code>进行抓包查看.一次完成的PHP运行MySQL PDO查询的TCP包就呈现在眼前:<br/>
<img src="http://bimg.cxstars.com/2017-03-12-14893045265092.jpg" alt=""/></p>
<p><mark>简单的回顾一下TCP握手协议</mark></p>
<h4 id="toc_3">TCP三路握手</h4>
<p><img src="http://bimg.cxstars.com/2017-03-12-14893050630847.jpg" alt=""/></p>
<h4 id="toc_4">TCP关闭确认</h4>
<p><img src="http://bimg.cxstars.com/2017-03-12-14893059174539.jpg" alt=""/></p>
<p>回归正题,MySQL的查询体现:<br/>
<img src="http://bimg.cxstars.com/2017-03-12-14893068792357.jpg" alt=""/></p>
<p>变化就是替换并添加上了单引号(转义,同<code>mysql_real_escape_string</code>).其他没有什么变化.</p>
<p>2.驱动处理<br/>
代码正如:</p>
<pre><code class="language-php"><?php
$pdo = new PDO("mysql:host=127.0.0.1;dbname=words;charset=utf8","root","password");
$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);//这行是关键
$st = $pdo->prepare("SELECT `words`.* FROM `words` WHERE word = ? ORDER BY `id` DESC LIMIT 10 OFFSET 0");
$word = 'charm';
$st->bindParam(1,$word);
$st->execute();
$data = $st->fetchAll();
</code></pre>
<p><img src="http://bimg.cxstars.com/2017-03-12-14893082386821.jpg" alt=""/></p>
<p>哇噢,这次跟上次大不一样.来看看具体做了什么.<br/>
先是进行了SQL预处理.<br/>
<img src="http://bimg.cxstars.com/2017-03-12-14893083215979.jpg" alt=""/></p>
<p>根据MySQL协议返回的预处理完成信息.<br/>
<img src="http://bimg.cxstars.com/2017-03-12-14893088477923.jpg" alt=""/></p>
<p>进行参数映射查询<br/>
<img src="http://bimg.cxstars.com/2017-03-12-14893089225887.jpg" alt=""/></p>
<p>返回数据<br/>
<img src="http://bimg.cxstars.com/2017-03-12-14893093001183.jpg" alt=""/></p>
<p>关闭预处理<br/>
<img src="http://bimg.cxstars.com/2017-03-12-14893093293735.jpg" alt=""/></p>
<p>跟PHP本地预处理有什么区别呢?<br/>
<em>一次处理,终身(此次连接)受益,MySQL语句预处理,比如词法分析等,想象一下,在插入中使用,并且用二进制协议进行数据传输,更加安全效率</em></p>
<h2 id="toc_5">左右至MySQL求索</h2>
<p>其实也就是转换到MySQL中进行.</p>
<pre><code class="language-mysql">#prepare statement
mysql> PREPARE select1 FROM 'SELECT `words`.id FROM `words` WHERE word = ? ORDER BY `id` DESC LIMIT 10 OFFSET 0';
Query OK, 0 rows affected (0.00 sec)
Statement prepared
#bind variable
mysql> set @w1="charm";
Query OK, 0 rows affected (0.00 sec)
#execute
mysql> EXECUTE select1 USING @w1;
+----+
| id |
+----+
| 5 |
+----+
1 row in set (0.00 sec)
</code></pre>
<h4 id="toc_6">wiki的定义</h4>
<blockquote>
<p>As compared to executing SQL statements directly, prepared statements offer two main advantages:[1]</p>
</blockquote>
<ul>
<li>The overhead of compiling and optimizing the statement is incurred only once, although the statement is executed multiple times. Not all optimization can be performed at the time the prepared statement is compiled, for two reasons: the best plan may depend on the specific values of the parameters, and the best plan may change as tables and indexes change over time.[2]</li>
<li>Prepared statements are resilient against SQL injection, because parameter values, which are transmitted later using a different protocol, need not be correctly escaped. If the original statement template is not derived from external input, SQL injection cannot occur.</li>
</ul>
<p>链接<a href="https://en.wikipedia.org/wiki/Prepared_statement">https://en.wikipedia.org/wiki/Prepared_statement</a></p>
</div>
</div>
</a>
<div class="read-more clearfix">
<div class="more-left left">
<span class="date">2017/3/12 17:35 下午</span>
<span>posted in </span>
<span class="posted-in"><a href='MySQL.html'>MySQL</a></span>
</div>
<div class="more-right right">
<span class="comments">
<a class="ds-thread-count" data-thread-key="14893113007289.html" data-count-type="comments" href="14893113007289.html#ds-thread"></a>
</span>
</div>
</div>
</div><!-- article -->
<div class="article">
<a class="clearlink" href="14890706857877.html">
<h1>unsupervised learning</h1>
<div class="a-content">
<div class="a-content-text">
<h2 id="toc_0">中英字幕</h2>
<p><strong>视频用中文字幕(捂脸,英文太渣),一边看视频一边看字幕文件,时间+中项对照</strong><br/>
<a href="https://www.coursera.org/learn/machine-learning/lecture/olRZo/unsupervised-learning">https://www.coursera.org/learn/machine-learning/lecture/olRZo/unsupervised-learning</a><br/>
0:00<br/>
In this video, we'll talk about the second major type of machine learning problem, called Unsupervised Learning. <br/>
在这段视频中 我们要讲 第二种主要的机器学习问题 叫做无监督学习 <br/>
0:06<br/>
In the last video, we talked about Supervised Learning. Back then, recall data sets that look like this, where each example was labeled either as a positive or negative example, whether it was a benign or a malignant tumor. <br/>
在上一节视频中 我们已经讲过了监督学习 回想起上次的数据集 每个样本 都已经被标明为 正样本或者负样本 即良性或恶性肿瘤 <br/>
0:20<br/>
So for each example in Supervised Learning, we were told explicitly what is the so-called right answer, whether it's benign or malignant. In Unsupervised Learning, we're given data that looks different than data that looks like this that doesn't have any labels or that all has the same label or really no labels. <br/>
因此 对于监督学习中的每一个样本 我们已经被清楚地告知了 什么是所谓的正确答案 即它们是良性还是恶性 在无监督学习中 我们用的数据会和监督学习里的看起来有些不一样 在无监督学习中 没有属性或标签这一概念 也就是说所有的数据 都是一样的 没有区别 <br/>
0:39<br/>
So we're given the data set and we're not told what to do with it and we're not told what each data point is. Instead we're just told, here is a data set. Can you find some structure in the data? Given this data set, an Unsupervised Learning algorithm might decide that the data lives in two different clusters. And so there's one cluster <br/>
所以在无监督学习中 我们只有一个数据集 没人告诉我们该怎么做 我们也不知道 每个数据点究竟是什么意思 相反 它只告诉我们 现在有一个数据集 你能在其中找到某种结构吗？ 对于给定的数据集 无监督学习算法可能判定 该数据集包含两个不同的聚类 你看 这是第一个聚类 <br/>
0:59<br/>
and there's a different cluster. <br/>
然后这是另一个聚类 <br/>
1:01<br/>
And yes, Supervised Learning algorithm may break these data into these two separate clusters. <br/>
你猜对了 无监督学习算法 会把这些数据分成两个不同的聚类 <br/>
1:06<br/>
So this is called a clustering algorithm. And this turns out to be used in many places. <br/>
所以这就是所谓的聚类算法 实际上它被用在许多地方 <br/>
1:11<br/>
One example where clustering is used is in Google News and if you have not seen this before, you can actually go to this URL news.google.com to take a look. What Google News does is everyday it goes and looks at tens of thousands or hundreds of thousands of new stories on the web and it groups them into cohesive news stories. <br/>
我们来举一个聚类算法的栗子 Google 新闻的例子 如果你还没见过这个页面的话 你可以到这个URL news.google.com 去看看 谷歌新闻每天都在干什么呢？ 他们每天会去收集 成千上万的 网络上的新闻 然后将他们分组 组成一个个新闻专题 <br/>
1:30<br/>
For example, let's look here. <br/>
比如 让我们来看看这里 <br/>
1:33<br/>
The URLs here link to different news stories about the BP Oil Well story. <br/>
这里的URL链接 连接着不同的 有关BP油井事故的报道 <br/>
1:41<br/>
So, let's click on one of these URL's and we'll click on one of these URL's. What I'll get to is a web page like this. Here's a Wall Street Journal article about, you know, the BP Oil Well Spill stories of "BP Kills Macondo", which is a name of the spill and if you click on a different URL <br/>
所以 让我们点击 这些URL中的一个 恩 让我们点一个 然后我们会来到这样一个网页 这是一篇来自华尔街日报的 有关……你懂的 有关BP油井泄漏事故的报道 标题为《BP杀死了Macondo》 Macondo 是个地名 就是那个漏油事故的地方 如果你从这个组里点击一个不同的URL <br/>
2:00<br/>
from that group then you might get the different story. Here's the CNN story about a game, the BP Oil Spill, <br/>
那么你可能会得到不同的新闻 这里是一则CNN的新闻 是一个有关BP石油泄漏的视频 <br/>
2:07<br/>
and if you click on yet a third link, then you might get a different story. Here's the UK Guardian story about the BP Oil Spill. <br/>
如果你再点击第三个链接 又会出现不同的新闻 这边是英国卫报的报道 也是关于BP石油泄漏 <br/>
2:16<br/>
So what Google News has done is look for tens of thousands of news stories and automatically cluster them together. So, the news stories that are all about the same topic get displayed together. It turns out that clustering algorithms and Unsupervised Learning algorithms are used in many other problems as well. <br/>
所以 谷歌新闻所做的就是 去搜索成千上万条新闻 然后自动的将他们聚合在一起 因此 有关同一主题的 新闻被显示在一起 实际上 聚类算法和无监督学习算法 也可以被用于许多其他的问题 <br/>
2:35<br/>
Here's one on understanding genomics. <br/>
这里我们举个它在基因组学中的应用 <br/>
2:38<br/>
Here's an example of DNA microarray data. The idea is put a group of different individuals and for each of them, you measure how much they do or do not have a certain gene. Technically you measure how much certain genes are expressed. So these colors, red, green, gray and so on, they show the degree to which different individuals do or do not have a specific gene. <br/>
下面是一个关于基因芯片的例子 基本的思想是 给定一组不同的个体 对于每个个体 检测它们是否拥有某个特定的基因 也就是说，你要去分析有多少基因显现出来了 因此 这些颜色 红 绿 灰 等等 它们 展示了这些不同的个体 是否拥有一个特定基因 的不同程度 <br/>
3:02<br/>
And what you can do is then run a clustering algorithm to group individuals into different categories or into different types of people. <br/>
然后你能做的就是 运行一个聚类算法 把不同的个体归入不同的类 或归为不同类型的人 <br/>
3:10<br/>
So this is Unsupervised Learning because we're not telling the algorithm in advance that these are type 1 people, those are type 2 persons, those are type 3 persons and so on and instead what were saying is yeah here's a bunch of data. I don't know what's in this data. I don't know who's and what type. I don't even know what the different types of people are, but can you automatically find structure in the data from the you automatically cluster the individuals into these types that I don't know in advance? Because we're not giving the algorithm the right answer for the examples in my data set, this is Unsupervised Learning. <br/>
这就是无监督学习 我们没有提前告知这个算法 这些是第一类的人 这些是第二类的人 这些是第三类的人等等 相反我们只是告诉算法 你看 这儿有一堆数据 我不知道这个数据是什么东东 我不知道里面都有些什么类型 叫什么名字 我甚至不知道都有哪些类型 但是 请问你可以自动的找到这些数据中的类型吗？ 然后自动的 按得到的类型把这些个体分类 虽然事先我并不知道哪些类型 因为对于这些数据样本来说 我们没有给算法一个 正确答案 所以 这就是无监督学习 <br/>
3:44<br/>
Unsupervised Learning or clustering is used for a bunch of other applications. <br/>
无监督学习或聚类算法在其他领域也有着大量的应用 <br/>
3:48<br/>
It's used to organize large computer clusters. <br/>
它被用来组织大型的计算机集群 <br/>
3:51<br/>
I had some friends looking at large data centers, that is large computer clusters and trying to figure out which machines tend to work together and if you can put those machines together, you can make your data center work more efficiently. <br/>
我有一些朋友在管理 大型数据中心 也就是 大型计算机集群 并试图 找出哪些机器趋向于 协同工作 如果你把这些机器放在一起 你就可以让你的数据中心更高效地工作 <br/>
4:04<br/>
This second application is on social network analysis. <br/>
第二种应用是用于社交网络的分析 <br/>
4:07<br/>
So given knowledge about which friends you email the most or given your Facebook friends or your Google+ circles, can we automatically identify which are cohesive groups of friends, also which are groups of people that all know each other? <br/>
所以 如果可以得知 哪些朋友你用email联系的最多 或者知道你的Facebook好友 或者你Google+里的朋友 知道了这些之后 我们是否可以自动识别 哪些是很要好的朋友组 哪些仅仅是互相认识的朋友组 <br/>
4:22<br/>
Market segmentation. <br/>
还有在市场分割中的应用 <br/>
4:24<br/>
Many companies have huge databases of customer information. So, can you look at this customer data set and automatically discover market segments and automatically <br/>
许多公司拥有庞大的客户信息数据库 那么 给你一个 客户数据集 你能否 自动找出不同的市场分割 <br/>
4:33<br/>
group your customers into different market segments so that you can automatically and more efficiently sell or market your different market segments together? <br/>
并自动将你的客户分到不同的 细分市场中 从而有助于我在 不同的细分市场中 进行更有效的销售 <br/>
4:44<br/>
Again, this is Unsupervised Learning because we have all this customer data, but we don't know in advance what are the market segments and for the customers in our data set, you know, we don't know in advance who is in market segment one, who is in market segment two, and so on. But we have to let the algorithm discover all this just from the data. <br/>
这也是无监督学习 我们现在有 这些客户数据 但我们预先并不知道 有哪些细分市场 而且 对于我们数据集的某个客户 我们也不能预先知道 谁属于细分市场一 谁又属于细分市场二等等 但我们必须让这个算法自己去从数据中发现这一切 <br/>
5:01<br/>
Finally, it turns out that Unsupervised Learning is also used for surprisingly astronomical data analysis and these clustering algorithms gives surprisingly interesting useful theories of how galaxies are formed. All of these are examples of clustering, which is just one type of Unsupervised Learning. Let me tell you about another one. I'm gonna tell you about the cocktail party problem. <br/>
最后 事实上无监督学习也被用于 天文数据分析 通过这些聚类算法 我们发现了许多 惊人的、有趣的 以及实用的 关于星系是如何诞生的理论 所有这些都是聚类算法的例子 而聚类只是无监督学习的一种 现在让我来告诉你另一种 我先来介绍一下鸡尾酒宴问题 <br/>
5:26<br/>
So, you've been to cocktail parties before, right? Well, you can imagine there's a party, room full of people, all sitting around, all talking at the same time and there are all these overlapping voices because everyone is talking at the same time, and it is almost hard to hear the person in front of you. So maybe at a cocktail party with two people, <br/>
恩 我想你参加过鸡尾酒会的 是吧？ 嗯 想象一下 有一个宴会 有一屋子的人 大家都坐在一起 而且在同时说话 有许多声音混杂在一起 因为每个人都是在同一时间说话的 在这种情况下你很难听清楚你面前的人说的话 因此 比如有这样一个场景 宴会上只有两个人 <br/>
5:45<br/>
two people talking at the same time, and it's a somewhat small cocktail party. And we're going to put two microphones in the room so there are microphones, and because these microphones are at two different distances from the speakers, each microphone records a different combination of these two speaker voices. <br/>
两个人 同时说话 恩 这是个很小的鸡尾酒宴会 我们准备好了两个麦克风 把它们放在房间里 然后 因为这两个麦克风距离这两个人 的距离是不同的 每个麦克风都记录下了 来自两个人的声音的不同组合 <br/>
6:05<br/>
Maybe speaker one is a little louder in microphone one and maybe speaker two is a little bit louder on microphone 2 because the 2 microphones are at different positions relative to the 2 speakers, but each microphone would cause an overlapping combination of both speakers' voices. <br/>
也许A的声音 在第一个麦克风里的声音会响一点 也许B的声音 在第二个麦克风里会比较响一些 因为2个麦克风 的位置相对于 2个说话者的位置是不同的 但每个麦克风都会录到 来自两个说话者的重叠部分的声音 <br/>
6:23<br/>
So here's an actual recording <br/>
这里有一个 <br/>
6:26<br/>
of two speakers recorded by a researcher. Let me play for you the first, what the first microphone sounds like. One (uno), two (dos), three (tres), four (cuatro), five (cinco), six (seis), seven (siete), eight (ocho), nine (nueve), ten (y diez). <br/>
来自一个研究员录下的两个说话者的声音 让我先放给你听第一个 这是第一个麦克风录到的录音： 一 (UNO) 二 (DOS) 三 (TRES) 四 (CUATRO) 五 (CINCO) 六 (SEIS) 七 (SIETE) 八 (ocho) 九 (NUEVE) 十 (Y DIEZ) <br/>
6:41<br/>
All right, maybe not the most interesting cocktail party, there's two people counting from one to ten in two languages but you know. What you just heard was the first microphone recording, here's the second recording. <br/>
好吧 这大概不是什么有趣的酒会…… ……在这个酒会上 有两个人 各自从1数到10 但用的是两种不同语言 你刚才听到的是 第一个麦克风的录音 这里是第二个的： <br/>
6:57<br/>
Uno (one), dos (two), tres (three), cuatro (four), cinco (five), seis (six), siete (seven), ocho (eight), nueve (nine) y diez (ten). So we can do, is take these two microphone recorders and give them to an Unsupervised Learning algorithm called the cocktail party algorithm, and tell the algorithm - find structure in this data for you. And what the algorithm will do is listen to these audio recordings and say, you know it sounds like the two audio recordings are being added together or that have being summed together to produce these recordings that we had. Moreover, what the cocktail party algorithm will do is separate out these two audio sources that were being added or being summed together to form other recordings and, in fact, here's the first output of the cocktail party algorithm. <br/>
一 (UNO) 二 (DOS) 三 (TRES) 四 (CUATRO) 五 (CINCO) 六 (SEIS) 七 (SIETE) 八 (ocho) 九 (NUEVE) 十 (Y DIEZ) 所以 我们能做的就是把 这两个录音输入 一种无监督学习算法中 称为“鸡尾酒会算法” 让这个算法 帮你找出其中蕴含的分类 然后这个算法 就会去听这些 录音 并且你知道 这听起来像 两个音频录音 被叠加在一起 所以我们才能听到这样的效果 此外 这个算法 还会分离出 这两个被 叠加到一起的 音频源 事实上 这是我们的鸡尾酒会算法的第一个输出 <br/>
7:39<br/>
One, two, three, four, five, six, seven, eight, nine, ten. <br/>
一 二 三 四 五 六 七 八 九 十 <br/>
7:47<br/>
So, I separated out the English voice in one of the recordings. <br/>
所以我在一个录音中 分离出了英文声音 <br/>
7:52<br/>
And here's the second of it. Uno, dos, tres, quatro, cinco, seis, siete, ocho, nueve y diez. Not too bad, to give you <br/>
这是第二个输出 Uno dos tres quatro cinco seis siete ocho nueve y diez 听起来不错嘛 <br/>
8:03<br/>
one more example, here's another recording of another similar situation, here's the first microphone : One, two, three, four, five, six, seven, eight, nine, ten. <br/>
再举一个例子 这是另一个录音 也是在一个类似的场景下 这是第一个麦克风的录音： 一 二 三 四 五 六 七 八 九 十 <br/>
8:16<br/>
OK so the poor guy's gone home from the cocktail party and he 's now sitting in a room by himself talking to his radio. <br/>
OK 这个可怜的家伙从 鸡尾酒会回家了 他现在独自一人坐在屋里 对着录音机自言自语 <br/>
8:23<br/>
Here's the second microphone recording. <br/>
这是第二个麦克风的录音 <br/>
8:28<br/>
One, two, three, four, five, six, seven, eight, nine, ten. <br/>
一 二 三 四 五 六 七 八 九 十 <br/>
8:33<br/>
When you give these two microphone recordings to the same algorithm, what it does, is again say, you know, it sounds like there are two audio sources, and moreover, <br/>
当你把这两个麦克风录音 送给与刚刚相同的算法处理 它所做的还是 告诉你 这听起来有 两种音频源 并且 <br/>
8:42<br/>
the album says, here is the first of the audio sources I found. <br/>
算法说 这里是我找到的第一个音频源 <br/>
8:47<br/>
One, two, three, four, five, six, seven, eight, nine, ten. <br/>
一 二 三 四 五 六 七 八 九 十 <br/>
8:54<br/>
So that wasn't perfect, it got the voice, but it also got a little bit of the music in there. Then here's the second output to the algorithm. <br/>
恩 不是太完美 提取到了人声 但还有一点音乐没有剔除掉 这是算法的第二个输出 <br/>
9:10<br/>
Not too bad, in that second output it managed to get rid of the voice entirely. And just, you know, cleaned up the music, got rid of the counting from one to ten. <br/>
还好 在第二个输出中 它设法剔除掉了整个人声 只是清理了下音乐 剔除了从一到十的计数 <br/>
9:18<br/>
So you might look at an Unsupervised Learning algorithm like this and ask how complicated this is to implement this, right? It seems like in order to, you know, build this application, it seems like to do this audio processing you need to write a ton of code or maybe link into like a bunch of synthesizer Java libraries that process audio, seems like a really complicated program, to do this audio, separating out audio and so on. <br/>
所以 你可以看到 像这样的无监督学习算法 也许你想问 要实现这样的算法 很复杂吧？ 看起来 为了 构建这个应用程序 做这个音频处理 似乎需要写好多代码啊 或者需要链接到 一堆处理音频的Java库 貌似需要一个 非常复杂的程序 分离出音频等 <br/>
9:42<br/>
It turns out the algorithm, to do what you just heard, that can be done with one line of code - shown right here. <br/>
实际上 要实现你刚刚听到的效果 只需要一行代码就可以了 写在这里呢 <br/>
9:50<br/>
It take researchers a long time to come up with this line of code. I'm not saying this is an easy problem, But it turns out that when you use the right programming environment, many learning algorithms can be really short programs. <br/>
当然 研究人员 花了很长时间才想出这行代码的 -^ 我不是说这是一个简单的问题 但事实上 如果你 使用正确的编程环境 许多学习 算法是用很短的代码写出来的 <br/>
10:03<br/>
So this is also why in this class we're going to use the Octave programming environment. <br/>
所以这也是为什么在 这门课中我们要 使用Octave的编程环境 <br/>
10:08<br/>
Octave, is free open source software, and using a tool like Octave or Matlab, many learning algorithms become just a few lines of code to implement. Later in this class, I'll just teach you a little bit about how to use Octave and you'll be implementing some of these algorithms in Octave. Or if you have Matlab you can use that too. <br/>
Octave是一个免费的 开放源码的软件 使用Octave或Matlab这类的工具 许多学习算法 都可以用几行代码就可以实现 在后续课程中 我会教你如何使用Octave 你会学到 如何在Octave中实现这些算法 或者 如果你有Matlab 你可以用它 <br/>
10:27<br/>
It turns out the Silicon Valley, for a lot of machine learning algorithms, what we do is first prototype our software in Octave because software in Octave makes it incredibly fast to implement these learning algorithms. <br/>
事实上 在硅谷 很多的机器学习算法 我们都是先用Octave 写一个程序原型 因为在Octave中实现这些 学习算法的速度快得让你无法想象 <br/>
10:38<br/>
Here each of these functions like for example the SVD function that stands for singular value decomposition; but that turns out to be a linear algebra routine, that is just built into Octave. <br/>
在这里 每一个函数 例如 SVD 意思是奇异值分解 但这其实是解线性方程 的一个惯例 它被内置在Octave软件中了 <br/>
10:49<br/>
If you were trying to do this in C++ or Java, this would be many many lines of code linking complex C++ or Java libraries. So, you can implement this stuff as C++ or Java or Python, it's just much more complicated to do so in those languages. <br/>
如果你试图 在C + +或Java中做这个 将需要写N多代码 并且还要连接复杂的C + +或Java库 所以 你可以在C++或 Java或Python中 实现这个算法 只是会 更加复杂而已 <br/>
11:03<br/>
What I've seen after having taught machine learning for almost a decade now, is that, you learn much faster if you use Octave as your programming environment, and if you use Octave as your learning tool and as your prototyping tool, it'll let you learn and prototype learning algorithms much more quickly. <br/>
在教授机器学习 将近10年后 我得出的一个经验就是 如果你使用Octave的话 会学的更快 并且如果你用 Octave作为你的学习工具 和开发原型的工具 你的学习和开发过程 会变得更快 <br/>
11:22<br/>
And in fact what many people will do to in the large Silicon Valley companies is in fact, use an algorithm like Octave to first prototype the learning algorithm, and only after you've gotten it to work, then you migrate it to C++ or Java or whatever. It turns out that by doing things this way, you can often get your algorithm to work much faster than if you were starting out in C++. <br/>
而事实上在硅谷 很多人会这样做 他们会先用Octave 来实现这样一个学习算法原型 只有在确定 这个算法可以工作后 才开始迁移到 C++ Java或其它编译环境 事实证明 这样做 实现的算法 比你一开始就用C++ 实现的算法要快多了 <br/>
11:44<br/>
So, I know that as an instructor, I get to say "trust me on this one" only a finite number of times, but for those of you who've never used these Octave type programming environments before, I am going to ask you to trust me on this one, and say that you, you will, I think your time, your development time is one of the most valuable resources. <br/>
所以 我知道 作为一个老师 我不能老是念叨： “在这个问题上相信我“ 但对于 那些从来没有用过这种 类似Octave的编程环境的童鞋 我还是要请你 相信我这一次 我认为 你的时间 研发时间 是你最宝贵的资源之一 <br/>
12:04<br/>
And having seen lots of people do this, I think you as a machine learning researcher, or machine learning developer will be much more productive if you learn to start in prototype, to start in Octave, in some other language. <br/>
当见过很多的人这样做以后 我觉得如果你也这样做 作为一个机器学习的 研究者和开发者 你会更有效率 如果你学会先用Octave开发原型 而不是先用其他的编程语言来开发 <br/>
12:17<br/>
Finally, to wrap up this video, I have one quick review question for you. <br/>
最后 总结一下 这里有一个问题需要你来解答 <br/>
12:24<br/>
We talked about Unsupervised Learning, which is a learning setting where you give the algorithm a ton of data and just ask it to find structure in the data for us. Of the following four examples, which ones, which of these four do you think would will be an Unsupervised Learning algorithm as opposed to Supervised Learning problem. For each of the four check boxes on the left, check the ones for which you think Unsupervised Learning algorithm would be appropriate and then click the button on the lower right to check your answer. So when the video pauses, please answer the question on the slide. <br/>
我们谈到了无监督学习 它是一种学习机制 你给算法大量的数据 要求它找出数据中 蕴含的类型结构 以下的四个例子中 哪一个 您认为是 无监督学习算法 而不是监督学习问题 对于每一个选项 在左边的复选框 选中你认为 属于无监督学习的 选项 然后按一下右下角的按钮 提交你的答案 所以 当视频暂停时 请回答幻灯片上的这个问题 <br/>
13:01<br/>
So, hopefully, you've remembered the spam folder problem. If you have labeled data, you know, with spam and non-spam e-mail, we'd treat this as a Supervised Learning problem. <br/>
恩 没忘记垃圾邮件文件夹问题吧？ 如果你已经标记过数据 那么就有垃圾邮件和 非垃圾邮件的区别 我们会将此视为一个监督学习问题 <br/>
13:11<br/>
The news story example, that's exactly the Google News example that we saw in this video, we saw how you can use a clustering algorithm to cluster these articles together so that's Unsupervised Learning. <br/>
新闻故事的例子 正是我们在本课中讲到的 谷歌新闻的例子 我们介绍了你可以如何使用 聚类算法这些文章聚合在一起 所以这是无监督学习问题 <br/>
13:23<br/>
The market segmentation example I talked a little bit earlier, you can do that as an Unsupervised Learning problem because I am just gonna get my algorithm data and ask it to discover market segments automatically. <br/>
市场细分的例子 我之前有说过 这也是一个无监督学习问题 因为我是要 拿到数据 然后要求 它自动发现细分市场 <br/>
13:35<br/>
And the final example, diabetes, well, that's actually just like our breast cancer example from the last video. Only instead of, you know, good and bad cancer tumors or benign or malignant tumors we instead have diabetes or not and so we will use that as a supervised, we will solve that as a Supervised Learning problem just like we did for the breast tumor data. <br/>
最后一个例子 糖尿病 这实际上就像我们 上节课讲到的乳腺癌的例子 只不过这里不是 好的或坏的癌细胞 良性或恶性肿瘤我们 现在是有糖尿病或 没有糖尿病 所以这是 有监督的学习问题 像处理那个乳腺癌的问题一样 我们会把它作为一个 有监督的学习问题来处理 <br/>
13:58<br/>
So, that's it for Unsupervised Learning and in the next video, we'll delve more into specific learning algorithms and start to talk about just how these algorithms work and how we can, how you can go about implementing them.<br/>
好了 关于无监督学习问题 就讲这么多了 下一节课中我们 会涉及到更具体的学习算法 并开始讨论 这些算法是如何工作的 以及我们如何来实现它们 【教育无边界字幕组】翻译：碳老师 校对：linuxfish 审核：所罗门捷列夫</p>
</div>
</div>
</a>
<div class="read-more clearfix">
<div class="more-left left">
<span class="date">2017/3/9 22:44 下午</span>
<span>posted in </span>
<span class="posted-in"><a href='python.html'>python</a></span>
</div>
<div class="more-right right">
<span class="comments">
<a class="ds-thread-count" data-thread-key="14890706857877.html" data-count-type="comments" href="14890706857877.html#ds-thread"></a>
</span>
</div>
</div>
</div><!-- article -->
<div class="article">
<a class="clearlink" href="14884651923136.html">
<h1>Github高阶使用之webhook</h1>
<div class="a-content">
<div class="a-content-text">
<h2 id="toc_0">github webhook</h2>
<p>官网文档:<a href="https://developer.github.com/webhooks/">https://developer.github.com/webhooks/</a></p>
<h4 id="toc_1">tips</h4>
<ul>
<li>每个repo可以创建最多20个webhook</li>
<li>默认只订阅<code>push</code>事件</li>
<li><code>*</code>通配符事件不建议使用</li>
<li><code>Payloads</code>最大5M,不建议一次性<code>push</code>太多分支或者标签及备注</li>
</ul>
<h2 id="toc_2">Webhook Headers</h2>
<table>
<thead>
<tr>
<th>Name</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><code>X-GitHub-Event</code></td>
<td>The <a href="/v3/activity/events/types/">event type</a> that was triggered.</td>
</tr>
<tr>
<td><code>X-GitHub-Delivery</code></td>
<td>A <a href="http://en.wikipedia.org/wiki/Globally_unique_identifier">guid</a> to identify the payload and event being sent.</td>
</tr>
<tr>
<td><code>X-Hub-Signature</code></td>
<td>The value of this header is computed as the HMAC hex digest of the body, using the <code>secret</code> config option as the key.</td>
</tr>
</tbody>
</table>
<h2 id="toc_3">事件表</h2>