相關連結：

1、Word2Vec原始碼最詳細解析（上）

2、Word2Vec原始碼最詳細解析（下）

Word2Vec原始碼最詳細解析（下）

        在這一部分中，重點分析的是Word2Vec原始碼中演算法部分的實現，需要一定得演算法理論基礎，如果對CBOW和skip-gram演算法沒有了解的話，請參考csdn著名部落格《word2vec中的數學原理詳解》。其他詞表構建、Haffman樹生成等輔助函式參見《Word2Vec原始碼最詳細解析（上）》。

該部分程式碼分析如下：

//初始化神經網路結構
void InitNet() {
  long long a, b;
  unsigned long long next_random = 1;
  //syn0儲存的是詞表中每個詞的詞向量
  //這裡為syn0分配記憶體空間
  //呼叫posiz_memalign來獲取一塊數量為vocab_size * layer1_size，128byte頁對齊的記憶體
  //其中layer1_size是詞向量的長度
  a = posix_memalign((void **)&syn0, 128, (long long)vocab_size * layer1_size * sizeof(real));
  if (syn0 == NULL) {printf("Memory allocation failed\n"); exit(1);}
  
  //多層Softmax迴歸
  if (hs) {
	//syn1儲存的是Haffman樹中每個非葉節點的向量
	//這裡為syn1分配記憶體空間
    a = posix_memalign((void **)&syn1, 128, (long long)vocab_size * layer1_size * sizeof(real));
    if (syn1 == NULL) {printf("Memory allocation failed\n"); exit(1);}
    //初始化syn1為0
	for (a = 0; a < vocab_size; a++) for (b = 0; b < layer1_size; b++)
     syn1[a * layer1_size + b] = 0;
  }
  
  //如果要使用負取樣，則需要為syn1neg分配記憶體空間
  //syn1neg是負取樣時每個詞的輔助向量
  if (negative>0) {
    a = posix_memalign((void **)&syn1neg, 128, (long long)vocab_size * layer1_size * sizeof(real));
    if (syn1neg == NULL) {printf("Memory allocation failed\n"); exit(1);}
	//初始化syn1neg為0
    for (a = 0; a < vocab_size; a++) for (b = 0; b < layer1_size; b++)
     syn1neg[a * layer1_size + b] = 0;
  }
  for (a = 0; a < vocab_size; a++) for (b = 0; b < layer1_size; b++) {
    next_random = next_random * (unsigned long long)25214903917 + 11;
    //初始化詞向量syn0，每一維的值為[-0.5, 0.5]/layer1_size範圍內的隨機數
	syn0[a * layer1_size + b] = (((next_random & 0xFFFF) / (real)65536) - 0.5) / layer1_size;
  }
  //建立Haffman二叉樹
  CreateBinaryTree();
}


//該函式為執行緒函式，是訓練演算法程式碼實現的主要部分
//預設在執行該執行緒函式前，已經完成詞表排序、Haffman樹的生成以及每個詞的Haffman編碼計算
void *TrainModelThread(void *id) {
  long long a, b, d;
  //cw：視窗長度（中心詞除外）
  long long cw;
  //word: 在提取句子時用來表示當前詞在詞表中的索引                                                          
  //last_word: 用於在視窗掃描輔助，記錄當前掃描到的上下文單詞
  //setence_length: 當前處理的句子長度
  //setence_position: 當前處理的單詞在當前句子中的位置
  long long word, last_word, sentence_length = 0, sentence_position = 0;
  //word_count: 當前執行緒當前時刻已訓練的語料的長度
  //last_word_count: 當前執行緒上一次記錄時已訓練的語料長度
  long long word_count = 0, last_word_count = 0;
  //sen：當前從檔案中讀取的待處理句子，存放的是每個詞在詞表中的索引
  long long sen[MAX_SENTENCE_LENGTH + 1];
  //l1：在skip-gram模型中，在syn0中定位當前詞詞向量的起始位置
  //l2：在syn1或syn1neg中定位中間節點向量或負取樣向量的起始位置
  //target：在負取樣中儲存當前樣本
  //label：在負取樣中儲存當前樣本的標記
  long long l1, l2, c, target, label, local_iter = iter;
  //next_random：用來輔助生成隨機數
  unsigned long long next_random = (long long)id;
  real f, g;
  clock_t now;
  //neu1：輸入詞向量，在CBOW模型中是Context(x)中各個詞的向量和，在skip-gram模型中是中心詞的詞向量
  real *neu1 = (real *)calloc(layer1_size, sizeof(real));
  //neuele：累計誤差項
  real *neu1e = (real *)calloc(layer1_size, sizeof(real));
  
  FILE *fi = fopen(train_file, "rb");
  
  //每個程序對應一段文字，根據當前執行緒的id找到該執行緒對應文字的初始位置
  //file_size就是之前LearnVocabFromTrainFile和ReadVocab函式中獲取的訓練檔案的大小
  fseek(fi, file_size / (long long)num_threads * (long long)id, SEEK_SET);
  
  //開始主迴圈
  while (1) {
	//每訓練約10000詞輸出一次訓練進度
    if (word_count - last_word_count > 10000) {
      //word_count_actual是所有執行緒總共當前處理的詞數
	  word_count_actual += word_count - last_word_count;
      last_word_count = word_count;
      if ((debug_mode > 1)) {
        now=clock();
		//輸出資訊包括：
		//當前的學習率alpha；
		//訓練總進度（當前訓練的總詞數/(迭代次數*訓練樣本總詞數)+1）；
		//每個執行緒每秒處理的詞數
        printf("%cAlpha: %f  Progress: %.2f%%  Words/thread/sec: %.2fk  ", 13, alpha,
         word_count_actual / (real)(iter * train_words + 1) * 100,
         word_count_actual / ((real)(now - start + 1) / (real)CLOCKS_PER_SEC * 1000));
        fflush(stdout);
      }
	  //在初始學習率的基礎上，隨著實際訓練詞數的上升，逐步降低當前學習率（自適應調整學習率）
      alpha = starting_alpha * (1 - word_count_actual / (real)(iter * train_words + 1));
	  //調整的過程中保證學習率不低於starting_alpha * 0.0001
      if (alpha < starting_alpha * 0.0001) alpha = starting_alpha * 0.0001;
    }
	
	//從訓練樣本中取出一個句子，句子間以回車分割
    if (sentence_length == 0) {
      while (1) {
		//從檔案中讀入一個詞，將該詞在詞表中的索引賦給word
        word = ReadWordIndex(fi);
        if (feof(fi)) break;
        if (word == -1) continue;
        word_count++;
		//如果讀到的時回車，表示句子結束
        if (word == 0) break;
		//對高頻詞進行隨機下采樣，丟棄掉一些高頻詞，能夠使低頻詞向量更加準確，同時加快訓練速度
		//可以看作是一種平滑方法
        if (sample > 0) {
          real ran = (sqrt(vocab[word].cn / (sample * train_words)) + 1) * (sample * train_words) / vocab[word].cn;
          next_random = next_random * (unsigned long long)25214903917 + 11;
		  //以1-ran的概率捨棄高頻詞
          if (ran < (next_random & 0xFFFF) / (real)65536) continue;
        }
        sen[sentence_length] = word;
        sentence_length++;
		//如果句子長度超出最大長度則截斷
        if (sentence_length >= MAX_SENTENCE_LENGTH) break;
      }
	  //定位到句子頭
      sentence_position = 0;
    }
	
	//如果當前執行緒處理的詞數超過了它應該處理的最大值，那麼開始新一輪迭代
	//如果迭代數超過上限，則停止迭代
    if (feof(fi) || (word_count > train_words / num_threads)) {
      word_count_actual += word_count - last_word_count;
      local_iter--;
      if (local_iter == 0) break;
      word_count = 0;
      last_word_count = 0;
      sentence_length = 0;
      fseek(fi, file_size / (long long)num_threads * (long long)id, SEEK_SET);
      continue;
    }
	
	//取出當前單詞
    word = sen[sentence_position];
    if (word == -1) continue;
	//初始化輸入詞向量
    for (c = 0; c < layer1_size; c++) neu1[c] = 0;
	//初始化累計誤差項
    for (c = 0; c < layer1_size; c++) neu1e[c] = 0;
	//生成一個[0, window-1]的隨機數，用來確定|context(w)|視窗的實際寬度（提高訓練速率？）
    next_random = next_random * (unsigned long long)25214903917 + 11;
	b = next_random % window;
	
	
	/********如果使用的是CBOW模型：輸入是某單詞周圍視窗單詞的詞向量，來預測該中心單詞本身*********/
    if (cbow) {
      cw = 0;
	  //一個詞的視窗為[setence_position - window + b, sentence_position + window - b]
	  //因此視窗總長度為 2*window - 2*b + 1
      for (a = b; a < window * 2 + 1 - b; a++) 
		if (a != window) {//去除視窗的中心詞，這是我們要預測的內容，僅僅提取上下文
          c = sentence_position - window + a;
          if (c < 0) continue;
          if (c >= sentence_length) continue;
		  //sen陣列中存放的是句子中的每個詞在詞表中的索引
          last_word = sen[c];
          if (last_word == -1) continue;
		  //計算視窗中詞向量的和
          for (c = 0; c < layer1_size; c++) neu1[c] += syn0[c + last_word * layer1_size];
		  //統計實際視窗中的有效詞數
          cw++;
        }
		
      if (cw) {
		//求平均向量和
        for (c = 0; c < layer1_size; c++) neu1[c] /= cw;
		
		
		//如果採用分層softmax優化
		//根據Haffman樹上從根節點到當前詞的葉節點的路徑，遍歷所有經過的中間節點
        if (hs) for (d = 0; d < vocab[word].codelen; d++) {
          f = 0;
		  //l2為當前遍歷到的中間節點的向量在syn1中的起始位置
          l2 = vocab[word].point[d] * layer1_size;
          
		  //f為輸入向量neu1與中間結點向量的內積
          for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1[c + l2];
		  
		  //檢測f有沒有超出Sigmoid函式表的範圍
          if (f <= -MAX_EXP) continue;
          else if (f >= MAX_EXP) continue;
		  //如果沒有超出範圍則對f進行Sigmoid變換
          else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
		  
          //g是梯度和學習率的乘積
		  //學習率越大，則錯誤分類的懲罰也越大，對中間向量的修正量也越大
		  //注意！word2vec中將Haffman編碼為1的節點定義為負類，而將編碼為0的節點定義為正類
		  //即一個節點的label = 1 - d
          g = (1 - vocab[word].code[d] - f) * alpha;
          //根據計算得到的修正量g和中間節點的向量更新累計誤差
          for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
          //根據計算得到的修正量g和輸入向量更新中間節點的向量值
		  //很好理解，假設vocab[word].code[d]編碼為1，即負類，其節點label為1-1=0
		  //sigmoid函式得到的值為(0,1)範圍內的數，大於label，很自然的，我們需要把這個中間節點的向量調小
		  //而此時的g = (label - f)*alpha是一個負值，作用在中間節點向量上時，剛好起到調小效果
		  //調小的幅度與sigmoid函式的計算值偏離label的幅度成正比
          for (c = 0; c < layer1_size; c++) syn1[c + l2] += g * neu1[c];
        }
		
		
        //如果採用負取樣優化
		//遍歷所有正負樣本（1個正樣本+negative個負樣本）
        if (negative > 0) for (d = 0; d < negative + 1; d++) {
          if (d == 0) {
			//第一次迴圈處理的是目標單詞，即正樣本
            target = word;
            label = 1;
          } else {
			//從能量表中隨機抽取負樣本
            next_random = next_random * (unsigned long long)25214903917 + 11;
            target = table[(next_random >> 16) % table_size];
            if (target == 0) target = next_random % (vocab_size - 1) + 1;
            if (target == word) continue;
            label = 0;
          }
		  //在負取樣優化中，每個詞在syn1neg陣列中對應一個輔助向量
		  //此時的l2為syn1neg中目標單詞向量的起始位置
          l2 = target * layer1_size;
          f = 0;
		  //f為輸入向量neu1與輔助向量的內積
          for (c = 0; c < layer1_size; c++) f += neu1[c] * syn1neg[c + l2];
          if (f > MAX_EXP) g = (label - 1) * alpha;
          else if (f < -MAX_EXP) g = (label - 0) * alpha;
		  //g = (label - f)*alpha
          else g = (label - expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))]) * alpha;
          //用輔助向量和g更新累計誤差
		  for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1neg[c + l2];
		  //用輸入向量和g更新輔助向量
          for (c = 0; c < layer1_size; c++) syn1neg[c + l2] += g * neu1[c];
        }
		
        //根據獲得的的累計誤差，更新context(w)中每個詞的詞向量
        for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
          c = sentence_position - window + a;
          if (c < 0) continue;
          if (c >= sentence_length) continue;
          last_word = sen[c];
          if (last_word == -1) continue;
          for (c = 0; c < layer1_size; c++) syn0[c + last_word * layer1_size] += neu1e[c];
        }
      }
    }
	
	
	/********如果使用的是skip-gram模型：輸入是中心單詞，來預測該單詞的上下文*********/
	else {
		
	  //因為需要預測Context(w)中的每個詞，因此需要迴圈2window - 2b + 1次遍歷整個視窗
	  //遍歷時跳過中心單詞
      for (a = b; a < window * 2 + 1 - b; a++) if (a != window) {
        c = sentence_position - window + a;
        if (c < 0) continue;
        if (c >= sentence_length) continue;
        //last_word為當前待預測的上下文單詞
		last_word = sen[c];
        if (last_word == -1) continue;
		//l1為當前單詞的詞向量在syn0中的起始位置
        l1 = last_word * layer1_size;
		//初始化累計誤差
        for (c = 0; c < layer1_size; c++) neu1e[c] = 0;
		
		
        //如果採用分層softmax優化
		//根據Haffman樹上從根節點到當前詞的葉節點的路徑，遍歷所有經過的中間節點
        if (hs) for (d = 0; d < vocab[word].codelen; d++) {
          f = 0;
          l2 = vocab[word].point[d] * layer1_size;
          //注意！這裡用到了模型對稱：p(u|w) = p(w|u)，其中w為中心詞，u為context(w)中每個詞
		  //也就是skip-gram雖然是給中心詞預測上下文，真正訓練的時候還是用上下文預測中心詞
		  //與CBOW不同的是這裡的u是單個詞的詞向量，而不是視窗向量之和
		  //演算法流程基本和CBOW的hs一樣，這裡不再贅述
          for (c = 0; c < layer1_size; c++) f += syn0[c + l1] * syn1[c + l2];
          if (f <= -MAX_EXP) continue;
          else if (f >= MAX_EXP) continue;
          else f = expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))];
          g = (1 - vocab[word].code[d] - f) * alpha;
          for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1[c + l2];
          for (c = 0; c < layer1_size; c++) syn1[c + l2] += g * syn0[c + l1];
        }
        
		
		//如果採用負取樣優化
		//遍歷所有正負樣本（1個正樣本+negative個負樣本）
		//演算法流程基本和CBOW的ns一樣，也採用的是模型對稱
        if (negative > 0) for (d = 0; d < negative + 1; d++) {
          if (d == 0) {
            target = word;
            label = 1;
          } else {
            next_random = next_random * (unsigned long long)25214903917 + 11;
            target = table[(next_random >> 16) % table_size];
            if (target == 0) target = next_random % (vocab_size - 1) + 1;
            if (target == word) continue;
            label = 0;
          }
          l2 = target * layer1_size;
          f = 0;
          for (c = 0; c < layer1_size; c++) f += syn0[c + l1] * syn1neg[c + l2];
          if (f > MAX_EXP) g = (label - 1) * alpha;
          else if (f < -MAX_EXP) g = (label - 0) * alpha;
          else g = (label - expTable[(int)((f + MAX_EXP) * (EXP_TABLE_SIZE / MAX_EXP / 2))]) * alpha;
          for (c = 0; c < layer1_size; c++) neu1e[c] += g * syn1neg[c + l2];
          for (c = 0; c < layer1_size; c++) syn1neg[c + l2] += g * syn0[c + l1];
        }
        for (c = 0; c < layer1_size; c++) syn0[c + l1] += neu1e[c];
      }
    }
	
	//完成了一個詞的訓練，句子中位置往後移一個詞
    sentence_position++;
	//處理完一句句子後，將句子長度置為零，進入迴圈，重新讀取句子並進行逐詞計算
    if (sentence_position >= sentence_length) {
      sentence_length = 0;
      continue;
    }
  }
  
  fclose(fi);
  free(neu1);
  free(neu1e);
  pthread_exit(NULL);
}

//完整的模型訓練流程函式
void TrainModel() {
  long a, b, c, d;
  FILE *fo;
  //建立多執行緒，執行緒數為num_threads
  pthread_t *pt = (pthread_t *)malloc(num_threads * sizeof(pthread_t));
  printf("Starting training using file %s\n", train_file);
  //設定初始學習率
  starting_alpha = alpha;
  //如果有詞彙表文件，則從中載入生成詞表和hash表，否則從訓練檔案中獲得
  if (read_vocab_file[0] != 0) ReadVocab(); else LearnVocabFromTrainFile();
  //根據需要，可以將詞表中的詞和詞頻輸出到檔案
  if (save_vocab_file[0] != 0) SaveVocab();
  if (output_file[0] == 0) return;
  //初始化訓練網路
  InitNet();
  //如果使用負取樣優化，則需要初始化能量表
  if (negative > 0) InitUnigramTable();
  //開始計時
  start = clock();
  //建立訓練執行緒
  for (a = 0; a < num_threads; a++) pthread_create(&pt[a], NULL, TrainModelThread, (void *)a);
  for (a = 0; a < num_threads; a++) pthread_join(pt[a], NULL);
  fo = fopen(output_file, "wb");
  
  //如果classes引數為0，則輸出所有詞向量到檔案中
  if (classes == 0) {
    fprintf(fo, "%lld %lld\n", vocab_size, layer1_size);
    for (a = 0; a < vocab_size; a++) {
      fprintf(fo, "%s ", vocab[a].word);
      if (binary) for (b = 0; b < layer1_size; b++) fwrite(&syn0[a * layer1_size + b], sizeof(real), 1, fo);
      else for (b = 0; b < layer1_size; b++) fprintf(fo, "%lf ", syn0[a * layer1_size + b]);
      fprintf(fo, "\n");
    }
  }
  
  //如果classes引數不為0，則需要對詞向量進行K-means聚類，輸出詞類
  //classes為最後要分成的類的個數
  else {
	//clcn：總類數
	//iter：總迭代次數
	//closeid：用來儲存計算過程中離某個詞最近的類編號
    int clcn = classes, iter = 10, closeid;
	//centcn：屬於每個類的單詞數
    int *centcn = (int *)malloc(classes * sizeof(int));
	//cl：每個單詞所屬的類編號
    int *cl = (int *)calloc(vocab_size, sizeof(int));
	//x：用來儲存每次計算得到的詞向量和類中心的內積，值越大說明距離越近
	//closev：用來最大的內積，即距離最近
	real closev, x;
	//cent：每個類的中心向量
    real *cent = (real *)calloc(classes * layer1_size, sizeof(real));
	
    //先給所有單詞隨機指派類
	for (a = 0; a < vocab_size; a++) cl[a] = a % clcn;
	
	//一共迭代iter次
    for (a = 0; a < iter; a++) {
	  //初始化類中心向量陣列為0
      for (b = 0; b < clcn * layer1_size; b++) cent[b] = 0;
	  //初始化每個類含有的單詞數為1
      for (b = 0; b < clcn; b++) centcn[b] = 1;
	  //將剛才隨意分配的所屬於同一個類的詞向量相加，並且計算屬於每個類的詞數
      for (c = 0; c < vocab_size; c++) {
        for (d = 0; d < layer1_size; d++) cent[layer1_size * cl[c] + d] += syn0[c * layer1_size + d];
        centcn[cl[c]]++;
      }
	  
      for (b = 0; b < clcn; b++) {
        closev = 0;
        for (c = 0; c < layer1_size; c++) {
		  //計算每個類的平均中心向量
          cent[layer1_size * b + c] /= centcn[b];
		  //closev為類平均中心向量的二範數的平方
          closev += cent[layer1_size * b + c] * cent[layer1_size * b + c];
        }
		//對closev開方，此時的closev即為類平均中心向量的二範數
        closev = sqrt(closev);
		//用得到的範數對中心向量進行歸一化
        for (c = 0; c < layer1_size; c++) cent[layer1_size * b + c] /= closev;
      }
	  
	  //遍歷詞表中的每個詞，為其重新分配距離最近的類
      for (c = 0; c < vocab_size; c++) {
        closev = -10;
        closeid = 0;
        for (d = 0; d < clcn; d++) {
          x = 0;
		  //對詞向量和歸一化的類中心向量做內積
          for (b = 0; b < layer1_size; b++) x += cent[layer1_size * d + b] * syn0[c * layer1_size + b];
          //內積越大說明兩點之間距離越近
		  //取所有類中與這個詞的詞向量內積最大的一個類，將詞分到這個類中
		  if (x > closev) {
            closev = x;
            closeid = d;
          }
        }
        cl[c] = closeid;
      }
    }
	
    //經過多次迭代後，逐漸會將詞向量向正確的類靠攏
	//輸出K-means聚類結果到檔案中
    for (a = 0; a < vocab_size; a++) fprintf(fo, "%s %d\n", vocab[a].word, cl[a]);
    free(centcn);
    free(cent);
    free(cl);
  }
  fclose(fo);
}

//當引數缺失時，輸出提示資訊
int ArgPos(char *str, int argc, char **argv) {
  int a;
  for (a = 1; a < argc; a++) if (!strcmp(str, argv[a])) {
    if (a == argc - 1) {
      printf("Argument missing for %s\n", str);
      exit(1);
    }
    return a;
  }
  return -1;
}