英语形态还原

最新推荐文章于 2019-03-19 21:55:24 发布
最新推荐文章于 2019-03-19 21:55:24 发布
阅读量529 收藏
点赞数
分类专栏： 词法分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nlpzryyclxz/article/details/48047203
版权

英语单词具有丰富的词形变化（时态的表示，可数名词的复数，形容词比较级最高级等），如果把这些带有词形变化的词都放在词典中，就会使词典规模过大，造成资源浪费。
因此利用形态还原（stemming）把单词还原成词干形式是必要的。同时，在词形还原的过程中还可以获得丰富的
词法信息，这也为句法分析的后续处理提供了重要依据。

形态还原（stemming）的方法分为两类
1、规则 Porter算法
2、统计 Hafer算法

下边的代码为一个Porter算法的代码
头文件

//
// $Id$
//

//
// Copyright (c) 2001-2014, Andrew Aksyonoff
// Copyright (c) 2008-2014, Sphinx Technologies Inc
// All rights reserved
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License. You should have
// received a copy of the GPL license along with this program; if you
// did not, you can find it at http://www.gnu.org/
//

#ifndef _sphinxstem_
#define _sphinxstem_



/// initialize English stemmar
void    stem_en_init ();



/// stem lowercase English word
void    stem_en ( unsigned char * pWord, int iLen );

#endif // _sphinxstem_

//
// $Id$
//

实现文件

//
// $Id$
//

//
// Copyright (c) 2001-2014, Andrew Aksyonoff
// Copyright (c) 2008-2014, Sphinx Technologies Inc
// All rights reserved
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License. You should have
// received a copy of the GPL license along with this program; if you
// did not, you can find it at http://www.gnu.org/
//


#if defined(_MSC_VER) && !defined(__cplusplus)
#define inline
#endif

// #define SNOWBALL2011

static unsigned char stem_en_doubles[] = "bdfgmnprt";

static unsigned char vowel_map[] =
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 0
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 1
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 2
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 3
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 4
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 5
    //` a b c d e f g h i j k l m n o - NOLINT
    "\0\1\0\0\0\1\0\0\0\1\0\0\0\0\0\1" // 6
    //p q r s t u v w x y z - NOLINT
    "\0\0\0\0\0\1\0\0\0\1\0\0\0\0\0\0" // 7
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 8
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // 9
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // a
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // b
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // c
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // d
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" // e
    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; // f

#define is_vowel(idx) vowel_map[word[idx]]

static inline int stem_en_id ( unsigned char l )
{
    register unsigned char * v = stem_en_doubles;
    while ( *v && *v!=l ) v++;
    return ( *v==l ) ? 1 : 0;
}

static inline int stem_en_ivwxy ( unsigned char l )
{
    return vowel_map[l] || l=='w' || l=='x' || l=='Y';
}

void stem_en_init ()
{
}

#define EXCBASE(b) ( iword==( ( (int)b[3]<<24 ) + ( (int)b[2]<<16 ) + ( (int)b[1]<<8 ) + (int)b[0] ) )
#define EXC4(a,b) ( len==4 && EXCBASE(b) )
#define EXC5(a,b) ( len==5 && EXCBASE(b) )
#define EXC6(a,b) ( len==6 && EXCBASE(b) && a[4]==b[4] )
#define EXC7(a,b) ( len==7 && EXCBASE(b) && a[4]==b[4] && a[5]==b[5] )
#define EXC8(a,b) ( len==8 && EXCBASE(b) && a[4]==b[4] && a[5]==b[5] && a[6]==b[6] )

void stem_en ( unsigned char * word, int len )
{
    int i, first_vowel, r1, r2, iword;
    unsigned char has_Y = 0;

    if ( len<=2 )
        return;

#if UNALIGNED_RAM_ACCESS
    iword = *(int*)word;
#else
    iword = ( (int)word[3]<<24 ) + ( (int)word[2]<<16 ) + ( (int)word[1]<<8 ) + (int)word[0];
#endif

    // check for 3-letter exceptions (currently just one, "sky") and shortcuts
    if ( len==3 )
    {
#define CHECK3(c1,c2,c3) if ( iword==( (c1<<0)+(c2<<8)+(c3<<16) ) ) return;
#ifdef SNOWBALL2011
#define CHECK3A CHECK3
#else
#define CHECK3A(c1,c2,c3) if ( iword==( (c1<<0)+(c2<<8)+(c3<<16) ) ) { word[2] = '\0'; return; }
#endif
        CHECK3 ( 't', 'h', 'e' );
        CHECK3 ( 'a', 'n', 'd' );
        CHECK3 ( 'y', 'o', 'u' );
        CHECK3A ( 'w', 'a', 's' );
        CHECK3A ( 'h', 'i', 's' );
        CHECK3 ( 'f', 'o', 'r' );
        CHECK3 ( 'h', 'e', 'r' );
        CHECK3 ( 's', 'h', 'e' );
        CHECK3 ( 'b', 'u', 't' );
        CHECK3 ( 'h', 'a', 'd' );
        CHECK3 ( 's', 'k', 'y' );
    }

    // check for 4..8-letter exceptions
    if ( len>=4 && len<=8 )
    {
        // check for 4-letter exceptions and shortcuts
        if ( len==4 )
        {
            // shortcuts
            if ( iword==0x74616874 ) return; // that
            if ( iword==0x68746977 ) return; // with
            if ( iword==0x64696173 ) return; // said
            if ( iword==0x6d6f7266 ) return; // from

            // exceptions
            if ( iword==0x7377656e ) return; // news
            if ( iword==0x65776f68 ) return; // howe
        }

        // all those exceptions only have a few valid endings; early check
        switch ( word[len-1] )
        {
            case 'd':
                if ( EXC7 ( word, "proceed" ) )     return;
                if ( EXC6 ( word, "exceed" ) )      return;
                if ( EXC7 ( word, "succeed" ) )     return;
                break;

            case 'g':
                if ( EXC5 ( word, "dying" ) )       { word[1] = 'i'; word[2] = 'e'; word[3] = '\0'; return; }
                if ( EXC5 ( word, "lying" ) )       { word[1] = 'i'; word[2] = 'e'; word[3] = '\0'; return; }
                if ( EXC5 ( word, "tying" ) )       { word[1] = 'i'; word[2] = 'e'; word[3] = '\0'; return; }
                if ( EXC6 ( word, "inning" ) )      return;
                if ( EXC6 ( word, "outing" ) )      return;
                if ( EXC7 ( word, "canning" ) )     return;
#ifdef SNOWBALL2011
                if ( EXC7 ( word, "herring" ) )     return;
                if ( EXC7 ( word, "earring" ) )     return;
#endif
                break;

            case 's':
                if ( EXC5 ( word, "skies" ) )       { word[2] = 'y'; word[3] = '\0'; return; }
                if ( EXC7 ( word, "innings" ) )     { word[6] = '\0'; return; }
                if ( EXC7 ( word, "outings" ) )     { word[6] = '\0';return; }
                if ( EXC8 ( word, "cannings" ) )    { word[7] = '\0';return; }
#ifdef SNOWBALL2011
                if ( EXC4 ( word, "skis" ) )        { word[3] = '\0'; return; }
                if ( EXC5 ( word, "atlas" ) )       return;
                if ( EXC6 ( word, "cosmos" ) )      return;
                if ( EXC4 ( word, "bias" ) )        return;
                if ( EXC5 ( word, "andes" ) )       return;
                if ( EXC8 ( word, "herrings" ) )    { word[7] = '\0'; return; }
                if ( EXC8 ( word, "earrings" ) )    { word[7] = '\0'; return; }
                if ( EXC8 ( word, "proceeds" ) )    { word[7] = '\0'; return; }
                if ( EXC7 ( word, "exceeds" ) )     { word[6] = '\0'; return; }
                if ( EXC8 ( word, "succeeds" ) )    { word[7] = '\0'; return; }
#endif
                break;

            case 'y':
                if ( EXC4 ( word, "idly" ) )        { word[3] = '\0';return; }
                if ( EXC6 ( word, "gently" ) )      { word[5] = '\0';return; }
                if ( EXC4 ( word, "ugly" ) )        { word[3] = 'i'; word[4] = '\0'; return; }
                if ( EXC5 ( word, "early" ) )       { word[4] = 'i'; word[5] = '\0'; return; }
                if ( EXC4 ( word, "only" ) )        { word[3] = 'i'; word[4] = '\0'; return; }
                if ( EXC6 ( word, "singly" ) )      { word[5] = '\0'; return; }
                break;
        }
    }

    // hide consonant-style y's
    if ( word[0]=='y' )
        word[0] = has_Y = 'Y';
    for ( i=1; i<len; i++ )
        if ( word[i]=='y' && is_vowel ( i-1 ) )
            word[i] = has_Y = 'Y';

    // mark regions
    // R1 begins after first "vowel, consonant" sequence in the word
    // R2 begins after second "vowel, consonant" sequence
    if ( len>=5 && EXCBASE("gene") && word[4]=='r' )
    {
        r1 = 5; // gener-
        first_vowel = 1;
    }
#ifdef SNOWBALL2011
    else if ( len>=6 && EXCBASE("comm") && word[4]=='u' && word[5]=='n' )
    {
        r1 = 6; // commun-
        first_vowel = 1;
    } else if ( len>=5 && EXCBASE("arse") && word[4]=='n' )
    {
        r1 = 5; // arsen-
        first_vowel = 0;
    }
#endif
    else
    {
        for ( i=0; i<len && !is_vowel(i); i++ );
        first_vowel = i;

        for ( i=first_vowel; i<len-2; i++ )
            if ( is_vowel(i) && !is_vowel(i+1) )
                break;
        r1 = i+2;
    }
    for ( i=r1; i<len-2; i++ )
        if ( is_vowel(i) && !is_vowel(i+1) )
            break;
    r2 = i+2;

#define W(p,c) ( word[len-p]==c )

#define SUFF2(c2,c1) ( len>=2 && W(1,c1) && W(2,c2) )
#define SUFF3(c3,c2,c1) ( len>=3 && W(1,c1) && W(2,c2) && W(3,c3) )
#define SUFF4(c4,c3,c2,c1) ( len>=4 && W(1,c1) && W(2,c2) && W(3,c3) && W(4,c4) )
#define SUFF5(c5,c4,c3,c2,c1) ( len>=5 && W(1,c1) && W(2,c2) && W(3,c3) && W(4,c4) && W(5,c5) )
#define SUFF6(c6,c5,c4,c3,c2,c1) ( len>=6 && W(1,c1) && W(2,c2) && W(3,c3) && W(4,c4) && W(5,c5) && W(6,c6) )
#define SUFF7(c7,c6,c5,c4,c3,c2,c1) ( len>=7 && W(1,c1) && W(2,c2) && W(3,c3) && W(4,c4) && W(5,c5) && W(6,c6) && W(7,c7) )

#define SUFF3A(c3,c2) ( len>=3 && W(2,c2) && W(3,c3) )
#define SUFF4A(c4,c3,c2) ( len>=4 && W(2,c2) && W(3,c3) && W(4,c4) )
#define SUFF5A(c5,c4,c3,c2) ( len>=5 && W(2,c2) && W(3,c3) && W(4,c4) && W(5,c5) )
#define SUFF6A(c6,c5,c4,c3,c2) ( len>=6 && W(2,c2) && W(3,c3) && W(4,c4) && W(5,c5) && W(6,c6) )
#define SUFF7A(c7,c6,c5,c4,c3,c2) ( len>=6 && W(2,c2) && W(3,c3) && W(4,c4) && W(5,c5) && W(6,c6) && W(7,c7) )

    ///
    // STEP 1A
    ///

#ifdef SNOWBALL2011
#define IED_ACTION { if ( len-->4 ) len--; }
#else
#define IED_ACTION { if ( len--!=4 ) len--; }
#endif

    switch ( word[len-1] )
    {
        case 'd':
            if ( word[len-3]=='i' && word[len-2]=='e' )
                IED_ACTION
            break;
        case 's':
            if ( SUFF4 ( 's', 's', 'e', 's' ) ) // faster that suff4a for some reason!
                len -= 2;
            else if ( word[len-3]=='i' && word[len-2]=='e' )
                IED_ACTION
            else if ( word[len-2]!='u' && word[len-2]!='s' )
            {
#ifdef SNOWBALL2011
                if ( first_vowel<=len-3 )
#endif

                len--;
            }
            break;
    }

    ///
    // STEP 1B
    ///

    i = 0;
    switch ( word[len-1] )
    {
        case 'd':
            if ( SUFF3A ( 'e', 'e' ) )              { if ( len-3>=r1 ) len--; break; }
            if ( word[len-2]=='e' )                 i = 2;
            break;

        case 'y':
            if ( word[len-2]=='l' )
            {
                if ( SUFF5A ( 'e', 'e', 'd', 'l' ) )    { if ( len-5>=r1 ) len -= 3; break; }
                if ( SUFF4A ( 'e', 'd', 'l' ) )         { i = 4; break; }
                if ( SUFF5A ( 'i', 'n', 'g', 'l' ) )    { i = 5; break; }
            }
            break;

        case 'g':
            if ( SUFF3A ( 'i', 'n' ) )              i = 3;
            break;
    }

    if ( i && first_vowel<len-i )
    {
        len -= i;
        if ( SUFF2 ( 'a', 't' ) || SUFF2 ( 'b', 'l' ) || SUFF2 ( 'i', 'z' ) )
            word[len++] = 'e';
        else if ( len>=2 && word[len-1]==word[len-2] && stem_en_id ( word[len-1] ) )
            len--;
        else if ( ( len==2 && is_vowel(0) && !is_vowel(1) )
            || ( len==r1 && !is_vowel ( len-3 ) && is_vowel ( len-2 ) && !stem_en_ivwxy ( word[len-1] ) ) )
        {
            word[len++] = 'e';
        }
    }

    ///
    // STEP 1C
    ///

    if ( len>2
        && ( word[len-1]=='y' || word[len-1]=='Y' )
        && !is_vowel ( len-2 ) )
    {
        word[len-1] = 'i';
    }

    //
    // STEP 2
    //

    if ( len-2>=r1 )
        switch ( word[len-1] )
    {
        case 'i':
            if ( len>=3 && ( W ( 2, 'c' ) || W ( 2, 'l' ) || W ( 2, 't' ) ) )
            {
                if ( SUFF4A ( 'e', 'n', 'c' ) )             { if ( len-4>=r1 ) word[len-1] = 'e'; break; }
                if ( SUFF4A ( 'a', 'n', 'c' ) )             { if ( len-4>=r1 ) word[len-1] = 'e'; break; }
                if ( SUFF4A ( 'a', 'b', 'l' ) )             { if ( len-4>=r1 ) word[len-1] = 'e'; break; }
                if ( SUFF3A ( 'b', 'l' ) )                  { if ( len-3>=r1 ) word[len-1] = 'e'; break; }

                if ( SUFF5A ( 'e', 'n', 't', 'l' ) )        { if ( len-5>=r1 ) len -= 2; break; }
                if ( SUFF5A ( 'a', 'l', 'i', 't' ) )        { if ( len-5>=r1 ) len -= 3; break; }
                if ( SUFF5A ( 'o', 'u', 's', 'l' ) )        { if ( len-5>=r1 ) len -= 2; break; }

                if ( SUFF5A ( 'i', 'v', 'i', 't' ) )        { if ( len-5>=r1 ) { word[len-3] = 'e'; len -= 2; } break; }
                if ( SUFF6A ( 'b', 'i', 'l', 'i', 't' ) )   { if ( len-6>=r1 ) { word[len-5] = 'l'; word[len-4] = 'e'; len -= 3; } break; }
                if ( SUFF5A ( 'f', 'u', 'l', 'l' ) )        { if ( len-5>=r1 ) len -= 2; break; }
                if ( SUFF6A ( 'l', 'e', 's', 's', 'l' ) )   { if ( len-6>=r1 ) len -= 2; break; }
            }

#ifdef SNOWBALL2011
            if ( len-3>=r1 && SUFF3A ( 'o', 'g' ) && word[len-4]=='l' ) { len -= 1; break; }
#else
            if ( len-3>=r1 && SUFF3A ( 'o', 'g' ) ) { len -= 1; break; }
#endif

            if ( len-2>=r1 && word[len-2]=='l' )
                len -= 2;
            else
                break;

            if ( len-2>=r1 && SUFF2 ( 'a', 'l' ) )
            {
                len -= 2;
                if ( len-5>=r1 && SUFF5 ( 'a', 't', 'i', 'o', 'n' ) )
                {
                    len -= 3;
                    word[len++] = 'e';
                    break;
                }
                if ( SUFF4 ( 't', 'i', 'o', 'n' ) )
                    break;
                len += 2;
            } else
            {
                switch ( word[len-1] )
                {
                    case 'b':
                    case 'c':
                    case 'd':
                    case 'e':
                    case 'g':
                    case 'h':
                    case 'k':
                    case 'm':
                    case 'n':
                    case 'r':
                    case 't':
                        break;
                    default:
                        len += 2;
                        break;
                }
            }
            break;

        case 'l':
            if ( SUFF7A ( 'a', 't', 'i', 'o', 'n', 'a' ) )  { if ( len-7>=r1 ) { word[len-5] = 'e'; len -= 4; } break; }
            if ( SUFF6A ( 't', 'i', 'o', 'n', 'a' ) )       { if ( len-6>=r1 ) len -= 2; break; }
            break;

        case 'm':
            if ( SUFF5A ( 'a', 'l', 'i', 's' ) )            { if ( len-5>=r1 ) len -= 3; break; }
            break;

        case 'n':
            if ( SUFF7A ( 'i', 'z', 'a', 't', 'i', 'o' ) )  { if ( len-7>=r1 ) { word[len-5] = 'e'; len -= 4; } break; }
            if ( SUFF5A ( 'a', 't', 'i', 'o' ) )            { if ( len-5>=r1 ) { word[len-3] = 'e'; len -= 2; } break; }
            break;

        case 'r':
            if ( SUFF4A ( 'i', 'z', 'e' ) ) { if ( len-4>=r1 ) len -= 1; break; }
            if ( SUFF4A ( 'a', 't', 'o' ) ) { if ( len-4>=r1 ) { word[len-2] = 'e'; len -= 1; } break; }
            break;

        case 's':
            if ( len-7>=r1 && (
                SUFF7A ( 'f', 'u', 'l', 'n', 'e', 's' ) ||
                SUFF7A ( 'o', 'u', 's', 'n', 'e', 's' ) ||
                SUFF7A ( 'i', 'v', 'e', 'n', 'e', 's' ) ) )
            {
                len -= 4;
            }
            break;
    }

    //
    // STEP 3
    //

    if ( len-3>=r1 )
        switch ( word[len-1] )
    {
        case 'e':
            if ( SUFF5A ( 'a', 'l', 'i', 'z' ) )    { if ( len-5>=r1 ) len -= 3; break; }
            if ( SUFF5A ( 'i', 'c', 'a', 't' ) )    { if ( len-5>=r1 ) len -= 3; break; }
#ifdef SNOWBALL2011
            if ( SUFF5A ( 'a', 't', 'i', 'v' ) )    { if ( len-5>=r2 ) len -= 5; break; }
#else
            if ( SUFF5A ( 'a', 't', 'i', 'v' ) )    { if ( len-5>=r1 ) len -= 5; break; }
#endif
            break;

        case 'i':
            if ( SUFF5A ( 'i', 'c', 'i', 't' ) )    { if ( len-5>=r1 ) len -= 3; break; }
            break;

        case 'l':
            if ( SUFF4A ( 'i', 'c', 'a' ) )         { if ( len-4>=r1 ) len -= 2; break; }
            if ( SUFF3A ( 'f', 'u' ) )              { len -= 3; break; }
            break;

        case 's':
            if ( SUFF4A ( 'n', 'e', 's' ) )         { if ( len-4>=r1 ) len -= 4; break; }
            break;
    }

    //
    // STEP 4
    //

    if ( len-2>=r2 )
        switch ( word[len-1] )
    {
        case 'c':
            if ( word[len-2]=='i' ) len -= 2; // -ic
            break;

        case 'e':
            if ( len-3>=r2 )
            {
                if ( SUFF4A ( 'a', 'n', 'c' ) )     { if ( len-4>=r2 ) len -= 4; break; }
                if ( SUFF4A ( 'e', 'n', 'c' ) )     { if ( len-4>=r2 ) len -= 4; break; }
                if ( SUFF4A ( 'a', 'b', 'l' ) )     { if ( len-4>=r2 ) len -= 4; break; }
                if ( SUFF4A ( 'i', 'b', 'l' ) )     { if ( len-4>=r2 ) len -= 4; break; }
                if ( SUFF3A ( 'a', 't' ) )          { len -= 3; break; }
                if ( SUFF3A ( 'i', 'v' ) )          { len -= 3; break; }
                if ( SUFF3A ( 'i', 'z' ) )          { len -= 3; break; }
            }
            break;

        case 'i':
            if ( SUFF3A ( 'i', 't' ) )              { if ( len-3>=r2 ) len -= 3; break; }
            break;

        case 'l':
            if ( word[len-2]=='a' ) len -= 2; // -al
            break;

        case 'm':
            if ( SUFF3A ( 'i', 's' ) )              { if ( len-3>=r2 ) len -= 3; break; }
            break;

        case 'n':
            if ( len-3>=r2 && SUFF3 ( 'i', 'o', 'n' ) && ( word[len-4]=='t' || word[len-4]=='s' ) )
                len -= 3;
            break;

        case 'r':
            if ( word[len-2]=='e' ) len -= 2; // -er
            break;

        case 's':
            if ( SUFF3A ( 'o', 'u' ) )              { if ( len-3>=r2 ) len -= 3; break; }
            break;

        case 't':
            if ( word[len-2]=='n' )
            {
                if ( SUFF5A ( 'e', 'm', 'e', 'n' ) )    { if ( len-5>=r2 ) len -= 5; break; }
                if ( SUFF4A ( 'm', 'e', 'n' ) )         { if ( len-4>=r2 ) len -= 4; break; }
                if ( SUFF3A ( 'a', 'n' ) )              { if ( len-3>=r2 ) len -= 3; break; }
                if ( SUFF3A ( 'e', 'n' ) )              { if ( len-3>=r2 ) len -= 3; break; }
            }
            break;
    }

    //
    // STEP 5
    //

#ifdef SNOWBALL2011
    if ( len>r2 && word[len-1]=='l' && word[len-2]=='l' )
        len--;
    else
#endif
    while ( word[len-1]=='e' )
    {
        if ( len>r2 )
        {
            len--;
            break;
        }
        if ( len<=r1 )
            break;
        if ( len>3 && !is_vowel ( len-4 ) && is_vowel ( len-3 ) && !stem_en_ivwxy ( word[len-2] ) )
            break;
        if ( len==3 && is_vowel(0) && !is_vowel(1) )
            break;
        len--;
        break;
    }
#ifndef SNOWBALL2011
    if ( len>r2 && word[len-1]=='l' && word[len-2]=='l' )
        len--;
#endif

    
    // FINALIZE
    

    word[len] = 0;
    if ( has_Y )
        for ( i=0; i<len; i++ )
            if ( word[i]=='Y' )
                word[i] = 'y';
}

//
// $Id$
//
nlpzryyclxz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
英文词根还原和中文分词系统
11-01
在实现上，系统可能采用了诸如正则表达式、词缀去除、词性标注等方法，通过对英语词汇形态变化的规则进行编程，实现词根的自动识别和提取。 其次，中文分词是汉语处理的关键步骤。由于汉语没有明显的词与词之间的...
NLP（四）词形还原（Lemmatization）
TFATS的博客
10-15 9308
    词形还原（Lemmatization）是文本预处理中的重要部分，与词干提取（stemming）很相似。 一，什么是词形还原     简单说来，词形还原就是去掉单词的词缀，提取单词的主干部分，通常提取后的单词会是字典中的单词，不同于词干提取（stemming），提取后的单词不一定会出现在单词中。比如，单词“cars”词形还原后的单词为“car”，单词“ate”词形还原后的单词为“eat”。     在Python的nltk模块中，使用WordNet为我们提供了稳健的词形还原的函数。如以下示例Pyt.
NLP—形态还原算法
晴天小猪在fighting
10-30 2539
自然语言处理中的形态还原就是把句子中的词还原成基本词形，作为词的其它信息（词典、个性规则）的索引。
NLP入门（三）词形还原（Lemmatization）
weixin_33963594的博客
11-02 3418
  词形还原（Lemmatization）是文本预处理中的重要部分，与词干提取（stemming）很相似。  简单说来，词形还原就是去掉单词的词缀，提取单词的主干部分，通常提取后的单词会是字典中的单词，不同于词干提取（stemming），提取后的单词不一定会出现在单词中。比如，单词“cars”词形还原后的单词为“car”，单词“ate”词...
词干提取（stemming）和词形还原（lemmatization）
热门推荐
march_on的专栏
05-16 4万+
今天想完成词干提取的功能，发现提出来的结果并不是有意义的单词，原来还有词形还原这个技术。 以下内容均摘自论文《词形还原方法及实现工具比较分析》 词形还原（lemmatization），是把一个任何形式的语言词汇还原为一般形式（能表达完整语义），而词干提取 （stemming）是抽取词的词干或词根形式（不一定能够表达完整语义）。词形还原和词干提取是词形规范化的两类 重要方式，都能够达
Oto-Morph:耳曼语的形态学变化
03-20
耳曼语是一大语系，包括了诸如英语、德语、荷兰语等广泛使用的语言。形态学是语言学的一个分支，关注词汇如何通过添加前缀、后缀和其他结构变化来形成不同的词形，以表达不同的语法功能。在耳曼语中，形态变化尤为...
azuki-cma:Azuki Framework 字符形态分析器库
06-07
在自然语言处理（NLP）领域，字符形态分析（也称为词形还原或词干提取）是一项关键技术。它旨在识别词汇的基本形式，即词根，以揭示词汇间的语义关系。例如，英语中的"running"、"runs"和"ran"都源自词根"run"。...
b.rar_单词识别_英文单词识别
09-23
然而，这只是最基础的步骤，因为英文单词还有复数形式、过去式、现在进行时等各种形态变化，所以识别出单词的原型（也叫词干提取或词形还原）是更为复杂的过程。 词干提取是一种将单词转换为其基本形式的技术，通常...
英文维基百科语料库txt（7）
03-10
这份压缩包包含了一系列经过预处理的文本文件，如enwiki_61.txt至enwiki_67.txt等，这些文件已经完成了分词、停用词去除、英文小写化、词干提取和词形还原等关键步骤，极大地简化了后续的分析工作。 分词是自然语言...
自然语言处理中/英文对比
u014033218的专栏
03-19 6155
人工智能时代，让计算机自动化进行文字语义理解非常重要，广泛应用于社会的方方面面，而语言本身的复杂性又给计算机技术带来了很大的挑战，攻克文本语义对实现AI全面应用有至关重要的意义。相应的自然语言处理（Natural Language Processing，NLP）技术因而被称为是“人工智能皇冠上的明珠”。 中国和美国作为AI应用的两个世界大国，在各自语言的自动化处理方面有一些独特之处。接下来笔者对...
英文单词词形还原程序
张土豆的博客
09-26 8355
英语单词还原，即是指将一个给定的英文单词还原为其原型。如名词复数形式变为原型，动词过去式、现在进行时变为原型，形容词变为其名词或动词本体等。
人工智能：python 实现 第十章，NLP 第二天 基于词义的词形还原
聂雄超的博客
02-24 1318
基于词义的词形还原lemmatization 是另一种词形还原的方式。 在前一节中，我们可以明白从词干中提取词的基本形式没有任何意义。例如，三个三个词干提取器都显示calves的基本形式是calv,但它并不是一个真正的单词。Lemmatization 采取了一种更具结构化的方法解决了这个问题。lemmatizatio原理是使用语法和词态分析器进行单词分析，它包含了去除了如ing和ed等后缀的单词基...
词形还原（lemmatization）和词性辨别（PartOfSpeech）工具
hksskh的博客
10-16 3829
词干提取不难，网上有很多波特词干算法的实现。 词形还原的话，自己在网上寻找了一下，发现Stanford的NLP库可用，具体链接： http://nlp.stanford.edu/software/corenlp.shtml 这个是corenlp那个包的介绍网址，还有其他的很多包可以自行查看。 用法示例： StringBuilder stringBuilder = new String
NLP Lemmatisation（词性还原） 和 Stemming（词干提取） NLTK pos_tag word_tokenize
心之所向
03-03 2万+
词形还原（lemmatization），是把一个词汇还原为一般形式（能表达完整语义），方法较为复杂；而词干提取（stemming）是抽取词的词干或词根形式（不一定能够表达完整语义），方法较为简单。 Stemming（词干提取）： 基于语言的规则。如英语中名词变复数形式规则。由于基于规则，可能出现规则外的情况。 # Porter Stemmer基于Porter词干提取算法 from nlt...
python 实现文章中词汇的频率统计并进行显示(针对英文文章)
柠檬黄先生的博客
01-30 8724
python实现英文文章中出现单词频率的统计 本文的思路： 首先打开文件 ，对于文件的每一行进行词汇的统计，在这里需要注意 需要替换每一行中的单词之间的分隔符为空格，然后使用split()函数去掉空格，这样每一行剩下的就是纯粹的单词，然后遍历每一行中的每一个单词，将已经出现在字典中的单词，频次直接+1就行(这里需要用到字典中根据键来查找值的操作:dictionaryName[key]+=1)
097N04L-VB一款N-Channel沟道DFN8(3X3)的MOSFET晶体管参数介绍与应用说明
最新发布
07-15
097N04L-VB；Package：DFN8(3X3)；Configuration：Single-N-Channel；VDS：40V；VGS：20（±V）；Vth：2.5V；RDS(ON)=6mΩ@VGS=4.5V；RDS(ON)=4.5mΩ@VGS=10V；ID：40A；Technology：Trench；
帮我生成图片：AI绘画 AI绘画是什么 AI 绘画是指利用人工智能技术来生成绘画作品的一种创新方式 它基于深度学习算法和大量
07-15
帮我生成图片：AI绘画 AI绘画是什么 AI 绘画是指利用人工智能技术来生成绘画作品的一种创新方式。 它基于深度学习算法和大量的图像数据进行训练，从而能够理解和学习不同的绘画风格、主题、色彩搭配等要素。 AI 绘画的工作原理通常是用户向系统输入一些描述性的文本、关键词、选择特定的风格或提供一些参考图像等，然后 AI 模型会根据这些输入信息进行分析和计算，生成相应的绘画作品。 例如，您输入“在月光下的宁静森林中，一只白色的狐狸”，AI 绘画工具就可能为您生成一幅展现此场景的图像。 AI 绘画具有以下一些特点和优势： 高效性：能够在短时间内生成大量的绘画作品。 创新性：可以创造出独特、新颖的艺术风格和表现形式。 辅助创作：为艺术家提供灵感和创意启发，帮助他们拓展思路。 然而，AI 绘画也引发了一些争议，比如关于版权归属、对传统艺术家的影响等问题。但无论如何，它都为艺术领域带来了新的可能性和探索方向。 VisualBasic Visual Basic（简称 VB） 是一种由微软公司开发的事件驱动编程语言。 它具有以下显著特点： 易学易用：语法相对简单直观，对于初学者来说，入门门槛较低。 可
Mysql及SQLyog建表说明.docx
07-15
数据库

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值