为什么有的句子中with前直接接在所修饰词后,有的with前却加了逗号???
例程：He gave his card,with a few words in pencil. He gave his card,with a few words in pencil.
 翻译：他把它的名便给我,上面有几个铅笔字
 解析：with a few words in pecil是伴随状态,所以要用逗号,前面是一个完整的句子。而有时候He write with a pen.像这个句子前半句并非是一个完整的句子,所以不能用逗号
 例程：Flask has many configuration values, with sensible defaults, and a few conventions when getting started.

 
基于词袋模型的场景识别 Scene Recognition with Bag of Words
 
项目要求
项目原理
1. 图像分类算法
2. 基于词袋模型的图像分类技术
3. 梯度方向直方图HOG特征提取算法
4. 词袋构建：K-means聚类算法
4.1. 大数据的聚类算法 Mini Batch K-Means
   
5. 分类器的构建：KNN分类算法
6. 分类器的构建：线性SVM多分类算法
  
主要内容
0. 具体操作流程->主函数
1. 图像特征表示
1.1. 图像的tiny特征表示
函数：get_tiny_images()
效果
    
1.2 图像的词袋模型构建
1.2.1 图像特征提取,以及词袋构建
函数：build_vocabulary(image_paths, vocab_size):
     
1.2.2 统计词频，构建图像直方图
函数get_bags_of_words(image_paths)
    
   
   
2. 分类器的构建
2.1. 使用KNN分类器进行特征分类
函数：nearest_neighbor_classify()
    
2.2. 使用SVM分类器进行特征分类
函数：svm_classify(train_image_feats, train_labels, test_image_feats)
   
  
  
结果展示
参考资料
项目源码下载链接

 
项目要求
 
通过HOG特征提取和K-means实现图像的词袋化特征表示
训练SVM分类器和KNN分类器
实现基于词袋模型的场景识别
 
 
项目原理
 
1. 图像分类算法
 
图像分类是机器视觉中一个重要的问题，其基本概念是：通过算法自动把图像划分到特定的概念类别中。图像分类问题可以描述为：给定若干个学习好的图像类别，对输入的新图像序列进行处理，并对其做出一个决策，判断一个已知的类别是否出现在数据中。图像分类算法分为训练和测试两个阶段，其基本流程如下图所示：
 
 
2. 基于词袋模型的图像分类技术
 
词袋模型最初用于文本分类中，然后逐步引入到了图像分类任务中。在文本分类中，文本被视为一些不考虑先后顺序的单词集合。而在图像分类中，图像被视为是一些与位置无关的局部区域的集合，因此这些图像中的局部区域就等同于文本中的单词了。在不同的图像中，局部区域的分布是不同的。因此，可以利用提取的局部区域的分布对图像进行识别。图像分类和文本分类的不同点在于，在文本分类的词袋模型算法中，字典是已存在的，不需要通过学习获得；而在图像分类中，词袋模型算法需要通过监督或非监督的学习来获得视觉词典。
 
基于词袋模型的图像分类算法一般分为四步：
 
对图像进行局部特征向量的提取。为了取得很好的分类效果，提取的特征向量需要具备不同程度的不变性，如旋转，缩放，平移等不变性(SIFT或HOG)
利用上一步得到的特征向量集，抽取其中有代表性的向量，作为单词，形成视觉词典；
对图像进行视觉单词的统计，一般判断图像的局部区域和某一单词的相似性是否超过某一阈值。这样即可将图像表示成单词的分布，即完成了图像的表示。
设计并训练分类器，利用图像中单词的分布进行图像分类。
 
3. 梯度方向直方图HOG特征提取算法
 
Histogram of Oriented Gridients，缩写为HOG，是目前计算机视觉、模式识别领域很常用的一种描述图像局部纹理的特征。
 
 
分隔图像。因为HOG是一个局部特征，所有需要把图像分割成很多块，然后对每一块计算HOG特征，分割方法有重叠切分(overlap)和不重叠切分(non-overlap)两种，这两种策略各有各的好处。
 
overlap可以防止对一些局部特征的切割，比如对于一张人脸图片，如果分割的时候正好把眼睛从中间切割并且分到了两个patch中，提取完HOG特征之后，这会影响接下来的分类效果，但是如果两个patch之间overlap，那么至少在一个patch会有完整的眼睛。overlap的缺点是计算量大，因为重叠区域的像素需要重复计算。
 
再说non-overlap，缺点就是上面提到的，有时会将一个连续的物体切割开，得到不太好的HOG特征，优点是计算量小，尤其是与Pyramid（金字塔）结合时，这个优点更为明显。
 
 
计算每个区块的方向梯度直方图。利用任意一种梯度算子，例如：sobel，laplacian等，对每个patch进行卷积，计算得到每个像素点处的梯度方向和幅值。再将360度（2*PI）根据需要分割成若干个分，例如：分割成12分，每分包含30度，整个直方图包含12维。然后根据每个像素点的梯度方向，利用双线性内插法将其幅值累加到直方图中。
 
 
 
4. 词袋构建：K-means聚类算法
 
K-means算法是很典型的基于距离的聚类算法，采用距离作为相似性的评价指标，即认为两个对象的距离越近，其相似度就越大。该算法认为簇是由距离靠近的对象组成的，因此把得到紧凑且独立的簇作为最终目标。算法接受一个未标记的数据集，是一种无监督学习。
 假设要把数据通过k-means算法分成K个类，可以分为以下4个步骤：
 
随机选取k个点，作为聚类中心；
计算每个点分别到k个聚类中心的距离，然后将该点分到最近的聚类中心，这样就行成了k个簇；
再重新计算每个簇的质心（均值）；
重复以上2~4步，直到质心的位置不再发生变化或者达到设定的迭代次数。
 
4.1. 大数据的聚类算法 Mini Batch K-Means
 
在项目中，因为训练样本大，特征数目较多，采用传统的K-means进行聚类会导致计算时间过长，所以考虑使用Mini Batch KMeans。Mini Batch KMeans是一种能尽量保持聚类准确性下但能大幅度降低计算时间的聚类模型。
 
与K均值算法相比，数据的更新是在每一个小的样本集上。对于每一个小批量，通过计算平均值得到更新质心，并把小批量里的数据分配给该质心，随着迭代次数的增加，这些质心的变化是逐渐减小的，直到质心稳定或者达到指定的迭代次数，停止计算。由于计算样本量少，所以会相应的减少运行时间，而且准确度下降的并不明显，所以在处理大样本时常常采用该方法进行聚类。
 
5. 分类器的构建：KNN分类算法
 
邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。KNN属于懒惰学习，没有显式的学习过程，也就是说没有训练阶段，数据集事先已有了分类和特征值，待收到新样本后直接进行处理。
 　
 　思路是：如果一个样本在特征空间中的k个最邻近的样本中的大多数属于某一个类别，则该样本也划分为这个类别。KNN算法中，所选择的邻居都是已经正确分类的对象。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。
 
 KNN分类算法一般具有以下4个步骤：
 
计算测试数据与各个训练数据之间的距离；
按照距离的递增关系进行排序；
选取距离最小的K个点；
确定前K个点所在类别的出现频率；
返回前K个点中出现频率最高的类别作为测试数据的预测分类.
 
6. 分类器的构建：线性SVM多分类算法
 
支持向量机分类器(Support Vector Classifier)最开始用于解决二分类问题，基本思想是是根据训练样本的分布，将样本一分为二，即它只回答属于正类还是负类的问题。决定分类边界位置的样本并不是所有训练数据，是其中的两个类别空间的间隔最小的两个不同类别的数据点，即“支持向量”。
 
在面对多分类问题，我们设想的是用多个超平面把空间划分为多个区域，每个区域对应一个类别，这一看测试样本落在哪个区域就知道他的分类。但是这种一次性求解的方法计算量太大，无法实践，于是便退而求其次，想到采用“一类对其余”的方法，这样每次仍然解决一个二分类问题，一个类别训练一个分类器。这种方法好处是每个优化问题规模较小，分类速度快，但是缺点是容易出现分类重叠和不可分类现象：多个分类器都说属于自己的类别或每个分类器都说不属于自己的类别。
 
于是将负类变成一次只选一个类，这样便成了最原始的一对一分类问题，但这样分类器的数目会平方级增多，当有k个类别时，分类器应该有k*(k-1)/2个。而且这种方法仍然存在分类重叠现象。
 
于是想方法改变分类策略，我们采用DAG SVM来组织分类器。具体策略如下图所示。
 
 先问分类器"1还是5?"，如果是5，再问分类器“2还是5？”这种方法的优点是分类速度快，没有分类重叠和不可分类现象。
 
主要内容
 
0. 具体操作流程->主函数
 
def projSceneRecBoW():
'''
    Step 0: 初始化操作（选择特征提取器，分类器和数据文件路径，并设置类别名称和训练参数）
'''
    #FEATURE = 'tiny image'
    #FEATURE = 'bag of words'
    FEATURE = 'tiny image'

    #CLASSIFIER = 'nearest neighbor'
    #CLASSIFIER = 'support vector machine'
    CLASSIFIER = 'nearest neighbor'

    data_path = '../data/'
    categories = ['Kitchen', 'Store', 'Bedroom', 'LivingRoom', 'Office',
           'Industrial', 'Suburb', 'InsideCity', 'TallBuilding', 'Street',
           'Highway', 'OpenCountry', 'Coast', 'Mountain', 'Forest']        
    abbr_categories = ['Kit', 'Sto', 'Bed', 'Liv', 'Off', 'Ind', 'Sub',
        'Cty', 'Bld', 'St', 'HW', 'OC', 'Cst', 'Mnt', 'For']
	#每个类别的训练集和测试集的大小
    num_train_per_cat = 100
	# 得到4个1500个元素的列表，分别存储了训练集每张图片的相对地址，测试集每张图片的相对地址，训练集每张图片的类别标签，测试集每张图片的类别标签
    print('Getting paths and labels for all train and test data.')
    train_image_paths, test_image_paths, train_labels, test_labels = \
        get_image_paths(data_path, categories, num_train_per_cat)
        
    '''
    Step 1: 得到每张图像的特征
    '''
    print('Using %s representation for images.' % FEATURE)
    if FEATURE.lower() == 'tiny image':
 		# 若使用微图像特征提取方法，每张图像会返回一个256*1的特征列表，所以训练集和测试集各得到一个1500*256的特征矩阵。
        train_image_feats = get_tiny_images(train_image_paths)
        test_image_feats  = get_tiny_images(test_image_paths)

    elif FEATURE.lower() == 'bag of words':
        if not os.path.isfile('vocab.npy'):
        	#词袋数据文件，由build_vocabulary（）函数生成，需要耗费大量时间，所以以生成则直接调用。
            print('No existing visual word vocabulary found. Computing one from training images.')
            vocab_size = 200 #词袋大小
			#构建词袋
            vocab = build_vocabulary(train_image_paths, vocab_size)
            np.save('vocab.npy', vocab)
        #训练集和测试集图片的词袋直方图表示
        train_image_feats = get_bags_of_words(train_image_paths)
        test_image_feats  = get_bags_of_words(test_image_paths)

    elif FEATURE.lower() == 'placeholder':
        train_image_feats = []
        test_image_feats = []
    else:
        raise ValueError('Unknown feature type!')

    '''
 	Step 2: 通过分类器训练测试集图像并进行分类，返回一个N*1的列表，其中N是测试集大小，存储了与之前定义的categories对应的类别。
    '''
    print('Using %s classifier to predict test set categories.' % CLASSIFIER)

    if CLASSIFIER.lower() == 'nearest neighbor':
        predicted_categories = nearest_neighbor_classify(train_image_feats, train_labels, test_image_feats)

    elif CLASSIFIER.lower() == 'support vector machine':
        predicted_categories = svm_classify(train_image_feats, train_labels, test_image_feats)

    elif CLASSIFIER.lower() == 'placeholder':
		#为每张图片随机分类
        random_permutation = np.random.permutation(len(test_labels))
        predicted_categories = [test_labels[i] for i in random_permutation]
    else:
        raise ValueError('Unknown classifier type')

 	'''
    ## Step 3:结果可视化，该函数项目本身已经提供。
    '''
    create_results_webpage2( train_image_paths, \
                            test_image_paths, \
                            train_labels, \
                            test_labels, \
                            categories, \
                            abbr_categories, \
                            predicted_categories, \
                            FEATURE, \
                            CLASSIFIER)
 
1. 图像特征表示
 
我们通过两种相互独立的手段获取图像的特征，第一种手段是直接获得图像的tiny特征，优点是速度快，缺点是精度差，最后的分类准确率大于在20%左右，用来对比衬托出词袋模型的高准确率。第二种手段就是通过构建词袋模型，具体过程在下面会结合相关函数介绍，分类准确率在60%左右，相比于tiny特征有很大提升，缺点是训练时间较长。
 
1.1. 图像的tiny特征表示
 
微型图像表征具有理解容易，实现简单等优点。Torralba等人的微图像特征表示技术可以在最小的尺度空间内表示原始图像的特征。一个简单的做法是把原图像缩小到固定像素（这里我设置成16*16像素）并进行归一化操作，最后进行一维输出。
 
函数：get_tiny_images()
 
def get_tiny_images(image_paths):
    N = len(image_paths)
    size = 16
    tiny_images = []
    for each in image_paths:
      image = Image.open(each)
      image = image.resize((size, size))
      image = (image - np.mean(image))/np.std(image)
      image = image.flatten()
      tiny_images.append(image)
    tiny_images = np.asarray(tiny_images)
    return tiny_images
 
效果
 
原始图像，微小化图像，归一化图像依次如下图所示。
 
 
 
 
1.2 图像的词袋模型构建
 
具体操作过程中主要有以下几步：
 
利用SIFT或者HOG算法，从训练集的每张图像中提取局部特征（一个图像大约有几十个），每一类图片、每一张图片所有的局部特征都聚集在一起。
利用K-means对训练集的局部特征进行聚类，聚成k（项目中为200）类，合并相近的特征，构成一个视觉词汇（就是每一类的中心），至此，我们就得到了一个包含K个词汇的单词表。
利用单词表中的词汇表示图像，具体过程见1.2.2
 
1.2.1 图像特征提取,以及词袋构建
 
函数：build_vocabulary(image_paths, vocab_size):
 
功能：训练集图片的HOG特征提取,使用K-means对提取特征进行聚类后返回特征中心。
 
def build_vocabulary(image_paths, vocab_size):
    image_list = [imread(file) for file in image_paths]
    cells_per_block = (2, 2)
    z = cells_per_block[0]
    pixels_per_cell = (4, 4)
    feature_vectors_images = []
    for image in image_list:
        feature_vectors = hog(image, feature_vector=True, pixels_per_cell=pixels_per_cell,cells_per_block=cells_per_block, visualize=False)
        feature_vectors = feature_vectors.reshape(-1, z*z*9)
        feature_vectors_images.append(feature_vectors)
    all_feature_vectors = np.vstack(feature_vectors_images)
    kmeans = MiniBatchKMeans(n_clusters=vocab_size, max_iter=500).fit(all_feature_vectors) # change max_iter for lower compute time
    vocabulary = np.vstack(kmeans.cluster_centers_)
    return vocabulary
 
具体步骤：
 
 
基于scikit-image的HOG特征提取
 相关参数：
 -> image: input image, 输入图像
 -> feature_vector: 将输出转换为一维向量.
 -> pixels_per_cell : 每个cell的像素数, 是一个tuple类型数据,本项目中为（4,4）
 -> cell_per_block : 每个BLOCK内有多少个cell, tuple类型, 本项目中为(2,2), 意思是将block均匀划分为2x2的块
 -> visualise: 是否输出梯度图
 
输入图像和梯度效果图如下所示：
 
 
 
 
基于scikit-image的mini batch K-means特征聚类
 相关参数：
 -> n_clusters：整形，缺省值=8 ,生成的聚类数，即产生的质心（centroids）数。
 -> max_iter：整形，缺省值=300 ,执行一次k-means算法所进行的最大迭代数。
 方法：
 -> fit(X[,y]): 计算k-means聚类。
 
 
1.2.2 统计词频，构建图像直方图
 
在上一步构建完词典后，下面通过该特征词典，分别统计训练集和测试集中每幅图像的词频。
 具体做法： 我们把之前每一个图像分割成很多的patch，现在统计每一个patch和前面聚类得到的每一个中心的距离。离哪个质心近，直方图中相对应的bin就加1，计算完这幅图像所有的patch后对直方图进行归一化（/L2），之后图像就可以用这个直方图进行表示了（images_histograms[i] = histogram）
 在所有图像计算完成之后，就可以进行分类了。
 
函数get_bags_of_words(image_paths)
 
def get_bags_of_words(image_paths):
    vocab = np.load('vocab.npy')
    print('Loaded vocab from file.')
    vocab_length = vocab.shape[0]
    image_list = [imread(file) for file in image_paths]
    # Instantiate empty array
    images_histograms = np.zeros((len(image_list), vocab_length))
    cells_per_block = (2, 2) # Change for lower compute time
    z = cells_per_block[0]
    pixels_per_cell = (4, 4) # Change for lower compute time
    feature_vectors_images = []
    for i, image in enumerate(image_list):
        feature_vectors = hog(image, feature_vector=True, pixels_per_cell=pixels_per_cell,cells_per_block=cells_per_block, visualize=False)
        feature_vectors = feature_vectors.reshape(-1, z*z*9)
        histogram = np.zeros(vocab_length)
        distances = cdist(feature_vectors, vocab)  
        closest_vocab = np.argsort(distances, axis=1)[:,0]
        indices, counts = np.unique(closest_vocab, return_counts=True)
        histogram[indices] += counts
        histogram = histogram / norm(histogram)
        images_histograms[i] = histogram
    return images_histograms
 
2. 分类器的构建
 
2.1. 使用KNN分类器进行特征分类
 
我们通过查找训练集图像的相应最似特征来预测测试图像的类别。对于任意给定的KNN参数K给出相对于测试集图像最近的K个邻居，并通过投票法返回最临近邻居的分类。
 输入参数：
 
训练图像特征：一个n*d的numpy数组，n是训练集大小，d是特征向量维度。
训练图像标签：一个n*1的列表，记录了训练数据的真实分类标签。
测试图像特征：一个m*d的numpy数组，m是测试集大小，d是特征向量维度。
 
返回：
 一个m*1的numpy数组，表示测试集中每个图片的预测类别。
 函数内容：
 
获取每个测试图像特征与每个训练图像特征之间的距离，这里使用了欧式距离，输入两个d* n的矩阵（d是每个图片特征数，n是图片数）返回n* n的矩阵，表示测试集每个图片和训练集每个图片之间的距离。
找出与每个测试图像距离最短的k个训练集图片。
确定这k个训练集图片的类别标签。
用投票法选出最常见的标签，作为该测试图片的预测类别。
 
函数：nearest_neighbor_classify()
 
def nearest_neighbor_classify(train_image_feats, train_labels, test_image_feats):
    k = 5;
    distances = cdist(test_image_feats, train_image_feats, 'euclidean')
    sorted_indices = np.argsort(distances, axis=1)
    knns = sorted_indices[:,0:k]
    labels = np.zeros_like(knns)
    get_labels = lambda t: train_labels[t]
    vlabels = np.vectorize(get_labels)
    labels = vlabels(knns) 
    labels = mode(labels,axis=1)[0]
    return labels
 
2.2. 使用SVM分类器进行特征分类
 
函数：svm_classify(train_image_feats, train_labels, test_image_feats)
 
输入参数：
 
训练图像特征：一个n*d的numpy数组，n是训练集大小，d是特征向量维度。
训练图像标签：一个n*1的列表，记录了训练数据的真实分类标签。
测试图像特征：一个m*d的numpy数组，m是测试集大小，d是特征向量维度。
 
返回：
 一个m*1的numpy数组，表示测试集中每个图片的预测类别。
 
sklearn svm.LinearSVC参数说明：
 -> random_state : 在随机数据混洗时使用的伪随机数生成器的种子。 如果是int，则random_state是随机数生成器使用的种子。
 ->tol : float, 公差停止标准。
 
def svm_classify(train_image_feats, train_labels, test_image_feats):
    clf = LinearSVC(random_state=0, tol=1e-5)
    clf.fit(train_image_feats, train_labels)
    test_predictions = clf.predict(test_image_feats)
    return test_predictions
 
结果展示
 
特征提取器：NULL
 分类器：NULL
 准确率：6.9%（纯随机）
 
 特征提取器：Tiny
 分类器：KNN
 准确率：18.9%
 
 特征提取器：Tiny
 分类器：SVM
 准确率：22.3%
 
 
特征提取器：BOW（HOG+K-means)
 分类器：KNN
 准确率：58.1%
 
 特征提取器：BOW（HOG+K-means)
 分类器：SVM
 准确率：68.9%
 
 
参考资料
 
Introduction to Computer Vision
 Scene Recognition with Bag of Words
 基于词袋模型的图像分类算法
 Beyond Bags of Features: Spatial Pyramid Matching for Recognizing Natural Scene Categories
 Histograms of oriented gradients for human detection
 Learn OpenCV-Histogram of Oriented Gradients
 SVM入门（十）将SVM用于多类分类
 
项目源码下载链接
 
基于词袋模型的场景识别 Scene Recognition with Bag of Words

前言
 
 
  本笔记整理于中国地质大学（武汉）的一门英语发音课程：英语语音，的第十一、十二单元的文档资料，主要是连读技巧。包括半元音，用半元音/w/和/j/衔接元音的连读，用卷舌音/r/衔接元音的连读等，以及辅音加半元音时的连读。整理于此，主要是便于以后查阅，若有侵权，通知立删。
 
 
半元音与连读
 
 
  无论是单词内部，还是在单词与单词之间，口语表达中，常在两个相邻的元音读音之间添加半元音/w/和/j/，或者是卷舌音/r/来衔接。他们的使用可以使得元音发音之间过渡自然，进而使得发音流畅。注意，/w/和/j/这两个音素，实属于辅音。之所以叫“半元音”（semi-vowels），是因为它们的发音特点分别与元音/u:/、/i:/非常接近，但它们却起着辅音的作用，即放在元音前面引导一个音节，如wait(/weit/)和yes(/jes/)中的首辅音。半元音/w/发音跟/u:/相似，但更短促；/j/发音跟/i:/相似，同样更短促。另外，在有些辅音与半元音相邻时，连读与原读音不同。
 
 
/w/衔接相邻元音的连读
 
 
词内连读
 
  在单词内部，相邻的两个元音，如果前一个音标单词以/u/、/u:/、/au/或/әu/结尾，添加/w/连读两个元音。
   如：
   lower /'lәu-wә/（读音）
   flower/flour /'flau-wә/（读音）
   however /hauˈ-wevər/
   doing /'du:-wiŋ/
   going /'gәu-wiŋ/
   poem/'pәu-wim/
   ruin /'ru:-win/
 
词间连读
 
  在短语中，前一个单词以/u/、/u:/、/au/或/әu/结尾（特指发音，不是字母），下一个单词以元音开始（特指发音，不是字母），口头表达时，在中间采用/w/连接。
   如：
   Do it. /'du: wit/（读音）
   Show us. '∫әu wәs/（读音）
   two hours,/tuː waurz
   go w-on,
   How w-are you?
   If you know w-it, show w-it.
   two w-answers
 
 
/j/衔接相邻元音的连读
 
 
词内连读
 
  在单词内部，相邻的两个元音，如果前一个单词以/~i/或/i:/结尾（包括/i:/、/i/、/ai/、/ei/和/ɔi/），应添加/j/连读两个元音.
   如：
   player /'plei-jә/（读音）
   fire /'fai-jә/（读音）
   employer /im’plɔi-jә/（读音）
   oil /ɔi-jl/
   soil /sɔi-jl/
 
词间连读
 
  在短语中，前一个单词以/~i/或/i:/结尾（包括/i:/、/i/、/ai/、/ei/和/ɔi/）（特指发音，不是字母），下一个单词以元音开始（特指发音，不是字母），口头表达时，在中间采用/j/连接
   如：
 
  A and B /ei-jәn bi:/（读音）
   my office /mai 'jɔfis/（读音）
   hurry j-up,
   worry j-about
   Can you say j-it again?
   Lemme(let me) try j-it.
   three j-answers
   my j-answer
   Gimme(give me) j-a-n example. (an被切分成两块，分别与/j-/和/i-/连读，冠词发音见上一篇笔记)
 
  注：在美式发音中，/dju:/和/nju:/这两个单音节读音倾向于省去半元音/j/，就变成了/du:/和/nu:/。
 
 
/r/衔接相邻元音的连读
 
 
词内连读
 
  在单词内部，相邻的两个元音，如果前一个音节以元音结尾，且构成元音的字母组合中含有字母r（此处指单词中，不是音标里），应添加/r/连读两个元音。
   如：
   forever /fɔ:-'revә/（读音）
   wherever /weә-'revә/（读音）
 
词间连读
 
  在短语中，前一个单词以元音结尾（特指发音，不是字母），且构成元音的字母组合中含有字母r，下一个单词以元音开始（特指发音，不是字母），口头表达时，在中间采用/r/连接。
   如：
   four o’clock à /fɔ:-rә’klɔk/（读音）
   after all à /'a:ftә-’clock à /fɔ:-rɔ:l/（读音）
   far r-away,
   for r-example
   Now what’s your r-answer?
   four r-answers,
   your r-answer
 
 
辅音加半元音/w/的连读
 
 
  英语单词中，能跟半元音/w/相邻的辅音不多，常见的有四个爆破音/t, d, k, g/+/w/。它们组合发音时，可以把/w/当做元音/u(:)/来对待，组合发音会更加流畅、轻快，但/w/发音要迅速，不能拖音。
   如：
   twice /`twais/
   between /bi’twi:n/
   dwell /dwel/
   dwarf /dwɔ:f/
   quite /kwait/
   question /'kwest∫әn/
   penguine /'peŋgwin/
   language /'læŋgwidʒ/
 
 
辅音加半元音/j/的连读
 
 
  变音组合：/s, z, t, d/ 与/j/相连，相邻的两个辅音都要发生音变，变化的结果是二者融合为第三个辅音。这种变化也可以理解为音的“同化”。这种现象可以发生在单词内部和单词之间。（单词内部变了之后感觉怪怪的，如resume /rɪˈzjuːm/）
 
  /s/+/j/变读为/∫/
   如：sugar/'∫ugә /, miss you /'mi∫u/, kiss you /'ki∫u/
 
  /z/+/j/变读为/ʒ/
   如：usual /'ju:ʒuəl/, use your pen /'ju:ʒɔ: pen/
 
  /t/+/j/变读为/t∫/
   如：virtue /'və:t∫u:/, meet you /'mit∫u:/。当然，如果愿意，也可以在同化变音后，把/u:/读成/ju:/，相当于半元音/j/操作了两次。
 
  /d/+/j/变读为/dʒ/
   如：gradual /'grædʒuəl/, Did you? /'didʒu/或/'didʒju/
 
 
辅音/l/加半元音/j/的连读
 
 
  /l/+ 半元音/j/常被称作争议组合，因为当这两个辅音相邻时，典型的英式发音和美式发音采取了不同的处理方法。
 
  英式发音
   直接连读，如million /'mi-ljən/, failure /'fei-ljə/。
   美式发音
   /l/和/j/被当做两个标准的辅音对待，认为它们不能连读，因此拆分在前后两个不同的音节里，分别读出，如：million /'mil-jən/, failure /'feil-jə/。更大的数字billion、trillion、zillion在英美发音里的差异同上。
 
 
连读小结
 
 
  若前一个单词读音以辅音结尾，后一个单词读音以元音开头，常常将前者的最后一个辅音与后者的第一个辅音连起来读。见上一篇笔记。如：
   look after (/'lukæftә/)
   若词间前一个单词读音以元音结尾，后一个单词读音以元音开头，为了元音过渡自然，常常在两者之间添加半元音或者卷舌音（卷舌音要复杂些，见上文）衔接。如：
   Do it. /'du: wit/
   hurry j-up
   for r-example
   若词内前一个音节以元音结尾，后一个音节以元音开头（有时不是音节，就是指两个元音相连，如：三元音读法），为了元音过渡自然，常常在两者之间添加半元音或者卷舌音（卷舌音要复杂些，见上文）衔接。如：
   however /hauˈ-wevər/
   fire /'fai-jә/ （三元音读法）
   forever /fɔ:-'revә/
   词间或者词内/s/+/j/变读为/∫/、/t/+/j/变读为/t∫/、/z/+/j/变读为/ʒ/、/d/+/j/变读为/dʒ/。例子如上。
 
例句
 
 
We will (/wil/) treat you as a VIP.
 
 
Don’t you like it?
 
 
I will get you a drink. (/ail 'get∫u(w)ə/)
 
 
We heard your voice jus(t) now.
 
 
Did you hurt yourself?
 
 
Number twelve an(d) twenty, come over with your quesitons.
 
 
If you can spea(k) 2 (w)or more languages, you (w)are called a multi-linguist.
 
 
We are (/wiə/) curious about her beauty an(d) reputation. (her的首辅音省去)
 
 
We had a power fail-ure las(t) night. (/'pau(w)ə 'feil-jə/)
 
 
A clever guy often starts with self-education and improves with graduation. (/sel,fedʒu’kei∫n/；/,grædʒu’(w)ei∫n/)
 
 
value, evaluate, evaluation, familiar,Australia, salutation.（美式与英式读音差别，个人在这里更喜欢英式发音）
 
 
 
参考
 
 
  https://www.icourse163.org/learn/CUG-1205884805?tid=1450393462#/learn/content
   https://www.icourse163.org/learn/CUG-1205884805?tid=1450393462#/learn/content?type=detail&id=1214730870&sm=1

                                                    Python——腾讯词向量的预处理
 
 
 
目标：下载腾讯词向量，并对其进行预处理，输出字向量与对应的tokenizer。
 
腾讯词向量下载地址：Tencent AI Lab Embedding Corpus for Chinese Words and Phrases。解压后是一个约16G的txt文件，命名为：Tencent_AILab_ChineseEmbedding.txt。
 
Python代码：
 
#!/usr/bin/env python
# -*- coding:utf-8 -*-

"""
@Time     :2020/2/3
@Name     :Zhang Wei
@Contact  :1223242863@qq.com
@File     :tencent.py
@Software :Pycharm
"""

import pickle as pk
# from gensim.models import KeyedVectors
from tqdm import tqdm
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np


# 加载pkl文件
def load_pkl(input_path):
    with open(input_path, 'rb') as f:
        loaded_obj = pk.load(f)
    return loaded_obj


# 写入pkl文件
def to_pkl(content, output_path):
    with open(output_path, 'wb') as f:
        pk.dump(content, f)


# 加载腾讯词向量, 数据清洗
def load_tencent_word_embedding():
    n = 0
    with open('tencent.txt', 'a', encoding='utf-8', errors='ignore') as w_f:
        with open('Tencent_AILab_ChineseEmbedding.txt', 'r', encoding='utf-8', errors='ignore')as f:
            for i in tqdm(range(8824330)):  # 似乎不同时期下载的词向量range并不一样
                data = f.readline()
                a = data.split()
                if i == 0:
                    w_f.write('8748463 200\n')  # 行数的写入也有可能不同
                if len(a) == 201:
                    if not a[0].isdigit():
                        n = n + 1
                        w_f.write(data)
    print(n)  # 输出清洗后的range
    # model = KeyedVectors.load_word2vec_format('tencent.txt', binary=False, unicode_errors='ignore')
    print("successfully load tencent word embedding!")


# 保存字向量与对应的tokenier
def save_char_embedding(embedding_path, tokenizer_path):
    flag, keras_embedding, words = 0, [], []

    with open('tencent.txt','r',encoding='utf-8') as file:
        for line in file:
            flag += 1
            if flag >= 3:
                vectorlist = line.split()  # 切分一行，分为词汇和词向量
                # 单字符
                if len(vectorlist[0]) == 1:  # 单字: '\u4e00' <= vectorlist[0] <= '\u9fff'
                    vector = list(map(lambda x:float(x),vectorlist[1:]))  # 对词向量进行处理
                    vec = np.array(vector)  # 将列表转化为array
                    keras_embedding.append(vec)
                    words.append(vectorlist[0])
        res = np.array(keras_embedding)
        to_pkl(res, embedding_path)  # 保存腾讯字向量

        # 创建分词器Tokenzier对象
        tokenizer = Tokenizer()

        # fit_on_texts 方法
        tokenizer.fit_on_texts(words)
        to_pkl(tokenizer, tokenizer_path)  # 保存腾讯字分词器

        print("successfully save!")


# 保存为单字词典word.txt
def save_one_word(tokenizer_path, word_path="word.txt"):
    tokenizer = load_pkl(tokenizer_path)
    with open(word_path, "w", encoding="utf-8") as file:
        for word in tokenizer.word_docs.keys():
            if '\u4e00' <= word <= '\u9fff':  # 可以设置长度, 用来保存常用词典
                file.write(word + "\n")
    print("successfully save one word!")



if __name__ == "__main__":
    embedding_path = "keras_embedding.pkl"
    tokenizer_path = "keras_tokenizer.pkl"
    # save_char_embedding(embedding_path, tokenizer_path)  # 保存腾讯字向量与字分词器

    tokenizer = load_pkl(tokenizer_path)

    # 单元测试
    query = "武汉加油。中国加油。"
    text = " ".join(list(query))  # 对 "武汉加油" 进行切分,得到 "武 汉 加 油"
    seq = tokenizer.texts_to_sequences([text])
    print(query, seq)
 
输出：
 
武汉加油。中国加油。 [[1449, 1663, 304, 553, 96, 131, 451, 304, 553, 96]]
 
 
 
参考资料：
 
1、Keras深度学习库
 
2、Python函数——Keras分词器Tokenizer