| 1 |  |  | import numpy as np | 
            
                                                                                                            
                            
            
                                    
            
            
                | 2 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 3 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 4 |  |  | def normalize(v): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 5 |  |  |     if v.ndim != 1: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 6 |  |  |         raise ValueError('v should be 1-D, {}-D was given'.format( | 
            
                                                                                                            
                            
            
                                    
            
            
                | 7 |  |  |             v.ndim)) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 8 |  |  |     norm = np.linalg.norm(v) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 9 |  |  |     if norm == 0: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 10 |  |  |         return v | 
            
                                                                                                            
                            
            
                                    
            
            
                | 11 |  |  |     return v / norm | 
            
                                                                                                            
                            
            
                                    
            
            
                | 12 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 13 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 14 |  |  | def cosine_similarity(v, u): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 15 |  |  |     v_norm = np.linalg.norm(v) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 16 |  |  |     u_norm = np.linalg.norm(u) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 17 |  |  |     similarity = v @ u / (v_norm * u_norm) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 18 |  |  |     return similarity | 
            
                                                                                                            
                            
            
                                    
            
            
                | 19 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 20 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 21 |  |  | def project_vector(v, u): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 22 |  |  |     """Projecting the vector v onto direction u.""" | 
            
                                                                                                            
                            
            
                                    
            
            
                | 23 |  |  |     normalize_u = normalize(u) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 24 |  |  |     return (v @ normalize_u) * normalize_u | 
            
                                                                                                            
                            
            
                                    
            
            
                | 25 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 26 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 27 |  |  | def reject_vector(v, u): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 28 |  |  |     """Rejecting the vector v onto direction u.""" | 
            
                                                                                                            
                            
            
                                    
            
            
                | 29 |  |  |     return v - project_vector(v, u) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 30 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 31 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 32 |  |  | def project_reject_vector(v, u): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 33 |  |  |     """Projecting and rejecting the vector v onto direction u.""" | 
            
                                                                                                            
                            
            
                                    
            
            
                | 34 |  |  |     projected_vector = project_vector(v, u) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 35 |  |  |     rejected_vector = v - project_vector(v, u) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 36 |  |  |     return projected_vector, rejected_vector | 
            
                                                                                                            
                            
            
                                    
            
            
                | 37 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 38 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 39 |  |  | def update_word_vector(model, word, new_vector): | 
            
                                                                                                            
                            
            
                                    
            
            
                | 40 |  |  |     model.syn0[model.vocab[word].index] = new_vector | 
            
                                                                                                            
                            
            
                                    
            
            
                | 41 |  |  |     if model.syn0norm is not None: | 
            
                                                                                                            
                            
            
                                    
            
            
                | 42 |  |  |         model.syn0norm[model.vocab[word].index] = normalize(new_vector) | 
            
                                                                                                            
                            
            
                                    
            
            
                | 43 |  |  |  | 
            
                                                                                                            
                                                                
            
                                    
            
            
                | 44 |  |  |  | 
            
                                                                        
                            
            
                                    
            
            
                | 45 |  |  | def generate_one_word_forms(word): | 
            
                                                                        
                            
            
                                    
            
            
                | 46 |  |  |     return [word.lower(), word.upper(), word.title()] | 
            
                                                                                                            
                            
            
                                    
            
            
                | 47 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 48 |  |  |  | 
            
                                                                                                            
                            
            
                                    
            
            
                | 49 |  |  | def generate_words_forms(words): | 
            
                                                                                                            
                                                                
            
                                    
            
            
                | 50 |  |  |     return sum([generate_one_word_forms(word) for word in words], []) | 
            
                                                        
            
                                    
            
            
                | 51 |  |  |  |