{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-05-29T08:46:35.442427Z","iopub.execute_input":"2023-05-29T08:46:35.443072Z","iopub.status.idle":"2023-05-29T08:46:35.456854Z","shell.execute_reply.started":"2023-05-29T08:46:35.443038Z","shell.execute_reply":"2023-05-29T08:46:35.455859Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!pip install -q transformers --quiet","metadata":{"execution":{"iopub.status.busy":"2023-05-25T13:20:24.271507Z","iopub.execute_input":"2023-05-25T13:20:24.271865Z","iopub.status.idle":"2023-05-25T13:20:35.569732Z","shell.execute_reply.started":"2023-05-25T13:20:24.271839Z","shell.execute_reply":"2023-05-25T13:20:35.568471Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport struct\nimport matplotlib.pyplot as plt\nimport torch\nimport torch.nn as nn \nimport numpy as np\nfrom torch.utils.data import DataLoader, Dataset\nimport pandas as pd \nfrom tqdm import tqdm \nfrom transformers import BertModel ,BertTokenizer,AdamW, get_linear_schedule_with_warmup, set_seed\nfrom pylab import rcParams\nimport seaborn as sns\nfrom sklearn.model_selection import KFold, StratifiedKFold\nfrom sklearn.model_selection import train_test_split\nimport random \nimport numpy as np\nimport re\nimport warnings\nfrom nltk.corpus import stopwords\nwarnings.filterwarnings('ignore')\n\nclass Params_init:\n    all_you_need_is_seed=42\n    lr = 2e-5\n    eps =1e-6\n    maxlen = 110\n    test_size = 0.2\n    train_batchsize = 64\n    val_batchsize = 64\n    test_batchsize=64\n    kfold_sp=4\n    TOKENIZER = BertTokenizer.from_pretrained('bert-base-cased')\n    train_data='/kaggle/input/goodreads-books-reviews-290312/goodreads_train.csv'\n    test_data='/kaggle/input/goodreads-books-reviews-290312/goodreads_test.csv'\n    subFile='/kaggle/input/goodreads-books-reviews-290312/goodreads_sample_submission.csv'\n    \ndef load():\n    train_data = pd.read_csv(Params_init.train_data)\n    test_data=pd.read_csv(Params_init.test_data)\n    subFile=pd.read_csv(Params_init.subFile)\n    \n    print(train_data.info())\n    print(test_data.info())\n    train_data = train_data.drop(['user_id','book_id','date_added','date_updated','read_at', \\\n              'started_at','n_votes','n_comments'], axis =1)\n    train_data = train_data[['review_id','review_text','rating']]\n    train_data1=train_data.sample(frac=0.01)\n    train_data,final_test_data=train_test_split(train_data1, test_size=Params_init.test_size, random_state=42)\n    \n    final_test_data_y=final_test_data[['rating']]\n    final_test_data=final_test_data[['review_text']]\n    final_test_data_y=final_test_data_y.reset_index(drop=True)\n    \n    \n    test_data = test_data.drop(['user_id','book_id','date_added','date_updated','read_at', \\\n              'started_at','n_votes','n_comments'], axis =1)\n    #test_data = test_data[['review_id','review_text']]\n    test_data = test_data[['review_text']]\n    test_data=test_data.sample(frac=0.01)\n    \n    return train_data,test_data,subFile,train_data1,final_test_data,final_test_data_y\n\ndef counting_word(df):#常用词\n    #前三十个常用词\n    fre_words = pd.Series(' '.join(df).split()).value_counts()[:30]\n    fre_words.plot.bar(figsize=(15,4))\n    #print(fre_words.shape)\n    plt.title('30 words')\n    plt.show()\ndef cleaning(df):    \n    #停用词表\n    stopwords_english = set(stopwords.words('english'))\n    #自定义一些停用词表\n    my_stopwords = set([\"'s\", \"n't\", \"'m\", \"'re\", \"'ve\"])\n    stopwords_english.update(my_stopwords)\n    \n    df = df.lower()\n\n    #去除剧透\n    df=re.sub(r'(\\(view spoiler\\).*?\\(hide spoiler\\))','',df)\n    \n    #去除@和#和链接\n    tag = re.compile('@(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+')\n    df=tag.sub('',df)\n    \n    http = re.compile(r'http\\S+')\n    df=http.sub(r'',df)\n    \n    #去掉数字\n    df = re.sub(r'\\d+', '', df)\n\n    #去掉标点\n    df = re.sub(r'[^\\w\\s]', '', df)\n\n    #分词\n    tokens = df.split()\n\n    #筛选停用词\n    clean_tokens = [tok for tok in tokens if tok not in stopwords_english and len(tok) > 1]\n\n    #重新组成句子\n    clean_text = ' '.join(clean_tokens)\n\n    return clean_text\n\ndef len_count(df):\n    \n    len_list=[]\n    for rw in df.review_text:\n        token = Params_init.TOKENIZER.encode(rw, max_length=512)\n        len_list.append(len(token)) \n    plt.hist(len_list)\n\n    # 添加标题和轴标签\n    plt.title('length of after-cleaning review')\n    # 显示图片\n    plt.show()\n    \n\ndef train_data_count(df):\n    pd.set_option('display.float_format', '{:.2f}%'.format)\n    counts = df['rating'].value_counts(normalize = True).sort_index(ascending=True)\n    print(counts)\n    counts.plot(kind='bar')\n    # 添加x轴和y轴标签\n    plt.xlabel(\"rating\")\n    plt.ylabel(\"count\")\n    # 显示图形\n    plt.show()\n\n\n#将dataframe转化为tensor\nclass goodreads_trainval_Dataset(Dataset):\n    def __init__(self, review_text, targets):\n        self.review_text = review_text\n        self.targets = targets\n        self.tokenizer = Params_init.TOKENIZER\n        self.max_len = Params_init.maxlen\n    def __len__(self):\n        return len(self.review_text)\n    \n    def __getitem__(self, idx):\n        review_text = str(self.review_text[idx])\n        review_text = ' '.join(review_text.split())\n        global inputs\n       \n        inputs = self.tokenizer(\n                            review_text,\n                            add_special_tokens=True,#加入特殊标记CLS ESP和表示掩码和填充的标记\n                            max_length=self.max_len,\n                            padding=\"max_length\",\n                            truncation = True ,\n                            pad_to_max_length=True,#自动填充\n                            )\n        \n        ids = torch.tensor(inputs['input_ids'], dtype=torch.long)\n        mask = torch.tensor(inputs['attention_mask'], dtype=torch.long)\n        token_type = torch.tensor(inputs['token_type_ids'], dtype=torch.long)\n        targets = torch.tensor(self.targets[idx], dtype=torch.long)\n        return {\n            'ids': ids,\n            'mask': mask,\n            'token_type':token_type,\n            'targets': targets\n        }\n\ndef goodreads_train_Dataloader(df, batch_size):\n    dataset = goodreads_trainval_Dataset(df[\"review_text\"].values, df[\"rating\"].values)\n    dataloader = DataLoader(dataset , batch_size , shuffle=False)\n    return dataloader\n\nclass goodreads_test_Dataset(Dataset):\n    def __init__(self, review_text):\n        self.review_text = review_text\n        self.tokenizer = Params_init.TOKENIZER\n        self.max_len = Params_init.maxlen\n    \n    def __len__(self):\n        return len(self.review_text)\n    \n    def __getitem__(self, idx):\n        review_text = str(self.review_text[idx])\n        review_text = ' '.join(review_text.split())\n        global inputs\n       \n        inputs = self.tokenizer(\n                            review_text,\n                            add_special_tokens=True,\n                            max_length=self.max_len,\n                            padding=\"max_length\" ,\n                            truncation = True ,\n                            pad_to_max_length=True, \n                            )\n        \n        ids = torch.tensor(inputs['input_ids'], dtype=torch.long)\n        mask = torch.tensor(inputs['attention_mask'], dtype=torch.long)\n        token_type = torch.tensor(inputs['token_type_ids'], dtype=torch.long)\n        return{\n        'ids': ids,\n        'mask': mask,\n        'token_type':token_type\n        }\n\ndef goodreads_test_Dataloader(df, batch_size):\n    dataset = goodreads_test_Dataset(df[\"review_text\"].values)\n    dataloader = DataLoader(dataset , batch_size , shuffle=False)\n    return dataloader\n\nclass bert(nn.Module):\n    def __init__(self , n_classes):\n        super(bert,self).__init__()\n        self.bert = BertModel.from_pretrained('bert-base-cased' , return_dict=False)\n        \n        #return_dict=False,只返回了 BERT 模型最后一层的所有隐状态，可以使用较少的内存和计算资源来处理大型文本数据集，使得整个模型运行更加高效\n        self.drop=  nn.Dropout(p=0.5)#创建一个dropout防止过拟合\n        self.out = nn.Linear(768,n_classes)#全连接层，进行分类\n\n    def forward(self , input_ids, attention_mask ,token_type_ids):\n        \n        #前向传播，得到bert输出的池化向量pooledout，然后对pooledout进行dropout，再传过去进行全连接从而分类\n        _,pooledout = self.bert(input_ids,attention_mask,token_type_ids)\n        \n        output = self.drop(pooledout)\n        output = self.out(output)\n        \n        return output\n\ndef loss_fn(outputs, labels):\n    return nn.CrossEntropyLoss()(outputs, labels)#交叉熵\n\ndef yield_optimizer(model):\n    \"\"\"\n    Returns optimizer for specific parameters\n    \"\"\"\n    param_optimizer = list(model.named_parameters())\n    no_decay = [\"bias\", \"LayerNorm.bias\", \"LayerNorm.weight\"]#对偏差和LayerNorm 层中的偏置和权重矩阵不需要梯度下降。\n\n    optimizer_parameters = [\n        {\n            \"params\": [\n                p for n, p in param_optimizer if not any(nd in n for nd in no_decay)\n            ],\n            \"weight_decay\": 0.001,\n        },\n        {\n            \"params\": [\n                p for n, p in param_optimizer if any(nd in n for nd in no_decay)\n            ],\n            \"weight_decay\": 0.0,\n        },\n    ]\n    return AdamW(optimizer_parameters, lr=Params_init.lr, eps=Params_init.eps)\n\ndef train_model(model , data_loader , loss_fn , optimizer , device , scheduler , n_examples):\n    model.train()\n    losses = []\n    correct_predictions = 0\n    for step , Token in tqdm(enumerate(data_loader) , total=len(data_loader)):\n        input_ids =Token['ids'].to(device) \n        token_type_ids = Token['token_type'].to(device)\n        attention_mask = Token['mask'].to(device)\n        targets = Token['targets'].to(device)\n\n        outputs = model(\n             input_ids ,\n            attention_mask ,\n            token_type_ids)\n        \n        _, pred =  torch.max(outputs , dim=1)\n\n        loss = loss_fn(outputs , targets)\n        correct_predictions +=torch.sum(pred ==targets)\n        losses.append(loss.item())\n\n\n        loss.backward()\n        optimizer.step()\n        scheduler.step()\n        optimizer.zero_grad()\n    acc=correct_predictions.double() / n_examples\n    loss=np.mean(losses)\n    return acc, loss\n\n\ndef eval_model(model , data_loader , loss_fn , device , n_examples):\n    model.eval()\n  \n    losses = []\n    correct_predictions = 0\n\n    with torch.no_grad() :\n        \n        for step , Token in tqdm(enumerate(data_loader) , total=len(data_loader)):\n            \n            input_ids =Token['ids'].to(device)\n            token_type_ids = Token['token_type'].to(device)\n            attention_mask = Token['mask'].to(device)\n            targets = Token['targets'].to(device)\n        \n            outputs = model(\n                   input_ids ,\n                attention_mask ,\n                token_type_ids  )\n\n            _, pred =  torch.max(outputs , dim=1)\n            loss = loss_fn(outputs , targets)\n            correct_predictions +=torch.sum(pred ==targets)\n            losses.append(loss.item())\n    acc=correct_predictions.double() / n_examples \n    loss=np.mean(losses)\n    return acc,loss\n\n\ndef Train(model , df_train , epochs):\n    train_acc_list=[]\n    val_acc_list=[]\n    train_loss_list=[]\n    val_loss_list=[]\n    \n    \n    every_train_acclist=[]\n    every_train_losslist=[]\n    every_val_acclist=[]\n    every_val_losslist=[]\n    \n    for epoch in range(epochs):\n        print('Epoch:{}'.format(epoch + 1))\n        train_acc = []\n        val_acc = []\n        train_loss = []\n        val_loss = []\n        kf = StratifiedKFold(n_splits=Params_init.kfold_sp,random_state=42, shuffle=True)\n        for step,(train, val) in enumerate(kf.split(df_train , df_train[\"rating\"])) :\n          \n            train_data_loader= goodreads_train_Dataloader(df_train.iloc[train],Params_init.train_batchsize)\n            val_data_loader = goodreads_train_Dataloader(df_train.iloc[val],Params_init.val_batchsize)\n            nb_train_steps = int(len(train_data_loader) /Params_init.train_batchsize * epochs)\n            optimizer = yield_optimizer(model)\n            scheduler = get_linear_schedule_with_warmup(\n                                        optimizer,\n                                        num_warmup_steps=0,\n                                        num_training_steps=nb_train_steps)    \n            \n            current_train_acc,current_train_loss = train_model(model,train_data_loader,loss_fn,optimizer,device,scheduler,len(df_train.iloc[train])) \n            train_acc.append(current_train_acc.item())\n            train_loss.append(current_train_loss)\n            every_train_acclist.append(current_train_acc.item())\n            every_train_losslist.append(current_train_loss)\n            \n            \n            current_val_acc,current_val_loss = eval_model(model,val_data_loader,loss_fn,device,len(df_train.iloc[val]))\n            val_acc.append(current_val_acc)\n            val_loss.append(current_val_loss)\n            every_val_acclist.append(current_val_acc.item())\n            every_val_losslist.append(current_val_loss)\n            \n\n            torch.save(model.state_dict(),'epoch{}model{}.bin'.format(epoch,step))\n        \n        train_acc_list.append(sum(train_acc)/len(train_acc))\n        val_acc_list.append((sum(val_acc)/len(val_acc)).item())\n        train_loss_list.append(sum(train_loss)/len(train_loss))\n        val_loss_list.append(sum(val_loss)/len(val_loss))\n        print(\"train acc={},val acc={},train loss={},val_loss={}\".format(train_acc_list[-1],val_acc_list[-1],train_loss_list[-1],val_loss_list[-1]))\n    \n    return train_acc_list,val_acc_list,train_loss_list,val_loss_list,every_train_acclist,every_val_acclist,every_train_losslist,every_val_losslist\n\n\ndef get_predictions(Y,model, df_test):\n    \n    model = model.eval()\n    data_loader = goodreads_test_Dataloader(df_test, 1)\n   \n    with torch.no_grad():\n        for d in data_loader:\n            \n            input_ids = d[\"ids\"].to(device)\n            attention_mask = d[\"mask\"].to(device)\n            token_type_ids = d[\"token_type\"].to(device)\n            \n            outputs = model(\n                            input_ids,\n                            attention_mask ,\n                            token_type_ids\n                              )\n            Y.append(outputs)\n            _, preds = torch.max(outputs, dim=1)\n        \ndef es_get_pre(Y,model, df_test):\n    get_predictions(Y,model,df_test)\n    tab=[]\n    for i in Y:\n        tab.append(i.flatten().tolist())\n    predict_pd = pd.DataFrame(data=tab , columns=[0,1,2,3,4,5])\n    get_prediction = predict_pd.idxmax(axis=1)\n    return get_prediction\n\ndef vote(a,b,c,d):\n    concatenated_series = pd.concat([a,b,c,d],axis=1)\n    # 将数组转换为DataFrame对象\n    res = pd.DataFrame(concatenated_series)\n\n    # 对每行执行 mode 操作，得到每行出现次数最多的值及其对应的次数\n    row_mode = res.mode(axis=1)\n    \n    # 取出每行出现最多的值\n    row_max = row_mode.iloc[:, 0]\n    \n    # 将结果转化为长度为 48 的 Series\n    result = pd.Series(row_max)\n    \n    return result\n\ndef cal_test_acc(x,y):\n    x1=x.values\n    y1=y.values\n    cal_res=(x1==y1)\n    \n    alll=len(x1)\n    \n    sum_cor=cal_res.sum()\n    \n    test_acc=sum_cor/alll\n    \n    return test_acc ","metadata":{"execution":{"iopub.status.busy":"2023-05-30T15:08:50.360270Z","iopub.execute_input":"2023-05-30T15:08:50.368862Z","iopub.status.idle":"2023-05-30T15:09:10.954740Z","shell.execute_reply.started":"2023-05-30T15:08:50.368720Z","shell.execute_reply":"2023-05-30T15:09:10.950914Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"if __name__=='__main__':\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    print(device)\n    \n    random.seed(Params_init.all_you_need_is_seed) \n    np.random.seed(Params_init.all_you_need_is_seed) \n    torch.manual_seed(Params_init.all_you_need_is_seed)\n    if torch.cuda.is_available(): \n        torch.cuda.manual_seed(Params_init.all_you_need_is_seed)\n        torch.cuda.manual_seed_all(Params_init.all_you_need_is_seed)\n        torch.backends.cudnn.deterministic = True \n        torch.backends.cudnn.benchmark = False\n    train_data,test_data,subFile,train_data1,final_test_data,final_test_data_y=load()\n    \n    train_data1[\"clean_text\"] = train_data1[\"review_text\"].apply(cleaning)\n    test_data[\"clean_text\"] = test_data[\"review_text\"].apply(cleaning)\n    train_data1[\"review_text\"]=train_data1[\"clean_text\"]\n    test_data[\"review_text\"]=test_data[\"clean_text\"]\n    train_data1 = train_data1.drop([\"clean_text\"], axis =1)\n    test_data = test_data.drop([\"clean_text\"], axis =1)\n    \n    '''len_count(train_data)\n    counting_word(train_data)'''\n    \n    '''\n    #counting_word(train_data1.review_text)#这两个分开运行，忘记plt弄不同画幅了'''\n    \n    \n    \n    \n    Traindataloader = goodreads_train_Dataloader(train_data1, 1)\n    Testdataloader = goodreads_test_Dataloader(test_data, 1)\n    \n    \n    model = bert(6)\n    model.to(device)\n    train_acc_list,val_acc_list,train_loss_list,val_loss_list,every_train_acclist,every_val_acclist,every_train_losslist,every_val_losslist=Train(model, train_data1, 8)\n    plt.figure(figsize=(8, 6))\n    plt.plot(train_acc_list, label='Train Accuracy')\n    plt.plot(val_acc_list, label='Val Accuracy')\n    plt.xlabel('Epoch')\n    plt.ylabel('Accuracy')\n    plt.legend()\n    plt.title('epoch meaning Accuracy Comparison between Train and Val sets')\n    plt.show()\n    \n    # 绘制训练集、验证集loss折线图\n    plt.figure(figsize=(8, 6))\n    plt.plot(train_loss_list, label='Train Loss')\n    plt.plot(val_loss_list, label='Val Loss')\n    plt.xlabel('Epoch')\n    plt.ylabel('Loss')\n    plt.legend()\n    plt.title('epoch meaning Loss Comparison between Train and Val sets')\n    plt.show()\n    \n    \n    plt.figure(figsize=(8, 6))\n    plt.plot(every_train_acclist, label='Train acc')\n    plt.plot(every_val_acclist, label='Val acc')\n    plt.xlabel('Epoch')\n    plt.ylabel('acc')\n    plt.legend()\n    plt.title('lonely model Comparison between Train and Val sets')\n    plt.show()\n    \n    \n    \n    plt.figure(figsize=(8, 6))\n    plt.plot(every_train_losslist, label='Train Loss')\n    plt.plot(every_val_losslist, label='Val Loss')\n    plt.xlabel('Epoch')\n    plt.ylabel('Loss')\n    plt.legend()\n    plt.title('lonely model Comparison between Train and Val sets')\n    plt.show()\n    \n    \n    \n    \n    best_model_idx=np.argmax(val_acc_list)\n    \n    model_list=[]\n    \n    for i in range(Params_init.kfold_sp):\n        model_list.append('epoch' + str(best_model_idx) + 'model' + str(i)+'.bin')\n    \n    Y0=[]\n    Y1=[]\n    Y2=[]\n    Y3=[]\n\n    model_idx0=model_list[0]\n    model_idx1=model_list[1]\n    model_idx2=model_list[2]\n    model_idx3=model_list[3]\n    \n    '''model.load_state_dict(torch.load(model_idx0))\n    get_prediction0=es_get_pre(Y0,model,test_data)\n    print(\"model0 finished\")\n    \n    \n    model.load_state_dict(torch.load(model_idx1))\n    get_prediction1=es_get_pre(Y1,model,test_data)\n    print(\"model1 finished\")\n    \n    model.load_state_dict(torch.load(model_idx2))\n    get_prediction2=es_get_pre(Y2,model,test_data)\n    print(\"model2 finished\")\n    \n    model.load_state_dict(torch.load(model_idx3))\n    get_prediction3=es_get_pre(Y3,model,test_data)\n    print(\"model3 finished\")\n    \n    \n    result =vote(get_prediction0, get_prediction1, get_prediction2, get_prediction3)'''\n    \n    \n    model.load_state_dict(torch.load(model_idx0))\n    get_prediction0=es_get_pre(Y0,model,final_test_data)\n    print(\"model0 finished\")\n    \n    \n    model.load_state_dict(torch.load(model_idx1))\n    get_prediction1=es_get_pre(Y1,model,final_test_data)\n    print(\"model1 finished\")\n    \n    model.load_state_dict(torch.load(model_idx2))\n    get_prediction2=es_get_pre(Y2,model,final_test_data)\n    print(\"model2 finished\")\n    \n    model.load_state_dict(torch.load(model_idx3))\n    get_prediction3=es_get_pre(Y3,model,final_test_data)\n    print(\"model3 finished\")\n    \n    \n    result =vote(get_prediction0, get_prediction1, get_prediction2, get_prediction3)\n    result.columns = ['rating']\n    \n    test_acc=cal_test_acc(final_test_data_y, result)\n    a=len(final_test_data_y)\n    b=test_acc/a\n    print(\"测试集准确率{}\".format(test_acc))\n    print(\"测试集准确率{}\".format(b))\n","metadata":{"execution":{"iopub.status.busy":"2023-05-30T15:09:33.119229Z","iopub.execute_input":"2023-05-30T15:09:33.119928Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"'''if __name__=='__main__':\n    device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n    print(device)\n    seed_all(42)\n    train_data,test_data,subFile,train_data1,test_data1=load()\n    #加载\n    \n    \n    #统计训练集\n    #train_data_count(train_data)\n    \n    \n    train_data[\"clean_text\"] = train_data[\"review_text\"].apply(cleaning)\n    test_data[\"clean_text\"] = test_data[\"review_text\"].apply(cleaning)\n    train_data[\"review_text\"]=train_data[\"clean_text\"]\n    test_data[\"review_text\"]=test_data[\"clean_text\"]\n    train_data = train_data.drop([\"clean_text\"], axis =1)\n    test_data = test_data.drop([\"clean_text\"], axis =1)\n    len_count(train_data)\n    '''","metadata":{"execution":{"iopub.status.busy":"2023-05-25T14:36:43.054756Z","iopub.execute_input":"2023-05-25T14:36:43.055266Z","iopub.status.idle":"2023-05-25T15:44:32.261074Z","shell.execute_reply.started":"2023-05-25T14:36:43.055230Z","shell.execute_reply":"2023-05-25T15:44:32.259708Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"'''counting_word(train_data.review_text)'''","metadata":{"execution":{"iopub.status.busy":"2023-05-25T16:11:30.112157Z","iopub.execute_input":"2023-05-25T16:11:30.112630Z","iopub.status.idle":"2023-05-25T16:12:29.373550Z","shell.execute_reply.started":"2023-05-25T16:11:30.112596Z","shell.execute_reply":"2023-05-25T16:12:29.372021Z"},"trusted":true},"execution_count":null,"outputs":[]}]}