JavaScript Dev

JavaScript Dev

1612467180

Extract Text From Documents (PDF, DOC, XLS, PPT, Etc)

docsToText

A JavaScript library that extract text from documents without server upload in browser

You can extract text from doc, docx, xls, xlsx, ppt, pptx, pdf, hwp files. Take a look at the following example. It can be extracted very simply.

Parse on remote url download

example

const docToText = new DocToText();
const url = 'https://docs-extractor.com/sample/sample.docx';

// single file extract to text
docToText.extractToText(url, 'docx')
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Parse on local upload file

const file = files[0];
const {name} = file;
const ext = name.toLowerCase().substring(name.lastIndexOf('.') + 1);

const docToText = new DocToText();

// single file extract to text
docToText.extractToText(file, ext)
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Parse on remote zip url download

const docToText = new DocToText();
const url = 'https://docs-extractor.com/sample/sample.zip';

// single zip file extract to text
docToText.extractZipToText(url)
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Parse on local upload zip file

const docToText = new DocToText();
const url = 'https://docs-extractor.com/sample/sample.zip';

const file = files[0];
const docToText = new DocToText();

// single zip file extract to text
docToText.extractZipToText(file)
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Support Browser

Internet Explorer 11+ / Edge / Chrome / Safari / Firefox

Download Details:

Author: bshopcho

Demo: https://www.docs-extractor.com/

Source Code: https://github.com/bshopcho/docsToText

#javascript

What is GEEK

Buddha Community

Extract Text From Documents (PDF, DOC, XLS, PPT, Etc)
Cayla  Erdman

Cayla Erdman

1594369800

Introduction to Structured Query Language SQL pdf

SQL stands for Structured Query Language. SQL is a scripting language expected to store, control, and inquiry information put away in social databases. The main manifestation of SQL showed up in 1974, when a gathering in IBM built up the principal model of a social database. The primary business social database was discharged by Relational Software later turning out to be Oracle.

Models for SQL exist. In any case, the SQL that can be utilized on every last one of the major RDBMS today is in various flavors. This is because of two reasons:

1. The SQL order standard is genuinely intricate, and it isn’t handy to actualize the whole standard.

2. Every database seller needs an approach to separate its item from others.

Right now, contrasts are noted where fitting.

#programming books #beginning sql pdf #commands sql #download free sql full book pdf #introduction to sql pdf #introduction to sql ppt #introduction to sql #practical sql pdf #sql commands pdf with examples free download #sql commands #sql free bool download #sql guide #sql language #sql pdf #sql ppt #sql programming language #sql tutorial for beginners #sql tutorial pdf #sql #structured query language pdf #structured query language ppt #structured query language

Navigating Between DOM Nodes in JavaScript

In the previous chapters you've learnt how to select individual elements on a web page. But there are many occasions where you need to access a child, parent or ancestor element. See the JavaScript DOM nodes chapter to understand the logical relationships between the nodes in a DOM tree.

DOM node provides several properties and methods that allow you to navigate or traverse through the tree structure of the DOM and make changes very easily. In the following section we will learn how to navigate up, down, and sideways in the DOM tree using JavaScript.

Accessing the Child Nodes

You can use the firstChild and lastChild properties of the DOM node to access the first and last direct child node of a node, respectively. If the node doesn't have any child element, it returns null.

Example

<div id="main">
    <h1 id="title">My Heading</h1>
    <p id="hint"><span>This is some text.</span></p>
</div>

<script>
var main = document.getElementById("main");
console.log(main.firstChild.nodeName); // Prints: #text

var hint = document.getElementById("hint");
console.log(hint.firstChild.nodeName); // Prints: SPAN
</script>

Note: The nodeName is a read-only property that returns the name of the current node as a string. For example, it returns the tag name for element node, #text for text node, #comment for comment node, #document for document node, and so on.

If you notice the above example, the nodeName of the first-child node of the main DIV element returns #text instead of H1. Because, whitespace such as spaces, tabs, newlines, etc. are valid characters and they form #text nodes and become a part of the DOM tree. Therefore, since the <div> tag contains a newline before the <h1> tag, so it will create a #text node.

To avoid the issue with firstChild and lastChild returning #text or #comment nodes, you could alternatively use the firstElementChild and lastElementChild properties to return only the first and last element node, respectively. But, it will not work in IE 9 and earlier.

Example

<div id="main">
    <h1 id="title">My Heading</h1>
    <p id="hint"><span>This is some text.</span></p>
</div>

<script>
var main = document.getElementById("main");
alert(main.firstElementChild.nodeName); // Outputs: H1
main.firstElementChild.style.color = "red";

var hint = document.getElementById("hint");
alert(hint.firstElementChild.nodeName); // Outputs: SPAN
hint.firstElementChild.style.color = "blue";
</script>

Similarly, you can use the childNodes property to access all child nodes of a given element, where the first child node is assigned index 0. Here's an example:

Example

<div id="main">
    <h1 id="title">My Heading</h1>
    <p id="hint"><span>This is some text.</span></p>
</div>

<script>
var main = document.getElementById("main");

// First check that the element has child nodes 
if(main.hasChildNodes()) {
    var nodes = main.childNodes;
    
    // Loop through node list and display node name
    for(var i = 0; i < nodes.length; i++) {
        alert(nodes[i].nodeName);
    }
}
</script>

The childNodes returns all child nodes, including non-element nodes like text and comment nodes. To get a collection of only elements, use children property instead.

Example

<div id="main">
    <h1 id="title">My Heading</h1>
    <p id="hint"><span>This is some text.</span></p>
</div>

<script>
var main = document.getElementById("main");

// First check that the element has child nodes 
if(main.hasChildNodes()) {
    var nodes = main.children;
    
    // Loop through node list and display node name
    for(var i = 0; i < nodes.length; i++) {
        alert(nodes[i].nodeName);
    }
}
</script>

#javascript 

Sarah Adina

1603334847

How to Extract Text From PDF Files in All Formats.

Do you need to extract text from different files such as pdfs and Word files?

This quick tutorial shows how sort files by type, and then extract text from PDF files. I downloaded two fake resumes in pdf format from Overleaf to demonstrate how this code works. I am not going to cover how to extract text from Word documents. You can download docxpy Python package and use it to extract text from Word files. Feel free to contact me at anna@sakura-ai.com if you have any questions or need help parsing documents.

The main challenge in extracting text from PDF files is that they have different formats:

  • PDF files are either 8-bit binary files or 7-bit ASCII text files (using ASCII-85 encoding).

  • Every line in a PDF can contain up to 255 characters.

  • Every line ends with a carriage return, a line feed, or a carriage return followed by a line feed (depending upon the application or platform used to create the PDF file).

  • PDF is case sensitive.

  • The file format is completely independent of the platform that it is viewed or created on. Files can be moved back and forth between Macs, Windows system, Linux systems,… When FTP-ing a PDF file, it does make sense to compress it, to avoid data corruption by some outdated web system that the file needs to go through.

  • Scanned PDFs are stored as images

#text-extraction #python3 #pdf-text-extractor #pdf

JavaScript Dev

JavaScript Dev

1612467180

Extract Text From Documents (PDF, DOC, XLS, PPT, Etc)

docsToText

A JavaScript library that extract text from documents without server upload in browser

You can extract text from doc, docx, xls, xlsx, ppt, pptx, pdf, hwp files. Take a look at the following example. It can be extracted very simply.

Parse on remote url download

example

const docToText = new DocToText();
const url = 'https://docs-extractor.com/sample/sample.docx';

// single file extract to text
docToText.extractToText(url, 'docx')
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Parse on local upload file

const file = files[0];
const {name} = file;
const ext = name.toLowerCase().substring(name.lastIndexOf('.') + 1);

const docToText = new DocToText();

// single file extract to text
docToText.extractToText(file, ext)
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Parse on remote zip url download

const docToText = new DocToText();
const url = 'https://docs-extractor.com/sample/sample.zip';

// single zip file extract to text
docToText.extractZipToText(url)
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Parse on local upload zip file

const docToText = new DocToText();
const url = 'https://docs-extractor.com/sample/sample.zip';

const file = files[0];
const docToText = new DocToText();

// single zip file extract to text
docToText.extractZipToText(file)
    .then(function (text) {
        // text
    }).catch(function (error) {
        // error
    });

Support Browser

Internet Explorer 11+ / Edge / Chrome / Safari / Firefox

Download Details:

Author: bshopcho

Demo: https://www.docs-extractor.com/

Source Code: https://github.com/bshopcho/docsToText

#javascript

Comment créer un détecteur de fausses nouvelles en Python

Détection de fausses nouvelles en Python

Explorer l'ensemble de données de fausses nouvelles, effectuer une analyse de données telles que des nuages ​​​​de mots et des ngrams, et affiner le transformateur BERT pour créer un détecteur de fausses nouvelles en Python à l'aide de la bibliothèque de transformateurs.

Les fausses nouvelles sont la diffusion intentionnelle d'allégations fausses ou trompeuses en tant que nouvelles, où les déclarations sont délibérément mensongères.

Les journaux, les tabloïds et les magazines ont été supplantés par les plateformes d'actualités numériques, les blogs, les flux de médias sociaux et une pléthore d'applications d'actualités mobiles. Les organes de presse ont profité de l'utilisation accrue des médias sociaux et des plates-formes mobiles en fournissant aux abonnés des informations de dernière minute.

Les consommateurs ont désormais un accès instantané aux dernières nouvelles. Ces plateformes de médias numériques ont gagné en importance en raison de leur connectivité facile au reste du monde et permettent aux utilisateurs de discuter et de partager des idées et de débattre de sujets tels que la démocratie, l'éducation, la santé, la recherche et l'histoire. Les fausses informations sur les plateformes numériques deviennent de plus en plus populaires et sont utilisées à des fins lucratives, telles que des gains politiques et financiers.

Quelle est la taille de ce problème ?

Parce qu'Internet, les médias sociaux et les plateformes numériques sont largement utilisés, n'importe qui peut propager des informations inexactes et biaisées. Il est presque impossible d'empêcher la diffusion de fausses nouvelles. Il y a une énorme augmentation de la diffusion de fausses nouvelles, qui ne se limite pas à un secteur comme la politique, mais comprend le sport, la santé, l'histoire, le divertissement, la science et la recherche.

La solution

Il est essentiel de reconnaître et de différencier les informations fausses des informations exactes. Une méthode consiste à demander à un expert de décider et de vérifier chaque élément d'information, mais cela prend du temps et nécessite une expertise qui ne peut être partagée. Deuxièmement, nous pouvons utiliser des outils d'apprentissage automatique et d'intelligence artificielle pour automatiser l'identification des fausses nouvelles.

Les informations d'actualité en ligne incluent diverses données de format non structuré (telles que des documents, des vidéos et de l'audio), mais nous nous concentrerons ici sur les informations au format texte. Avec les progrès de l'apprentissage automatique et du traitement automatique du langage naturel , nous pouvons désormais reconnaître le caractère trompeur et faux d'un article ou d'une déclaration.

Plusieurs études et expérimentations sont menées pour détecter les fake news sur tous les supports.

Notre objectif principal de ce tutoriel est :

  • Explorez et analysez l'ensemble de données Fake News.
  • Construisez un classificateur capable de distinguer les fausses nouvelles avec autant de précision que possible.

Voici la table des matières :

  • introduction
  • Quelle est la taille de ce problème ?
  • La solution
  • Exploration des données
    • Répartition des cours
  • Nettoyage des données pour l'analyse
  • Analyse exploratoire des données
    • Nuage à un seul mot
    • Bigramme le plus fréquent (combinaison de deux mots)
    • Trigramme le plus fréquent (combinaison de trois mots)
  • Construire un classificateur en affinant le BERT
    • Préparation des données
    • Tokénisation de l'ensemble de données
    • Chargement et réglage fin du modèle
    • Évaluation du modèle
  • Annexe : Création d'un fichier de soumission pour Kaggle
  • Conclusion

Exploration des données

Dans ce travail, nous avons utilisé l'ensemble de données sur les fausses nouvelles de Kaggle pour classer les articles d'actualité non fiables comme fausses nouvelles. Nous disposons d'un jeu de données d'entraînement complet contenant les caractéristiques suivantes :

  • id: identifiant unique pour un article de presse
  • title: titre d'un article de presse
  • author: auteur de l'article de presse
  • text: texte de l'article ; pourrait être incomplet
  • label: une étiquette qui marque l'article comme potentiellement non fiable, notée 1 (non fiable ou faux) ou 0 (fiable).

Il s'agit d'un problème de classification binaire dans lequel nous devons prédire si une nouvelle particulière est fiable ou non.

Si vous avez un compte Kaggle, vous pouvez simplement télécharger l'ensemble de données à partir du site Web et extraire le fichier ZIP.

J'ai également téléchargé l'ensemble de données dans Google Drive, et vous pouvez l'obtenir ici , ou utiliser la gdownbibliothèque pour le télécharger automatiquement dans les blocs-notes Google Colab ou Jupyter :

$ pip install gdown
# download from Google Drive
$ gdown "https://drive.google.com/uc?id=178f_VkNxccNidap-5-uffXUW475pAuPy&confirm=t"
Downloading...
From: https://drive.google.com/uc?id=178f_VkNxccNidap-5-uffXUW475pAuPy&confirm=t
To: /content/fake-news.zip
100% 48.7M/48.7M [00:00<00:00, 74.6MB/s]

Décompressez les fichiers :

$ unzip fake-news.zip

Trois fichiers apparaîtront dans le répertoire de travail actuel : train.csv, test.csv, et submit.csv, que nous utiliserons train.csvdans la majeure partie du didacticiel.

Installation des dépendances requises :

$ pip install transformers nltk pandas numpy matplotlib seaborn wordcloud

Remarque : Si vous êtes dans un environnement local, assurez-vous d'installer PyTorch pour GPU, rendez-vous sur cette page pour une installation correcte.

Importons les bibliothèques essentielles pour l'analyse :

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

Les corpus et modules NLTK doivent être installés à l'aide du téléchargeur NLTK standard :

import nltk
nltk.download('stopwords')
nltk.download('wordnet')

L'ensemble de données sur les fausses nouvelles comprend les titres et le texte d'articles originaux et fictifs de divers auteurs. Importons notre jeu de données :

# load the dataset
news_d = pd.read_csv("train.csv")
print("Shape of News data:", news_d.shape)
print("News data columns", news_d.columns)

Sortir:

 Shape of News data: (20800, 5)
 News data columns Index(['id', 'title', 'author', 'text', 'label'], dtype='object')

Voici à quoi ressemble l'ensemble de données :

# by using df.head(), we can immediately familiarize ourselves with the dataset. 
news_d.head()

Sortir:

id	title	author	text	label
0	0	House Dem Aide: We Didn’t Even See Comey’s Let...	Darrell Lucus	House Dem Aide: We Didn’t Even See Comey’s Let...	1
1	1	FLYNN: Hillary Clinton, Big Woman on Campus - ...	Daniel J. Flynn	Ever get the feeling your life circles the rou...	0
2	2	Why the Truth Might Get You Fired	Consortiumnews.com	Why the Truth Might Get You Fired October 29, ...	1
3	3	15 Civilians Killed In Single US Airstrike Hav...	Jessica Purkiss	Videos 15 Civilians Killed In Single US Airstr...	1
4	4	Iranian woman jailed for fictional unpublished...	Howard Portnoy	Print \nAn Iranian woman has been sentenced to...	1

Nous avons 20 800 lignes, qui ont cinq colonnes. Voyons quelques statistiques de la textcolonne :

#Text Word startistics: min.mean, max and interquartile range

txt_length = news_d.text.str.split().str.len()
txt_length.describe()

Sortir:

count    20761.000000
mean       760.308126
std        869.525988
min          0.000000
25%        269.000000
50%        556.000000
75%       1052.000000
max      24234.000000
Name: text, dtype: float64

Statistiques pour la titlecolonne :

#Title statistics 

title_length = news_d.title.str.split().str.len()
title_length.describe()

Sortir:

count    20242.000000
mean        12.420709
std          4.098735
min          1.000000
25%         10.000000
50%         13.000000
75%         15.000000
max         72.000000
Name: title, dtype: float64

Les statistiques pour les ensembles d'entraînement et de test sont les suivantes :

  • L' textattribut a un nombre de mots plus élevé avec une moyenne de 760 mots et 75% ayant plus de 1000 mots.
  • L' titleattribut est une courte déclaration avec une moyenne de 12 mots, et 75% d'entre eux sont d'environ 15 mots.

Notre expérience porterait à la fois sur le texte et le titre.

Répartition des cours

Compter les parcelles pour les deux étiquettes :

sns.countplot(x="label", data=news_d);
print("1: Unreliable")
print("0: Reliable")
print("Distribution of labels:")
print(news_d.label.value_counts());

Sortir:

1: Unreliable
0: Reliable
Distribution of labels:
1    10413
0    10387
Name: label, dtype: int64

Distribution d'étiquettes

print(round(news_d.label.value_counts(normalize=True),2)*100);

Sortir:

1    50.0
0    50.0
Name: label, dtype: float64

Le nombre d'articles non fiables (faux ou 1) est de 10413, tandis que le nombre d'articles dignes de confiance (fiables ou 0) est de 10387. Près de 50% des articles sont faux. Par conséquent, la métrique de précision mesurera la performance de notre modèle lors de la construction d'un classificateur.

Nettoyage des données pour l'analyse

Dans cette section, nous allons nettoyer notre ensemble de données pour effectuer une analyse :

  • Supprimez les lignes et les colonnes inutilisées.
  • Effectuez une imputation de valeur nulle.
  • Supprimer les caractères spéciaux.
  • Supprimez les mots vides.
# Constants that are used to sanitize the datasets 

column_n = ['id', 'title', 'author', 'text', 'label']
remove_c = ['id','author']
categorical_features = []
target_col = ['label']
text_f = ['title', 'text']
# Clean Datasets
import nltk
from nltk.corpus import stopwords
import re
from nltk.stem.porter import PorterStemmer
from collections import Counter

ps = PorterStemmer()
wnl = nltk.stem.WordNetLemmatizer()

stop_words = stopwords.words('english')
stopwords_dict = Counter(stop_words)

# Removed unused clumns
def remove_unused_c(df,column_n=remove_c):
    df = df.drop(column_n,axis=1)
    return df

# Impute null values with None
def null_process(feature_df):
    for col in text_f:
        feature_df.loc[feature_df[col].isnull(), col] = "None"
    return feature_df

def clean_dataset(df):
    # remove unused column
    df = remove_unused_c(df)
    #impute null values
    df = null_process(df)
    return df

# Cleaning text from unused characters
def clean_text(text):
    text = str(text).replace(r'http[\w:/\.]+', ' ')  # removing urls
    text = str(text).replace(r'[^\.\w\s]', ' ')  # remove everything but characters and punctuation
    text = str(text).replace('[^a-zA-Z]', ' ')
    text = str(text).replace(r'\s\s+', ' ')
    text = text.lower().strip()
    #text = ' '.join(text)    
    return text

## Nltk Preprocessing include:
# Stop words, Stemming and Lemmetization
# For our project we use only Stop word removal
def nltk_preprocess(text):
    text = clean_text(text)
    wordlist = re.sub(r'[^\w\s]', '', text).split()
    #text = ' '.join([word for word in wordlist if word not in stopwords_dict])
    #text = [ps.stem(word) for word in wordlist if not word in stopwords_dict]
    text = ' '.join([wnl.lemmatize(word) for word in wordlist if word not in stopwords_dict])
    return  text

Dans le bloc de code ci-dessus :

  • Nous avons importé NLTK, qui est une plate-forme célèbre pour développer des applications Python qui interagissent avec le langage humain. Ensuite, nous importons repour regex.
  • Nous importons des mots vides à partir de nltk.corpus. Lorsque nous travaillons avec des mots, en particulier lorsque nous considérons la sémantique, nous devons parfois éliminer les mots courants qui n'ajoutent aucune signification significative à une déclaration, tels que "but", "can", "we", etc.
  • PorterStemmerest utilisé pour effectuer des mots radicaux avec NLTK. Les radicaux dépouillent les mots de leurs affixes morphologiques, laissant uniquement le radical du mot.
  • Nous importons WordNetLemmatizer()de la bibliothèque NLTK pour la lemmatisation. La lemmatisation est bien plus efficace que la radicalisation . Il va au-delà de la réduction des mots et évalue l'ensemble du lexique d'une langue pour appliquer une analyse morphologique aux mots, dans le but de supprimer simplement les extrémités flexionnelles et de renvoyer la forme de base ou de dictionnaire d'un mot, connue sous le nom de lemme.
  • stopwords.words('english')permettez-nous de regarder la liste de tous les mots vides en anglais pris en charge par NLTK.
  • remove_unused_c()La fonction est utilisée pour supprimer les colonnes inutilisées.
  • Nous imputons des valeurs nulles à Nonel'aide de la null_process()fonction.
  • A l'intérieur de la fonction clean_dataset(), nous appelons remove_unused_c()et null_process()fonctions. Cette fonction est responsable du nettoyage des données.
  • Pour nettoyer le texte des caractères inutilisés, nous avons créé la clean_text()fonction.
  • Pour le prétraitement, nous n'utiliserons que la suppression des mots vides. Nous avons créé la nltk_preprocess()fonction à cet effet.

Prétraitement de textet title:

# Perform data cleaning on train and test dataset by calling clean_dataset function
df = clean_dataset(news_d)
# apply preprocessing on text through apply method by calling the function nltk_preprocess
df["text"] = df.text.apply(nltk_preprocess)
# apply preprocessing on title through apply method by calling the function nltk_preprocess
df["title"] = df.title.apply(nltk_preprocess)
# Dataset after cleaning and preprocessing step
df.head()

Sortir:

title	text	label
0	house dem aide didnt even see comeys letter ja...	house dem aide didnt even see comeys letter ja...	1
1	flynn hillary clinton big woman campus breitbart	ever get feeling life circle roundabout rather...	0
2	truth might get fired	truth might get fired october 29 2016 tension ...	1
3	15 civilian killed single u airstrike identified	video 15 civilian killed single u airstrike id...	1
4	iranian woman jailed fictional unpublished sto...	print iranian woman sentenced six year prison ...	1

Analyse exploratoire des données

Dans cette section, nous effectuerons :

  • Analyse Univariée : C'est une analyse statistique du texte. Nous utiliserons un nuage de mots à cette fin. Un nuage de mots est une approche de visualisation des données textuelles où le terme le plus courant est présenté dans la taille de police la plus importante.
  • Analyse Bivariée : Bigramme et Trigramme seront utilisés ici. Selon Wikipedia : " un n-gramme est une séquence contiguë de n éléments d'un échantillon donné de texte ou de parole. Selon l'application, les éléments peuvent être des phonèmes, des syllabes, des lettres, des mots ou des paires de bases. Les n-grammes sont généralement collectées à partir d'un corpus textuel ou vocal ».

Nuage à un seul mot

Les mots les plus fréquents apparaissent en caractères gras et plus gros dans un nuage de mots. Cette section effectuera un nuage de mots pour tous les mots du jeu de données.

La fonction de la bibliothèque WordCloudwordcloud() sera utilisée, et la generate()est utilisée pour générer l'image du nuage de mots :

from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt

# initialize the word cloud
wordcloud = WordCloud( background_color='black', width=800, height=600)
# generate the word cloud by passing the corpus
text_cloud = wordcloud.generate(' '.join(df['text']))
# plotting the word cloud
plt.figure(figsize=(20,30))
plt.imshow(text_cloud)
plt.axis('off')
plt.show()

Sortir:

WordCloud pour toutes les fausses données de nouvelles

Nuage de mots pour les informations fiables uniquement :

true_n = ' '.join(df[df['label']==0]['text']) 
wc = wordcloud.generate(true_n)
plt.figure(figsize=(20,30))
plt.imshow(wc)
plt.axis('off')
plt.show()

Sortir:

Nuage de mots pour des nouvelles fiables

Nuage de mots pour les fake news uniquement :

fake_n = ' '.join(df[df['label']==1]['text'])
wc= wordcloud.generate(fake_n)
plt.figure(figsize=(20,30))
plt.imshow(wc)
plt.axis('off')
plt.show()

Sortir:

Nuage de mots pour les fausses nouvelles

Bigramme le plus fréquent (combinaison de deux mots)

Un N-gramme est une séquence de lettres ou de mots. Un unigramme de caractère est composé d'un seul caractère, tandis qu'un bigramme est composé d'une série de deux caractères. De même, les N-grammes de mots sont constitués d'une suite de n mots. Le mot "uni" est un 1-gramme (unigramme). La combinaison des mots "États-Unis" est un 2-gramme (bigramme), "new york city" est un 3-gramme.

Traçons le bigramme le plus courant sur les nouvelles fiables :

def plot_top_ngrams(corpus, title, ylabel, xlabel="Number of Occurences", n=2):
  """Utility function to plot top n-grams"""
  true_b = (pd.Series(nltk.ngrams(corpus.split(), n)).value_counts())[:20]
  true_b.sort_values().plot.barh(color='blue', width=.9, figsize=(12, 8))
  plt.title(title)
  plt.ylabel(ylabel)
  plt.xlabel(xlabel)
  plt.show()
plot_top_ngrams(true_n, 'Top 20 Frequently Occuring True news Bigrams', "Bigram", n=2)

Top des bigrammes sur les fake news

Le bigramme le plus courant sur les fake news :

plot_top_ngrams(fake_n, 'Top 20 Frequently Occuring Fake news Bigrams', "Bigram", n=2)

Top des bigrammes sur les fake news

Trigramme le plus fréquent (combinaison de trois mots)

Le trigramme le plus courant sur les informations fiables :

plot_top_ngrams(true_n, 'Top 20 Frequently Occuring True news Trigrams', "Trigrams", n=3)

Le trigramme le plus courant sur les fake news

Pour les fausses nouvelles maintenant :

plot_top_ngrams(fake_n, 'Top 20 Frequently Occuring Fake news Trigrams', "Trigrams", n=3)

Les trigrammes les plus courants sur les fausses nouvelles

Les tracés ci-dessus nous donnent quelques idées sur l'apparence des deux classes. Dans la section suivante, nous utiliserons la bibliothèque de transformateurs pour créer un détecteur de fausses nouvelles.

Construire un classificateur en affinant le BERT

Cette section récupèrera largement le code du tutoriel de réglage fin du BERT pour créer un classificateur de fausses nouvelles à l'aide de la bibliothèque de transformateurs. Ainsi, pour des informations plus détaillées, vous pouvez vous diriger vers le tutoriel d'origine .

Si vous n'avez pas installé de transformateurs, vous devez :

$ pip install transformers

Importons les bibliothèques nécessaires :

import torch
from transformers.file_utils import is_tf_available, is_torch_available, is_torch_tpu_available
from transformers import BertTokenizerFast, BertForSequenceClassification
from transformers import Trainer, TrainingArguments
import numpy as np
from sklearn.model_selection import train_test_split

import random

Nous voulons rendre nos résultats reproductibles même si nous redémarrons notre environnement :

def set_seed(seed: int):
    """
    Helper function for reproducible behavior to set the seed in ``random``, ``numpy``, ``torch`` and/or ``tf`` (if
    installed).

    Args:
        seed (:obj:`int`): The seed to set.
    """
    random.seed(seed)
    np.random.seed(seed)
    if is_torch_available():
        torch.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        # ^^ safe to call this function even if cuda is not available
    if is_tf_available():
        import tensorflow as tf

        tf.random.set_seed(seed)

set_seed(1)

Le modèle que nous allons utiliser est le bert-base-uncased:

# the model we gonna train, base uncased BERT
# check text classification models here: https://huggingface.co/models?filter=text-classification
model_name = "bert-base-uncased"
# max sequence length for each document/sentence sample
max_length = 512

Chargement du tokenizer :

# load the tokenizer
tokenizer = BertTokenizerFast.from_pretrained(model_name, do_lower_case=True)

Préparation des données

Nettoyons maintenant les NaNvaleurs des colonnes text, authoret :title

news_df = news_d[news_d['text'].notna()]
news_df = news_df[news_df["author"].notna()]
news_df = news_df[news_df["title"].notna()]

Ensuite, créez une fonction qui prend l'ensemble de données en tant que dataframe Pandas et renvoie les fractionnements de train/validation des textes et des étiquettes sous forme de listes :

def prepare_data(df, test_size=0.2, include_title=True, include_author=True):
  texts = []
  labels = []
  for i in range(len(df)):
    text = df["text"].iloc[i]
    label = df["label"].iloc[i]
    if include_title:
      text = df["title"].iloc[i] + " - " + text
    if include_author:
      text = df["author"].iloc[i] + " : " + text
    if text and label in [0, 1]:
      texts.append(text)
      labels.append(label)
  return train_test_split(texts, labels, test_size=test_size)

train_texts, valid_texts, train_labels, valid_labels = prepare_data(news_df)

La fonction ci-dessus prend l'ensemble de données dans un type de trame de données et les renvoie sous forme de listes divisées en ensembles d'apprentissage et de validation. Définir include_titlesur Truesignifie que nous ajoutons la titlecolonne à celle textque nous allons utiliser pour la formation, définir include_authorsur Truesignifie que nous ajoutons authorégalement la au texte.

Assurons-nous que les étiquettes et les textes ont la même longueur :

print(len(train_texts), len(train_labels))
print(len(valid_texts), len(valid_labels))

Sortir:

14628 14628
3657 3657

Tokénisation de l'ensemble de données

Utilisons le tokenizer BERT pour tokeniser notre jeu de données :

# tokenize the dataset, truncate when passed `max_length`, 
# and pad with 0's when less than `max_length`
train_encodings = tokenizer(train_texts, truncation=True, padding=True, max_length=max_length)
valid_encodings = tokenizer(valid_texts, truncation=True, padding=True, max_length=max_length)

Conversion des encodages en un jeu de données PyTorch :

class NewsGroupsDataset(torch.utils.data.Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings
        self.labels = labels

    def __getitem__(self, idx):
        item = {k: torch.tensor(v[idx]) for k, v in self.encodings.items()}
        item["labels"] = torch.tensor([self.labels[idx]])
        return item

    def __len__(self):
        return len(self.labels)

# convert our tokenized data into a torch Dataset
train_dataset = NewsGroupsDataset(train_encodings, train_labels)
valid_dataset = NewsGroupsDataset(valid_encodings, valid_labels)

Chargement et réglage fin du modèle

Nous utiliserons BertForSequenceClassificationpour charger notre modèle de transformateur BERT :

# load the model
model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)

Nous avons mis num_labelsà 2 puisqu'il s'agit d'une classification binaire. La fonction ci-dessous est un rappel pour calculer la précision à chaque étape de validation :

from sklearn.metrics import accuracy_score

def compute_metrics(pred):
  labels = pred.label_ids
  preds = pred.predictions.argmax(-1)
  # calculate accuracy using sklearn's function
  acc = accuracy_score(labels, preds)
  return {
      'accuracy': acc,
  }

Initialisons les paramètres d'entraînement :

training_args = TrainingArguments(
    output_dir='./results',          # output directory
    num_train_epochs=1,              # total number of training epochs
    per_device_train_batch_size=10,  # batch size per device during training
    per_device_eval_batch_size=20,   # batch size for evaluation
    warmup_steps=100,                # number of warmup steps for learning rate scheduler
    logging_dir='./logs',            # directory for storing logs
    load_best_model_at_end=True,     # load the best model when finished training (default metric is loss)
    # but you can specify `metric_for_best_model` argument to change to accuracy or other metric
    logging_steps=200,               # log & save weights each logging_steps
    save_steps=200,
    evaluation_strategy="steps",     # evaluate each `logging_steps`
)

J'ai réglé le per_device_train_batch_sizeà 10, mais vous devriez le régler aussi haut que votre GPU pourrait éventuellement s'adapter. En réglant le logging_stepset save_stepssur 200, cela signifie que nous allons effectuer une évaluation et enregistrer les poids du modèle à chaque étape de formation de 200.

Vous pouvez consulter  cette page  pour des informations plus détaillées sur les paramètres d'entraînement disponibles.

Instancions le formateur :

trainer = Trainer(
    model=model,                         # the instantiated Transformers model to be trained
    args=training_args,                  # training arguments, defined above
    train_dataset=train_dataset,         # training dataset
    eval_dataset=valid_dataset,          # evaluation dataset
    compute_metrics=compute_metrics,     # the callback that computes metrics of interest
)

Entraînement du modèle :

# train the model
trainer.train()

La formation prend quelques heures pour se terminer, en fonction de votre GPU. Si vous êtes sur la version gratuite de Colab, cela devrait prendre une heure avec NVIDIA Tesla K80. Voici la sortie :

***** Running training *****
  Num examples = 14628
  Num Epochs = 1
  Instantaneous batch size per device = 10
  Total train batch size (w. parallel, distributed & accumulation) = 10
  Gradient Accumulation steps = 1
  Total optimization steps = 1463
 [1463/1463 41:07, Epoch 1/1]
Step	Training Loss	Validation Loss	Accuracy
200		0.250800		0.100533		0.983867
400		0.027600		0.043009		0.993437
600		0.023400		0.017812		0.997539
800		0.014900		0.030269		0.994258
1000	0.022400		0.012961		0.998086
1200	0.009800		0.010561		0.998633
1400	0.007700		0.010300		0.998633
***** Running Evaluation *****
  Num examples = 3657
  Batch size = 20
Saving model checkpoint to ./results/checkpoint-200
Configuration saved in ./results/checkpoint-200/config.json
Model weights saved in ./results/checkpoint-200/pytorch_model.bin
<SNIPPED>
***** Running Evaluation *****
  Num examples = 3657
  Batch size = 20
Saving model checkpoint to ./results/checkpoint-1400
Configuration saved in ./results/checkpoint-1400/config.json
Model weights saved in ./results/checkpoint-1400/pytorch_model.bin

Training completed. Do not forget to share your model on huggingface.co/models =)

Loading best model from ./results/checkpoint-1400 (score: 0.010299865156412125).
TrainOutput(global_step=1463, training_loss=0.04888018785440506, metrics={'train_runtime': 2469.1722, 'train_samples_per_second': 5.924, 'train_steps_per_second': 0.593, 'total_flos': 3848788517806080.0, 'train_loss': 0.04888018785440506, 'epoch': 1.0})

Évaluation du modèle

Étant donné que load_best_model_at_endest réglé sur True, les meilleurs poids seront chargés une fois l'entraînement terminé. Évaluons-le avec notre ensemble de validation :

# evaluate the current model after training
trainer.evaluate()

Sortir:

***** Running Evaluation *****
  Num examples = 3657
  Batch size = 20
 [183/183 02:11]
{'epoch': 1.0,
 'eval_accuracy': 0.998632759092152,
 'eval_loss': 0.010299865156412125,
 'eval_runtime': 132.0374,
 'eval_samples_per_second': 27.697,
 'eval_steps_per_second': 1.386}

Enregistrement du modèle et du tokenizer :

# saving the fine tuned model & tokenizer
model_path = "fake-news-bert-base-uncased"
model.save_pretrained(model_path)
tokenizer.save_pretrained(model_path)

Un nouveau dossier contenant la configuration du modèle et les poids apparaîtra après l'exécution de la cellule ci-dessus. Si vous souhaitez effectuer une prédiction, vous utilisez simplement la from_pretrained()méthode que nous avons utilisée lorsque nous avons chargé le modèle, et vous êtes prêt à partir.

Ensuite, créons une fonction qui accepte le texte de l'article comme argument et retourne s'il est faux ou non :

def get_prediction(text, convert_to_label=False):
    # prepare our text into tokenized sequence
    inputs = tokenizer(text, padding=True, truncation=True, max_length=max_length, return_tensors="pt").to("cuda")
    # perform inference to our model
    outputs = model(**inputs)
    # get output probabilities by doing softmax
    probs = outputs[0].softmax(1)
    # executing argmax function to get the candidate label
    d = {
        0: "reliable",
        1: "fake"
    }
    if convert_to_label:
      return d[int(probs.argmax())]
    else:
      return int(probs.argmax())

J'ai pris un exemple à partir test.csvduquel le modèle n'a jamais vu effectuer d'inférence, je l'ai vérifié, et c'est un article réel du New York Times :

real_news = """
Tim Tebow Will Attempt Another Comeback, This Time in Baseball - The New York Times",Daniel Victor,"If at first you don’t succeed, try a different sport. Tim Tebow, who was a Heisman   quarterback at the University of Florida but was unable to hold an N. F. L. job, is pursuing a career in Major League Baseball. <SNIPPED>
"""

Le texte original se trouve dans l'environnement Colab si vous souhaitez le copier, car il s'agit d'un article complet. Passons-le au modèle et voyons les résultats :

get_prediction(real_news, convert_to_label=True)

Sortir:

reliable

Annexe : Création d'un fichier de soumission pour Kaggle

Dans cette section, nous allons prédire tous les articles dans le test.csvpour créer un dossier de soumission pour voir notre justesse dans le jeu de test sur le concours Kaggle :

# read the test set
test_df = pd.read_csv("test.csv")
# make a copy of the testing set
new_df = test_df.copy()
# add a new column that contains the author, title and article content
new_df["new_text"] = new_df["author"].astype(str) + " : " + new_df["title"].astype(str) + " - " + new_df["text"].astype(str)
# get the prediction of all the test set
new_df["label"] = new_df["new_text"].apply(get_prediction)
# make the submission file
final_df = new_df[["id", "label"]]
final_df.to_csv("submit_final.csv", index=False)

Après avoir concaténé l'auteur, le titre et le texte de l'article, nous passons la get_prediction()fonction à la nouvelle colonne pour remplir la labelcolonne, nous utilisons ensuite la to_csv()méthode pour créer le fichier de soumission pour Kaggle. Voici mon score de soumission :

Note de soumission

Nous avons obtenu une précision de 99,78 % et 100 % sur les classements privés et publics. C'est génial!

Conclusion

Très bien, nous avons terminé avec le tutoriel. Vous pouvez consulter cette page pour voir divers paramètres d'entraînement que vous pouvez modifier.

Si vous avez un ensemble de données de fausses nouvelles personnalisé pour un réglage fin, il vous suffit de transmettre une liste d'échantillons au tokenizer comme nous l'avons fait, vous ne modifierez plus aucun autre code par la suite.

Vérifiez le code complet ici , ou l'environnement Colab ici .