diff --git "a/20171020 \347\254\25418\346\234\237/PerceptuallyUniformColorSpaces.md" "b/20171020 \347\254\25418\346\234\237/PerceptuallyUniformColorSpaces.md"
deleted file mode 100644
index 20176036b0516605cf39d791e9a42dc3e9be1e68..0000000000000000000000000000000000000000
--- "a/20171020 \347\254\25418\346\234\237/PerceptuallyUniformColorSpaces.md"
+++ /dev/null
@@ -1,139 +0,0 @@
-# 感知一致性色彩空间
-
-原文链接：[Perceptually uniform color spaces](https://programmingdesignsystems.com/color/perceptually-uniform-color-spaces/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com)
-
-> “在视觉感知中，颜色几乎从未被看到，因为它实际上就是它。这一事实使得色彩成为艺术中最相关的媒介。“
->
-> Josef Albers (1963), Interaction of Color
-
-如果你围捕了一组图形设计师并要求他们定义感知统一色彩空间的概念,t那么很可能他们都不知道该说些什么。 On the surface, perceptual uniformity is somewhat easy to explain: These color spaces are human-friendly alternatives to color spaces such as sRGB, and they are incredibly helpful for designers working in code. Despite of this, they can feel daunting to use in programmatic designs. Perceptually uniform color spaces have roots in scientific color theory, and this community does little to make them accessible to a larger audience. In this chapter, we will look at the concept of perceptually uniform color spaces, and answer some common questions related to them: What are they? Why do we need them? How can we use them in code?
-
-# What is wrong with sRGB?
-
-Let us pretend that you want to design a poster with ten squares changing in color from green to blue in equal steps. *“Easy”*, you might say, and whip up some code that creates an equal change in hue between each rectangle. Convinced that the result will be a nice looking gradient, you are surprised to see the following output after running the code.
-
-
-
-You might notice something odd about this colored strip of rectangles. Although the colors change from green to blue, they appear to change a lot more towards the end of the strip. The green colors look almost identical, while the blue colors are more diverse. It also has a lot of variation in the lightness of the colors, with the cyan colors in the middle looking brighter than the blue colors. This happens because the default sRGB color space (and any color model built on it like HSV and HSL) is irregular, which means that even though the rectangles have evenly spaced hue values, the corresponding effect is not linear to the human eye.
-
-The CIE chromaticity diagram showing wavelength of major colors in the color spectrum.
-
-To explain why, we need to look at the chromaticity diagram we briefly discussed in the last chapter. This diagram is the result of extensive scientific experiments in the 1930’s, and it plots the visible color spectrum onto a scale based on the human vision. The first thing you might notice is that the diagram has a lot of green in it. The blue numbers displayed on the edge of the color spectrum show the wavelength of the corresponding color, and you will notice that the colors from around 520nm to 560nm all look green. But if you take another 40nm range, e.g. 460nm to 500nm, it includes a much broader set of colors between blue, cyan, and green. This explains why a majority of the rectangles in our design above are green, and why we see a sudden shift towards blue at the end of the scale: moving linearly through the hues will look disproportionate to the eye. If we want to operate with color as it relates to the human vision, we need a color space built on these human measurements, and that is what perceptually uniform color spaces are.
-
-The following rectangles also have an even distribution in hues, but this time the colors were created with a perceptually uniform color space. Notice how the colors remain constant in their lightness, and that the hues are evenly distributed to make a linear color gradient.
-
-
-
-Why do we need perceptually uniform color spaces? Because working with color in code is different than working with color in traditional design tools. Traditional tools encourage designers to think in manual workflows with the color picker as the primary way of choosing color combinations. In this scenario, designers use their eyes to decide whether a color is right or wrong, and the RGB values play no role in this decision. Code is different, because programming languages encourage designers to think about colors as numbers or positions within the chosen color model. This skill is hard to learn if the numbers do not correspond with the output. Perceptually uniform color spaces allow us to align numbers in our code with the visual effect perceived in our viewers.
-
-In some cases, perceptually uniformity is essential. A simple example like wanting to choose a random color to be readable against a dark background can be hard in irregular color spaces, because colors with the same lightness or brightness vary greatly in how bright they appear (blue and yellow both have 100% brightness in HSV, but blue is much darker than yellow). One would need to do all sorts of calculation based on the chosen hue to make the random colors equally bright.
-
-If designers are not aware of this, it can even lead to misleading designs. A good example is the use of continuous color scales in data visualization. For certain map types, designers use a gradient to color geographic areas to reflect the value of a data point, and the user can compare colors between regions to get a sense of the data. If the designer created the color scale in a regular color space, the perceived colors will be different from the data points reflected in the color values. To have the design show the actual data, a perceptually uniform color space is required.
-
-# A better solution
-
-The International Commission on Illumination (CIE) created the aforementioned chromaticity diagram in the 1930’s to solve this problem. This diagram is actually a 2D view of a color space called CIEXYZ, which in the 1970’s was replaced with the slightly improved CIELUV and CIELAB color spaces. It is hard to describe how these color spaces work without going into the underlying math, but they generally allow you to specify color, not in light mixes, but in dimensions that relate more to the human vision, and they do sophisticated color transformations to ensure that these dimensions reflect how the human vision works. For example, the CIELUV color space has two dimensions – *u* and *v* – that represent color scales from red to green and yellow to blue. To create a color in the CIELUV color space, one has to define the lightness of the color (*l*), whether it is reddish or greenish (*u*), and whether it is yellowish or bluish (*v*). Similarly, humans compute signals from our retina cones via the opponent process model, which makes it impossible to see reddish-green or yellowish-blue colors.
-
-Even though these color spaces are based on human perception, they are not intuitive when working in code. Like a RGB color space, it can be hard to guess which LUV numbers are required to create e.g. a dark purple or bright cyan. Thankfully, perceptually uniform color spaces can also remap their dimensions in different color models, so designers can work with more intuitive dimensions, while keeping the perceptual uniformity.
-
-# HSLuv
-
-The [HSLuv project](http://www.hsluv.org/) is one of the more recent attempts at making these color spaces more intuitive. It allows you to use the CIELUV color space in the same dimensions as the HSL color model. Referred to as a human-friendly HSL, the original code was written in the Haxe programming language, but the project is now implemented in most of the popular programming languages, including JavaScript.
-
-Before diving into the code-specifics, it is important to understand how HSLuv differs from HSL. HSLuv allows you to define a color based on three dimensions – hue, saturation, and lightness – but contrary to a HSL color model based on sRGB, colors that share the same value for a dimension are guaranteed to look similar. Two colors with an identical lightness value will look equally bright, and two colors with the same saturation will have the same perceived color purity. Like HSL, the saturation and lightness dimension is represented as a percentage between `0` and `100`, but in HSLuv those percentages reflect the perceived color mixing. A gray color with a lightness of `50` is guaranteed to be mid-gray.
-
-Even though it is not a built-in color mode, HSLuv works great with P5.js. To use the library, you first need to download the [latest HSLuv release](https://github.com/hsluv/hsluv/releases), and then include the library file in your HTML file. This makes the HSLuv color conversion functions accessible in your sketch.
-
-```
-
-
-```
-
-Every implementation of HSLuv includes four functions that can be used to convert between HSLuv and RGB. We can use one of these functions – `hsluvToRgb()` – to convert the HSLuv color values into RGB values that the `fill()` and `stroke()` functions can understand. The `hsluvToRgb()` function expects an array with three values – the desired hue, saturation, and lightness of the color – and returns another array with RGB values in the range of `0` to `1`. Because P5.js expects RGB values between `0` and `255`, we need to multiply the array values to scale them up. This boils down to two lines of code, which is illustrated in the example below.
-
-```
-// First convert the HSLuv values to a RGB array
-var rgb = hsluv.hsluvToRgb([0, 50, 50]);
-
-// Then use the RGB values in a scale of 0-255
-fill(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
-```
-
-This means that every time you have to create a perceptually uniform color for the `fill()` or `stroke()` function, you need an extra line of code to handle the HSLuv to RGB conversion. This can be prevented by creating small helper functions that wrap these two lines of code.
-
-```
-function fillHsluv(h, s, l) {
- var rgb = hsluv.hsluvToRgb([h, s, l]);
- fill(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
-}
-
-function strokeHsluv(h, s, l) {
- var rgb = hsluv.hsluvToRgb([h, s, l]);
- stroke(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
-}
-```
-
-You can now use these two functions instead of the built-in fill and stroke functions. It is essentially a way to make your own colorMode in P5.js without using the colorMode function. Below is a quick example to demonstrate how to use them.
-
-```
-noStroke();
-fillHsluv(0, 100, 50);
-ellipse(150, height/2, 200, 200);
-
-noFill();
-strokeWeight(5);
-strokeHsluv(120, 100, 50);
-ellipse(300, height/2, 200, 200);
-
-noStroke();
-fillHsluv(240, 100, 50);
-ellipse(450, height/2, 200, 200);
-```
-
-
-
-Now that we have the ability to use a perceptually uniform color space in P5.js, we can replicate the rectangle gradient experiment from the beginning of the chapter. The following example uses the same color values to draw a strip of rectangles using both HSL and HSLuv. Notice how the colors in the latter example look equally bright.
-
-```
-var w = width / 10;
-
-colorMode(HSL);
-for(var i = 0; i < numRects; i++) {
- fill(i * 18, 100, 50);
- rect(i * w, 0, w, height/2);
-}
-
-colorMode(RGB);
-translate(0, height/2);
-for(var i = 0; i < numRects; i++) {
- fillHsluv(i * 18, 100, 50);
- rect(i * w, 0, w, height/2);
-}
-```
-
-
-
-We can also use these new functions to choose random colors that are readable against a specific background color. The example below shows a line of text in random colors using both HSL and HSLuv. Notice how the first example sometimes use very bright yellows even though the lightness is constant. The latter example that uses the perceptually uniform color space does not have this problem.
-
-```
-var fontSize = 30;
-textSize(fontSize);
-
-translate(50, 50 + fontSize);
-colorMode(HSL);
-for(var i = 0; i < 10; i++) {
- fill(random(360), 100, 50);
- text("Can you read this line of text?", 0, i * fontSize);
-}
-
-colorMode(RGB);
-translate(0, 340);
-for(var i = 0; i < 10; i++) {
- fillHsluv(random(360), 100, 50);
- text("Can you read this line of text?", 0, i * fontSize);
-}
-```
-
-
-
-Even though P5.js does not understand the concept of perceptually uniform color spaces, this chapter has demonstrated how to use the HSLuv JavaScript library to convert from a perceptually uniform color space into the sRGB color space that P5.js uses. In the coming chapters, we will use this technique to procedurally generate color schemes and use them to create dynamic designs in P5.js
\ No newline at end of file
diff --git "a/20171020 \347\254\25418\346\234\237/StopUsingWord2vec.md" "b/20171020 \347\254\25418\346\234\237/StopUsingWord2vec.md"
deleted file mode 100644
index 23e9cc4c12f031e748eb9f4a0f61df9a91eef987..0000000000000000000000000000000000000000
--- "a/20171020 \347\254\25418\346\234\237/StopUsingWord2vec.md"
+++ /dev/null
@@ -1,58 +0,0 @@
-# Stop Using word2vec
-
-原文链接：[Stop Using word2vec](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com)
-
-When I started playing with word2vec four years ago I needed (and luckily had) tons of supercomputer time. But because of advances in our understanding of word2vec, computing word vectors now takes fifteen minutes on a single run-of-the-mill computer with standard numerical libraries[1](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#1). Word vectors are [awesome](http://multithreaded.stitchfix.com/blog/2015/03/11/word-is-worth-a-thousand-vectors/) but you don’t need a neural network – and definitely don’t need deep learning – to find them[2](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#2). So if you’re using word vectors and aren’t gunning for state of the art or a paper publication then *stop using word2vec.*
-
-When we’re finished you’ll measure word similarities:
-
-```
-facebook ~ twitter, google, ...
-```
-
-… and the classic word vector operations: `zuckerberg - facebook + microsoft ~ nadella`
-
-…but you’ll do it mostly by counting words and dividing, no gradients harmed in the making!
-
-## The recipe
-
-Let’s assume you’ve already gotten your hands on the [Hacker News corpus](https://cloud.google.com/bigquery/public-data/hacker-news) and cleaned & tokenized it (or downloaded the preprocessed version [here](https://zenodo.org/record/49899)). Here’s the method:
-
-1. **Unigram Probability**. How often do I see `word1` and `word2` independently? *Example*: This is just a simple word count that fills in the `unigram_counts` array. Then divide `unigram_counts` array by it’s sum to get the probability `p` and get numbers like: `p('facebook')` is 0.001% and `p('lambda')` is 0.000001%
-
-2. **Skipgram Probability**. How often did I see `word1` nearby `word2`? These are called ‘skipgrams’ because we can ‘skip’ up to a few words between `word1` and `word2`.[3](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#3) *Example*: Here we’re counting pairs of words that are near each other, but not necessarily right next to each other. After normalizing the `skipgram_count` array, you’ll get a measurement of word-near-word probabilities like `p('facebook', 'twitter')`. If the value for `p('facebook', 'twitter')` is 10^-9 then out of one billion skipgram tuples you’ll typically see ‘facebook’ and ‘twitter’ once. For another skipgram like `p('morning', 'facebook')` this fraction might be much larger, like 10^-5, simply because the word `morning` is a frequent word.
-
-3. **Normalized Skipgram Probability (or PMI)**. Was the skipgram frequency higher or lower than what we expected from the unigram frequency? Some words are extremely common, some are very rare, so divide the skipgram frequency by the two unigram frequencies. If the result is more than 1.0, then that skipgram occurred more frequently than the unigram probabilities of the two input words and we’ll call the two input words “associated”. The greater the ratio, the more associated. For ratios less than 1.0, the more “anti-associated”. If we take the log of this number it’s called the [pointwise mutual information (PMI)](https://en.wikipedia.org/wiki/Pointwise_mutual_information) of word X and word Y. This is a well-understood measurement in the information theory community and represents how frequently X and Y coincide ‘mutually’ (or jointly) rather than independently. *Example 1*: If we look at the association between `facebook` and `twitter` we’ll see that it’s above 1.0: `p('facebook', 'twitter') / p('facebook') / p('twitter') = 1000`. So `facebook` and `twitter` have unusually high-cooccurrence and we infer that they must be associated or similar. Note that we haven’t done any neural network stuff and no math aside from counting & dividing, but we can already measure how associated two words are. Later on we’ll calculate word vectors from this data, and those vectors will be constrained to reproduce these word-to-word relationships. [4](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#4)
-
- *Example 2*: For `facebook` and `okra` the PMI (`p('facebook', 'okra') / p('facebook') / p('okra')`) is close to 1.0, so `facebook` and `okra` aren’t associated empirically in the data. Later on we’ll form vectors that reconstruct and respect this relationship, and so will have little overlap. But of course the word counts are noisy, and this noise induces spurious associations between words.
-
-4. **PMI Matrix**. Make a big matrix where each row represents word `X` and each column represents word `Y` and each value is the `PMI` we calculated in step 3: `PMI(X, Y) = log (p(x, y) / p(x) / p(y))`. Because we have as many rows and columns as we have words, the size of the matrix is (`n_vocabulary`, `n_vocabulary`). And because `n_vocabulary` is typically 10k-100k, this is a big matrix with lots of zeros, so it’s best to use sparse array data structures to represent the PMI matrix. 
-
-5. **SVD**. Now we reduce the dimensionality of that matrix. This effectively compresses our giant matrix into two smaller matrices. Each of these smaller matrices form a set of word vectors with size (`n_vocabulary`, `n_dim`).[5](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#5) Each row of one matrix represents a single word vector. This is a straightforward operation in any linear algebra library, and in Python it looks like: `U, S, V = scipy.sparse.linalg.svds(PMI, k=256)` *Example*. The SVD is one of the most fundamental and beautiful tools you can use in machine learning and is what’s doing most of the magic. Read more about it in [Jeremy Kun’s](https://twitter.com/jeremyjkun?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) excellent [series](https://jeremykun.com/2016/04/18/singular-value-decomposition-part-1-perspectives-on-linear-algebra/). Here, we can think of it as compressing the original input matrix which (counting zeros) had close to ~10 billion entries (100k x 100k) reduced into two matrices with a total of ~50 million entries (100k x 256 x 2), a 200x reduction in space. The SVD outputs a space that is orthogonal, which is where we get our “linear regularity” and is where we get the property of being able to add and subtract word vectors meaningfully.
-
-6. **Searching**. Each row of the SVD output matrices is a word vector. Once you have these word eigenvectors, you can search for the tokens closest to `consolas`, which is a font popular in programming.
-
-```
-# In psuedocode:
-# Get the row vector corresponding to the word 'consolas'
-vector_consolas = U['consolas']
-# Get how similar it is to all other words
-similarities = dot(U, vector_consolas)
-# Sort by similarity, and pick the most similar
-most_similar = tokens[argmax(similarities)]
-most_similar
-```
-
-So searching for `consolas` yields `verdana` and `inconsolata` as most similar – which makes sense as these are other fonts. Searching for `Functional Programming` yields `FP`(an acronym), `Haskell` (a popular functional language), and `OOP` (which stands for Object Oriented Programming, an alternative to functional programming). Further, adding and subtracting these vectors and then searching gets word2vec’s hallmark feature: in computing the analogy `Mark Zuckerberg - Facebook + Amazon` we can relate the CEO of Facebook to that of Amazon, which appropriately evaluates to the `Jeff Bezos` token.
-
-It’s a hell of a lot more intuitive & easier to count skipgrams, divide by the word counts to get how ‘associated’ two words are and SVD the result than it is to understand what even a simple neural network is doing.
-
-So stop using the neural network formulation, but still have fun making word vectors!
-
-### Footnotes
-
-1. 1 The approach outlined here isn't exactly equivalent, but it performs about the same as word2vec skipgram negative-sampling [SGNS](https://papers.nips.cc/paper/5477-neural-word-embedding-as-implicit-matrix-factorization). It turns out that word2vec isn't [totally identical to matrix factorization](http://building-babylon.net/2016/05/12/skipgram-isnt-matrix-factorisation/), but for applied purposes (e.g., industry) the SVD technique is good enough. If you care about the differences between Word2vec, [Glove](https://nlp.stanford.edu/projects/glove/) and [Swivel](https://arxiv.org/abs/1602.02215) -- and in industrial purposes I rarely do -- then you'll care about word2vec SGNS vs this SVD formulation. Also, the SVD formulation neatly fits into a family of count-based bag-of-words techniques like TF-IDF, LSI and LDA: TF-IDF compares term frequencies to term frequencies within a document, with LSI doing a low-rank factorization of that TF-IDF matrix using the SVD. LDA also counts term frequencies within documents, but instead of SVD factorizes that result using a sparsity-inducing prior in the term and document vectors. That prior, among other things, makes them interpretable. Similarly, the formulation outlined here counts term-to-term associations (no documents) and SVD factorizes those into a low-rank representation. [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-1)
-2. 2 A few caveats: if you're doing academic research and spinning off your own embedding systems (for example as in lda2vec [[code\]](https://github.com/cemoody/lda2vec), [[paper\]](https://arxiv.org/abs/1605.02019) [[blog\]](http://multithreaded.stitchfix.com/blog/2016/05/27/lda2vec/#topic=38&lambda=1&term=)), tweaking the neural network approach can be useful. Also, SVD scales as O(N^3) so it isn't the best where you have large vocabularies N >> 100k. In this case, SGD is nice for online problems. [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-2)
-3. 3 In this simplest case, we won't model the effect of distance-weighted skipgrams. We'll just consider skipgrams within a fixed-size moving window around each word. Also note that we aren't regularizing our model, which could benefit from smoothing or forming a prior. Penalizing complexity especially helps in low-data cases, but in my experience this isn't necessary to get decent results on a wide set of real-life corpora with these methods. [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-3)
-4. 4 In some formulations, especially in truncated PMI, an important ingredient is the threshold `k` (typically a value like 25.0) which dampens the effect of low-PMI words, ostensibly to get a handle on noise. I interpret the `k` constant as a form of regularization, although it isn't clear to me that this is a disciplined prior. You can see [gauss2vec](https://arxiv.org/abs/1412.6623) for a more careful derivation, and this [paper](https://arxiv.org/abs/1402.3722) for an empirical exploration of this parameter. [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-4)
-5. 5 The interpretation is that these word vectors explain the covariance within the PMI matrix -- essentially a low-rank way of saying word X and Y are associated because they co-occur beyond their base rate popularity. Because the axes in the reduced space and are orthogonal it also explains why one can find 'linear regularities' that made the original word2vec famous. For example 'King' and 'Queen' might be seperated along a 'gender' direction but 'London' and 'Berlin' might share a spot in a 'capital' direction. These eigenevectors effectively find a small set of directions in the input space that can still maximially recreate the original large input matrix. [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-5)
\ No newline at end of file
diff --git "a/20171015 \347\254\25413\346\234\237/Intro To Data Analysis For Everyone! Part 1.md" "b/2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/Intro To Data Analysis For Everyone! Part 1.md"
similarity index 98%
rename from "20171015 \347\254\25413\346\234\237/Intro To Data Analysis For Everyone! Part 1.md"
rename to "2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/Intro To Data Analysis For Everyone! Part 1.md"
index a238f12b74ff238208d092867ffc6f0d3b9fb996..51ff9b0a12d28586cb5ecacf6cc8ac4f6f8a88b5 100644
--- "a/20171015 \347\254\25413\346\234\237/Intro To Data Analysis For Everyone! Part 1.md"
+++ "b/2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/Intro To Data Analysis For Everyone! Part 1.md"
@@ -1,171 +1,171 @@
-# 每个人的数据分析! Part 1
-
-原文链接：[Intro To Data Analysis For Everyone! Part 1](https://towardsdatascience.com/intro-to-data-analysis-for-everyone-part-1-ff252c3a38b5?from=hackcv&hmsr=hackcv.com)
-
-数据分析是任何数据科学家日常工作的一部分([以及数据篡改和清理](https://www.thoughtworks.com/insights/blog/let-data-scientists-be-data-mungers))。这对现代劳动力中其他大部分人来说也是非常重要的。可以是系统分析师、业务所有者、财务团队和项目经理。
-
-然而，大多数本科课程并没有[或至少没有](https://www.coursera.org/browse/datscience/datanalysis?)数据分析，而是有数学和统计学的课程，还有大量涉及数据结构和算法的计算机编程课程。
-
-然而，这些都没有关注如何查看来自数据库、csvs或现代数据世界中存在的数十个其他数据源的数据集。
-
-可能偶尔会有需要分析数据的项目。有些人可能很幸运地收到了一组项目，迫使他们第一次从数据库中分析数据。然而，大多数学生都在他们的第一份工作中试图自己解决这个问题。
-
-对于不打算成为程序员的学生来说， [理解数据库和SQL是一项非常有价值的技能](http://www.skilledup.com/articles/learn-sql-it-most-in-demand-skill-in-single-day)，这样可以让他们理解那些已经被数据库团队分析后的数据。
-
-管理人员不再能接受他们的团队看不懂数据，或不知道如何进行数据分析!因此，即使是营销专业的学生也需要知道如何使用和设计数据分析!
-
-数据分析是抽象的。它不是数学(虽然涉及数学)，也不是英语或会计。要真正理解优秀分析师会遇到的陷阱，就需要有实际的方法。然而，很遗憾的是大多数学生在进入第一份工作时，还不需要处理模糊的参数和庞大的数据集，许多学生甚至没有听说过数据仓库，然后这正是帮助管理者做出关键决策的大部分数据所在之处。
-
-在现代商业世界中，数据分析并不局限于数据科学家。对于分析师、系统工程师、金融团队、公关、人力资源、营销等等来说，这也是很重要的技能。
-
-因此，我们的团队想提供一个指南，帮助新学生和那些有兴趣学习更多数据科学和分析的人。
-
-### 良好数据科学和分析的基础
-
-本系列的第一部分将介绍良好分析所需的重要软技能。 [数据分析不仅仅是数学、SQL和脚本](https://www.theseattledataguy.com/statistics-data-scientist-review/)。它还包括保持组织有序，能够清晰地向管理者阐明已经发现的发现。这是[成功的数据科学和分析团队所描绘](https://www.theseattledataguy.com/top-30-tips-data-science-team-succeeds/)的众多特征之一。我们认为首先指出这些是很重要的，因为它为我们接下来的几个部分奠定了基础。
-
-在本节之后，我们将讨论分析过程、技术，并通过数据集、SQL和python笔记给出示例。
-
-**沟通**
-
-[术语数据讲故事者已经与数据科学家联系在一起](https://www.ted.com/talks/hans_rosling_shows_the_best_stats_you_ve_ever_seen)，但对于使用数据的人来说，擅长传达他们的发现也很重要！
-
-这种技能子集符合通信的一般技能。数据科学家可以访问来自不同部门的多个数据源。这使他们有责任并且需要能够清楚地解释他们在多个领域向高管和中小企业发现的内容。他们采用复杂的数学和技术概念，创建清晰简洁的信息，管理人员可以采取行动。不只是躲在他们的行话背后，而是将他们复杂的想法转化为商业话语。分析师和数据科学家都必须能够获取数字并返回明确规定的投资回报率和可行的决策。
-
-这意味着不仅要记笔记，还要创造扎实的工作簿。它还意味着为其他团队创建可靠的报告和遍历。
-
-这是如何做到的？（这可能是一个帖子本身），但这里有一些快速提示，可以更好地在报告或演示文稿中传达你的想法。
-
- 1. 标记每个图形，轴，数据点等
- 2. 在笔记本中创建自然的数据和笔记流
- 3. 确保突出您的主要发现！不要藏起来，把你的结论展示出来！使用大量数据证明您的观点时，这说起来容易做起来难。
- 4. 想象一下，你实际上在讲故事或写一篇有关数据的文章
- 5. 不要让观众觉得枯燥，保持甜美和简洁
- 6. 避免繁重的数学术语！如果你不能用简单的英语解释你的计算，你就没有完全理解。
- 7. 让同行审核您的报告和演示文稿，以确保最大程度的清晰度
-
-**我们最喜欢的数据故事之一！**
-
-
-
-
-
-**善于倾听**
-
-数据科学家和分析师并不总是与企业主和管理人员在同一个团队中提出问题。这使得分析师非常重视聆听实际被问到的内容。
-
-在大公司工作，试图寻找其他团队的痛点和问题并帮助他们度过难关是很有价值的！这意味着要有同理心。这项技能的一部分需要劳动力的经验，而这项技能的其他部分只需要了解其他人。
-
-为什么他们真的要求进行分析?你如何使分析尽可能清晰准确?
-
-与企业主沟通不畅很容易发生。因此 [认真倾听和倾听言外之意是一项很棒的技能](https://www.forbes.com/sites/glennllopis/2013/05/20/6-effective-ways-listening-can-make-you-a-better-leader/#3fafb2421756)。
-
-
-
-
-
-**关注背景**
-
-除了关注细节。数据分析师和数据科学家还需要关注他们分析的数据背后的背景。这意味着理解请求项目的其他部门的需求，以及实际理解他们分析的数据背后的过程。
-
-数据通常表示业务的流程。这可能是一个用户与电子商务网站交互，一个病人在医院，一个项目获得批准，软件被购买和开发等等。
-
-这意味着，数据分析师需要理解这些业务规则和逻辑!否则，他们就无法进行良好的分析，他们会做出错误的假设，并且常常会创建脏的、重复的数据。
-
-这都是因为他们不理解使用的场景。上下文允许以数据为中心的团队更清楚地做出假设。他们不需要在假设阶段花太多时间去检验所有可能的理论。相反，他们可以利用上下文来帮助加速分析的过程。
-
-数据周围的元数据(例如上下文)对于数据科学家来说就像黄金。它并不总是在那里，但当它在的时候。它使我们的工作更容易!
-
-**记录能力**
-
-[无论是用excel还是Jupyter笔记本](http://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html).。对于数据分析师来说，了解如何跟踪他们的工作是很重要的!
-
-分析需要大量的假设和问题，如果没有记录下来，就会失去思路。
-
-第二天回来时，很容易忘记分析了什么，不同的查询和指标是如何以及为什么被提取的，等等。因此，以一种勤奋的方式记录下每一件事情是很重要的。这个技巧是不能留给第二天的，因为总是会有信息丢失!
-
-创建一个清晰的记录方式使每个人都更容易参与。我们在之前的交流中提到过。然而,一次。
-
-标签，创造自然流通的笔记，避免商业术语可以帮助每个人参与，包括当初的记录人!当记录者都不理解自己的笔记，这将是相当尴尬的一件事。
-
-记笔记很重要！
-
-**创造性和抽象思维**
-
-创造力和 [抽象思维 ](http://www.projectlearnet.org/tutorials/concrete_vs_abstract_thinking.html)有助于数据科学家更好地假设他们在最初探索阶段看到的可能模式和特征。将逻辑思维与最小的数据点结合起来，数据科学家可以得出几种可能的解决方案。然而，这需要跳出框框进行思考。
-
-分析是有纪律的研究和创造性思维的结合。如果分析师受到确认偏差或过程的限制，那么他们可能无法得出正确的结论。
-
-另一方面，如果他们过于疯狂地思考，没有使用基本的推论和归纳来驱动他们的搜索。在浏览各种数据集时，他们可能会花上数周时间试图回答一个简单的问题，而没有任何明确的目标。
-
-**Engineering Mindset**
-
-分析师需要能够将大问题和数据集分解成更小的部分。有时候，一个单独的团队提出的2-3个问题无法用2-3个答案来回答。
-
-相反，2-3个问题本身可能需要被分解成小问题，这些问题可以被数据分析和支持。
-
-只有这样，分析师才能回去回答更大的问题。特别是对于大而复杂的数据集。[能够清楚地将分析分解成适当的部分](http://www.thwink.org/sustain/articles/000_AnalyticalApproach/index.htm).变得越来越重要。
-
-**注意细节**
-
-分析需要注意细节。仅仅因为一个分析师或数据科学家可能是一个大局观的人。这并不意味着他们不负责找出围绕项目的所有有价值的细节。
-
-公司，甚至是小公司都有很多角落和缝隙。流程上有流程，但不理解这些流程及其细节会影响可执行的分析级别。
-
-特别是在编写复杂的查询和编程脚本时。很容易不正确地连接表或过滤错误的东西。因此，总是进行两次和三次检查工作是非常关键的(而且，如果涉及脚本，同行评审也应该如此!)
-
-
-
-
-
-**好奇心**
-
-分析需要的好奇心。当我们分解这个过程时，我们会讲到这个。然而，分析过程中的一个步骤是列出所有您认为对分析有价值的问题。这需要一个好奇的心去关心答案。
-
-为什么数据是这样，为什么我们看到模式，我们能用什么来找到答案，谁知道呢?
-
-这些只是一些模糊的问题，可以帮助我们开始向正确的方向进行分析。 [需要有那种动力和欲望去知道为什么!](http://www.ibmbigdatahub.com/podcast/curious-data-scientist)
-
-**宽容失败**
-
-数据科学与科学领域有许多相似之处。从这个意义上说，可能有99个失败的假设导致1个成功的解决方案。一些数据驱动型的公司只希望他们的机器学习工程师和数据科学家每年创造新的算法，或者每年半的相关性。这取决于任务的大小和所需的实现类型(例如流程实现、技术、策略等)。在所有这些工作中都有失败后的失败，有未回答的问题后的问题和分析师不得不继续。
-
-关键是要得到答案，或者清楚地说明为什么你不能回答这个问题。然而，它不能仅仅因为最初的几次尝试失败而放弃。
-
-分析可以成为时间的黑洞。一个接一个的问题可能是不正确的。这就是为什么半结构化过程很重要。它可以指导分析师，但不会阻止他们。
-
-### **数据科学和分析软技能**
-
-这些技能分析人员和数据科学家需要的不仅仅是编程和统计分析。相反，这些技巧的重点在于确保所发现的洞见是易于转移的。这允许其他团队成员和经理也从分析中获益!
-
-分析师需要做的不仅仅是得出结论。他们需要能够创造出易于复制和传播的工作。
-
-**为什么?**
-
-它不仅节省时间!
-
-更重要的是，这有助于领导信任分析师的结论。否则，分析师可能是对的，但如果他或她听起来不自信，如果他们记错了笔记，甚至漏掉了一个数据点。这会立即导致领导层之间的不信任!
-
-不幸的是，这是真的!当仅仅一个数据点不正确或沟通不畅时，分析师的工作就会立即受到质疑。我们经常建议数据团队检查他们的报告和演示文稿，检查漏洞。在这种情况下，有一个善于质疑每个角度的团队成员是很好的!
-
-你的团队可以提前回答高管可能提出的问题越多。高管们更有可能在项目的下一阶段签字!
-
-
-
-
-
-**数据分析的过程**
-
-在下一部分中，我们将介绍分析数据的过程。我们将建立基本的笔记和描述简单的过程，这将帮助新的和有经验的数据科学家和分析师确保他们有效地跟踪他们的工作。
-
-### [Part 2 每个人的数据分析](https://medium.com/@SeattleDataGuy/data-analysis-for-everyone-part-2-cf1c79441940)
-
-**其他关于数据科学和策略的资源**
-
-[How To Apply Data Science To Real World Problems](https://www.theseattledataguy.com/data-science-case-studies/)
-
-[Amazon Using Data To Win The Grocery Store Game](https://www.theseattledataguy.com/amazon-taking-lunch-data-driven-strategies/)
-
-[30 Tips To Ensure Your Data Science Team Succeeds](https://www.theseattledataguy.com/top-30-tips-data-science-team-succeeds/)
-
+# 每个人的数据分析! Part 1
+
+原文链接：[Intro To Data Analysis For Everyone! Part 1](https://towardsdatascience.com/intro-to-data-analysis-for-everyone-part-1-ff252c3a38b5?from=hackcv&hmsr=hackcv.com)
+
+数据分析是任何数据科学家日常工作的一部分([以及数据篡改和清理](https://www.thoughtworks.com/insights/blog/let-data-scientists-be-data-mungers))。这对现代劳动力中其他大部分人来说也是非常重要的。可以是系统分析师、业务所有者、财务团队和项目经理。
+
+然而，大多数本科课程并没有[或至少没有](https://www.coursera.org/browse/datscience/datanalysis?)数据分析，而是有数学和统计学的课程，还有大量涉及数据结构和算法的计算机编程课程。
+
+然而，这些都没有关注如何查看来自数据库、csvs或现代数据世界中存在的数十个其他数据源的数据集。
+
+可能偶尔会有需要分析数据的项目。有些人可能很幸运地收到了一组项目，迫使他们第一次从数据库中分析数据。然而，大多数学生都在他们的第一份工作中试图自己解决这个问题。
+
+对于不打算成为程序员的学生来说， [理解数据库和SQL是一项非常有价值的技能](http://www.skilledup.com/articles/learn-sql-it-most-in-demand-skill-in-single-day)，这样可以让他们理解那些已经被数据库团队分析后的数据。
+
+管理人员不再能接受他们的团队看不懂数据，或不知道如何进行数据分析!因此，即使是营销专业的学生也需要知道如何使用和设计数据分析!
+
+数据分析是抽象的。它不是数学(虽然涉及数学)，也不是英语或会计。要真正理解优秀分析师会遇到的陷阱，就需要有实际的方法。然而，很遗憾的是大多数学生在进入第一份工作时，还不需要处理模糊的参数和庞大的数据集，许多学生甚至没有听说过数据仓库，然后这正是帮助管理者做出关键决策的大部分数据所在之处。
+
+在现代商业世界中，数据分析并不局限于数据科学家。对于分析师、系统工程师、金融团队、公关、人力资源、营销等等来说，这也是很重要的技能。
+
+因此，我们的团队想提供一个指南，帮助新学生和那些有兴趣学习更多数据科学和分析的人。
+
+### 良好数据科学和分析的基础
+
+本系列的第一部分将介绍良好分析所需的重要软技能。 [数据分析不仅仅是数学、SQL和脚本](https://www.theseattledataguy.com/statistics-data-scientist-review/)。它还包括保持组织有序，能够清晰地向管理者阐明已经发现的发现。这是[成功的数据科学和分析团队所描绘](https://www.theseattledataguy.com/top-30-tips-data-science-team-succeeds/)的众多特征之一。我们认为首先指出这些是很重要的，因为它为我们接下来的几个部分奠定了基础。
+
+在本节之后，我们将讨论分析过程、技术，并通过数据集、SQL和python笔记给出示例。
+
+**沟通**
+
+[术语数据讲故事者已经与数据科学家联系在一起](https://www.ted.com/talks/hans_rosling_shows_the_best_stats_you_ve_ever_seen)，但对于使用数据的人来说，擅长传达他们的发现也很重要！
+
+这种技能子集符合通信的一般技能。数据科学家可以访问来自不同部门的多个数据源。这使他们有责任并且需要能够清楚地解释他们在多个领域向高管和中小企业发现的内容。他们采用复杂的数学和技术概念，创建清晰简洁的信息，管理人员可以采取行动。不只是躲在他们的行话背后，而是将他们复杂的想法转化为商业话语。分析师和数据科学家都必须能够获取数字并返回明确规定的投资回报率和可行的决策。
+
+这意味着不仅要记笔记，还要创造扎实的工作簿。它还意味着为其他团队创建可靠的报告和遍历。
+
+这是如何做到的？（这可能是一个帖子本身），但这里有一些快速提示，可以更好地在报告或演示文稿中传达你的想法。
+
+ 1. 标记每个图形，轴，数据点等
+ 2. 在笔记本中创建自然的数据和笔记流
+ 3. 确保突出您的主要发现！不要藏起来，把你的结论展示出来！使用大量数据证明您的观点时，这说起来容易做起来难。
+ 4. 想象一下，你实际上在讲故事或写一篇有关数据的文章
+ 5. 不要让观众觉得枯燥，保持甜美和简洁
+ 6. 避免繁重的数学术语！如果你不能用简单的英语解释你的计算，你就没有完全理解。
+ 7. 让同行审核您的报告和演示文稿，以确保最大程度的清晰度
+
+**我们最喜欢的数据故事之一！**
+
+
+
+
+
+**善于倾听**
+
+数据科学家和分析师并不总是与企业主和管理人员在同一个团队中提出问题。这使得分析师非常重视聆听实际被问到的内容。
+
+在大公司工作，试图寻找其他团队的痛点和问题并帮助他们度过难关是很有价值的！这意味着要有同理心。这项技能的一部分需要劳动力的经验，而这项技能的其他部分只需要了解其他人。
+
+为什么他们真的要求进行分析?你如何使分析尽可能清晰准确?
+
+与企业主沟通不畅很容易发生。因此 [认真倾听和倾听言外之意是一项很棒的技能](https://www.forbes.com/sites/glennllopis/2013/05/20/6-effective-ways-listening-can-make-you-a-better-leader/#3fafb2421756)。
+
+
+
+
+
+**关注背景**
+
+除了关注细节。数据分析师和数据科学家还需要关注他们分析的数据背后的背景。这意味着理解请求项目的其他部门的需求，以及实际理解他们分析的数据背后的过程。
+
+数据通常表示业务的流程。这可能是一个用户与电子商务网站交互，一个病人在医院，一个项目获得批准，软件被购买和开发等等。
+
+这意味着，数据分析师需要理解这些业务规则和逻辑!否则，他们就无法进行良好的分析，他们会做出错误的假设，并且常常会创建脏的、重复的数据。
+
+这都是因为他们不理解使用的场景。上下文允许以数据为中心的团队更清楚地做出假设。他们不需要在假设阶段花太多时间去检验所有可能的理论。相反，他们可以利用上下文来帮助加速分析的过程。
+
+数据周围的元数据(例如上下文)对于数据科学家来说就像黄金。它并不总是在那里，但当它在的时候。它使我们的工作更容易!
+
+**记录能力**
+
+[无论是用excel还是Jupyter笔记本](http://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html).。对于数据分析师来说，了解如何跟踪他们的工作是很重要的!
+
+分析需要大量的假设和问题，如果没有记录下来，就会失去思路。
+
+第二天回来时，很容易忘记分析了什么，不同的查询和指标是如何以及为什么被提取的，等等。因此，以一种勤奋的方式记录下每一件事情是很重要的。这个技巧是不能留给第二天的，因为总是会有信息丢失!
+
+创建一个清晰的记录方式使每个人都更容易参与。我们在之前的交流中提到过。然而,一次。
+
+标签，创造自然流通的笔记，避免商业术语可以帮助每个人参与，包括当初的记录人!当记录者都不理解自己的笔记，这将是相当尴尬的一件事。
+
+记笔记很重要！
+
+**创造性和抽象思维**
+
+创造力和 [抽象思维 ](http://www.projectlearnet.org/tutorials/concrete_vs_abstract_thinking.html)有助于数据科学家更好地假设他们在最初探索阶段看到的可能模式和特征。将逻辑思维与最小的数据点结合起来，数据科学家可以得出几种可能的解决方案。然而，这需要跳出框框进行思考。
+
+分析是有纪律的研究和创造性思维的结合。如果分析师受到确认偏差或过程的限制，那么他们可能无法得出正确的结论。
+
+另一方面，如果他们过于疯狂地思考，没有使用基本的推论和归纳来驱动他们的搜索。在浏览各种数据集时，他们可能会花上数周时间试图回答一个简单的问题，而没有任何明确的目标。
+
+**Engineering Mindset**
+
+分析师需要能够将大问题和数据集分解成更小的部分。有时候，一个单独的团队提出的2-3个问题无法用2-3个答案来回答。
+
+相反，2-3个问题本身可能需要被分解成小问题，这些问题可以被数据分析和支持。
+
+只有这样，分析师才能回去回答更大的问题。特别是对于大而复杂的数据集。[能够清楚地将分析分解成适当的部分](http://www.thwink.org/sustain/articles/000_AnalyticalApproach/index.htm).变得越来越重要。
+
+**注意细节**
+
+分析需要注意细节。仅仅因为一个分析师或数据科学家可能是一个大局观的人。这并不意味着他们不负责找出围绕项目的所有有价值的细节。
+
+公司，甚至是小公司都有很多角落和缝隙。流程上有流程，但不理解这些流程及其细节会影响可执行的分析级别。
+
+特别是在编写复杂的查询和编程脚本时。很容易不正确地连接表或过滤错误的东西。因此，总是进行两次和三次检查工作是非常关键的(而且，如果涉及脚本，同行评审也应该如此!)
+
+
+
+
+
+**好奇心**
+
+分析需要的好奇心。当我们分解这个过程时，我们会讲到这个。然而，分析过程中的一个步骤是列出所有您认为对分析有价值的问题。这需要一个好奇的心去关心答案。
+
+为什么数据是这样，为什么我们看到模式，我们能用什么来找到答案，谁知道呢?
+
+这些只是一些模糊的问题，可以帮助我们开始向正确的方向进行分析。 [需要有那种动力和欲望去知道为什么!](http://www.ibmbigdatahub.com/podcast/curious-data-scientist)
+
+**宽容失败**
+
+数据科学与科学领域有许多相似之处。从这个意义上说，可能有99个失败的假设导致1个成功的解决方案。一些数据驱动型的公司只希望他们的机器学习工程师和数据科学家每年创造新的算法，或者每年半的相关性。这取决于任务的大小和所需的实现类型(例如流程实现、技术、策略等)。在所有这些工作中都有失败后的失败，有未回答的问题后的问题和分析师不得不继续。
+
+关键是要得到答案，或者清楚地说明为什么你不能回答这个问题。然而，它不能仅仅因为最初的几次尝试失败而放弃。
+
+分析可以成为时间的黑洞。一个接一个的问题可能是不正确的。这就是为什么半结构化过程很重要。它可以指导分析师，但不会阻止他们。
+
+### **数据科学和分析软技能**
+
+这些技能分析人员和数据科学家需要的不仅仅是编程和统计分析。相反，这些技巧的重点在于确保所发现的洞见是易于转移的。这允许其他团队成员和经理也从分析中获益!
+
+分析师需要做的不仅仅是得出结论。他们需要能够创造出易于复制和传播的工作。
+
+**为什么?**
+
+它不仅节省时间!
+
+更重要的是，这有助于领导信任分析师的结论。否则，分析师可能是对的，但如果他或她听起来不自信，如果他们记错了笔记，甚至漏掉了一个数据点。这会立即导致领导层之间的不信任!
+
+不幸的是，这是真的!当仅仅一个数据点不正确或沟通不畅时，分析师的工作就会立即受到质疑。我们经常建议数据团队检查他们的报告和演示文稿，检查漏洞。在这种情况下，有一个善于质疑每个角度的团队成员是很好的!
+
+你的团队可以提前回答高管可能提出的问题越多。高管们更有可能在项目的下一阶段签字!
+
+
+
+
+
+**数据分析的过程**
+
+在下一部分中，我们将介绍分析数据的过程。我们将建立基本的笔记和描述简单的过程，这将帮助新的和有经验的数据科学家和分析师确保他们有效地跟踪他们的工作。
+
+### [Part 2 每个人的数据分析](https://medium.com/@SeattleDataGuy/data-analysis-for-everyone-part-2-cf1c79441940)
+
+**其他关于数据科学和策略的资源**
+
+[How To Apply Data Science To Real World Problems](https://www.theseattledataguy.com/data-science-case-studies/)
+
+[Amazon Using Data To Win The Grocery Store Game](https://www.theseattledataguy.com/amazon-taking-lunch-data-driven-strategies/)
+
+[30 Tips To Ensure Your Data Science Team Succeeds](https://www.theseattledataguy.com/top-30-tips-data-science-team-succeeds/)
+
[A Brilliant Explanation of A Decision Tree](http://www.acheronanalytics.com/acheron-blog/brilliant-explanation-of-a-decision-tree-algorithms)
\ No newline at end of file
diff --git "a/20171015 \347\254\25413\346\234\237/PyTorch tutorial distilled.md" "b/2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/PyTorch tutorial distilled.md"
similarity index 99%
rename from "20171015 \347\254\25413\346\234\237/PyTorch tutorial distilled.md"
rename to "2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/PyTorch tutorial distilled.md"
index 07b3d8e5ef046fc458ae9692d5270833a6728207..13df31c62b53047b486c664ded3c9e64564fda06 100644
--- "a/20171015 \347\254\25413\346\234\237/PyTorch tutorial distilled.md"
+++ "b/2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/PyTorch tutorial distilled.md"
@@ -1,188 +1,188 @@
-# PyTorch教程
-
-原文链接：[PyTorch tutorial distilled](https://towardsdatascience.com/pytorch-tutorial-distilled-95ce8781a89c?from=hackcv&hmsr=hackcv.com)
-
-## 从 TensorFlow 转向了 PyTorch
-
-
-
-
-
-在我第一次开始学习PyTorch时候，过了几天我就放弃了，对我来说理解这个框架的核心概念和TensorFlow比起来太难了。这就是为什么我把它放在了我的“知识书架”上，渐渐的遗忘了它。但是不久之后，PyTorch的新版本的发布了，我决定再尝试一次。过了一会，我意识到这个框架简便易行，让我很开心的使用PyTorch来编程。我会尝试清楚地解释它的核心概念，这样你就会有动力，至少现在试一试，而不是几年或更长时间。我们将介绍一些基本原则和一些高级内容，如学习速率调度程序，自定义层等。
-
-#### 学习资料
-
-首先，你应该了解PyTorch， [文档](http://pytorch.org/docs/master/) 和 [教程](http://pytorch.org/tutorials/)是分开存储的。因为更新的太快了，所有他们可能有部分会不一样，所以请查阅 [源代码](http://pytorch.org/tutorials/)，这就非常明确和直截了当。而且，还有一个很棒的[PyTorch论坛](https://discuss.pytorch.org/),在那里你可以提出任何合适的问题，你可以得到一个相对较快的答案。 对于PyTorch用户来说，这个地方似乎比StackOverflow更受欢迎。
-
-#### PyTorch as NumPy
-
-让我们来讨论PyTorch本身，PyTorch的主要构建块是tensors。确实他和[NumPy ones](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)很相似。 Tensors支持很多和相同的API，因此有时可以使用PyTorch作为NumPy的代替品。你可能想问为什么要这么做，主要的原因是PyTorch的主要目标是使用GPU，这样您就可以将数据预处理或任何其他需要大量计算的内容转移到机器学习中。很容易就可以转换tensors从NumPy转换为PyTorch，反之亦然。我们用代码来举个例子：
-
-
-
-您可能会注意到, 我们手动计算并应用了渐变。我们有优化器吗？答案是肯定的！
-
-
-
-
-
-现在我们所有的变量都会自动更新。但是你应该从最后一个片段得到的要点：我们仍然应该在计算新的渐变之前手动归零。这是PyTorch的核心概念之一。有时为什么我们应该这样做可能不是很明显，但另一方面，我们可以完全控制我们的渐变，我们何时以及如何应用它们。
-
-#### 静态与动态计算图的比较
-
-PyTorch和TensorFlow的下一个主要区别是它们对图形表示的方法。 Tensorflow [使用静态图表](https://www.tensorflow.org/programmers_guide/graphs)，这意味着我们一次又一次地执行该图表后定义它。在PyTorch中，每个前向传递定义了一个新的计算图。一开始，这些方法之间的区别并不那么大。但是，当您想要调试代码或定义一些条件语句时，动态图变得非常少。您可以使用自己喜欢的调试器！比较while循环语句的下两个定义 - TensorFlow中的第一个定义和PyTorch中的第二个定义：
-
-
-
-
-
-
-
-
-
-It seems to me that second solution much easier than first one. And what do you think about it?
-
-#### Models definition
-
-好的，现在我们看到在PyTorch中构建一些if / else / while复杂语句很容易。但是让我们回到通常的模型。该框架提供了与[Keras](https://keras.io/) 非常相似的开箱即用层构造函数：
-
-> `nn`包定义了一组**模块**，大致相当于神经网络层。模块接收输入变量并计算输出变量，但也可以保持内部状态，例如包含可学习参数的变量。 `nn`包还定义了一组在训练神经网络时常用的有用损失函数。
-
-
-
-
-
-另外，如果我们想构建更复杂的模型，我们可以子类提供`nn.Module`类。当然，这两种方法可以相互混合。
-
-
-
-
-
-在`__init__`方法中，我们应该定义稍后将使用的所有层。在`forward`方法中，我们应该提出我们想要使用已经定义的层的步骤。像往常一样，向后传递将自动计算。
-
-#### 自定义图层
-
-但是如果我们想用非标准的backprop定义一些自定义模型呢？这是一个例子 - XNOR网络：
-
-
-
-
-
-
-
-我不会深入了解详细信息，更多关于您可能在[入门手册](https://arxiv.org/abs/1603.05279)中阅读的此类网络。与我们的问题相关的是，反向传播应仅适用于小于1且大于-1的权重。在PyTorch中，它[可以非常简单地实现](http://pytorch.org/docs/master/notes/extending.html):
-
-
-
-你可能会看到，我们应该只定义两个方法：一个用于前进，一个用于后向传递。如果我们需要从前向传递中访问一些变量，我们可以将它们存储在`ctx`变量中。注意：在以前的API中，前向/后向方法不是静态的，我们将所需的变量存储为`self.save_for_backward(input)`并通过`input,_ = self.saved_tensors`访问。
-
-#### 用CUDA训练模型
-
-如果之前讨论过如何将一个张量传递给CUDA。但是如果我们想要传递整个模型，可以从模型本身调用`.cuda（）`方法，并将每个输入变量包装到`.cuda（）`中就足够了。在所有计算之后，我们应该使用`.cpu（）`方法返回结果。
-
-
-
-
-
-此外，PyTorch支持源代码中的直接设备分配：
-
-
-
-
-
-因为有时我们想在没有代码修改的情况下在CPU和GPU上运行相同的模型，我建议使用某种包装器：
-
-
-
-
-
-#### 权重初始化
-
-在TensorFlow中，权重初始化主要在张量声明期间进行。 PyTorch提供了另一种方法 - 首先应该声明张量，并且在下一步中应该改变该张量的权重。权重可以初始化为对tensor属性的直接访问，作为对`torch.nn.init`包中的一堆方法的调用。这个决定可能不是很简单，但是当你想用相同的初始化初始化某些类型的所有层时它会变得很有用。
-
-
-
-
-
-#### 逆向排除子图
-
-有时，当您想要重新训练模型的某些层或为生产模式做好准备时，您可以为某些图层禁用自动编程机制。为此，[PyTorch提供了两个标志](http://pytorch.org/docs/master/notes/autograd.html)：`requires_grad`和`volatile`。第一个将禁用当前图层的渐变，但子节点仍然可以计算一些。第二个将禁用当前层和所有子节点的autograd。
-
-
-
-
-
-#### 训练过程
-
-PyTorch中还存在一些其他的花里胡哨。例如，您可以使用[学习率调度程序](http://pytorch.org/docs/master/optim.html#how-to-adjust-learning-rate)来根据某些规则调整学习率。或者您可以使用简单的训练标志来启用或者禁用批次归一化和丢失。如果你想要为CPU和GPU分别更改随机种子，将会很容易实现。
-
-
-
-此外，您可以打印有关模型的信息，或使用几行代码保存/加载它。如果您的模型使用[OrderedDict](https://docs.python.org/3/library/collections.html)或者基于类的模型字符串表示形式初始化的，那么将包含层的名称。
-
-
-
-根据PyTorch文档保存模型，使用‘state_dict()’方法更为可取(http://pytorch.org/docs/master/notes/serializ.htm)。
-
-根据PyTorch文档保存模型，使用`state_dict()`方法[更为可取](http://pytorch.org/docs/master/notes/serializ.htm)。
-
-#### 记录
-
-记录训练过程是一个非常重要的部分。不幸的是，PyTorch没有tensorboard这样的工具。因此，您可以使用[Python日志模块](https://docs.python.org/3/library/logging.html)中的常规文本日志，或者尝试一些第三方库:
-
-- [一个用于实验的简单记录器](https://github.com/oval-group/logger)
-- [TensorBoard与语言无关的界面](https://github.com/torrvision/crayon)
-- [在不触及TensorFlow的情况下记录TensorBoard事件](https://github.com/TeamHG-Memex/tensorboard_logger)
-- [pytorch使用tensorboard ](https://github.com/lanpa/tensorboard-pytorch)
-- [Facebook可视化库智慧](https://github.com/facebookresearch/visdom)
-
-#### 数据处理
-
-您可能还记得[TensorFlow中提出的数据加载器](https://www.tensorflow.org/api_guides/python/reading_data)，甚至尝试实现其中的一些加载器。对我来说，花了大约4个小时或更多的时间来了解所有管道应该如何工作。
-
-
-
-
-
-图片来源:TensorFlow docs
-
-最初，我想在这里添加一些代码，但我认为这样的gif足以解释所有事情是如何发生的基本思想。
-
-PyTorch的开发者决定不重新发明轮子。他们只是使用多处理。要创建自己的自定义数据加载器，从' torch.utils.data '继承类就足够了。数据集'和改变一些方法:
-
-
-
-
-
-你应该知道的两件事。首先 ， 图像尺寸与TensorFlow不同。它们是[batch_size x channels x height x width]。但是，通过预处理步骤`torchvision.transforms.ToTensor()`，可以在没有您交互的情况下进行此转换。[转化包](http://pytorch.org/docs/master/torchvision/transforms.html)中还有很多有用的工具。
-
-第二个重要的事情是你可以在GPU上使用固定内存。为此，您只需要在`cuda()`调用中添加另外的标志`async = True`，并从DataLoader获取带有标志`pin_memory = True`的固定批次。 [更多相关讨论](http://pytorch.org/docs/master/notes/cuda.html#use-pinned-memory-buffers).
-
-#### 最后的体系结构概述
-
-现在你知道了模型，优化器和很多其他的东西。合并它们的正确方法是什么?我建议将你的模型和所有包装在这样的积木上:
-
-
-
-这里有一些用于阐述的伪代码:
-
-
-
-#### 总结
-
-我希望通过这篇文章，你能理解PyTorch的要点:
-
-- 它可以作为临时代替Numpy
-- 这对于原型设计来说非常快
-- 调试和使用条件流很容易
-- 有很多现成的好工具
-
+# PyTorch教程
+
+原文链接：[PyTorch tutorial distilled](https://towardsdatascience.com/pytorch-tutorial-distilled-95ce8781a89c?from=hackcv&hmsr=hackcv.com)
+
+## 从 TensorFlow 转向了 PyTorch
+
+
+
+
+
+在我第一次开始学习PyTorch时候，过了几天我就放弃了，对我来说理解这个框架的核心概念和TensorFlow比起来太难了。这就是为什么我把它放在了我的“知识书架”上，渐渐的遗忘了它。但是不久之后，PyTorch的新版本的发布了，我决定再尝试一次。过了一会，我意识到这个框架简便易行，让我很开心的使用PyTorch来编程。我会尝试清楚地解释它的核心概念，这样你就会有动力，至少现在试一试，而不是几年或更长时间。我们将介绍一些基本原则和一些高级内容，如学习速率调度程序，自定义层等。
+
+#### 学习资料
+
+首先，你应该了解PyTorch， [文档](http://pytorch.org/docs/master/) 和 [教程](http://pytorch.org/tutorials/)是分开存储的。因为更新的太快了，所有他们可能有部分会不一样，所以请查阅 [源代码](http://pytorch.org/tutorials/)，这就非常明确和直截了当。而且，还有一个很棒的[PyTorch论坛](https://discuss.pytorch.org/),在那里你可以提出任何合适的问题，你可以得到一个相对较快的答案。 对于PyTorch用户来说，这个地方似乎比StackOverflow更受欢迎。
+
+#### PyTorch as NumPy
+
+让我们来讨论PyTorch本身，PyTorch的主要构建块是tensors。确实他和[NumPy ones](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)很相似。 Tensors支持很多和相同的API，因此有时可以使用PyTorch作为NumPy的代替品。你可能想问为什么要这么做，主要的原因是PyTorch的主要目标是使用GPU，这样您就可以将数据预处理或任何其他需要大量计算的内容转移到机器学习中。很容易就可以转换tensors从NumPy转换为PyTorch，反之亦然。我们用代码来举个例子：
+
+
+
+您可能会注意到, 我们手动计算并应用了渐变。我们有优化器吗？答案是肯定的！
+
+
+
+
+
+现在我们所有的变量都会自动更新。但是你应该从最后一个片段得到的要点：我们仍然应该在计算新的渐变之前手动归零。这是PyTorch的核心概念之一。有时为什么我们应该这样做可能不是很明显，但另一方面，我们可以完全控制我们的渐变，我们何时以及如何应用它们。
+
+#### 静态与动态计算图的比较
+
+PyTorch和TensorFlow的下一个主要区别是它们对图形表示的方法。 Tensorflow [使用静态图表](https://www.tensorflow.org/programmers_guide/graphs)，这意味着我们一次又一次地执行该图表后定义它。在PyTorch中，每个前向传递定义了一个新的计算图。一开始，这些方法之间的区别并不那么大。但是，当您想要调试代码或定义一些条件语句时，动态图变得非常少。您可以使用自己喜欢的调试器！比较while循环语句的下两个定义 - TensorFlow中的第一个定义和PyTorch中的第二个定义：
+
+
+
+
+
+
+
+
+
+It seems to me that second solution much easier than first one. And what do you think about it?
+
+#### Models definition
+
+好的，现在我们看到在PyTorch中构建一些if / else / while复杂语句很容易。但是让我们回到通常的模型。该框架提供了与[Keras](https://keras.io/) 非常相似的开箱即用层构造函数：
+
+> `nn`包定义了一组**模块**，大致相当于神经网络层。模块接收输入变量并计算输出变量，但也可以保持内部状态，例如包含可学习参数的变量。 `nn`包还定义了一组在训练神经网络时常用的有用损失函数。
+
+
+
+
+
+另外，如果我们想构建更复杂的模型，我们可以子类提供`nn.Module`类。当然，这两种方法可以相互混合。
+
+
+
+
+
+在`__init__`方法中，我们应该定义稍后将使用的所有层。在`forward`方法中，我们应该提出我们想要使用已经定义的层的步骤。像往常一样，向后传递将自动计算。
+
+#### 自定义图层
+
+但是如果我们想用非标准的backprop定义一些自定义模型呢？这是一个例子 - XNOR网络：
+
+
+
+
+
+
+
+我不会深入了解详细信息，更多关于您可能在[入门手册](https://arxiv.org/abs/1603.05279)中阅读的此类网络。与我们的问题相关的是，反向传播应仅适用于小于1且大于-1的权重。在PyTorch中，它[可以非常简单地实现](http://pytorch.org/docs/master/notes/extending.html):
+
+
+
+你可能会看到，我们应该只定义两个方法：一个用于前进，一个用于后向传递。如果我们需要从前向传递中访问一些变量，我们可以将它们存储在`ctx`变量中。注意：在以前的API中，前向/后向方法不是静态的，我们将所需的变量存储为`self.save_for_backward(input)`并通过`input,_ = self.saved_tensors`访问。
+
+#### 用CUDA训练模型
+
+如果之前讨论过如何将一个张量传递给CUDA。但是如果我们想要传递整个模型，可以从模型本身调用`.cuda（）`方法，并将每个输入变量包装到`.cuda（）`中就足够了。在所有计算之后，我们应该使用`.cpu（）`方法返回结果。
+
+
+
+
+
+此外，PyTorch支持源代码中的直接设备分配：
+
+
+
+
+
+因为有时我们想在没有代码修改的情况下在CPU和GPU上运行相同的模型，我建议使用某种包装器：
+
+
+
+
+
+#### 权重初始化
+
+在TensorFlow中，权重初始化主要在张量声明期间进行。 PyTorch提供了另一种方法 - 首先应该声明张量，并且在下一步中应该改变该张量的权重。权重可以初始化为对tensor属性的直接访问，作为对`torch.nn.init`包中的一堆方法的调用。这个决定可能不是很简单，但是当你想用相同的初始化初始化某些类型的所有层时它会变得很有用。
+
+
+
+
+
+#### 逆向排除子图
+
+有时，当您想要重新训练模型的某些层或为生产模式做好准备时，您可以为某些图层禁用自动编程机制。为此，[PyTorch提供了两个标志](http://pytorch.org/docs/master/notes/autograd.html)：`requires_grad`和`volatile`。第一个将禁用当前图层的渐变，但子节点仍然可以计算一些。第二个将禁用当前层和所有子节点的autograd。
+
+
+
+
+
+#### 训练过程
+
+PyTorch中还存在一些其他的花里胡哨。例如，您可以使用[学习率调度程序](http://pytorch.org/docs/master/optim.html#how-to-adjust-learning-rate)来根据某些规则调整学习率。或者您可以使用简单的训练标志来启用或者禁用批次归一化和丢失。如果你想要为CPU和GPU分别更改随机种子，将会很容易实现。
+
+
+
+此外，您可以打印有关模型的信息，或使用几行代码保存/加载它。如果您的模型使用[OrderedDict](https://docs.python.org/3/library/collections.html)或者基于类的模型字符串表示形式初始化的，那么将包含层的名称。
+
+
+
+根据PyTorch文档保存模型，使用‘state_dict()’方法更为可取(http://pytorch.org/docs/master/notes/serializ.htm)。
+
+根据PyTorch文档保存模型，使用`state_dict()`方法[更为可取](http://pytorch.org/docs/master/notes/serializ.htm)。
+
+#### 记录
+
+记录训练过程是一个非常重要的部分。不幸的是，PyTorch没有tensorboard这样的工具。因此，您可以使用[Python日志模块](https://docs.python.org/3/library/logging.html)中的常规文本日志，或者尝试一些第三方库:
+
+- [一个用于实验的简单记录器](https://github.com/oval-group/logger)
+- [TensorBoard与语言无关的界面](https://github.com/torrvision/crayon)
+- [在不触及TensorFlow的情况下记录TensorBoard事件](https://github.com/TeamHG-Memex/tensorboard_logger)
+- [pytorch使用tensorboard ](https://github.com/lanpa/tensorboard-pytorch)
+- [Facebook可视化库智慧](https://github.com/facebookresearch/visdom)
+
+#### 数据处理
+
+您可能还记得[TensorFlow中提出的数据加载器](https://www.tensorflow.org/api_guides/python/reading_data)，甚至尝试实现其中的一些加载器。对我来说，花了大约4个小时或更多的时间来了解所有管道应该如何工作。
+
+
+
+
+
+图片来源:TensorFlow docs
+
+最初，我想在这里添加一些代码，但我认为这样的gif足以解释所有事情是如何发生的基本思想。
+
+PyTorch的开发者决定不重新发明轮子。他们只是使用多处理。要创建自己的自定义数据加载器，从' torch.utils.data '继承类就足够了。数据集'和改变一些方法:
+
+
+
+
+
+你应该知道的两件事。首先 ， 图像尺寸与TensorFlow不同。它们是[batch_size x channels x height x width]。但是，通过预处理步骤`torchvision.transforms.ToTensor()`，可以在没有您交互的情况下进行此转换。[转化包](http://pytorch.org/docs/master/torchvision/transforms.html)中还有很多有用的工具。
+
+第二个重要的事情是你可以在GPU上使用固定内存。为此，您只需要在`cuda()`调用中添加另外的标志`async = True`，并从DataLoader获取带有标志`pin_memory = True`的固定批次。 [更多相关讨论](http://pytorch.org/docs/master/notes/cuda.html#use-pinned-memory-buffers).
+
+#### 最后的体系结构概述
+
+现在你知道了模型，优化器和很多其他的东西。合并它们的正确方法是什么?我建议将你的模型和所有包装在这样的积木上:
+
+
+
+这里有一些用于阐述的伪代码:
+
+
+
+#### 总结
+
+我希望通过这篇文章，你能理解PyTorch的要点:
+
+- 它可以作为临时代替Numpy
+- 这对于原型设计来说非常快
+- 调试和使用条件流很容易
+- 有很多现成的好工具
+
PyTorch是一个快速发展的框架，拥有很棒的社区。我认为今天的尝试很棒！
\ No newline at end of file
diff --git "a/20171015 \347\254\25413\346\234\237/README.md" "b/2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/README.md"
similarity index 100%
rename from "20171015 \347\254\25413\346\234\237/README.md"
rename to "2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/README.md"
diff --git "a/20171015 \347\254\25413\346\234\237/The Search for Better Search at Reddit.md" "b/2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/The Search for Better Search at Reddit.md"
similarity index 98%
rename from "20171015 \347\254\25413\346\234\237/The Search for Better Search at Reddit.md"
rename to "2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/The Search for Better Search at Reddit.md"
index c6eb44c731c213ecb46fbc96a030a0e3b8d5aa10..461fbe9536ed3c37c8dc783c6dc6bf58af8d51c3 100644
--- "a/20171015 \347\254\25413\346\234\237/The Search for Better Search at Reddit.md"
+++ "b/2017\345\271\26410\346\234\210/20171015 \347\254\25413\346\234\237/The Search for Better Search at Reddit.md"
@@ -1,132 +1,132 @@
-# 在Reddit上搜索更好的搜索
-
-原文链接：[The Search for Better Search at Reddit](https://redditblog.com/2017/09/07/the-search-for-better-search-at-reddit/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com)
-
-
-
-[TECHNOLOGY](https://redditblog.com/topic/technology/) [Staff](https://redditblog.com/author/blabyrinth/) • [September 7, 2017](https://redditblog.com/2017/09/07/the-search-for-better-search-at-reddit/)
-
-**Chris Slowe, Nick Caldwell, & Luis Bitencourt-Emilio***CTO, VP of Engineering, Director of Engineering*
-
-## **什么是Fuss?**
-
-我们从Reddit的新手工程团队成员那里得到的一个常见问题是“我们什么时候才能修复搜索？”直到今年，答案总是“去询问5楼的搜索团队。”这很有趣，因为
-
-1. 到5楼的电梯按钮没有工作
-2. 没有搜索团队
-
-但是时代在进步，这是一个改革。我们很高兴地宣布，我们正在Reddit推出一个新的搜索引擎。实际上，在过去的几周里它已经启动了50％的流量，并且已经提供了近5亿次查询。现在我们对我们的系统充满信心，我们将其推向100％的流量。我们希望您享受更快，更可靠的结果！
-
-更重要的是，我们还在Reddit开设了一个专门用于搜索和相关的整个产品部门，由我们的工程总监Luis领导。我们认识到这些技术对Reddit的未来至关重要。我们的平台包含世界上最有趣的内容集合之一，目前索引超过25亿个搜索帖子，并且它每天都在变大。但我们知道这个内容很难找到。改进搜索和相关性将使Reddit能够筛选数百万个帖子，评论和社区，以便直接为您的家庭Feed提供定制的精彩内容流。
-
-那就是未来。就目前而言，我们认为沿着记忆之路旅行会很有趣。
-
-
-
-## **Reddit搜索简洁的历史**
-
-不用说，搜索不是一个容易解决的挑战。在Reddit上搜索的时候，我们就像坐过山车一样，但现在我们已经是第六次搜索了，我们对大规模搜索的困难并不陌生。下面是关于12年历史的粗略概述，以及一些来自我们团队的精选引语，我们通过迭代来将我们的infra扩展到Reddit的需求:
-
-- 2005 – Steve Huffman ([u/spez](https://www.reddit.com/user/spez)), 创始人之一，现任首席执行官, 开启了 postgres 7.4’s contrib/[tsearch2](http://www.sai.msu.su/~megera/postgres/gist/tsearch/V2/).
-
- 当有人说 “哦，我们可以用 Postgres来完成!” ， “对我来说听起来不错!?” “我们当时也非常喜欢TRIGGERs（”不，这很酷。数据库完成所有工作，并且保证准确无误“是我们毫无疑问的说法）。它工作得很好，但它不是很可调，我们很快发现我们正在以少数（约2％）搜索流量阻塞大多数Postgres查询：
-
- - “我们修复了搜索结果排序中的错误。” —[Steve](https://redditblog.com/2006/02/27/if-you-want-something-done-right-do-it-yourself/)
- - “我们今天早上更新了搜索系统，以帮助缓解一些负载问题。” —[Steve](https://redditblog.com/2006/07/25/searching/)
- - “Jeremy正致力于搜索！这不是一个复杂的修复（排序很糟糕）。” —[Steve](https://redditblog.com/2007/04/28/updates/)
-
-- 2007 – Chris Slowe ([u/KeyserSosa](https://www.reddit.com/user/KeyserSosa)), 创始工程师（现在是CTO），与PyLucene一起重新实施。
-
-
-
- 这实际上是在10年前的2007年7月实现的。它由一个Python进程组成，该进程被设置为TCP上的线程RPC服务器。在初始版本中，我们实际上支持搜索帖子标题和评论，并且Lucene索引文件可以舒适地存储在一个盒子上。这也是在我们搬到AWS之前，当时我们已经认真考虑过使用Google Search Appliance，这对我们的单机架来说是一个很好的补充。这个版本很灵活，但我们没有以一种易于扩展的方式进行设置：
-
- - “搜索的效果变得更好这标记着用户可以更好的进行控制。” —[Steve](https://redditblog.com/2007/07/26/new-reddit-on-the-horizon/)
- - “搜索效果更好，但是不是我们喜欢的地方。” —[Steve](https://redditblog.com/2007/08/21/its-slow-its-unstable-its-beta/)
- - “统计数据和搜索暂时被禁用，但只要我们能够修复它们就会回来。” —[Steve](https://redditblog.com/2007/10/16/reddit-status-update/)
- - “我们希望包含升级后的搜索，与上一版本不同，它实际上非常有用，可以帮助您找到所需内容。不幸的是，我们确定的版本并没有很好地加载测试。” —[Steve](https://redditblog.com/2007/10/18/reddit-status-update-part-ii/)
- - “我快速修复了搜索，我希望有所帮助，直到我们有机会真正解决它。” —[Steve](https://redditblog.com/2007/06/08/a-note-on-search-and-what-were-working-on/)
-
-- 2008 – David King ([u/ketralnis](https://www.reddit.com/user/ketralnis)), 第三名员工，现在是搜索工程师，实施Solr。
-
- 实际上，他实现了一个自制的pysolr，它能够以XML格式将更新文档发送给Solr，并以这样的方式包装响应，以便模拟我们现有的Query模型，足以将其放入任何类型或列表中。它实际上很甜蜜。初始版本不支持评论，但后来确实如此。
-
- - “[David]一直在修复Erlang的搜索和黑客攻击项目。” —[Alexis Ohanian](https://redditblog.com/2008/04/17/welcome-david/)
- - “我完全取代了reddit搜索功能。” —[David King](https://redditblog.com/2008/04/21/new-search-2/)
-
-- 2010 – David将Solr替换为第三方搜索提供商IndexTank。
-
- 当你喜欢某些东西时，将其外包......从来没有人说过。随着网站持续增长，我们首先在一个月内与一个四人工程团队一起破解了十亿次网页浏览，我们将所有努力投入503缓解，继续添加Postgres读取，添加更多缓存，开始利用Cassandra的早期版本（之后很快就发生了一次令人难忘的停电），并且通常无视搜索的糟糕程度。我们有一个勇敢的决定，永远使用第三方搜索提供商，比我们为保持Solr运行所付出的更少，所以我们签了！
-
- - “我们昨天推出了一个新的搜索引擎。冷静。没关系。我知道。你以前受伤了。” —[David King](https://redditblog.com/2010/07/21/new-search/)
-
-- 2012 – Keith Mitchell (u/kemitche) 在LinkedIn关闭IndexTank后实施CloudSearch。
-
- 很明显，这个永远过于短暂，IndexTank在公司被收购之前为我们提供了很好的帮助。当我们发现他们正在关闭时，我们不得不离开IndexTank并快速过渡到AWS CloudSearch。继续我们长期以来的传统“让新人照顾它”，这项任务落到了Keith身上，在接下来的几年里，我们将CloudSearch扩展到了爆炸状态：
-
- - “今天，我们从旧的Amazon CloudSearch域迁移到新的Amazon CloudSearch域。旧的搜索域存在严重的性能问题：大约33％的查询需要5秒才能完成，并且会导致搜索错误页面。” —[u/bsimpson](https://www.reddit.com/r/changelog/comments/694o34/reddit_search_performance_improvements/)
-
-- TODAY – Lucidworks Fusion!
-
- 这一次，我们希望确保搜索符合三个标准：它需要快速，需要与Reddit的增长很好地扩展，最重要的是，它需要具有相关性。最终，这促使我们与Lucidworks的搜索专家合作，利用Fusion及其由多个Solr提交者组成的团队的独特搜索专业知识。下面，我们将更详细地解释我们如何进行此操作。
-
- - “As [/u/bitofsalt](https://www.reddit.com/u/bitofsalt) [几个月前我们提到过](https://www.reddit.com/r/funny/comments/65ryr3/and_now_a_look_at_the_machine_that_powers_reddits/dgd22mi/), 我们一直在努力改进搜索。我们甚至可能领先于 [spez’s 的10年计划](https://www.reddit.com/r/announcements/comments/59k22p/hey_its_reddits_totally_politically_neutral_ceo/d992fwq/?context=1).” —[u/starfishjenga](https://www.reddit.com/r/changelog/comments/6pi0kk/improving_search/)
-
-## **感受更多**
-
-今年早些时候，对Reddit的搜索变得非常糟糕。简单的查询只能在一半的时间内成功。想要使用两个关键字进行搜索？离开这里！
-
-
-
-图1：我们的CloudSearch集群负载过重时的示例错误页面。
-
-在查看了几个选项后，我们与 [Lucidworks](https://lucidworks.com/) 合作，重振Reddit的搜索系统。 Lucidworks是Fusion的创建者，Fusion是一个基于Solr的搜索堆栈，支持巨大的文档规模和高查询吞吐量。
-
-## **第一件事：以Reddit量表摄取**
-
-迁移到新搜索系统的最大挑战是我们的索引管道需要更新。第一次尝试很艰难。为了速度，我们匆忙将它放在我们由 [Jenkins](https://jenkins.io/)和[Azkaban](https://azkaban.github.io/) 组成的遗留ETL系统上，编排了许多Hive查询。正如您在下图中所看到的，将来自多个来源的数据汇总到一个有索引的规范视图中进行索引，证明比最初预期的更复杂。
-
-
-
-图2：我们新的搜索提取管道的第一次迭代，现在被替换为显着简化的版本。
-
-我们的第二次尝试既简单又产生了明显更好的结果。我们设法将整个管道修剪为仅仅四个更简单和更准确的Hive查询，这使得索引的帖子增加了33％。另一个重大改进是，我们不仅索引新的帖子创作，而且还实时更新其相关信号，因为投票，评论和其他信号全天都在流动。
-
-## **使其相关**
-
-如果它们不相关，搜索结果并不意味着什么。对于我们的初始部署，主要目标是避免降低返回结果的整体相关性。
-
-为了监控这一点，我们测量了搜索结果页面上的点击次数，并比较了在新旧搜索系统中点击的结果的排名。一个完美的搜索引擎会在返回的最高结果上产生100％的点击次数，这是另一种表示您希望在顶部获得最相关结果的方式。由于我们知道完美的搜索引擎不是一个可实现的目标，我们使用 [平均互惠等级](https://en.wikipedia.org/wiki/Mean_reciprocal_rank)和 [折扣累积增益](https://en.wikipedia.org/wiki/Discounted_cumulative_gain)等措施来比较我们的结果质量。
-
-虽然它在我们的实验中还处于早期阶段，但迄今为止的数据指向了我们的旧堆栈与新堆栈之间非常可比的相关性测量，而Fusion具有轻微的优势。这个有希望的部分是我们还没有进行太多的相关调整 - 这是我们的新系统实际支持的东西。个性化，机器学习模型以及查询意图和重写等进步现在已经成为现实。
-
-
-
-图3：Fusion和CloudSearch堆栈之间搜索结果点击位置的比较。
-
-## **首次展示**
-
-在我们克服数据提取挑战和监控相关性时，我们继续将使用率提高到越来越多的redditors。这个早期小组的 [反馈](https://www.reddit.com/r/changelog/comments/6pi0kk/improving_search/)非常宝贵，我们非常感谢社区帮助我们解决漏洞和不太常见的用例。我们在新筹码上只有1％的用户开始工作，处理报告的问题并改进了摄取管道，因为我们在GA之前将推出百分比提高到5,10,25和最终50％的流量。在这段时间里，我们将所有搜索查询作为黑暗流量发送到我们的新搜索群集，以确保随着我们增加推出百分比，它可以全面扩展。
-
-
-
-图4：黄色的CloudSearch错误和绿色的Fusion。
-
-我们很自豪地说Reddit Search比以往更好！所有Reddit内容的完整重新索引现在在大约5个小时内完成（从大约11个小时开始），我们不断将实时更新流式传输到索引。错误率下降了两个数量级，99％的搜索结果在500毫秒内完成。运行搜索所需的机器数量从今年早些时候的约200台减少到30台左右，因此我们甚至设法节省了一些成本。
-
-
-
-图5：Reddit新搜索堆栈概述。
-
-更快，更可靠，更相关，更低成本！当然这应该是我们最后一次需要更改搜索堆栈！
-
-## **展望未来**
-
-严肃地说，我们认为你会喜欢这个更新。我们希望新的搜索堆栈将成为改进的基础，以便更容易地发现Reddit上的所有优秀内容。更重要的是：我们没有完成。修复搜索只是一系列新功能的第一步，这些功能将使Reddit更加个性化并与您的兴趣相关。 Reddit最终拥有一个Search＆Relevance团队，我们正在疯狂招聘。如果您对在数亿人使用的搜索和相关性平台上使用世界上最有趣的数据集之一感到兴奋，那么请查看我们的工作列表：
-
-**Head of Search:** [https://boards.greenhouse.io/reddit/jobs/723000#.Wa3yONOGOEI
-](https://boards.greenhouse.io/reddit/jobs/723000#.Wa3yONOGOEI)**Head of Relevance:** [https://boards.greenhouse.io/reddit/jobs/611466#.WbC_ltOGOEI
-](https://boards.greenhouse.io/reddit/jobs/611466#.WbC_ltOGOEI)**Head of Discovery:** [https://boards.greenhouse.io/reddit/jobs/764831#.WbC_2NOGOEI
-](https://boards.greenhouse.io/reddit/jobs/764831#.WbC_2NOGOEI)**Search Engineers:**
-
+# 在Reddit上搜索更好的搜索
+
+原文链接：[The Search for Better Search at Reddit](https://redditblog.com/2017/09/07/the-search-for-better-search-at-reddit/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com)
+
+
+
+[TECHNOLOGY](https://redditblog.com/topic/technology/) [Staff](https://redditblog.com/author/blabyrinth/) • [September 7, 2017](https://redditblog.com/2017/09/07/the-search-for-better-search-at-reddit/)
+
+**Chris Slowe, Nick Caldwell, & Luis Bitencourt-Emilio***CTO, VP of Engineering, Director of Engineering*
+
+## **什么是Fuss?**
+
+我们从Reddit的新手工程团队成员那里得到的一个常见问题是“我们什么时候才能修复搜索？”直到今年，答案总是“去询问5楼的搜索团队。”这很有趣，因为
+
+1. 到5楼的电梯按钮没有工作
+2. 没有搜索团队
+
+但是时代在进步，这是一个改革。我们很高兴地宣布，我们正在Reddit推出一个新的搜索引擎。实际上，在过去的几周里它已经启动了50％的流量，并且已经提供了近5亿次查询。现在我们对我们的系统充满信心，我们将其推向100％的流量。我们希望您享受更快，更可靠的结果！
+
+更重要的是，我们还在Reddit开设了一个专门用于搜索和相关的整个产品部门，由我们的工程总监Luis领导。我们认识到这些技术对Reddit的未来至关重要。我们的平台包含世界上最有趣的内容集合之一，目前索引超过25亿个搜索帖子，并且它每天都在变大。但我们知道这个内容很难找到。改进搜索和相关性将使Reddit能够筛选数百万个帖子，评论和社区，以便直接为您的家庭Feed提供定制的精彩内容流。
+
+那就是未来。就目前而言，我们认为沿着记忆之路旅行会很有趣。
+
+
+
+## **Reddit搜索简洁的历史**
+
+不用说，搜索不是一个容易解决的挑战。在Reddit上搜索的时候，我们就像坐过山车一样，但现在我们已经是第六次搜索了，我们对大规模搜索的困难并不陌生。下面是关于12年历史的粗略概述，以及一些来自我们团队的精选引语，我们通过迭代来将我们的infra扩展到Reddit的需求:
+
+- 2005 – Steve Huffman ([u/spez](https://www.reddit.com/user/spez)), 创始人之一，现任首席执行官, 开启了 postgres 7.4’s contrib/[tsearch2](http://www.sai.msu.su/~megera/postgres/gist/tsearch/V2/).
+
+ 当有人说 “哦，我们可以用 Postgres来完成!” ， “对我来说听起来不错!?” “我们当时也非常喜欢TRIGGERs（”不，这很酷。数据库完成所有工作，并且保证准确无误“是我们毫无疑问的说法）。它工作得很好，但它不是很可调，我们很快发现我们正在以少数（约2％）搜索流量阻塞大多数Postgres查询：
+
+ - “我们修复了搜索结果排序中的错误。” —[Steve](https://redditblog.com/2006/02/27/if-you-want-something-done-right-do-it-yourself/)
+ - “我们今天早上更新了搜索系统，以帮助缓解一些负载问题。” —[Steve](https://redditblog.com/2006/07/25/searching/)
+ - “Jeremy正致力于搜索！这不是一个复杂的修复（排序很糟糕）。” —[Steve](https://redditblog.com/2007/04/28/updates/)
+
+- 2007 – Chris Slowe ([u/KeyserSosa](https://www.reddit.com/user/KeyserSosa)), 创始工程师（现在是CTO），与PyLucene一起重新实施。
+
+
+
+ 这实际上是在10年前的2007年7月实现的。它由一个Python进程组成，该进程被设置为TCP上的线程RPC服务器。在初始版本中，我们实际上支持搜索帖子标题和评论，并且Lucene索引文件可以舒适地存储在一个盒子上。这也是在我们搬到AWS之前，当时我们已经认真考虑过使用Google Search Appliance，这对我们的单机架来说是一个很好的补充。这个版本很灵活，但我们没有以一种易于扩展的方式进行设置：
+
+ - “搜索的效果变得更好这标记着用户可以更好的进行控制。” —[Steve](https://redditblog.com/2007/07/26/new-reddit-on-the-horizon/)
+ - “搜索效果更好，但是不是我们喜欢的地方。” —[Steve](https://redditblog.com/2007/08/21/its-slow-its-unstable-its-beta/)
+ - “统计数据和搜索暂时被禁用，但只要我们能够修复它们就会回来。” —[Steve](https://redditblog.com/2007/10/16/reddit-status-update/)
+ - “我们希望包含升级后的搜索，与上一版本不同，它实际上非常有用，可以帮助您找到所需内容。不幸的是，我们确定的版本并没有很好地加载测试。” —[Steve](https://redditblog.com/2007/10/18/reddit-status-update-part-ii/)
+ - “我快速修复了搜索，我希望有所帮助，直到我们有机会真正解决它。” —[Steve](https://redditblog.com/2007/06/08/a-note-on-search-and-what-were-working-on/)
+
+- 2008 – David King ([u/ketralnis](https://www.reddit.com/user/ketralnis)), 第三名员工，现在是搜索工程师，实施Solr。
+
+ 实际上，他实现了一个自制的pysolr，它能够以XML格式将更新文档发送给Solr，并以这样的方式包装响应，以便模拟我们现有的Query模型，足以将其放入任何类型或列表中。它实际上很甜蜜。初始版本不支持评论，但后来确实如此。
+
+ - “[David]一直在修复Erlang的搜索和黑客攻击项目。” —[Alexis Ohanian](https://redditblog.com/2008/04/17/welcome-david/)
+ - “我完全取代了reddit搜索功能。” —[David King](https://redditblog.com/2008/04/21/new-search-2/)
+
+- 2010 – David将Solr替换为第三方搜索提供商IndexTank。
+
+ 当你喜欢某些东西时，将其外包......从来没有人说过。随着网站持续增长，我们首先在一个月内与一个四人工程团队一起破解了十亿次网页浏览，我们将所有努力投入503缓解，继续添加Postgres读取，添加更多缓存，开始利用Cassandra的早期版本（之后很快就发生了一次令人难忘的停电），并且通常无视搜索的糟糕程度。我们有一个勇敢的决定，永远使用第三方搜索提供商，比我们为保持Solr运行所付出的更少，所以我们签了！
+
+ - “我们昨天推出了一个新的搜索引擎。冷静。没关系。我知道。你以前受伤了。” —[David King](https://redditblog.com/2010/07/21/new-search/)
+
+- 2012 – Keith Mitchell (u/kemitche) 在LinkedIn关闭IndexTank后实施CloudSearch。
+
+ 很明显，这个永远过于短暂，IndexTank在公司被收购之前为我们提供了很好的帮助。当我们发现他们正在关闭时，我们不得不离开IndexTank并快速过渡到AWS CloudSearch。继续我们长期以来的传统“让新人照顾它”，这项任务落到了Keith身上，在接下来的几年里，我们将CloudSearch扩展到了爆炸状态：
+
+ - “今天，我们从旧的Amazon CloudSearch域迁移到新的Amazon CloudSearch域。旧的搜索域存在严重的性能问题：大约33％的查询需要5秒才能完成，并且会导致搜索错误页面。” —[u/bsimpson](https://www.reddit.com/r/changelog/comments/694o34/reddit_search_performance_improvements/)
+
+- TODAY – Lucidworks Fusion!
+
+ 这一次，我们希望确保搜索符合三个标准：它需要快速，需要与Reddit的增长很好地扩展，最重要的是，它需要具有相关性。最终，这促使我们与Lucidworks的搜索专家合作，利用Fusion及其由多个Solr提交者组成的团队的独特搜索专业知识。下面，我们将更详细地解释我们如何进行此操作。
+
+ - “As [/u/bitofsalt](https://www.reddit.com/u/bitofsalt) [几个月前我们提到过](https://www.reddit.com/r/funny/comments/65ryr3/and_now_a_look_at_the_machine_that_powers_reddits/dgd22mi/), 我们一直在努力改进搜索。我们甚至可能领先于 [spez’s 的10年计划](https://www.reddit.com/r/announcements/comments/59k22p/hey_its_reddits_totally_politically_neutral_ceo/d992fwq/?context=1).” —[u/starfishjenga](https://www.reddit.com/r/changelog/comments/6pi0kk/improving_search/)
+
+## **感受更多**
+
+今年早些时候，对Reddit的搜索变得非常糟糕。简单的查询只能在一半的时间内成功。想要使用两个关键字进行搜索？离开这里！
+
+
+
+图1：我们的CloudSearch集群负载过重时的示例错误页面。
+
+在查看了几个选项后，我们与 [Lucidworks](https://lucidworks.com/) 合作，重振Reddit的搜索系统。 Lucidworks是Fusion的创建者，Fusion是一个基于Solr的搜索堆栈，支持巨大的文档规模和高查询吞吐量。
+
+## **第一件事：以Reddit量表摄取**
+
+迁移到新搜索系统的最大挑战是我们的索引管道需要更新。第一次尝试很艰难。为了速度，我们匆忙将它放在我们由 [Jenkins](https://jenkins.io/)和[Azkaban](https://azkaban.github.io/) 组成的遗留ETL系统上，编排了许多Hive查询。正如您在下图中所看到的，将来自多个来源的数据汇总到一个有索引的规范视图中进行索引，证明比最初预期的更复杂。
+
+
+
+图2：我们新的搜索提取管道的第一次迭代，现在被替换为显着简化的版本。
+
+我们的第二次尝试既简单又产生了明显更好的结果。我们设法将整个管道修剪为仅仅四个更简单和更准确的Hive查询，这使得索引的帖子增加了33％。另一个重大改进是，我们不仅索引新的帖子创作，而且还实时更新其相关信号，因为投票，评论和其他信号全天都在流动。
+
+## **使其相关**
+
+如果它们不相关，搜索结果并不意味着什么。对于我们的初始部署，主要目标是避免降低返回结果的整体相关性。
+
+为了监控这一点，我们测量了搜索结果页面上的点击次数，并比较了在新旧搜索系统中点击的结果的排名。一个完美的搜索引擎会在返回的最高结果上产生100％的点击次数，这是另一种表示您希望在顶部获得最相关结果的方式。由于我们知道完美的搜索引擎不是一个可实现的目标，我们使用 [平均互惠等级](https://en.wikipedia.org/wiki/Mean_reciprocal_rank)和 [折扣累积增益](https://en.wikipedia.org/wiki/Discounted_cumulative_gain)等措施来比较我们的结果质量。
+
+虽然它在我们的实验中还处于早期阶段，但迄今为止的数据指向了我们的旧堆栈与新堆栈之间非常可比的相关性测量，而Fusion具有轻微的优势。这个有希望的部分是我们还没有进行太多的相关调整 - 这是我们的新系统实际支持的东西。个性化，机器学习模型以及查询意图和重写等进步现在已经成为现实。
+
+
+
+图3：Fusion和CloudSearch堆栈之间搜索结果点击位置的比较。
+
+## **首次展示**
+
+在我们克服数据提取挑战和监控相关性时，我们继续将使用率提高到越来越多的redditors。这个早期小组的 [反馈](https://www.reddit.com/r/changelog/comments/6pi0kk/improving_search/)非常宝贵，我们非常感谢社区帮助我们解决漏洞和不太常见的用例。我们在新筹码上只有1％的用户开始工作，处理报告的问题并改进了摄取管道，因为我们在GA之前将推出百分比提高到5,10,25和最终50％的流量。在这段时间里，我们将所有搜索查询作为黑暗流量发送到我们的新搜索群集，以确保随着我们增加推出百分比，它可以全面扩展。
+
+
+
+图4：黄色的CloudSearch错误和绿色的Fusion。
+
+我们很自豪地说Reddit Search比以往更好！所有Reddit内容的完整重新索引现在在大约5个小时内完成（从大约11个小时开始），我们不断将实时更新流式传输到索引。错误率下降了两个数量级，99％的搜索结果在500毫秒内完成。运行搜索所需的机器数量从今年早些时候的约200台减少到30台左右，因此我们甚至设法节省了一些成本。
+
+
+
+图5：Reddit新搜索堆栈概述。
+
+更快，更可靠，更相关，更低成本！当然这应该是我们最后一次需要更改搜索堆栈！
+
+## **展望未来**
+
+严肃地说，我们认为你会喜欢这个更新。我们希望新的搜索堆栈将成为改进的基础，以便更容易地发现Reddit上的所有优秀内容。更重要的是：我们没有完成。修复搜索只是一系列新功能的第一步，这些功能将使Reddit更加个性化并与您的兴趣相关。 Reddit最终拥有一个Search＆Relevance团队，我们正在疯狂招聘。如果您对在数亿人使用的搜索和相关性平台上使用世界上最有趣的数据集之一感到兴奋，那么请查看我们的工作列表：
+
+**Head of Search:** [https://boards.greenhouse.io/reddit/jobs/723000#.Wa3yONOGOEI
+](https://boards.greenhouse.io/reddit/jobs/723000#.Wa3yONOGOEI)**Head of Relevance:** [https://boards.greenhouse.io/reddit/jobs/611466#.WbC_ltOGOEI
+](https://boards.greenhouse.io/reddit/jobs/611466#.WbC_ltOGOEI)**Head of Discovery:** [https://boards.greenhouse.io/reddit/jobs/764831#.WbC_2NOGOEI
+](https://boards.greenhouse.io/reddit/jobs/764831#.WbC_2NOGOEI)**Search Engineers:**
+
最后，感谢Lucidworks团队提供了一个惊人的合作伙伴关系，并帮助我们在Reddit上寻找更好的搜索。
\ No newline at end of file
diff --git "a/20171016 \347\254\25414\346\234\237/A Quick Introduction to Neural Networks.md" "b/2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/A Quick Introduction to Neural Networks.md"
similarity index 100%
rename from "20171016 \347\254\25414\346\234\237/A Quick Introduction to Neural Networks.md"
rename to "2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/A Quick Introduction to Neural Networks.md"
diff --git "a/20171016 \347\254\25414\346\234\237/BUILDING A NEURAL NET FROM SCRATCH IN GO.md" "b/2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/BUILDING A NEURAL NET FROM SCRATCH IN GO.md"
similarity index 100%
rename from "20171016 \347\254\25414\346\234\237/BUILDING A NEURAL NET FROM SCRATCH IN GO.md"
rename to "2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/BUILDING A NEURAL NET FROM SCRATCH IN GO.md"
diff --git "a/20171016 \347\254\25414\346\234\237/Practical Data Science in Python.md" "b/2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/Practical Data Science in Python.md"
similarity index 100%
rename from "20171016 \347\254\25414\346\234\237/Practical Data Science in Python.md"
rename to "2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/Practical Data Science in Python.md"
diff --git "a/20171016 \347\254\25414\346\234\237/README.md" "b/2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/README.md"
similarity index 100%
rename from "20171016 \347\254\25414\346\234\237/README.md"
rename to "2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/README.md"
diff --git "a/20171016 \347\254\25414\346\234\237/\347\245\236\347\273\217\347\275\221\347\273\234\347\232\204\347\256\200\345\215\225\344\273\213\347\273\215.md" "b/2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/\347\245\236\347\273\217\347\275\221\347\273\234\347\232\204\347\256\200\345\215\225\344\273\213\347\273\215.md"
similarity index 100%
rename from "20171016 \347\254\25414\346\234\237/\347\245\236\347\273\217\347\275\221\347\273\234\347\232\204\347\256\200\345\215\225\344\273\213\347\273\215.md"
rename to "2017\345\271\26410\346\234\210/20171016 \347\254\25414\346\234\237/\347\245\236\347\273\217\347\275\221\347\273\234\347\232\204\347\256\200\345\215\225\344\273\213\347\273\215.md"
diff --git "a/20171017 \347\254\25415\346\234\237/MapReduce\347\232\204\346\250\241\345\274\217\343\200\201\347\256\227\346\263\225\345\222\214\347\224\250\344\276\213.md" "b/2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/MapReduce\347\232\204\346\250\241\345\274\217\343\200\201\347\256\227\346\263\225\345\222\214\347\224\250\344\276\213.md"
similarity index 100%
rename from "20171017 \347\254\25415\346\234\237/MapReduce\347\232\204\346\250\241\345\274\217\343\200\201\347\256\227\346\263\225\345\222\214\347\224\250\344\276\213.md"
rename to "2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/MapReduce\347\232\204\346\250\241\345\274\217\343\200\201\347\256\227\346\263\225\345\222\214\347\224\250\344\276\213.md"
diff --git "a/20171017 \347\254\25415\346\234\237/NoSQL\346\225\260\346\215\256\345\272\223\344\270\255\347\232\204\345\210\206\345\270\203\345\274\217\347\256\227\346\263\225.md" "b/2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/NoSQL\346\225\260\346\215\256\345\272\223\344\270\255\347\232\204\345\210\206\345\270\203\345\274\217\347\256\227\346\263\225.md"
similarity index 100%
rename from "20171017 \347\254\25415\346\234\237/NoSQL\346\225\260\346\215\256\345\272\223\344\270\255\347\232\204\345\210\206\345\270\203\345\274\217\347\256\227\346\263\225.md"
rename to "2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/NoSQL\346\225\260\346\215\256\345\272\223\344\270\255\347\232\204\345\210\206\345\270\203\345\274\217\347\256\227\346\263\225.md"
diff --git "a/20171017 \347\254\25415\346\234\237/README.md" "b/2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/README.md"
similarity index 100%
rename from "20171017 \347\254\25415\346\234\237/README.md"
rename to "2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/README.md"
diff --git "a/20171017 \347\254\25415\346\234\237/\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\204\346\234\272\345\231\250\345\255\246\344\271\240\346\212\200\350\203\275.md" "b/2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\204\346\234\272\345\231\250\345\255\246\344\271\240\346\212\200\350\203\275.md"
similarity index 100%
rename from "20171017 \347\254\25415\346\234\237/\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\204\346\234\272\345\231\250\345\255\246\344\271\240\346\212\200\350\203\275.md"
rename to "2017\345\271\26410\346\234\210/20171017 \347\254\25415\346\234\237/\350\275\257\344\273\266\345\267\245\347\250\213\345\270\210\345\277\205\345\244\207\347\232\204\346\234\272\345\231\250\345\255\246\344\271\240\346\212\200\350\203\275.md"
diff --git "a/20171018 \347\254\25416\346\234\237/Benefits of Intel\302\256 Optimized Caffe in comparison with BVLC Caffe.md" "b/2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/Benefits of Intel\302\256 Optimized Caffe in comparison with BVLC Caffe.md"
similarity index 100%
rename from "20171018 \347\254\25416\346\234\237/Benefits of Intel\302\256 Optimized Caffe in comparison with BVLC Caffe.md"
rename to "2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/Benefits of Intel\302\256 Optimized Caffe in comparison with BVLC Caffe.md"
diff --git "a/20171018 \347\254\25416\346\234\237/NEW OPTIMIZATIONS IMPROVE DEEP LEARNING FRAMEWORKS FOR CPUS.md" "b/2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/NEW OPTIMIZATIONS IMPROVE DEEP LEARNING FRAMEWORKS FOR CPUS.md"
similarity index 100%
rename from "20171018 \347\254\25416\346\234\237/NEW OPTIMIZATIONS IMPROVE DEEP LEARNING FRAMEWORKS FOR CPUS.md"
rename to "2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/NEW OPTIMIZATIONS IMPROVE DEEP LEARNING FRAMEWORKS FOR CPUS.md"
diff --git "a/20171018 \347\254\25416\346\234\237/README.md" "b/2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/README.md"
similarity index 100%
rename from "20171018 \347\254\25416\346\234\237/README.md"
rename to "2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/README.md"
diff --git "a/20171018 \347\254\25416\346\234\237/Why SQL is beating NoSQL, and what this means for the future of data.md" "b/2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/Why SQL is beating NoSQL, and what this means for the future of data.md"
similarity index 100%
rename from "20171018 \347\254\25416\346\234\237/Why SQL is beating NoSQL, and what this means for the future of data.md"
rename to "2017\345\271\26410\346\234\210/20171018 \347\254\25416\346\234\237/Why SQL is beating NoSQL, and what this means for the future of data.md"
diff --git "a/20171019 \347\254\25417\346\234\237/README.md" "b/2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/README.md"
similarity index 100%
rename from "20171019 \347\254\25417\346\234\237/README.md"
rename to "2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/README.md"
diff --git "a/20171019 \347\254\25417\346\234\237/TensorFlow\345\234\250\347\216\260\344\273\243\350\213\261\347\211\271\345\260\224\344\275\223\347\263\273\347\273\223\346\236\204\344\270\213\347\232\204\344\274\230\345\214\226.md" "b/2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/TensorFlow\345\234\250\347\216\260\344\273\243\350\213\261\347\211\271\345\260\224\344\275\223\347\263\273\347\273\223\346\236\204\344\270\213\347\232\204\344\274\230\345\214\226.md"
similarity index 100%
rename from "20171019 \347\254\25417\346\234\237/TensorFlow\345\234\250\347\216\260\344\273\243\350\213\261\347\211\271\345\260\224\344\275\223\347\263\273\347\273\223\346\236\204\344\270\213\347\232\204\344\274\230\345\214\226.md"
rename to "2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/TensorFlow\345\234\250\347\216\260\344\273\243\350\213\261\347\211\271\345\260\224\344\275\223\347\263\273\347\273\223\346\236\204\344\270\213\347\232\204\344\274\230\345\214\226.md"
diff --git "a/20171019 \347\254\25417\346\234\237/\344\270\200\344\270\252\347\224\250Kears\345\222\214 OpenAi Gym\345\256\236\347\216\260\346\267\261\345\272\246Q\347\275\221\347\273\234\347\232\204Gotchas\346\214\207\345\215\227.md" "b/2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/\344\270\200\344\270\252\347\224\250Kears\345\222\214 OpenAi Gym\345\256\236\347\216\260\346\267\261\345\272\246Q\347\275\221\347\273\234\347\232\204Gotchas\346\214\207\345\215\227.md"
similarity index 100%
rename from "20171019 \347\254\25417\346\234\237/\344\270\200\344\270\252\347\224\250Kears\345\222\214 OpenAi Gym\345\256\236\347\216\260\346\267\261\345\272\246Q\347\275\221\347\273\234\347\232\204Gotchas\346\214\207\345\215\227.md"
rename to "2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/\344\270\200\344\270\252\347\224\250Kears\345\222\214 OpenAi Gym\345\256\236\347\216\260\346\267\261\345\272\246Q\347\275\221\347\273\234\347\232\204Gotchas\346\214\207\345\215\227.md"
diff --git "a/20171019 \347\254\25417\346\234\237/\347\247\221\345\255\246\345\256\266\345\217\257\344\273\245\350\257\273\345\217\226\344\270\200\345\217\252\351\270\237\347\232\204\345\244\247\350\204\221\345\271\266\344\270\224\351\242\204\346\265\213\345\256\203\347\232\204\344\270\213\344\270\200\345\243\260\345\225\274\345\217\253.md" "b/2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/\347\247\221\345\255\246\345\256\266\345\217\257\344\273\245\350\257\273\345\217\226\344\270\200\345\217\252\351\270\237\347\232\204\345\244\247\350\204\221\345\271\266\344\270\224\351\242\204\346\265\213\345\256\203\347\232\204\344\270\213\344\270\200\345\243\260\345\225\274\345\217\253.md"
similarity index 100%
rename from "20171019 \347\254\25417\346\234\237/\347\247\221\345\255\246\345\256\266\345\217\257\344\273\245\350\257\273\345\217\226\344\270\200\345\217\252\351\270\237\347\232\204\345\244\247\350\204\221\345\271\266\344\270\224\351\242\204\346\265\213\345\256\203\347\232\204\344\270\213\344\270\200\345\243\260\345\225\274\345\217\253.md"
rename to "2017\345\271\26410\346\234\210/20171019 \347\254\25417\346\234\237/\347\247\221\345\255\246\345\256\266\345\217\257\344\273\245\350\257\273\345\217\226\344\270\200\345\217\252\351\270\237\347\232\204\345\244\247\350\204\221\345\271\266\344\270\224\351\242\204\346\265\213\345\256\203\347\232\204\344\270\213\344\270\200\345\243\260\345\225\274\345\217\253.md"
diff --git "a/20171020 \347\254\25418\346\234\237/AlphaGoZero\344\273\216\351\233\266\345\274\200\345\247\213\345\255\246\344\271\240.md" "b/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/AlphaGoZero\344\273\216\351\233\266\345\274\200\345\247\213\345\255\246\344\271\240.md"
similarity index 100%
rename from "20171020 \347\254\25418\346\234\237/AlphaGoZero\344\273\216\351\233\266\345\274\200\345\247\213\345\255\246\344\271\240.md"
rename to "2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/AlphaGoZero\344\273\216\351\233\266\345\274\200\345\247\213\345\255\246\344\271\240.md"
diff --git "a/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/Perceptually Uniform Color Spaces.md" "b/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/Perceptually Uniform Color Spaces.md"
new file mode 100644
index 0000000000000000000000000000000000000000..78362d9e5666feb9977c2a194424ba917982a2ba
--- /dev/null
+++ "b/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/Perceptually Uniform Color Spaces.md"
@@ -0,0 +1,115 @@
+# 感知一致性色彩空间
+
+原文链接：[Perceptually uniform color spaces](https://programmingdesignsystems.com/color/perceptually-uniform-color-spaces/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com)
+
+> “在视觉感知中，颜色几乎从未被看到，因为它实际上就是它。这一事实使得色彩成为艺术中最相关的媒介。“
+>
+> Josef Albers (1963), Interaction of Color
+
+如果你围捕了一组图形设计师并要求他们定义感知统一色彩空间的概念,t那么很可能他们都不知道该说些什么。从表面上看，感性均匀性有点容易解释：这些色彩空间是人类友好的色彩空间替代品，例如sRGB，它们对于在代码中工作的设计师来说非常有用。尽管如此，他们在程序设计中使用起来仍然令人生畏。感知统一的色彩空间源于科学的色彩理论，而这个社区几乎没有让更多的观众接触到它们。在本章中，我们将研究感知统一色彩空间的概念，并回答一些与它们相关的常见问题：它们是什么？我们为什么需要它们？我们如何在代码中使用它们？
+
+# sRGB有什么问题？
+
+让我们假装你想设计一个海报，其中十个方块的颜色从绿色变为蓝色，步长相同。 *你可能会说，“那很简单”*，然后开始敲代码，这些代码会在每个矩形之间产生相等的色调变化。确信结果将是一个漂亮的渐变，你会惊讶地看到运行代码后的以下输出。
+
+
+
+你可能会注意到这条彩色条纹长方形有些奇怪。虽然颜色从绿色变为蓝色，但它们在条带末端的变化似乎更多。绿色看起来几乎相同，而蓝色则更加多样化。它在颜色的亮度方面也有很多变化，中间的青色看起来比蓝色更亮。发生这种情况是因为默认的sRGB颜色空间（以及在其上构建的任何颜色模型，如HSV和HSL）是不规则的，这意味着即使矩形具有均匀间隔的色调值，相应的效果也不会与人眼呈线性关系。
+
+
+
+CIE色度图显示了色谱中主要色彩的波长。
+
+为了解释原因，我们需要看一下我们在上一章中简要讨论过的色度图。该图是20世纪30年代广泛科学实验的结果，它将可见色谱绘制成基于人类视觉的尺度。您可能会注意到的第一件事是图表中有很多绿色。显示在色谱边缘的蓝色数字显示相应颜色的波长，您会注意到520nm到560nm左右的颜色都显示为绿色。但是，如果你采取另一个40nm范围，例如460nm至500nm，它包括蓝色，青色和绿色之间更广泛的颜色。这就解释了为什么我们上面设计中的大部分矩形都是绿色的，为什么我们看到在刻度结束时突然向蓝色移动：线性地穿过色调看起来与眼睛不成比例。如果我们想要使用与人类视觉相关的颜色进行操作，我们需要建立在这些人体测量上的色彩空间，这就是感知上均匀的色彩空间。
+
+以下矩形在色调中也具有均匀分布，但这次使用感知上均匀的色彩空间创建颜色。注意颜色在亮度上是如何保持恒定的，并且色调均匀分布以形成线性颜色渐变。
+
+
+为什么我们需要感知统一的色彩空间？因为在代码中使用颜色与在传统设计工具中使用颜色不同。传统工具鼓励设计师使用颜色选择器作为选择颜色组合的主要方式，在手动工作流程中进行思考。在这种情况下，设计师用他们的眼睛来决定颜色是对还是错，而RGB值在这个决定中没有任何作用。代码是不同的，因为编程语言鼓励设计师将颜色视为所选颜色模型中的数字或位置。如果数字与输出不对应，则很难学习这项技能。感知统一的颜色空间允许我们将代码中的数字与我们的观众中感知的视觉效果对齐。
+
+在某些情况下，感知均匀性至关重要。一个简单的例子，如想要选择随机颜色，以便在深色背景下可读，在不规则的色彩空间中很难，因为具有相同亮度或亮度的颜色在它们出现的亮度方面变化很大（在HSV中蓝色和黄色都具有100％的亮度，但蓝色比黄色深很多）。人们需要根据所选择的色调进行各种计算，以使随机颜色同样明亮。
+
+如果设计师不了解这一点，它甚至可能导致误导性设计。一个很好的例子是在数据可视化中使用连续色标。对于某些地图类型，设计人员使用渐变来为地理区域着色以反映数据点的值，并且用户可以比较区域之间的颜色以获得数据感。如果设计者在常规颜色空间中创建颜色标度，则感知颜色将与颜色值中反映的数据点不同。为了使设计显示实际数据，需要感知上均匀的颜色空间。
+
+# 更好的解决方案
+
+国际照明委员会（CIE）在20世纪30年代创造了上述色度图来解决这个问题。该图实际上是一个名为CIEXYZ的颜色空间的2D视图，它在1970年代被略微改进的CIELUV和CIELAB颜色空间所取代。很难描述这些色彩空间如何在不进入基础数学的情况下工作，但它们通常允许您指定颜色，而不是在光混合中，而是在与人类视觉更相关的维度中，并且它们进行复杂的颜色转换以确保这些尺寸反映了人类视觉的运作方式。例如，CIELUV颜色空间有两个维度 - *u 和 v* - 表示从红色到绿色和黄色到蓝色的颜色标度。要在CIELUV颜色空间中创建颜色，必须定义颜色的亮度（*l* ），无论是偏红色还是绿色（*u*），以及它是黄色还是蓝色（*v*）。同样，人类通过对手过程模型计算来自视网膜锥体的信号，这使得无法看到红绿色或黄蓝色。
+
+即使这些颜色空间基于人类感知，但在代码中工作时它们并不直观。像RGB颜色空间一样，很难猜测需要创建哪个LUV编号，例如深紫色或明亮的青色。值得庆幸的是，感知上均匀的色彩空间也可以在不同的颜色模型中重新映射它们的尺寸，因此设计师可以使用更直观的尺寸，同时保持感性均匀性。
+
+# HSLuv
+
+[HSLuv项目](http://www.hsluv.org/)是最近使这些色彩空间更直观的尝试之一。它允许您使用与HSL颜色模型相同尺寸的CIELUV颜色空间。被称为人性化的HSL，原始代码是用Haxe编程语言编写的，但该项目现在用大多数流行的编程语言实现，包括JavaScript。
+
+在深入研究特定代码之前，了解HSLuv与HSL的区别非常重要。 HSLuv允许您基于三个维度定义颜色 - 色调，饱和度和亮度 - 但与基于sRGB的HSL颜色模型相反，保持尺寸相同值的颜色看起来相似。具有相同亮度值的两种颜色看起来同样明亮，并且具有相同饱和度的两种颜色将具有相同的感知色纯度。与HSL一样，饱和度和亮度尺寸表示为“0”和“100”之间的百分比，但在HSLuv中，这些百分比反映了感知的颜色混合。亮度为“50”的灰色保证为中灰色。
+
+即使它不是内置的颜色模式，HSLuv也适用于P5.js.要使用该库，首先需要下载[最新的HSLuv版本](https://github.com/hsluv/hsluv/releases)，然后将库文件包含在HTML文件中。这使得HSLuv颜色转换功能可在草图中访问。
+
+```
+
+
+```
+
+HSLuv的每个实现包括四个可用于在HSLuv和RGB之间进行转换的函数。我们可以使用这些函数之一 - “hsluvToRgb（）” - 将HSLuv颜色值转换为`fill()`和`stroke()`函数可以理解的RGB值。 `hsluvToRgb()`函数需要一个具有三个值的数组 - 颜色所需的色调，饱和度和亮度 - 并返回另一个RGB值在“0”到“1”范围内的数组。因为P5.js期望RGB值介于“0”和“255”之间，所以我们需要将数组值相乘以进行缩放。这归结为两行代码，如下例所示。
+
+```
+// First convert the HSLuv values to a RGB array
+var rgb = hsluv.hsluvToRgb([0, 50, 50]);
+
+// Then use the RGB values in a scale of 0-255
+fill(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
+```
+
+这意味着每次必须为`fill()`或`stroke()`函数创建感知统一颜色时，您需要额外的代码行来处理HSLuv到RGB的转换。这可以通过创建包含这两行代码的小辅助函数来防止。
+
+```
+function fillHsluv(h, s, l) {
+ var rgb = hsluv.hsluvToRgb([h, s, l]);
+ fill(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
+}
+
+function strokeHsluv(h, s, l) {
+ var rgb = hsluv.hsluvToRgb([h, s, l]);
+ stroke(rgb[0] * 255, rgb[1] * 255, rgb[2] * 255);
+}
+```
+
+您现在可以使用这两个函数代替内置的填充和描边功能。它本质上是一种在不使用colorMode函数的情况下在P5.js中创建自己的colorMode的方法。下面是一个快速示例，演示如何使用它们。
+
+```
+noStroke();
+fillHsluv(0, 100, 50);
+ellipse(150, height/2, 200, 200);
+
+noFill();
+strokeWeight(5);
+strokeHsluv(120, 100, 50);
+ellipse(300, height/2, 200, 200);
+
+noStroke();
+fillHsluv(240, 100, 50);
+ellipse(450, height/2, 200, 200);
+```
+
+我们还可以使用这些新功能来选择对特定背景颜色可读的随机颜色。下面的示例显示了使用HSL和HSLuv的随机颜色的文本行。注意第一个例子有时使用非常亮的黄色，即使亮度是恒定的。使用感知上均匀的颜色空间的后一个例子没有这个问题。
+
+```
+var fontSize = 30;
+textSize(fontSize);
+
+translate(50, 50 + fontSize);
+colorMode(HSL);
+for(var i = 0; i < 10; i++) {
+ fill(random(360), 100, 50);
+ text("Can you read this line of text?", 0, i * fontSize);
+}
+
+colorMode(RGB);
+translate(0, 340);
+for(var i = 0; i < 10; i++) {
+ fillHsluv(random(360), 100, 50);
+ text("Can you read this line of text?", 0, i * fontSize);
+}
+```
+
+尽管P5.js不理解感知统一颜色空间的概念，但本章已经演示了如何使用HSLuv JavaScript库将感知统一颜色空间转换为P5.js使用的sRGB颜色空间。在接下来的章节中，我们将使用这种技术在程序上生成颜色方案，并使用它们在P5.js中创建动态设计
diff --git "a/20171020 \347\254\25418\346\234\237/README.md" "b/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/README.md"
similarity index 100%
rename from "20171020 \347\254\25418\346\234\237/README.md"
rename to "2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/README.md"
diff --git "a/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/Stop Using Word2vec.md" "b/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/Stop Using Word2vec.md"
new file mode 100644
index 0000000000000000000000000000000000000000..1ef47b3653274f1d2b76b31de19bce18cc57f5af
--- /dev/null
+++ "b/2017\345\271\26410\346\234\210/20171020 \347\254\25418\346\234\237/Stop Using Word2vec.md"
@@ -0,0 +1,86 @@
+# Stop Using word2vec
+
+原文链接：[Stop Using word2vec](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com)
+
+四年前，当我开始使用word2vec时，我需要（幸运的是）十分长的时间来计算。但是由于我们对word2vec的理解有所进步，现在只需要15分钟就能在一台普通的计算机上使用标准数值库[1](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#1)计算单词向量。单词向量是[awesome](http://multithreaded.stitchfix.com/blog/2015/03/11/word-is-worth-a-thousand-vectors/)但你不需要神经网络 - 并且肯定不需要深入学习 - 找到它们[2](http://multithreaded.stitchfix.com/blog/2015/03/11/word-is-worth-a-thousand-vectors/) 。因此，如果您正在使用单词向量并且没有针对最新技术或纸质出版物进行贡献，那么*停止使用word2vec。*
+
+当我们完成后，你将衡量单词的相似性：
+
+```
+facebook ~ twitter, google, ...
+```
+
+… 和经典的单词矢量操作： `zuckerberg - facebook + microsoft ~ nadella`
+
+…但你会主要通过计算单词和分割来做到这一点，在构造中梯度没有起任何作用！
+
+## 秘籍
+
+让我们假设您已经掌握了[hacker-news语料库](https://cloud.google.com/bigquery/public-data/hacker-news)并清理并标记了它（或下载了预处理版本[此处](https://zenodo.org/record/49899)）。步骤如下：
+
+1. **Unigram概率**。`word1`和`word2`的频率是？
+
+
+
+*示例*：这只是一个填充`unigram_counts`数组的简单词。然后将`unigram_counts`数组除以它们之和得到概率`p`并得到如下数字：`p('facebook')`是0.001％而`p('lambda')`是0.000001％
+
+2. **Skipgram概率**。在`word2`附近看到`word1`的频率？这些被称为'skipgrams'，因为我们可以“跳过”`word1`和`word2`之间的几个单词。[3](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#3)
+
+
+
+*示例*：这里我们计算相互附近的单词对，但不一定是在相互邻近的单词。规范化`skipgram_count`数组后，您将得到像`p('facebook'，'twitter')`这样的word-near-word概率。如果`p('facebook'，'twitter')`的值是10^-9那么在10亿个skipgram元组中你通常会看到'facebook'和'twitter'一次。对于另一个像`p('morning'，'facebook')`这样的单词对，这个分数可能会大得多，比如10 ^ -5，因为单词'morning`是一个常用词。
+
+3. **标准化的Skipgram概率（或PMI）**。skipgram频率是否高于或低于我们对单字频率的预期？有些词是非常常见的，有些是非常罕见的，所以将skipgram频率除以两个单字组频率。如果结果大于1.0，则该skipgram发生的频率高于两个输入词的单字组概率，我们将这两个输入字称为“关联”。比率越大，关联性越强。对于小于1.0的比率，“反关联”越多。如果我们记录这个数字的日志，它被称为单词X和单词Y的[逐点互信息（PMI）](https://en.wikipedia.org/wiki/Pointwise_mutual_information)。这是一个很好理解的测量信息理论社区并代表X和Y多次“相互”（或联合）而不是独立地。
+
+
+
+*示例1*：如果我们看看`facebook`和`twitter`之间的关联，我们会看到它高于1.0：`p('facebook'，'twitter')/ p('facebook')/ p(' twitter')= 1000`。所以`facebook`和`twitter`异常高度共存，我们推断它们必须是相关或类似的。请注意，除了计算和分割之外，我们还没有做任何神经网络的东西或数学计算，但我们已经可以测量两个单词的相关性。稍后我们将根据这些数据计算单词向量，并且这些向量将被约束以重现这些单词到单词的关系。 [4](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#4)
+
+*示例2*：对于`facebook`和`okra`，PMI(`p('facebook'，'okra')/ p('facebook')/ p('okra')`)接近1.0，所以`facebook`和`okra`在数据中没有依赖关系。稍后我们将形成重建和遵循这种关系的向量，因此几乎没有重叠。但当然，单词数量依旧含有噪声，这种噪声会导致字之间的虚假关联。
+
+4. **PMI矩阵**。制作一个大矩阵，其中每一行代表单词“X”，每列代表单词“Y”，每个值是我们在步骤3中计算的“PMI”：`PMI(X，Y)= log(p(x，y) / p(x)/ p(y))`。因为我们拥有与单词一样多的行和列，所以矩阵的大小是(`n_vocabulary`，`n_vocabulary`)。因为`n_vocabulary`通常是10k-100k，这是一个有很多零的大矩阵，所以最好使用稀疏数组数据结构来表示PMI矩阵。
+
+
+
+5. **SVD**。现在我们减少该矩阵的维数。这有效地将我们的巨型矩阵压缩成两个较小的矩阵。这些较小的矩阵中的每一个都形成一组具有大小的单词向量(`n_vocabulary`，`n_dim`)。[5](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#5)一个矩阵的每一行代表一个单词矢量。这是任何线性代数库中的直接操作，在Python中它看起来像：`U, S, V = scipy.sparse.linalg.svds(PMI, k=256)`
+
+
+
+*Example* SVD是您可以在机器学习中使用的最基本和最棒的工具之一，它正在做大部分的魔法。在[Jeremy Kun](https://twitter.com/jeremyjkun?ref_src=twsrc%5Egoogle%7Ctwcamp%5Eserp%7Ctwgr%5Eauthor) 很棒的 [系列](https://jeremykun.com/2016/04/18/singular-value-decomposition-part-1-perspectives-on-linear-algebra/)。在这里，我们可以将其视为压缩原始输入矩阵（计数零）接近~100亿个条目（100k x 100k），缩减为两个矩阵，总共约5000万个条目（100k x 256 x 2），空间减少200倍。 SVD输出一个正交的空间，这是我们获得“线性规律性”的地方，也是我们能够有意义地添加和减去单词向量的地方。
+
+6. **搜索**。 SVD输出矩阵的每一行是字向量。一旦你有了这些单词的奇异向量，你就可以搜索最接近`consolas`的标记，这是一种在编程中很流行的字体。
+
+
+```
+# In psuedocode:
+# Get the row vector corresponding to the word 'consolas'
+vector_consolas = U['consolas']
+# Get how similar it is to all other words
+similarities = dot(U, vector_consolas)
+# Sort by similarity, and pick the most similar
+most_similar = tokens[argmax(similarities)]
+most_similar
+```
+
+所以搜索`consolas`会产生`verdana`和`inconsolata`最相似 - 这是有意义的，因为这些是其他字体。搜索“功能编程”产生`FP`（首字母缩略词），`Haskell`（一种流行的函数式语言）和`OOP`（代表面向对象编程，是函数式编程的替代）。此外，添加和减去这些向量，然后搜索获得word2vec的标志性特征：在计算类比`Mark Zuckerberg - Facebook + Amazon`时，我们可以将Facebook的首席执行官与亚马逊的首席执行官联系起来，后者适当地评估`Jeff Bezos`词汇。
+
+这是一个更直观，更容易计算跳过的大坑，除了单词计数以获得两个单词的“关联”和SVD结果，而不是理解最简单的神经网络正在做什么。
+
+所以停止使用神经网络，但依旧有趣地构造单词向量！
+
+### 脚注
+
+1. 这里概述的方法并不完全等效，但它的表现与word2vec skipgram负采样大致相同 [SGNS](https://papers.nips.cc/paper/5477-neural-word-embedding-as-implicit-matrix-factorization). 事实证明，word2vec不是[与矩阵分解完全相同](http://building-babylon.net/2016/05/12/skipgram-isnt-matrix-factorisation/)， 但是对于应用目的（例如工业上），SVD技术足够好。如果你关心Word2vec之间的差异， [Glove](https://nlp.stanford.edu/projects/glove/) 和 [Swivel](https://arxiv.org/abs/1602.02215) -- 并且在工业方面，我很少这样做 -- 然后你会关心word2vec SGNS vs这个SVD公式。此外，SVD方法巧妙地融入了一系列基于计数的词袋技术，如TF-IDF，LSI和LDA：
+
+
+
+TF-IDF将术语频率与文档中的术语频率进行比较，LSI使用SVD对该TF-IDF矩阵进行低秩分解。 LDA还对文档中的术语频率进行计数，但不是SVD，而是使用术语和文档向量中的稀疏性先验导致的结果。 除此之外，之前的那些使它们具有可解释性。 同样，此处简要的表述计算了术语与术语的关联（无文档），SVD将这些关联分解为低秩表示。
+ [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-1)
+
+2. 一些警告：如果您正在进行学术研究并剥离自己的嵌入系统（例如在lda2vec中） [[code\]](https://github.com/cemoody/lda2vec), [[paper\]](https://arxiv.org/abs/1605.02019) [[blog\]](http://multithreaded.stitchfix.com/blog/2016/05/27/lda2vec/#topic=38&lambda=1&term=)), 调整神经网络方法可能很有用。此外，SVD时间复杂度为O（N^3），因此它不是最好的。当N >> 100k。在这种情况下，SGD很适合在线问题。 [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-2)
+
+3. 在这个最简单的情况下，我们不会模拟距离加权的跳跃图的效果。我们只考虑在每个单词周围的固定大小的移动窗口内的skipgrams。还要注意，我们没有规范我们的模型，这可以从平滑或形成先验中受益。惩罚复杂性特别有助于小数据情况，但根据我的经验，这对于使用这些方法在广泛的真实语料库中获得适当结果不是必要的。 [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-3)
+
+4. 在一些方法中，特别是在截短的PMI中，一个重要的成分是阈值`k`（通常是25.0的值），它可以抑制低PMI词的影响，表面上是为了处理噪音。我将`k`常数解释为正则化的一种形式，尽管我不清楚这是一个规范的先验。你可以查阅 [gauss2vec](https://arxiv.org/abs/1412.6623) 得到更详细地证明, 并且这篇文章 [paper](https://arxiv.org/abs/1402.3722) 对参数的进行了实际的探索。 [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-4)
+
+5. 解释是这些单词向量解释了PMI矩阵内的协方差 - 本质上是一种低级别的方式，说单词X和Y是相关联的，因为它们共同发生超出其基本速率流行度。因为缩小空间中的轴并且是正交的，这也解释了为什么人们可以找到使原始word2ve着名的“线性规则”。例如，“国王”和“女王”可能会沿着“性别”方向分开，但“伦敦”和“柏林”可能会在“首都”方向上分享一个位置。这些特征向量有效地在输入空间中找到一小组方向，仍然可以最大限度地重建原始的大输入矩阵。 [↩](https://multithreaded.stitchfix.com/blog/2017/10/18/stop-using-word2vec/?from=hackcv&hmsr=hackcv.com&utm_medium=hackcv.com&utm_source=hackcv.com#back-5)
\ No newline at end of file