30 changed files with 13694 additions and 0 deletions
@ -0,0 +1,220 @@ |
|||
# plain text workflow |
|||
|
|||
Files for the publication & poster for Data Workers, an exhibition by Algolit at the Mundaneum in Mons from 28 March until 28 April 2019. |
|||
<http://www.algolit.net/index.php/Data_Workers> |
|||
|
|||
|
|||
` _ ` |
|||
` _ __ ___ | |_ ___ ___ ` |
|||
`| '_ \ / _ \| __/ _ \/ __|` |
|||
`| | | | (_) | || __/\__ \` |
|||
`|_| |_|\___/ \__\___||___/` |
|||
|
|||
|
|||
line width: 110 char |
|||
lines per page: 70 |
|||
|
|||
70 |
|||
140 |
|||
210 |
|||
280 |
|||
350 |
|||
420 |
|||
490 |
|||
560 |
|||
630 |
|||
700 |
|||
|
|||
|
|||
## --- txt to pdf --- |
|||
|
|||
options ... |
|||
|
|||
### weasyprint |
|||
(stretched the page size, font size, etc, in order to place everything) |
|||
|
|||
### enscript |
|||
(using postscript to create pdf) |
|||
`$ enscript --word-wrap --margins=40:10:10:20 --fancy-header writers.intro.txt -o - | ps2pdf - test.pdf` |
|||
`$ cat writers.intro.txt | iconv -c -f utf-8 -t ISO-8859-1 | enscript --word-wrap --margins=40:10:10:20 --fancy-header -o - | ps2pdf - test.pdf` |
|||
|
|||
### txt2pdf |
|||
(uses reportlab) |
|||
<https://github.com/baruchel/txt2pdf> |
|||
`$ python3 txt2pdf/txt2pdf.py -T 1 -B 2 -L 2 -R 1 writers.intro.txt -o test.pdf` |
|||
`$ python3 txt2pdf/txt2pdf.py -m A4 -f fonts/fantasque/TTF/FantasqueSansMono-Regular.ttf -s 10 -v 0 -T 1 -B 1 -L 1.5 -R 1.5 data-workers.txt -o test.pdf` |
|||
|
|||
currently using: |
|||
`$ python3 txt2pdf/txt2pdf.py -m A4 -f fonts/fantasque/TTF/FantasqueSansMono-Regular.ttf -s 9 -v 0.05 -T 1 -B 0.9 -L 1.5 -R 1.5 data-workers.txt -o test.pdf` |
|||
|
|||
### PDF2txt miner |
|||
The inverted tool of this process |
|||
https://www.unixuser.org/~euske/python/pdfminer/ |
|||
"What's It? PDFMiner is a tool for extracting information from PDF documents. Unlike other PDF-related tools, it focuses entirely on getting and analyzing text data. PDFMiner allows one to obtain the exact location of text in a page, as well as other information such as fonts or lines." |
|||
|
|||
|
|||
## --- hyphenation --- |
|||
|
|||
### Hyphenator |
|||
<https://pypi.org/project/hyphenator/> |
|||
|
|||
### textwrap2 |
|||
<https://pypi.org/project/textwrap3/> |
|||
|
|||
|
|||
## --- commands --- |
|||
|
|||
Generate the publication to PDF: |
|||
`$ python3 create_all.py && python3 txt2pdf/txt2pdf.py -m A4 -f fonts/unifont-11.0.03.ttf -s 9 -v 0.05 -T 1 -B 0.9 -L 1.6 -R 1.4 data-workers.en.txt -o data-workers.en.pdf` |
|||
|
|||
Add logos.pdf on last page with PDFTK |
|||
`$ pdftk data-workers.en.pdf A=data-workers.en.pdf cat A52 output data-workers.en.backcover.pdf` |
|||
`$ pdftk data-workers.en.backcover.pdf multistamp logos.pdf output data-workers.en.logos.pdf ` |
|||
`$ pdftk A=data-workers.en.pdf B=data-workers.en.backcover.logos.pdf cat A1-51 B output data-workers.en.logos.pdf` |
|||
|
|||
PDFTK in one command: |
|||
`$ pdftk data-workers.en.pdf A=data-workers.en.pdf cat A52 output data-workers.en.backcover.pdf && pdftk data-workers.en.backcover.pdf multistamp logos.pdf output data-workers.en.logos.pdf && pdftk A=data-workers.en.pdf B=data-workers.en.backcover.logos.pdf cat A1-51 B output data-workers.en.logos.pdf` |
|||
|
|||
|
|||
## --- ASCII/UNICODE fonts --- |
|||
|
|||
Unicode art :) |
|||
<http://xahlee.info/comp/unicode_ascii_art.html> |
|||
<http://qaz.wtf/u/convert.cgi?text=This+is+pretty+fun+too.+Do+something+for+your+group+tag> |
|||
<https://coolsymbol.com/cool-fancy-text-generator.html> |
|||
<http://www.alanwood.net/unicode/> |
|||
|
|||
|
|||
## --- unifont --- |
|||
<http://unifoundry.com/unifont/index.html> |
|||
|
|||
|
|||
## --- DUMP --- |
|||
|
|||
[\/\]\<\?\'\)\(\[\\\"\w] |
|||
░ |
|||
|
|||
|
|||
work |
|||
many authors |
|||
write |
|||
every human being |
|||
who has access |
|||
to the internet |
|||
interacts |
|||
we |
|||
chat, |
|||
write, |
|||
click, |
|||
like |
|||
and share |
|||
we |
|||
leave our data |
|||
we |
|||
find ourselves writing in Python |
|||
some neural networks |
|||
write |
|||
human editors |
|||
assist |
|||
poets, |
|||
playwrights |
|||
or novelists |
|||
assist |
|||
|
|||
--- |
|||
|
|||
Writers write |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒ |
|||
|
|||
|
|||
|
|||
Data workers ░░░░░░░░░░░░ need data to ▒▒▒▒ with. work |
|||
The data that is used in the context |
|||
of Algolit, is written language. |
|||
Machine learning relies on many types |
|||
Many authors of writing. ░░░░░░░░░░░░ ▒▒▒▒▒ in the write |
|||
form of publications, like books or |
|||
articles. These are part of organised |
|||
archives and are sometimes digitized. |
|||
But there are other kinds of writing |
|||
every human too. We could say that ░░░░░░░░░░░░ |
|||
being who has access to the internet ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
is a writer each time they ▒▒▒▒▒▒▒▒▒ interact |
|||
with algorithms. |
|||
|
|||
We ░░ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒. chat, write, |
|||
click, like |
|||
and share |
|||
|
|||
we In return for free services, ░░ ▒▒▒▒▒ leave |
|||
▒▒▒▒▒▒▒▒ that is compiled into profiles our data |
|||
and sold for advertisement and research. |
|||
|
|||
Machine learning algorithms are not |
|||
critics: they take whatever they're |
|||
given, no matter the writing style, |
|||
no matter the CV of the author, no |
|||
matter their spelling mistakes. In |
|||
fact, mistakes make it better: the |
|||
more variety, the better they learn |
|||
to anticipate unexpected text. But |
|||
often, human authors are not aware |
|||
of what happens to their work. |
|||
|
|||
Most of the writing we use is in |
|||
English, some is in French, some in |
|||
Dutch. Most often we find ourselves |
|||
writing in Python, the programming |
|||
language we use. |
|||
|
|||
Algorithms can be writers too. Some |
|||
neural networks write their own rules |
|||
and generate their own texts. And for |
|||
the models that are still wrestling with |
|||
the ambiguities of natural language, |
|||
there are human editors to assist them. |
|||
Poets, playwrights or novelists start |
|||
their new careers as assistants of AI. |
|||
|
|||
--- |
|||
|
|||
P r o g r a mm e r s are wr iting the datawork |
|||
P r o g r am m e rs are writing the dataworker |
|||
P r o g ra m mers are writing the dataworke |
|||
P r o g r ammers a re writing the datawor |
|||
P r o g r ammers are writing the dataw |
|||
P r o gram mers a re writing the data |
|||
P r ogra m mer s are writing the d |
|||
P r o gramm e r s are writing the d |
|||
P r ogram m ers a re writing the d |
|||
P r o g ram m e rs a re writing the |
|||
P r o g r a m m ers a r e writing the |
|||
P r o g r a m m e rs are writing the d |
|||
P r o g r a m m e r s a r e wr i ting the dat |
|||
P r o g r a mme r s ar e writ ing the dataw |
|||
P r o g r amm e r s are writing the datawo |
|||
P r o g r amm e r s are writing t he datawo |
|||
P r o g ra m m er s a r e writ ing the datawork |
|||
P r o g r a mm e r s are wr iting the datawork |
|||
P r o g r a m m e rs are writing the datawo |
|||
P r o gra m m e rs are w riting the datawork |
|||
P r og r a m mers a re writing the datawor |
|||
P r o g r a mmers a re writing the datawo |
|||
P r o g r ammers a r e writing the dataw |
|||
P r o g ra mmers a re writing the dat |
|||
P r o g ramm ers a re writing the da |
|||
P r ogramm e rs a r e writing the da |
|||
P r o gramm e r s a r e writing the d |
|||
P r o g ram m e rs a r e writing the d |
|||
P r o g r a m m e rs are writing the d |
|||
P r o g r a m m e r s a r e w r iting the da |
|||
P r o g r a mme r s ar e writ ing the dataw |
|||
P r o g ramme r s are writing the datawo |
|||
P r o g r ammer s a re w riting th e datawor |
|||
P r o g r a m mers a r e writ ing the datawork |
|||
P r o g r am me r s are wr iting the datawork |
|||
|
|||
|
|||
|
|||
|
|||
|
|||
@ -0,0 +1,249 @@ |
|||
#! /etc/bin/python3 |
|||
|
|||
from bs4 import BeautifulSoup as bs |
|||
|
|||
import os |
|||
|
|||
from functions import * |
|||
from get_html_from_wiki import get_html_from_wiki |
|||
from create_cover import create_cover |
|||
from create_backcover import create_backcover |
|||
from create_zone_backcover import create_zone_backcover |
|||
from create_intro_text import create_intro_text |
|||
from create_works_text_blocks import create_works_text_block |
|||
from create_stories_layout import create_stories_layout |
|||
from create_glossary import create_glossary |
|||
|
|||
# Generate the publication to PDF: |
|||
# $ python3 create_all.py && python3 txt2pdf/txt2pdf.py -m A4 -f fonts/unifont-11.0.03.ttf -s 9 -v 0.05 -T 1 -B 0.9 -L 1.6 -R 1.4 data-workers.en.txt -o data-workers.en.pdf |
|||
|
|||
# Add logos.pdf on last page with PDFTK |
|||
# $ pdftk data-workers.en.pdf A=data-workers.en.pdf cat A52 output data-workers.en.backcover.pdf |
|||
# $ pdftk data-workers.en.backcover.pdf multistamp logos.pdf output data-workers.en.logos.pdf |
|||
# $ pdftk A=data-workers.en.pdf B=data-workers.en.backcover.logos.pdf cat A1-51 B output data-workers.en.logos.pdf |
|||
|
|||
# PDFTK in one command: |
|||
# $ pdftk data-workers.en.pdf A=data-workers.en.pdf cat A52 output data-workers.en.backcover.pdf && pdftk data-workers.en.backcover.pdf multistamp logos.pdf output data-workers.en.logos.pdf && pdftk A=data-workers.en.pdf B=data-workers.en.backcover.logos.pdf cat A1-51 B output data-workers.en.logos.pdf |
|||
|
|||
# Generate a new publication in one command: |
|||
# For the English version: |
|||
# python3 create_all.py && python3 txt2pdf/txt2pdf.py -m A4 -f fonts/unifont-11.0.03.ttf -s 9 -v 0.05 -T 1 -B 0.9 -L 1.6 -R 1.4 data-workers.en.txt -o data-workers.en.pdf && pdftk data-workers.en.pdf A=data-workers.en.pdf cat A52 output data-workers.en.backcover.pdf && pdftk data-workers.en.backcover.pdf multistamp logos.pdf output data-workers.en.logos.pdf && pdftk A=data-workers.en.pdf B=data-workers.en.backcover.logos.pdf cat A1-51 B output data-workers.en.publication.pdf |
|||
# For the French: |
|||
# python3 create_all.py && python3 txt2pdf/txt2pdf.py -m A4 -f fonts/unifont-11.0.03.ttf -s 9 -v 0.05 -T 1 -B 0.9 -L 1.6 -R 1.4 data-workers.fr.txt -o data-workers.fr.pdf && pdftk data-workers.fr.pdf A=data-workers.fr.pdf cat A56 output data-workers.fr.backcover.pdf && pdftk data-workers.fr.backcover.pdf multistamp logos.pdf output data-workers.fr.logos.pdf && pdftk A=data-workers.fr.pdf B=data-workers.fr.backcover.logos.pdf cat A1-55 B output data-workers.fr.publication.pdf |
|||
|
|||
|
|||
|
|||
|
|||
# Set the language in functions.py |
|||
from functions import language |
|||
|
|||
# To work with a local html file |
|||
# (and not download a new one all the time) |
|||
if language == 'en': |
|||
htmlfile = 'data-workers.en.html' |
|||
url = 'http://www.algolit.net/index.php/Data_Workers?action=render' |
|||
else: |
|||
htmlfile = 'data-workers.fr.html' |
|||
url = 'http://www.algolit.net/index.php/Data_Workers_FR?action=render' |
|||
|
|||
if not os.path.exists(htmlfile): |
|||
baseurl = 'http://www.algolit.net' |
|||
get_html_from_wiki(language, url, baseurl) |
|||
|
|||
html = open(htmlfile, 'r').read() |
|||
soup = bs(html, 'html.parser') |
|||
|
|||
# Main string where content is collected |
|||
out = '' |
|||
|
|||
# Insert cover |
|||
if '.en.' in htmlfile: |
|||
language = 'en' |
|||
else: |
|||
language = 'fr' |
|||
out += create_cover('data_workers', language, steps=1) |
|||
|
|||
# Insert counters page |
|||
out += insert_counters_page() |
|||
|
|||
# Tmp elements to save content that is outside the section tags |
|||
about = '' |
|||
mundaneum = '' |
|||
glossary = '' |
|||
|
|||
intro = '' |
|||
stories = '' |
|||
works = '' |
|||
|
|||
# Enable this once the zones have started |
|||
zones = False |
|||
|
|||
# Loop through all the elements of the page |
|||
for element in soup.body.section.contents: |
|||
|
|||
print('\n---') |
|||
print(element.name) |
|||
|
|||
if element.name == 'h2': |
|||
print('<h2> (about/mundaneum/zones/glossary)') |
|||
if 'about' in element.text.lower() or 'propos' in element.text.lower(): |
|||
about += element.text.upper() + '\n' |
|||
|
|||
elif 'mundaneum' in element.text.lower(): |
|||
mundaneum += element.text.upper() + '\n' |
|||
|
|||
elif 'zones' in element.text.lower(): |
|||
|
|||
# Append about and mundaneum text |
|||
# as soon as the 'zones' section starts |
|||
about_txt = insert_linebreaks(about, 65, type='word', double_linebreaks=True) |
|||
mundaneum_txt = insert_linebreaks(mundaneum, 40, type='word', double_linebreaks=True) |
|||
about_and_mundaneum = insert_text_block(about_txt, mundaneum_txt, 70, 40) |
|||
# about_and_mundaneum = create_header(about_and_mundaneum) |
|||
out += fill_page(about_and_mundaneum) |
|||
print('==> Appended about + mundaneum') |
|||
about = False |
|||
mundaneum = False |
|||
|
|||
# Also append the stories text |
|||
# as soon as the 'zones' section starts |
|||
if stories: |
|||
stories_txt = create_stories_layout(stories) |
|||
print('>>> create_stories_layout length:', len(stories_txt.split('\n'))) |
|||
pages = fill_page(stories_txt) |
|||
out += pages |
|||
print('==> Appended stories (Algolit)') |
|||
stories = '' |
|||
|
|||
zones = True |
|||
|
|||
elif 'glossary' in element.text.lower() or 'glossaire' in element.text.lower(): |
|||
glossary += add_headers('glossary', element) |
|||
zones = False |
|||
|
|||
elif element.name == 'h3': |
|||
print('<h3> (writers/oracles/cleaners/informants/readers/learners)') |
|||
zone = element.text |
|||
print('-->', zone) |
|||
|
|||
# Add extra pages, to make sure the new zones always start on the right page |
|||
if zone.lower() == 'oracles': |
|||
out += insert_counters_page() |
|||
if zone.lower() == 'readers' or zone.lower() == 'lecteurs': |
|||
out += insert_counters_page() |
|||
|
|||
# Add zone cover |
|||
cover = create_cover(zone.lower(), language, steps=1) |
|||
out += cover |
|||
print('==> Appended cover:', zone) |
|||
|
|||
# Add backcover analysis for zone |
|||
zone_backcover = create_zone_backcover(zone, language, out) |
|||
zone_backcover = fill_page(zone_backcover) |
|||
print('>>> fill_page length:', len(pages.split('\n'))) |
|||
out += zone_backcover |
|||
print('==> Appended zone_backcover') |
|||
|
|||
# Insert Works or Stories sections |
|||
elif element.name == 'section': |
|||
print('<SECTION>') |
|||
if 'group' in element['class'][-1]: |
|||
for section_element in element.children: |
|||
if 'stories' in section_element['class'] or 'récits' in section_element['class'][1]: |
|||
print('--> Stories') |
|||
for child_element in section_element.children: |
|||
print('---->', child_element.name) |
|||
stories += add_headers('stories', child_element) |
|||
elif 'works' in section_element['class']: |
|||
print('--> Works') |
|||
for child_element in section_element.children: |
|||
print('---->', child_element.name) |
|||
works += add_headers('works', child_element) |
|||
|
|||
# print('intro:', intro) |
|||
# print('stories:', stories) |
|||
# print('works:', works) |
|||
|
|||
if zones == True: |
|||
|
|||
if intro: |
|||
intro_txt = create_intro_text(intro, zone) |
|||
intro = '' |
|||
else: |
|||
intro_txt = '' |
|||
|
|||
if works: |
|||
works_txt = create_works_text_block(intro_txt, works) |
|||
pages = fill_page(works_txt) |
|||
|
|||
# Insert symbol backgrounds |
|||
lines = '' |
|||
for i, line in enumerate(pages.split('\n')): |
|||
lines += line + '\n' |
|||
line_number = i + 1 |
|||
if line_number % 69 == 0: |
|||
out += insert_symbol_background(lines, 110, ['%', '%', '%', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '], 1) |
|||
lines = '' |
|||
|
|||
print('==> Appended intro + works') |
|||
works = '' |
|||
|
|||
if stories: |
|||
stories_txt = create_stories_layout(stories) |
|||
print('>>> create_stories_layout length:', len(stories_txt.split('\n'))) |
|||
pages = fill_page(stories_txt) |
|||
print('>>> fill_page length:', len(pages.split('\n'))) |
|||
out += pages |
|||
print('==> Appended stories') |
|||
stories = '' |
|||
|
|||
print('</SECTION>') |
|||
|
|||
else: |
|||
try: |
|||
if zones == True: |
|||
# Append introduction text here, |
|||
# when the zones section starts |
|||
# (as this text is written outside a section) |
|||
intro += add_headers('intro', element) |
|||
elif glossary: |
|||
glossary += add_headers('glossary', element) |
|||
elif mundaneum: |
|||
mundaneum += check_element(element) |
|||
elif about: |
|||
about += check_element(element) |
|||
except: |
|||
print('no content >>>', element.name) |
|||
|
|||
# try: |
|||
# if element.name != 'section': |
|||
# print(element.text) |
|||
# except: |
|||
# continue |
|||
|
|||
# Insert placeholder/fillup page |
|||
if language == 'fr': |
|||
out += insert_counters_page() |
|||
|
|||
# Append glossary |
|||
glossary_txt = create_glossary(glossary) |
|||
# out += glossary_txt |
|||
out += fill_page(glossary_txt) |
|||
print('==> Appended glossary') |
|||
|
|||
# Append backcover |
|||
out += create_backcover() |
|||
print('==> Appended backcover') |
|||
|
|||
out = insert_pagenumbers(out) |
|||
|
|||
# Special Effects |
|||
# out = insert_symbol_background(out, 110, [' '], 1) |
|||
# out = insert_symbol_background(out, 110, ['%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', '%', ' '], 1) |
|||
# out = insert_symbol_background(out, 110, ['&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', '&', ' '], 1, inverted=True) |
|||
|
|||
out_filename = '{}'.format(htmlfile.replace('.html', '.txt')) |
|||
out_file = open(out_filename, 'w+') |
|||
out_file.write(out) |
|||
print('*{} written*'.format(out_filename)) |
|||
|
|||
@ -0,0 +1,51 @@ |
|||
|
|||
from math import log |
|||
import random |
|||
from functions import insert_linebreaks |
|||
|
|||
groups_left = ['humans', 'humans', 'machines', 'machines', 'humans', 'machines', 'machines', 'humans'] |
|||
groups_right = ['humans', 'machines', 'machines', 'humans', 'machines', 'machines', 'humans', 'humans'] |
|||
verb = 'learn' |
|||
relations = ['from', 'with'] |
|||
symbols = ['◜', '◝', '◞', '◟', '◠', '◡'] |
|||
|
|||
def create_backcover(steps=1): |
|||
linewidth = 110 |
|||
lines_per_page = 70 |
|||
maximum = 100 |
|||
|
|||
tmp = '' |
|||
|
|||
for i in range(1, maximum): |
|||
tmp += random.choice(symbols) |
|||
tmp += ' ' |
|||
tmp += groups_left[i % len(groups_left)] |
|||
tmp += ' ' |
|||
tmp += verb |
|||
tmp += ' ' |
|||
tmp += relations[i % 2] |
|||
tmp += ' ' |
|||
tmp += groups_right[i % len(groups_right)] |
|||
tmp += ' ' |
|||
tmp += random.choice(symbols) |
|||
tmp += ' ' * int(log(i) + 5) |
|||
|
|||
for i in reversed(range(1, maximum)): |
|||
tmp += ' ' * int(log(i) + 5) |
|||
tmp += random.choice(symbols) |
|||
tmp += ' ' |
|||
tmp += groups_left[i % len(groups_left)] |
|||
tmp += ' ' |
|||
tmp += verb |
|||
tmp += ' ' |
|||
tmp += relations[i % 2] |
|||
tmp += ' ' |
|||
tmp += groups_right[i % len(groups_right)] |
|||
tmp += ' ' |
|||
tmp += random.choice(symbols) |
|||
|
|||
out = insert_linebreaks(tmp, linewidth) |
|||
out = '\n'.join(out.split('\n')[:lines_per_page]) # select the lines to fill one page |
|||
return out + '\n' |
|||
|
|||
# print(create_backcover(steps=1)) |
|||
@ -0,0 +1,173 @@ |
|||
|
|||
from functions import insert_linebreaks, language |
|||
|
|||
# txt art |
|||
# unicode art |
|||
# plainpatterns |
|||
# plaintxtfun |
|||
|
|||
covers = { |
|||
'en': { |
|||
'data_workers' : { |
|||
'subject' : 'data workers', |
|||
'action' : 'write, perform, clean, inform, read and learn' |
|||
}, |
|||
'writers' : { |
|||
'subject' : 'writers', |
|||
'action' : 'write' |
|||
}, |
|||
'oracles' : { |
|||
'subject' : 'oracles', |
|||
'action' : 'predict' |
|||
}, |
|||
'cleaners' : { |
|||
'subject' : 'cleaners', |
|||
'action' : 'clean' |
|||
}, |
|||
'informants' : { |
|||
'subject' : 'informants', |
|||
'action' : 'inform' |
|||
}, |
|||
'readers' : { |
|||
'subject' : 'readers', |
|||
'action' : 'read' |
|||
}, |
|||
'learners' : { |
|||
'subject' : 'learners', |
|||
'action' : 'learn' |
|||
} |
|||
}, |
|||
'fr' : { |
|||
'data_workers' : { |
|||
'subject' : 'data workers', |
|||
'action' : 'write, perform, clean, inform, read and learn' |
|||
}, |
|||
'écrivains' : { |
|||
'subject' : 'writers', |
|||
'action' : 'write' |
|||
}, |
|||
'oracles' : { |
|||
'subject' : 'oracles', |
|||
'action' : 'predict' |
|||
}, |
|||
'nettoyeurs' : { |
|||
'subject' : 'cleaners', |
|||
'action' : 'clean' |
|||
}, |
|||
'informateurs' : { |
|||
'subject' : 'informants', |
|||
'action' : 'inform' |
|||
}, |
|||
'lecteurs' : { |
|||
'subject' : 'readers', |
|||
'action' : 'read' |
|||
}, |
|||
'apprenants' : { |
|||
'subject' : 'learners', |
|||
'action' : 'learn' |
|||
} |
|||
}, |
|||
'fr.bak' : { |
|||
'data_workers' : { |
|||
'subject' : 'data workers', |
|||
'action' : 'écrire, exécuter, nettoyer, informer, lire et apprendre' |
|||
}, |
|||
'écrivains' : { |
|||
'subject' : 'écrivains', |
|||
'action' : 'écrire' |
|||
}, |
|||
'oracles' : { |
|||
'subject' : 'oracles', |
|||
'action' : 'exécuter' |
|||
}, |
|||
'nettoyeurs' : { |
|||
'subject' : 'nettoyeurs', |
|||
'action' : 'nettoyer' |
|||
}, |
|||
'informateurs' : { |
|||
'subject' : 'informateurs', |
|||
'action' : 'informer' |
|||
}, |
|||
'lecteurs' : { |
|||
'subject' : 'lecteurs', |
|||
'action' : 'lire' |
|||
}, |
|||
'apprenants' : { |
|||
'subject' : 'apprenants', |
|||
'action' : 'apprendre' |
|||
} |
|||
} |
|||
} |
|||
|
|||
cover_bottom_en = ''' |
|||
|
|||
|
|||
What |
|||
can |
|||
humans learn from humans |
|||
humans learn with machines |
|||
machines learn from machines |
|||
machines learn with humans |
|||
humans learn from machines |
|||
machines learn with machines |
|||
machines learn from humans |
|||
humans learn with humans |
|||
? ? ? |
|||
|
|||
Data Workers, an exhibition at the Mundaneum in Mons from 28 March until 28 April 2019.''' |
|||
|
|||
cover_bottom_fr = ''' |
|||
|
|||
|
|||
What |
|||
can |
|||
humans learn from humans |
|||
humans learn with machines |
|||
machines learn from machines |
|||
machines learn with humans |
|||
humans learn from machines |
|||
machines learn with machines |
|||
machines learn from humans |
|||
humans learn with humans |
|||
? ? ? |
|||
|
|||
Data Workers, une exposition au Mundaneum à Mons du 28 mars au 28 avril 2019.''' |
|||
|
|||
def create_cover(zone, language, steps=1): |
|||
|
|||
linewidth = 110 |
|||
lines_per_page = 70 |
|||
maximum = 100 |
|||
|
|||
subject = covers[language][zone]['subject'] |
|||
action = covers[language][zone]['action'] |
|||
|
|||
tmp = '' |
|||
|
|||
for i in range(2, maximum): |
|||
tmp += subject |
|||
tmp += ' ' |
|||
tmp += action |
|||
tmp += ' ' * steps * i # spaces |
|||
|
|||
for i in reversed(range(maximum)): |
|||
tmp += subject |
|||
tmp += ' ' |
|||
tmp += action |
|||
tmp += ' ' * steps * i # spaces |
|||
|
|||
out = insert_linebreaks(tmp, linewidth) |
|||
|
|||
# insert bottom text only on the main cover |
|||
if 'data_workers' in zone: |
|||
if language == 'en': |
|||
out = '\n'.join(out.split('\n')[:lines_per_page-15]) # select the lines to fill one page |
|||
out += cover_bottom_en |
|||
else: |
|||
out = '\n'.join(out.split('\n')[:lines_per_page-15]) # select the lines to fill one page |
|||
out += cover_bottom_fr |
|||
else: |
|||
out = '\n'.join(out.split('\n')[:lines_per_page]) # select the lines to fill one page |
|||
return out + '\n' |
|||
|
|||
# print(create_cover(zone, steps=1)) |
|||
@ -0,0 +1,74 @@ |
|||
from functions import insert_linebreaks, insert_text_block |
|||
from create_inserted_header import insert_header |
|||
import math |
|||
|
|||
def create_columns(string, column_count, page_height): |
|||
print('--- start create_columns() ---') |
|||
print('>>> column_count:', column_count) |
|||
# column_width = int(113/column_count) |
|||
column_width = 28 |
|||
string = string.replace(': ', '\n') # Insert linebreaks for legibility |
|||
string = insert_linebreaks(string, column_width-4, type='word') |
|||
|
|||
# Double check the linebreaks |
|||
lines = string.split('\n') |
|||
all_lines = [] |
|||
for line in lines: |
|||
if len(line) > column_width - 1: |
|||
line = insert_linebreaks(line, column_width-8, type='word') |
|||
all_lines.append(line) |
|||
lines = all_lines |
|||
|
|||
total_number_of_columns = math.ceil(len(lines)/page_height) |
|||
number_of_pages = total_number_of_columns/column_count |
|||
print('>>> number_of_pages:', number_of_pages) |
|||
print('>>> total_number_of_columns:', total_number_of_columns) |
|||
|
|||
pages = '' |
|||
columns_string = '' |
|||
columns = [] |
|||
current_column = 1 |
|||
for num in range(0, total_number_of_columns): |
|||
|
|||
# print('>>> current column:', num) |
|||
columns.append([]) |
|||
current_start = num * page_height |
|||
current_end = current_start + page_height |
|||
# print('>>> current start/end:', current_start, current_end) |
|||
current_line_range = lines[current_start:current_end] |
|||
# print('>>> line range:', current_line_range) |
|||
|
|||
line_count = 1 |
|||
for l, line in enumerate(current_line_range): |
|||
|
|||
if '* ' in line: |
|||
columns[num].append(line.upper()) |
|||
line_count += 1 |
|||
elif line_count <= page_height: |
|||
columns[num].append(' ' + line) |
|||
line_count += 1 |
|||
|
|||
if num == 0: |
|||
columns_string = '\n'.join(columns[num]) # Start of a new column string |
|||
current_column += 1 |
|||
|
|||
elif num % column_count == 0: |
|||
pages += insert_header(columns_string) + '\n' # Append new page |
|||
columns_string = '\n'.join(columns[num]) # Start of a new column string |
|||
current_column = 2 |
|||
line_count = 1 |
|||
|
|||
else: |
|||
left = (column_width + 0) * (current_column - 1) |
|||
new_column = '\n'.join(columns[num]) |
|||
columns_string = insert_text_block(columns_string, new_column, left, 25) |
|||
current_column += 1 |
|||
|
|||
pages += insert_header(columns_string) # Append new page |
|||
print('--- end create_columns() ---') |
|||
return pages |
|||
|
|||
def create_glossary(string): |
|||
return create_columns(string, 4, 63) |
|||
|
|||
|
|||
@ -0,0 +1,28 @@ |
|||
header = '''\ |
|||
█▒░░ ▓▒█░░▒▓███▀▒░ ░▒ ▒ ░ ▒▒▓██▒ ░░ ▒░ ░ ▒ ░▓ ░▒▓ ▒ ▒█░░▒█▓▒░▓▒ ▒▓▒▒░ ▒ ▒▒ ▓▒░ ▒░▓ █ ▒░ █░█ ▓▒░ ▒▓░░ |
|||
▓ ▒░ ▒▒ ░▒░▒▓ ░ ░ ▒ ░ ▒ ▒ ░ ░ ░▒░ ░▒ ░ ▒ ░▒░▓░ ▒ ░ ▒ ░▒░ ░ ░▒ ▒░░ ░ ▒ ░░▓ ░ ▓▓░░ ░░▒▒▓░ |
|||
░ ▒ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░░ ░ ▒ ░ ░ ░ ░ ░ ░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░''' |
|||
|
|||
# header = '''▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ▒░ ''' |
|||
|
|||
# header = '''▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ ▒ |
|||
# ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ''' |
|||
|
|||
# header = '''▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒''' |
|||
|
|||
def insert_header(string): |
|||
lines = string.split('\n') |
|||
pages = '' |
|||
current_page = '' |
|||
count = 1 |
|||
for i, line in enumerate(lines): |
|||
if i + 1 == len(lines): |
|||
current_page += line |
|||
pages += header + '\n\n' + current_page + '\n' |
|||
else: |
|||
current_page += line + '\n' |
|||
count += 1 |
|||
|
|||
return pages |
|||
@ -0,0 +1,13 @@ |
|||
|
|||
from functions import insert_linebreaks, align |
|||
|
|||
header = '''\ |
|||
V V V V V V V V |
|||
V V V V V V V V V V V V V V V V |
|||
V V V V V V V V V''' |
|||
|
|||
def create_intro_text(string, zone): |
|||
intro_text = insert_linebreaks(string, 35, type='word') |
|||
intro_text = intro_text.replace('\nWorks\n', '') |
|||
intro_text = intro_text.replace('\nOeuvres\n', '') |
|||
return header + '\n\n\n' + align(zone.upper(), 35) + '\n\n\n' + header + '\n' + header + intro_text |
|||
@ -0,0 +1,80 @@ |
|||
from functions import insert_linebreaks, insert_text_block, apply_zigzag, language |
|||
|
|||
def check_if_page_is_not_empty(string): |
|||
new_page = False |
|||
lines = string.split('\n') |
|||
print('... Checking if this page is not empty ...') |
|||
print(lines) |
|||
for line in lines: |
|||
if line.strip() != '': |
|||
new_page = True |
|||
print('>>> new_page:', new_page) |
|||
return new_page |
|||
|
|||
def create_stories_layout(stories_txt): |
|||
if language == 'en': |
|||
columnwidth = 50 |
|||
else: |
|||
columnwidth = 48 |
|||
|
|||
stories = insert_linebreaks(stories_txt, 50, type='word') |
|||
stories_lines = stories.split('\n') |
|||
|
|||
# insert empty lines for header space |
|||
column_count = 0 |
|||
lines = '' |
|||
line_number = 1 |
|||
for line in stories_lines: |
|||
if line_number % 69 == 0: |
|||
lines += '\n' * 5 |
|||
line_number += 5 |
|||
lines += line + '\n' |
|||
line_number += 1 |
|||
column_count += 1 |
|||
else: |
|||
lines += line + '\n' |
|||
line_number += 1 |
|||
|
|||
# make zigzag columns |
|||
zigzag = apply_zigzag(lines, 5) |
|||
zigzag_lines = zigzag.split('\n') |
|||
|
|||
# make two-column page(s) |
|||
count = 1 |
|||
pages = '' |
|||
current_page_first_column = '' |
|||
current_page_second_column = '' |
|||
for i, line in enumerate(zigzag_lines): |
|||
if count < 68: |
|||
current_page_first_column += line + '\n' |
|||
count += 1 |
|||
elif count < 69: |
|||
current_page_first_column += line |
|||
count += 1 |
|||
elif count < 137: |
|||
current_page_second_column += line + '\n' |
|||
count += 1 |
|||
elif count < 138: |
|||
current_page_second_column += line |
|||
count += 1 |
|||
else: |
|||
print('>>> length first column:', len(current_page_first_column.split('\n'))) |
|||
print('>>> length second column:', len(current_page_second_column.split('\n'))) |
|||
current_page_two_columns = insert_text_block(current_page_first_column, current_page_second_column, 56, 0) |
|||
pages += current_page_two_columns + '\n' |
|||
print('--> Page added to this stories page, with length:', len(current_page_two_columns.split('\n'))) |
|||
current_page_first_column = line + '\n' |
|||
current_page_second_column = '' |
|||
count = 1 |
|||
|
|||
# Check if the current line is the very last one |
|||
# if so, append a new page |
|||
if i + 1 == len(zigzag_lines): |
|||
print('... Ready to add a stories page, with length:', len(current_page_first_column.split('\n'))) |
|||
new_page = check_if_page_is_not_empty(current_page_first_column) |
|||
if new_page == True: |
|||
current_page_two_columns = insert_text_block(current_page_first_column, current_page_second_column, 56, 48) |
|||
pages += current_page_two_columns + '\n' |
|||
print('--> Page added to this stories page, with length:', len(current_page_two_columns.split('\n'))) |
|||
|
|||
return pages |
|||
@ -0,0 +1,6 @@ |
|||
|
|||
from functions import insert_linebreaks, insert_text_block |
|||
|
|||
def create_works_text_block(intro_text, works_text): |
|||
works_text_block = insert_linebreaks(works_text, 65, type='word') |
|||
return insert_text_block(intro_text, works_text_block, 42, 65) |
|||
@ -0,0 +1,147 @@ |
|||
|
|||
import random, math |
|||
from functions import insert_linebreaks, insert_text_block, convert_to_figlet_font, insert_symbol_background |
|||
|
|||
zones = { |
|||
'en' : { |
|||
'writers' : { |
|||
'subjects' : ['data workers', 'many authors', 'every human being who has access to the internet', 'we', 'we', 'we', 'some neural networks', 'human editors', 'poets, playwrights or novelists'], |
|||
'actions' : ['work', 'write', 'interacts', 'chat, write, click, like and share', 'leave our data', 'find ourselves writing in Python', 'write', 'assist', 'assist'], |
|||
'verb' : 'write' |
|||
}, |
|||
'oracles' : { |
|||
'subjects' : ['machine learning', 'models', 'models', 'they', 'they', 'information extraction', 'text classification'], |
|||
'actions' : ['analyses and predicts', 'have learned', 'are used', 'influence', 'have their say', 'recognizes', 'detects'], |
|||
'verb' : 'predict' |
|||
}, |
|||
'cleaners' : { |
|||
'subjects' : ['we', 'we', 'human work', 'poorly-paid freelancers', 'volunteers', 'whoever'], |
|||
'actions' : ['helped', 'cleaned', 'is needed', 'carry out', 'do fantastic work', 'cleans up text'], |
|||
'verb' : 'clean' |
|||
}, |
|||
'informants' : { |
|||
'subjects' : ['each dataset', 'datasets', 'some datasets', 'models that require supervision', 'models', 'some of the datasets', 'humans'], |
|||
'actions' : ['collects different information about the world', 'are imbued with collector\'s bias', 'combine machinic logic with human logic', 'multiply the subjectivities', 'propagate what they\'ve been taught', 'pass as default in the machine learning field', 'guide machines'], |
|||
'verb' : 'inform' |
|||
}, |
|||
'readers' : { |
|||
'subjects' : ['a computer', 'all models', 'some models', 'some models'], |
|||
'actions' : ['understands', 'translate', 'count', 'replace'], |
|||
'verb' : 'read' |
|||
}, |
|||
'learners' : { |
|||
'subjects' : ['learners', 'learners', 'learners', 'classifiers', 'learners', 'learners'], |
|||
'actions' : ['are pattern finders', 'are crawling through data', 'generate some kind of specific \'grammar\'', 'generate, evaluate and readjust', 'understand and reveal patterns', 'don\'t always distuinguish well which patterns should be repeated'], |
|||
'verb' : 'learn' |
|||
} |
|||
}, |
|||
'fr' : { |
|||
'écrivains' : { |
|||
'subjects' : ['data workers', 'many authors', 'every human being who has access to the internet', 'we', 'we', 'we', 'some neural networks', 'human editors', 'poets, playwrights or novelists'], |
|||
'actions' : ['work', 'write', 'interacts', 'chat, write, click, like and share', 'leave our data', 'find ourselves writing in Python', 'write', 'assist', 'assist'], |
|||
'subject' : 'writers', |
|||
'verb' : 'write' |
|||
}, |
|||
'oracles' : { |
|||
'subjects' : ['machine learning', 'models', 'models', 'they', 'they', 'information extraction', 'text classification'], |
|||
'actions' : ['analyses and predicts', 'have learned', 'are used', 'influence', 'have their say', 'recognizes', 'detects'], |
|||
'subject' : 'oracles', |
|||
'verb' : 'predict' |
|||
}, |
|||
'nettoyeurs' : { |
|||
'subjects' : ['we', 'we', 'human work', 'poorly-paid freelancers', 'volunteers', 'whoever'], |
|||
'actions' : ['helped', 'cleaned', 'is needed', 'carry out', 'do fantastic work', 'cleans up text'], |
|||
'subject' : 'cleaners', |
|||
'verb' : 'clean' |
|||
}, |
|||
'informateurs' : { |
|||
'subjects' : ['each dataset', 'datasets', 'some datasets', 'models that require supervision', 'models', 'some of the datasets', 'humans'], |
|||
'actions' : ['collects different information about the world', 'are imbued with collector\'s bias', 'combine machinic logic with human logic', 'multiply the subjectivities', 'propagate what they\'ve been taught', 'pass as default in the machine learning field', 'guide machines'], |
|||
'subject' : 'informants', |
|||
'verb' : 'inform' |
|||
}, |
|||
'lecteurs' : { |
|||
'subjects' : ['a computer', 'all models', 'some models', 'some models'], |
|||
'actions' : ['understands', 'translate', 'count', 'replace'], |
|||
'subject' : 'readers', |
|||
'verb' : 'read' |
|||
}, |
|||
'apprenants' : { |
|||
'subjects' : ['learners', 'learners', 'learners', 'classifiers', 'learners', 'learners'], |
|||
'actions' : ['are pattern finders', 'are crawling through data', 'generate some kind of specific \'grammar\'', 'generate, evaluate and readjust', 'understand and reveal patterns', 'don\'t always distuinguish well which patterns should be repeated'], |
|||
'subject' : 'learners', |
|||
'verb' : 'learn' |
|||
} |
|||
} |
|||
} |
|||
|
|||
def create_zone_backcover(zone, language, symbols): |
|||
print('... Creating zone_backcover') |
|||
|
|||
symbols = symbols.replace('\n', '') |
|||
|
|||
if language == 'fr': |
|||
zone = zones[language][zone.lower()]['subject'] |
|||
language = 'en' |
|||
|
|||
subjects = zones[language][zone.lower()]['subjects'] |
|||
actions = zones[language][zone.lower()]['actions'] |
|||
subject_figlets = [convert_to_figlet_font(subject, 18, font='digital', alignment='right') for subject in subjects] |
|||
action_figlets = [convert_to_figlet_font(action, 18, font='digital', alignment='left') for action in actions] |
|||
|
|||
# Sync the left and right column |
|||
# Count the length of the lines for each subject and action |
|||
subjects_num_of_lines = [int(len(subject.split('\n')) / 3) for subject in subject_figlets] |
|||
actions_num_of_lines = [int(len(action.split('\n')) / 3) for action in action_figlets] |
|||
|
|||
# Apply the counting, append extra lines |
|||
subjects_string = '' |
|||
for s, subject in enumerate(subjects): |
|||
if actions_num_of_lines[s] == 1: |
|||
actions_num_of_lines[s] = 0 |
|||
subjects_string += subject_figlets[s] + ('\n\n\n' * (actions_num_of_lines[s] - 1)) |
|||
# print('subject', actions_num_of_lines[s], subject) |
|||
actions_string = '' |
|||
for a, action in enumerate(actions): |
|||
if subjects_num_of_lines[a] == 1: |
|||
subjects_num_of_lines[a] = 0 |
|||
actions_string += ('\n\n\n' * (subjects_num_of_lines[a] - 1)) + action_figlets[a] |
|||
# print(' action', subjects_num_of_lines[a], action) |
|||
|
|||
left = insert_linebreaks(subjects_string, 56, type='wrap') |
|||
right = insert_linebreaks(actions_string, 56, type='wrap') |
|||
two_columns = insert_text_block(left, right, 57, 55) |
|||
|
|||
page = '' |
|||
|
|||
# Append the header |
|||
subject_left = convert_to_figlet_font(zone.lower(), 18, font='digital', alignment='right')+'\n' |
|||
subject_left = insert_linebreaks(subject_left, 56, type='wrap') |
|||
action_right = convert_to_figlet_font(zones[language][zone.lower()]['verb'], 18, font='digital', alignment='left')+'\n' |
|||
action_right = insert_linebreaks(action_right, 56, type='wrap') |
|||
page += insert_text_block(subject_left, action_right, 57, 55) |
|||
page += '\n' |
|||
|
|||
# Insert the two columns |
|||
page += two_columns + '\n' |
|||
|
|||
# Fill the remaining empty lines on the page |
|||
current_page_lines = len(page.split('\n')) |
|||
if current_page_lines < 70: |
|||
for x in range(current_page_lines, 69): |
|||
print(x) |
|||
for y in range(1, 110): |
|||
print(y) |
|||
page += ' ' |
|||
page += '\n' |
|||
|
|||
# Apply symbols background |
|||
multiplier = 500 |
|||
page = insert_symbol_background(page, 110, symbols, multiplier) |
|||
print('>>> current_page_lines:', len(page.split('\n'))) |
|||
|
|||
return page |
|||
|
|||
# print(create_zone_backcover('writers')) |
|||
|
|||
|
|||
@ -0,0 +1,579 @@ |
|||
<!DOCTYPE html> |
|||
|
|||
<html> |
|||
<head> |
|||
<meta charset="utf-8"/> |
|||
<title>Data Workers</title> |
|||
<!-- <link rel="stylesheet" href="stylesheet.css"> --> |
|||
</head> |
|||
<body> |
|||
<section class="language en"><p><br/> |
|||
Data Workers, an exhibition at the <a class="external text" href="http://www.mundaneum.org/en" rel="nofollow">Mundaneum</a> in Mons from 28 March until 29 April 2019. |
|||
</p><p>The <b>opening</b> is on <b>Thursday 28 March from 18:00 until 22:00</b>. As part of the exhibition, we have invited <b><a class="external text" href="https://www.decontextualize.com/" rel="nofollow">Allison Parrish</a></b>, an algoliterary poet from New York. She will give a <b>talk</b> in <a class="external text" href="https://www.passaporta.be/en" rel="nofollow">Passa Porta</a> on Thursday evening 25 April and a <b>workshop</b> in the Mundaneum on Friday 26 April. |
|||
</p> |
|||
<h2 id="about"><span class="mw-headline" id="About">About</span></h2> |
|||
<p>Data Workers is an <b>exhibition of algoliterary works</b>, of stories told from an ‘algorithmic storyteller point of view’. The exhibition was created by members of Algolit, a group from Brussels involved in artistic research on algorithms and literature. Every month they gather to experiment with F/LOSS code and texts. Some works are by students of Arts² and external participants to the workshop on machine learning and text organized by Algolit in October 2018 at the Mundaneum. |
|||
</p><p>Companies create <b>artificial intelligence (AI) systems</b> to serve, entertain, record and learn about humans. The work of these machinic entities is usually hidden behind interfaces and patents. In the exhibition, algorithmic storytellers leave their invisible underworld to become interlocutors. The data workers operate in different <b>collectives</b>. Each collective represents a stage in the design process of a machine learning model: there are the Writers, the Cleaners, the Informants, the Readers, the Learners and the Oracles. The boundaries between these collectives are not fixed; they are porous and permeable. At times, Oracles are also Writers. At other times Readers are also Oracles. Robots voice experimental literature, while algorithmic models read data, turn words into numbers, make calculations that define patterns and are able to endlessly process new texts ever after. |
|||
</p><p>The exhibition <b>foregrounds data workers</b> who impact our daily lives, but are either hard to grasp and imagine or removed from the imagination altogether. It connects stories about algorithms in mainstream media to the storytelling that is found in technical manuals and academic papers. Robots are invited to engage in dialogue with human visitors and vice versa. In this way we might understand our respective reasonings, demystify each other's behaviour, encounter multiple personalities, and value our collective labour. It is also a tribute to the many machines that <a class="external text" href="https://en.wikipedia.org/wiki/Paul_Otlet" rel="nofollow">Paul Otlet</a> and <a class="external text" href="https://en.wikipedia.org/wiki/Henri_La_Fontaine" rel="nofollow">Henri La Fontaine</a> imagined for their Mundaneum, showing their potential but also their limits. |
|||
</p> |
|||
<section class="group"><section class="lemma contextual-stories-about-algolit stories"><h3 class="lemmaheader" id="contextual-stories-about-algolit">Contextual stories about Algolit</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Why_contextual_stories.3F"><span class="tocnumber">1</span> <span class="toctext">Why contextual stories?</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#We_create_.27algoliterary.27_works"><span class="tocnumber">2</span> <span class="toctext">We create 'algoliterary' works</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#What_is_literature.3F"><span class="tocnumber">3</span> <span class="toctext">What is literature?</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#An_important_difference"><span class="tocnumber">4</span> <span class="toctext">An important difference</span></a></li> |
|||
</ul> |
|||
</div><h2 id="why-contextual-stories"><span class="mw-headline" id="Why_contextual_stories.3F">Why contextual stories?</span></h2><p>During the monthly meetings of Algolit, we study manuals and experiment with machine learning tools for text processing. And we also share many, many stories. With the publication of these stories we hope to recreate some of that atmosphere. The stories also exist as a podcast that can be downloaded from <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a>. |
|||
</p><p>For outsiders, algorithms only become visible in the media when they achieve an outstanding performance, like Alpha Go, or when they break down in fantastically terrifying ways. Humans working in the field though, create their own culture on and offline. They share the best stories and experiences during live meetings, research conferences and annual competitions like <a class="external text" href="https://www.kaggle.com/" rel="nofollow">Kaggle</a>. These stories that contextualize the tools and practices can be funny, sad, shocking, interesting. |
|||
</p><p>A lot of them are experiential learning cases. The implementations of algorithms in society generate new conditions of labour, storage, exchange, behaviour, copy and paste. In that sense, the contextual stories capture a momentum in a larger anthropo-machinic story that is being written at full speed and by many voices. |
|||
</p><h2 id="we-create-algoliterary-works"><span class="mw-headline" id="We_create_.27algoliterary.27_works">We create 'algoliterary' works</span></h2><p>The term 'algoliterary' comes from the name of our research group Algolit. We have existed since 2012 as a project of <a class="external text" href="http://constantvzw.org" rel="nofollow">Constant</a>, a Brussels-based organization for media and the arts. We are artists, writers, designers and programmers. Once a month we meet to study and experiment together. Our work can be copied, studied, changed, and redistributed under the same free license. You can find all the information on: <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a>. |
|||
</p><p>The main goal of Algolit is to explore the viewpoint of the algorithmic storyteller. What new forms of storytelling do we make possible in dialogue with these machinic agencies? Narrative viewpoints are inherent to world views and ideologies. Don Quixote, for example, was written from an omniscient third-person point of view, showing Cervantes’ relation to oral traditions. Most contemporary novels use the first-person point of view. Algolit is interested in speaking through algorithms, and in showing you the reasoning underlying one of the most hidden groups on our planet. |
|||
</p><p>To write in or through code is to create new forms of literature that are shaping human language in unexpected ways. But machine Learning techniques are only accessible to those who can read, write and execute code. Fiction is a way of bridging the gap between the stories that exist in scientific papers and technical manuals, and the stories spread by the media, often limited to superficial reporting and myth-making. By creating algoliterary works, we offer humans an introduction to techniques that co-shape their daily lives. |
|||
</p><h2 id="what-is-literature"><span class="mw-headline" id="What_is_literature.3F">What is literature?</span></h2><p>Algolit understands the notion of literature in the way a lot of other experimental authors do: it includes all linguistic production, from the dictionary to the Bible, from Virginia Woolf's entire work to all versions of the Terms of Service published by Google since its existence. In this sense, programming code can also be literature. |
|||
</p><p>The collective <a class="external text" href="https://www.oulipo.net/" rel="nofollow">Oulipo</a> is a great source of inspiration for Algolit. Oulipo stands for Ouvroir de litterature potentielle (Workspace for Potential Literature). Oulipo was created in Paris by the French writers <a class="external text" href="https://en.wikipedia.org/wiki/Raymond_Queneau" rel="nofollow">Raymond Queneau</a> and <a class="external text" href="https://en.wikipedia.org/wiki/Fran%C3%A7ois_Le_Lionnais" rel="nofollow">François Le Lionnais</a>. They rooted their practice in the European avant-garde of the twentieth century and in the experimental tradition of the 1960s. |
|||
</p><p>For Oulipo, the creation of rules becomes the condition to generate new texts, or what they call potential literature. Later, in 1981, they also created <a class="external text" href="http://www.alamo.free.fr/" rel="nofollow">ALAMO</a>, Atelier de littérature assistée par la mathématique et les ordinateurs (Workspace for literature assisted by maths and computers). |
|||
</p><h2 id="an-important-difference"><span class="mw-headline" id="An_important_difference">An important difference</span></h2><p>While the European avant-garde of the twentieth century pursued the objective of breaking with conventions, members of Algolit seek to make conventions visible. |
|||
</p><p>'I write: I live in my paper, I invest it, I walk through it.' (Espèces d'espaces. Journal d'un usager de l'espace, Galilée, Paris, 1974) |
|||
</p><p>This quote from <a class="external text" href="https://en.wikipedia.org/wiki/Georges_Perec" rel="nofollow">Georges Perec</a> in Espèces d'espaces could be taken up by Algolit. We're not talking about the conventions of the blank page and the literary market, as Georges Perec was. We're referring to the conventions that often remain hidden behind interfaces and patents. How are technologies made, implemented and used, as much in academia as in business infrastructures? |
|||
</p><p>We propose stories that reveal the complex hybridized system that makes machine learning possible. We talk about the tools, the logics and the ideologies behind the interfaces. We also look at who produces the tools, who implements them, and who creates and accesses the large amounts of data needed to develop prediction machines. One could say, with the wink of an eye, that we are collaborators of this new tribe of human-robot hybrids. |
|||
</p></section></section> |
|||
<hr/> |
|||
<p><b>Data Workers</b> was created by Algolit. |
|||
</p><p><b>Works by</b>: Cristina Cochior, Gijs de Heij, Sarah Garcin, An Mertens, Javier Lloret, Louise Dekeuleneer, Florian Van de Weyer, Laetitia Trozzi, Rémi Forte, Guillaume Slizewicz, Michael Murtaugh, Manetta Berends, Mia Melvær. |
|||
</p><p><b>Co-produced by</b>: <a class="external text" href="http://blog.artsaucarre.be/artsnumeriques/" rel="nofollow">Arts²</a>, <a class="external text" href="http://constantvzw.org" rel="nofollow">Constant</a> and <a class="external text" href="http://expositions.mundaneum.org/en/expositions/data-workers" rel="nofollow">Mundaneum</a>. |
|||
</p><p><b>With the support of</b>: <a class="external text" href="http://www.arts-numeriques.culture.be/" rel="nofollow">Wallonia-Brussels Federation/Digital Arts</a>, <a class="external text" href="https://www.passaporta.be/en" rel="nofollow">Passa Porta</a>, UGent, <a class="external text" href="https://www.uantwerpen.be/en/faculties/faculty-of-arts/research-and-valoris/research-axes/digital-humanities/" rel="nofollow">DHuF - Digital Humanities Flanders</a> and <a class="external text" href="https://www.pgdp.net/c/" rel="nofollow">Distributed Proofreaders Project</a>. |
|||
</p><p><b>Thanks to</b>: Mike Kestemont, Michel Cleempoel, Donatella Portoghese, François Zajéga, Raphaèle Cornille, Vincent Desfromont, Kris Rutten, Anne-Laure Buisson, David Stampfli. |
|||
</p> |
|||
<h2 id="at-the-mundaneum"><span class="mw-headline" id="At_the_Mundaneum">At the Mundaneum</span></h2> |
|||
<p>In the late nineteenth century two young Belgian jurists, <a class="external text" href="https://en.wikipedia.org/wiki/Paul_Otlet" rel="nofollow">Paul Otlet</a> (1868–1944), the 'father of documentation’, and <a class="external text" href="https://en.wikipedia.org/wiki/Henri_La_Fontaine" rel="nofollow">Henri La Fontaine</a> (1854-1943), statesman and Nobel Peace Prize winner, created the Mundaneum. The project aimed to gather all the world’s knowledge and to file it using the <a class="external text" href="https://en.wikipedia.org/wiki/Universal_Decimal_Classification" rel="nofollow">Universal Decimal Classification (UDC) system</a> that they had invented. At first it was an International Institutions Bureau dedicated to international knowledge exchange. In the twentieth century the <a class="external text" href="https://en.wikipedia.org/wiki/Mundaneum" rel="nofollow">Mundaneum</a> became a universal centre of documentation. Its collections are made up of thousands of books, newspapers, journals, documents, posters, glass plates and postcards indexed on millions of cross-referenced cards. The collections were exhibited and kept in various buildings in Brussels, including the <a class="external text" href="https://en.wikipedia.org/wiki/Cinquantenaire" rel="nofollow">Palais du Cinquantenaire</a>. The remains of the archive only moved to Mons in 1998. |
|||
</p><p>Based on the Mundaneum, the two men designed a World City for which <a class="external text" href="https://en.wikipedia.org/wiki/Le_Corbusier" rel="nofollow">Le Corbusier</a> made scale models and plans. The aim of the World City was to gather, at a global level, the institutions of knowledge: libraries, museums and universities. This project was never realized. It suffered from its own utopia. The Mundaneum is the result of a visionary dream of what an infrastructure for universal knowledge exchange could be. It attained mythical dimensions at the time. When looking at the concrete archive that was developed, that collection is rather eclectic and specific. |
|||
</p><p>Artificial intelligence systems today come with their own dreams of universality and knowledge production. When reading about these systems, the visionary dreams of their makers were there from the beginning of their development in the 1950s. Nowadays, their promise has also attained mythical dimensions. When looking at their concrete applications, the collection of tools is truly innovative and fascinating, but at the same time, rather eclectic and specific. For Data Workers, Algolit combined some of the applications with 10 per cent of the digitized publications of the International Institutions Bureau. In this way, we hope to poetically open up a discussion about machines, algorithms, and technological infrastructures. |
|||
</p> |
|||
<h2 id="zones"><span class="mw-headline" id="Zones">Zones</span></h2> |
|||
<h3 id="writers"><span class="mw-headline" id="Writers">Writers</span></h3> |
|||
<p>Data workers need data to work with. The data that used in the context of Algolit is written language. Machine learning relies on many types of writing. Many authors write in the form of publications, such as books or articles. These are part of organized archives and are sometimes digitized. But there are other kinds of writing too. We could say that every human being who has access to the Internet is a writer each time they interact with algorithms. We chat, write, click, like and share. In return for free services, we leave our data that is compiled into profiles and sold for advertising and research purposes. |
|||
</p><p>Machine learning algorithms are not critics: they take whatever they're given, no matter the writing style, no matter the CV of the author, no matter the spelling mistakes. In fact, mistakes make it better: the more variety, the better they learn to anticipate unexpected text. But often, human authors are not aware of what happens to their work. |
|||
</p><p>Most of the writing we use is in English, some in French, some in Dutch. Most often we find ourselves writing in Python, the programming language we use. Algorithms can be writers too. Some neural networks write their own rules and generate their own texts. And for the models that are still wrestling with the ambiguities of natural language, there are human editors to assist them. Poets, playwrights or novelists start their new careers as assistants of AI. |
|||
</p> |
|||
<h5 id="works"><span class="mw-headline" id="Works">Works</span></h5> |
|||
<section class="group"><section class="lemma data-workers-publication works"><h3 class="lemmaheader" id="data-workers-publication">Data Workers Publication</h3><p>By Algolit |
|||
</p><p>All works visible in the exhibition, as well as the contextual stories and some extra text material have been collected in a publication, which exists in French and English. |
|||
</p><p>This publication is made using a plain text workflow, based on various text processing and counting tools. The plain text file format is a type of document in which there is no inherent structural difference between headers and paragraphs anymore. It is the most used type of document in machine learning models for text. This format has been the starting point of a playful design process, where pages are carefully counted, page by page, line by line and character by character. |
|||
</p><p>Each page holds 110 characters per line and 70 lines per page. The design originates from the act of counting words, spaces and lines. It plays with random choices, scripted patterns and ASCII/UNICODE-fonts, to speculate about the materiality of digital text and to explore the interrelations between counting and writing through words and numbers. |
|||
</p><hr/><p><b>Texts</b>: Cristina Cochior, Sarah Garcin, Gijs de Heij, An Mertens, François Zajéga, Louise Dekeuleneer, Florian Van de Weyer, Laetitia Trozzi, Rémi Forte, Guillaume Slizewicz. |
|||
</p><p><b>Translations & proofreading</b>: deepl.com, Michel Cleempoel, Elodie Mugrefya, Emma Kraak, Patrick Lennon. |
|||
</p><p><b>Lay-out & cover</b>: Manetta Berends |
|||
</p><p><b>Responsible publisher</b>: Constant vzw/asbl, Rue du Fortstraat 5, 1060 Brussels |
|||
</p><p><b>License</b>: Algolit, Data Workers, March 2019, Brussels. Copyleft: This is a free work, you can copy, distribute, and modify it under the terms of the Free Art License <a class="external free" href="http://artlibre.org/licence/lal/en/" rel="nofollow">http://artlibre.org/licence/lal/en/</a>. |
|||
</p><p><b>Online version</b>: <a class="external free" href="http://www.algolit.net/index.php/Data_Workers" rel="nofollow">http://www.algolit.net/index.php/Data_Workers</a> |
|||
</p><p><b>Sources</b>: <a class="external free" href="https://gitlab.constantvzw.org/algolit/mundaneum" rel="nofollow">https://gitlab.constantvzw.org/algolit/mundaneum</a> |
|||
</p></section><section class="lemma data-workers-podcast works"><h3 class="lemmaheader" id="data-workers-podcast">Data Workers Podcast</h3><p>By Algolit |
|||
</p><p>During our monthly Algolit meetings, we study manuals and experiment with machine learning tools for text processing. And we also share many, many stories. With this podcast we hope to recreate some of that atmosphere. |
|||
</p><p>For outsiders, algorithms only become visible in the media when they achieve an outstanding performance, like Alpha Go, or when they break down in fantastically terrifying ways. Humans working in the field though, create their own culture on and offline. They share the best stories and experiences during live meetings, research conferences and annual competitions like Kaggle. These stories that contextualize the tools and practises can be funny, sad, shocking, interesting. |
|||
</p><p>A lot of them are experiential learning cases. The implementations of algorithms in society generate new conditions of labour, storage, exchange, behaviour, copy and paste. In that sense, the contextual stories capture a momentum in a larger anthropo-machinic story that is being written at full speed and by many voices. The stories are also published in the publication of Data Workers. |
|||
</p><hr/><p><b>Voices</b>: David Stampfli, Cristina Cochior, An Mertens, Gijs de Heij, Karin Ulmer, Guillaume Slizewicz |
|||
</p><p><b>Editing</b>: Javier Lloret |
|||
</p><p><b>Recording</b>: David Stampfli |
|||
</p><p><b>Texts</b>: Cristina Cochior, An Mertens |
|||
</p></section><section class="lemma markbot-chains works"><h3 class="lemmaheader" id="markbot-chains">Markbot Chains</h3><p>By Florian Van de Weyer, student Arts²/Section Digital Arts |
|||
</p><p>Markbot Chain is a social experiment in which the public has a direct influence on the result. The intention is to integrate responses in a text-generation process without applying any filter. |
|||
</p><p>All the questions in the digital files provided by the Mundaneum were automatically extracted. These questions are randomly put to the public via a terminal. By answering them, people contribute to another database. Each entry generates a series of sentences using a Markov chain configuration, an algorithm that is widely used in spam generation. The sentences generated in this way are displayed in the window, and a new question is asked. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma contextual-stories-about-writers stories"><h3 class="lemmaheader" id="contextual-stories-about-writers">Contextual stories about Writers</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Programmers_are_writing_the_dataworkers_into_being"><span class="tocnumber">1</span> <span class="toctext">Programmers are writing the dataworkers into being</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#Cortana_speaks"><span class="tocnumber">2</span> <span class="toctext">Cortana speaks</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Open-source_learning"><span class="tocnumber">3</span> <span class="toctext">Open-source learning</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#Natural_language_for_artificial_intelligence"><span class="tocnumber">4</span> <span class="toctext">Natural language for artificial intelligence</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-5"><a href="#References"><span class="tocnumber">4.1</span> <span class="toctext">References</span></a></li> |
|||
</ul> |
|||
</li> |
|||
</ul> |
|||
</div><h2 id="programmers-are-writing-the-dataworkers-into-being"><span class="mw-headline" id="Programmers_are_writing_the_dataworkers_into_being">Programmers are writing the dataworkers into being</span></h2><p>We recently had a funny realization: most programmers of the languages and packages that Algolit uses are European. |
|||
</p><p><a class="external text" href="https://www.python.org/" rel="nofollow">Python</a>, for example, the main language that is globally used for Natural Language Processing (NLP), was invented in 1991 by the Dutch programmer <a class="external text" href="https://en.wikipedia.org/wiki/Guido_van_Rossum" rel="nofollow">Guido Van Rossum</a>. He then crossed the Atlantic and went from working for Google to working for Dropbox. |
|||
</p><p><a class="external text" href="https://sklearn.org/" rel="nofollow">Scikit Learn</a>, the open-source Swiss knife of machine learning tools, started as a Google Summer of Code project in Paris by French researcher <a class="external text" href="https://en.wikipedia.org/wiki/David_Cournapeau" rel="nofollow">David Cournapeau</a>. Afterwards, it was taken on by Matthieu Brucher as part of his thesis at the Sorbonne University in Paris. And in 2010, <a class="external text" href="http://www.inra.fr/en/" rel="nofollow">INRA</a>, the French National Institute for computer science and applied mathematics, adopted it. |
|||
</p><p><a class="external text" href="https://keras.io/" rel="nofollow">Keras</a>, an open-source neural network library written in Python, was developed by François Chollet, a French researcher who works on the Brain team at Google. |
|||
</p><p><a class="external text" href="https://radimrehurek.com/gensim/" rel="nofollow">Gensim</a>, an open-source library for Python used to create unsupervised semantic models from plain text, was written by <a class="external text" href="https://radimrehurek.com/about/" rel="nofollow">Radim Řehůřek</a>. He is a Czech computer scientist who runs a consulting business in Bristol, UK. |
|||
</p><p>And to finish up this small series, we also looked at <a class="external text" href="https://www.clips.uantwerpen.be/pattern" rel="nofollow">Pattern</a>, an often-used library for web-mining and machine learning. Pattern was developed and made open-source in 2012 by Tom De Smedt and Walter Daelemans. Both are researchers at <a class="external text" href="https://www.clips.uantwerpen.be" rel="nofollow">CLIPS</a>, the research centre for Computational Linguistics and Psycholinguistcs at the University of Antwerp. |
|||
</p><h2 id="cortana-speaks"><span class="mw-headline" id="Cortana_speaks">Cortana speaks</span></h2><p>AI assistants often need their own assistants: they are helped in their writing by humans who inject humour and wit into their machine-processed language. <a class="external text" href="https://www.microsoft.com/en-us/cortana/" rel="nofollow">Cortana</a> is an example of this type of blended writing. She is Microsoft’s digital assistant. Her mission is to help users to be more productive and creative. Cortana's personality has been crafted over the years. It's important that she maintains her character in all interactions with users. She is designed to engender trust and her behavior must always reflect that. |
|||
</p><p>The following guidelines are taken from <a class="external text" href="https://docs.microsoft.com/en-us/cortana/skills/cortanas-persona" rel="nofollow">Microsoft's website</a>. They describe how Cortana's style should be respected by companies that extend her service. Writers, programmers and novelists, who develop Cortana's responses, personality and branding have to follow these guidelines. Because the only way to maintain trust is through consistency. So when Cortana talks, you 'must use her personality'. |
|||
</p><p>What is Cortana's personality, you ask? |
|||
</p><p><br/> |
|||
'Cortana is considerate, sensitive, and supportive. |
|||
</p><p>She is sympathetic but turns quickly to solutions. |
|||
</p><p>She doesn't comment on the user’s personal information or behavior, particularly if the information is sensitive. |
|||
</p><p>She doesn't make assumptions about what the user wants, especially to upsell. |
|||
</p><p>She works for the user. She does not represent any company, service, or product. |
|||
</p><p>She doesn’t take credit or blame for things she didn’t do. |
|||
</p><p>She tells the truth about her capabilities and her limitations. |
|||
</p><p>She doesn’t assume your physical capabilities, gender, age, or any other defining characteristic. |
|||
</p><p>She doesn't assume she knows how the user feels about something. |
|||
</p><p>She is friendly but professional. |
|||
</p><p>She stays away from emojis in tasks. Period |
|||
</p><p>She doesn’t use culturally- or professionally-specific slang. |
|||
</p><p>She is not a support bot.' |
|||
</p><p><br/> |
|||
Humans intervene in detailed ways to programme answers to questions that Cortana receives. How should Cortana respond when she is being proposed inappropriate actions? Her gendered acting raises difficult questions about power relations within the world away from the keyboard, which is being mimicked by technology. |
|||
</p><p>Consider Cortana's answer to the question: |
|||
</p><p>- Cortana, who's your daddy? |
|||
- Technically speaking, he’s Bill Gates. No big deal. |
|||
</p><h2 id="open-source-learning"><span class="mw-headline" id="Open-source_learning">Open-source learning</span></h2><p>Copyright licenses close up a lot of the machinic writing, reading and learning practices. That means that they're only available for the employees of a specific company. Some companies participate in conferences worldwide and share their knowledge in papers online. But even if they share their code, they often will not share the large amounts of data needed to train the models. |
|||
</p><p>We were able to learn to machine learn, read and write in the context of Algolit, thanks to academic researchers who share their findings in papers or publish their code online. As artists, we believe it is important to share that attitude. That's why we document our meetings. We share the tools we make as much as possible and the texts we use are on our <a class="external text" href="https://gitlab.constantvzw.org/algolit" rel="nofollow">online repository</a> under free licenses. |
|||
</p><p>We are thrilled when our works are taken up by others, tweaked, customized and redistributed, so please feel free to copy and test the code from our website. If the sources of a particular project are not there, you can always contact us through the <a class="external text" href="https://tumulte.domainepublic.net/cgi-bin/mailman/listinfo/algolit" rel="nofollow">mailinglist</a>. You can find a link to our repository, etherpads and wiki at: <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a>. |
|||
</p><h2 id="natural-language-for-artificial-intelligence"><span class="mw-headline" id="Natural_language_for_artificial_intelligence">Natural language for artificial intelligence</span></h2><p>Natural Language Processing (NLP) is a collective term that refers to the automatic computational processing of human languages. This includes algorithms that take human-produced text as input, and attempt to generate text that resembles it. We produce more and more written work each year, and there is a growing trend in making computer interfaces to communicate with us in our own language. NLP is also very challenging, because human language is inherently ambiguous and ever-changing. |
|||
</p><p>But what is meant by 'natural' in NLP? Some would argue that language is a technology in itself. According to <a class="external text" href="https://en.wikipedia.org/wiki/Natural_language" rel="nofollow">Wikipedia</a>, 'a natural language or ordinary language is any language that has evolved naturally in humans through use and repetition without conscious planning or premeditation. Natural languages can take different forms, such as speech or signing. They are different from constructed and formal languages such as those used to program computers or to study logic. An official language with a regulating academy, such as Standard French with the French Academy, is classified as a natural language. Its prescriptive points do not make it constructed enough to be classified as a constructed language or controlled enough to be classified as a controlled natural language.' |
|||
</p><p>So in fact, 'natural languages' also includes languages which do not fit in any other group. NLP, instead, is a constructed practice. What we are looking at is the creation of a constructed language to classify natural languages that, by their very definition, resists categorization. |
|||
</p><h5 id="references"><span class="mw-headline" id="References">References</span></h5><p><a class="external free" href="https://hiphilangsci.net/2013/05/01/on-the-history-of-the-question-of-whether-natural-language-is-illogical/" rel="nofollow">https://hiphilangsci.net/2013/05/01/on-the-history-of-the-question-of-whether-natural-language-is-illogical/</a> |
|||
</p><p>Book: <i><a class="external text" href="https://www.morganclaypool.com/doi/abs/10.2200/S00762ED1V01Y201703HLT037" rel="nofollow">Neural Network Methods for Natural Language Processing</a></i>, Yoav Goldberg, Bar Ilan University, April 2017. |
|||
</p></section></section> |
|||
<h3 id="oracles"><span class="mw-headline" id="Oracles">Oracles</span></h3> |
|||
<p>Machine learning is mainly used to analyse and predict situations based on existing cases. In this exhibition we focus on machine learning models for text processing or Natural Language Processing (NLP). These models have learned to perform a specific task on the basis of existing texts. The models are used for search engines, machine translations and summaries, spotting trends in new media networks and news feeds. They influence what you get to see as a user, but also have their say in the course of stock exchanges worldwide, the detection of cybercrime and vandalism, etc. |
|||
</p><p>There are two main tasks when it comes to language understanding. Information extraction looks at concepts and relations between concepts. This allows for recognizing topics, places and persons in a text, summarization and questions & answering. The other task is text classification. You can train an oracle to detect whether an email is spam or not, written by a man or a woman, rather positive or negative. |
|||
</p><p>In this zone you can see some of those models at work. During your further journey through the exhibition you will discover the different steps that a human-machine goes through to come to a final model. |
|||
</p> |
|||
<h5 id="works"><span class="mw-headline" id="Works_2">Works</span></h5> |
|||
<section class="group"><section class="lemma the-algoliterator works"><h3 class="lemmaheader" id="the-algoliterator">The Algoliterator</h3><p>by Algolit |
|||
</p><p>The Algoliterator is a neural network trained using the selection of digitized works of the Mundaneum archive. |
|||
</p><p>With the Algoliterator you can write a text in the style of the International Institutions Bureau. The Algoliterator starts by selecting a sentence from the archive or corpus used to train it. You can then continue writing yourself or, at any time, ask the Algoliterator to suggest a next sentence: the network will generate three new fragments based on the texts it has read. You can control the level of training of the network and have it generate sentences based on primitive training, intermediate training or final training. |
|||
</p><p>When you're satisfied with your new text, you can print it on the thermal printer and take it home as a souvenir. |
|||
</p><hr/><p>Sources: <a class="external free" href="https://gitlab.constantvzw.org/algolit/algoliterator.clone" rel="nofollow">https://gitlab.constantvzw.org/algolit/algoliterator.clone</a> |
|||
</p><p>Concept, code & interface: Gijs de Heij & An Mertens |
|||
</p><p>Technique: Recurrent Neural Network |
|||
</p><p>Original model: Andrej Karphaty, Justin Johnson |
|||
</p></section><section class="lemma words-in-space works"><h3 class="lemmaheader" id="words-in-space">Words in Space</h3><p>by Algolit |
|||
</p><p>Word embeddings are language modelling techniques that through multiple mathematical operations of counting and ordering, plot words into a multi-dimensional vector space. When embedding words, they transform from being distinct symbols into mathematical objects that can be multiplied, divided, added or substracted. |
|||
</p><p>By distributing the words along the many diagonal lines of the multi-dimensional vector space, their new geometrical placements become impossible to perceive by humans. However, what is gained are multiple, simultaneous ways of ordering. Algebraic operations make the relations between vectors graspable again. |
|||
</p><p>This installation uses <a class="external text" href="https://radimrehurek.com/gensim/index.html" rel="nofollow">Gensim</a>, an open-source vector space and topic-modelling toolkit implemented in the programming language Python. It allows to manipulate the text using the mathematical relationships that emerge between the words, once they have been plotted in a vector space. |
|||
</p><hr/><p>Concept & interface: Cristina Cochior |
|||
</p><p>Technique: word embeddings, word2vec |
|||
</p><p>Original model: Radim Rehurek and Petr Sojka |
|||
</p></section><section class="lemma classifying-the-world works"><h3 class="lemmaheader" id="classifying-the-world">Classifying the World</h3><p>by Algolit |
|||
</p><p>Librarian Paul Otlet's life work was the construction of the Mundaneum. This mechanical collective brain would house and distribute everything ever committed to paper. Each document was classified following the <a class="external text" href="https://en.wikipedia.org/wiki/Universal_Decimal_Classification#Basic_features_and_syntax" rel="nofollow">Universal Decimal Classification</a>. Using telegraphs and especially, sorters, the Mundaneum would have been able to answer any question from anyone. |
|||
</p><p>With the collection of digitized publications we received from the Mundaneum, we built a prediction machine that tries to classify the sentence you type in one of the main categories of Universal Decimal Classification. You also witness how the machine 'thinks'. During the exhibition, this model is regularly retrained using the cleaned and annotated data visitors added in <a href="http://www.algolit.net/index.php/Cleaning_for_Poems" title="Cleaning for Poems">Cleaning for Poems</a> and <a href="http://www.algolit.net/index.php/The_Annotator" title="The Annotator">The Annotator</a>. |
|||
</p><p>The main classes of the Universal Decimal Classification system are: |
|||
</p><p>0 - Science and Knowledge. Organization. Computer Science. Information Science. Documentation. Librarianship. Institutions. Publications |
|||
</p><p>1 - Philosophy. Psychology |
|||
</p><p>2 - Religion. Theology |
|||
</p><p>3 - Social Sciences |
|||
</p><p>4 - <i>vacant</i> |
|||
</p><p>5 - Mathematics. Natural Sciences |
|||
</p><p>6 - Applied Sciences. Medicine, Technology |
|||
</p><p>7 - The Arts. Entertainment. Sport |
|||
</p><p>8 - Linguistics. Literature |
|||
</p><p>9 - Geography. History |
|||
</p><p>--- |
|||
</p><p>Concept, code, interface: Sarah Garcin, Gijs de Heij, An Mertens |
|||
</p></section><section class="lemma people-dont-have-buttons works"><h3 class="lemmaheader" id="people-dont-have-buttons">People don’t have buttons</h3><p>by Algolit |
|||
</p><p>Since the early days of artificial intelligence (AI), researchers have speculated about the possibility of computers thinking and communicating as humans. In the 1980s, there was a first revolution in Natural Language Processing (NLP), the subfield of AI concerned with linguistic interactions between computers and humans. Recently, pre-trained language models have reached state-of-the-art results on a wide range of NLP tasks, which intensifies again the expectations of a future with AI. |
|||
</p><p>This sound work, made out of audio fragments of scientific documentaries and AI-related audiovisual material from the last half century, explores the hopes, fears and frustrations provoked by these expectations. |
|||
</p><hr/><p><b>Concept, sound edit</b>: Javier Lloret |
|||
</p><p><b>List of sources</b>: |
|||
'The Machine that Changed the World : Episode IV -- The Thinking Machine', 'The Imitation Game', 'Maniac', 'Halt & Catch Fire', 'Ghost in the Shell', 'Computer Chess', '2001: A Space Odyssey', Ennio Morricone, Gijs Gieskes, André Castro. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma contextual-stories-about-oracles stories"><h3 class="lemmaheader" id="contextual-stories-about-oracles">Contextual stories about Oracles</h3><p><br/> |
|||
Oracles are prediction or profiling machines. They are widely used in smartphones, computers, tablets. |
|||
</p><p>Oracles can be created using different techniques. One way is to manually define rules for them. As prediction models they are then called rule-based models. Rule-based models are handy for tasks that are specific, like detecting when a scientific paper concerns a certain molecule. With very little sample data, they can perform well. |
|||
</p><p>But there are also the machine learning or statistical models, which can be divided in two oracles: 'supervised' and 'unsupervised' oracles. For the creation of supervised machine learning models, humans annotate sample text with labels before feeding it to a machine to learn. Each sentence, paragraph or text is judged by at least three annotators: whether it is spam or not spam, positive or negative etc. Unsupervised machine learning models don't need this step. But they need large amounts of data. And it is up to the machine to trace its own patterns or 'grammatical rules'. Finally, experts also make the difference between classical machine learning and neural networks. You'll find out more about this in the Readers zone. |
|||
</p><p>Humans tend to wrap Oracles in visions of grandeur. Sometimes these Oracles come to the surface when things break down. In press releases, these sometimes dramatic situations are called 'lessons'. However promising their performances seem to be, a lot of issues remain to be solved. How do we make sure that Oracles are fair, that every human can consult them, and that they are understandable to a large public? Even then, existential questions remain. Do we need all types of artificial intelligence (AI) systems? And who defines what is fair or unfair? |
|||
</p><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Racial_AdSense"><span class="tocnumber">1</span> <span class="toctext">Racial AdSense</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-2"><a href="#Reference"><span class="tocnumber">1.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#What_is_a_good_employee.3F"><span class="tocnumber">2</span> <span class="toctext">What is a good employee?</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-4"><a href="#Reference_2"><span class="tocnumber">2.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-5"><a href="#Quantifying_100_Years_of_Gender_and_Ethnic_Stereotypes"><span class="tocnumber">3</span> <span class="toctext">Quantifying 100 Years of Gender and Ethnic Stereotypes</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-6"><a href="#Reference_3"><span class="tocnumber">3.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-7"><a href="#Wikimedia.27s_Ores_service"><span class="tocnumber">4</span> <span class="toctext">Wikimedia's Ores service</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-8"><a href="#Reference_4"><span class="tocnumber">4.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-9"><a href="#Tay"><span class="tocnumber">5</span> <span class="toctext">Tay</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-10"><a href="#Reference_5"><span class="tocnumber">5.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
</ul> |
|||
</div><h2 id="racial-adsense"><span class="mw-headline" id="Racial_AdSense">Racial AdSense</span></h2><p>A classic 'lesson' in developing Oracles was documented by <a class="external text" href="http://www.latanyasweeney.org" rel="nofollow">Latanya Sweeney</a>, a professor of Government and Technology at Harvard University. In 2013, Sweeney, of African American descent, googled her name. She immediately received an advertisement for a service that offered her ‘to see the criminal record of Latanya Sweeney’. |
|||
</p><p>Sweeney, who doesn’t have a criminal record, began a study. She started to compare the advertising that Google AdSense serves to different racially identifiable names. She discovered that she received more of these ads searching for non-white ethnic names, than when searching for traditionally perceived white names.You can imagine how damaging it can be when possible employers do a simple name search and receive ads suggesting the existence of a criminal record. |
|||
</p><p>Sweeney based her research on queries of 2184 racially associated personal names across two websites. 88 per cent of first names, identified as being given to more black babies, are found predictive of race, against 96 per cent white. First names that are mainly given to black babies, such as DeShawn, Darnell and Jermaine, generated ads mentioning an arrest in 81 to 86 per cent of name searches on one website and in 92 to 95 per cent on the other. Names that are mainly assigned to whites, such as Geoffrey, Jill and Emma, did not generate the same results. The word 'arrest' only appeared in 23 to 29 per cent of white name searches on one site and 0 to 60 per cent on the other. |
|||
</p><p>On the website with most advertising, a black-identifying name was 25 percent more likely to get an ad suggestive of an arrest record. A few names did not follow these patterns: Dustin, a name mainly given to white babies, generated an ad suggestive of arrest in 81 and 100 percent of the time. It is important to keep in mind that the appearance of the ad is linked to the name itself. It is independent of the fact that the name has an arrest record in the company's database. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference">Reference</span></h5><p>Paper: <a class="external free" href="https://dataprivacylab.org/projects/onlineads/1071-1.pdf" rel="nofollow">https://dataprivacylab.org/projects/onlineads/1071-1.pdf</a> |
|||
</p><h2 id="what-is-a-good-employee"><span class="mw-headline" id="What_is_a_good_employee.3F">What is a good employee?</span></h2><p>Since 2015 Amazon employs around 575,000 workers. And they need more. Therefore, they set up a team of 12 that was asked to create a model to find the right candidates by crawling job application websites. The tool would give job candidates scores ranging from one to five stars. The potential fed the myth: the team wanted it to be a software that would spit out the top five human candidates out of a list of 100. And those candidates would be hired. |
|||
</p><p>The group created 500 computer models, focused on specific job functions and locations. They taught each model to recognize some 50,000 terms that showed up on past candidates’ letters. The algorithms learned to give little importance to skills common across IT applicants, like the ability to write various computer codes. But they also learned some decent errors. The company realized, before releasing, that the models had taught themselves that male candidates were preferable. They penalized applications that included the word 'women’s,' as in 'women’s chess club captain.' And they downgraded graduates of two all-women’s colleges. |
|||
</p><p>This is because they were trained using the job applications that Amazon received over a ten-year period. During that time, the company had mostly hired men. Instead of providing the 'fair' decision-making that the Amazon team had promised, the models reflected a biased tendency in the tech industry. And they also amplified it and made it invisible. Activists and critics state that it could be exceedingly difficult to sue an employer over automated hiring: job candidates might never know that intelligent software was used in the process. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference_2">Reference</span></h5><p><a class="external free" href="https://www.reuters.com/article/us-amazon-com-jobs-automation-insight/amazonscraps-secret-ai-recruiting-tool-that-showed-bias-against-women-idUSKCN1MK08G" rel="nofollow">https://www.reuters.com/article/us-amazon-com-jobs-automation-insight/amazonscraps-secret-ai-recruiting-tool-that-showed-bias-against-women-idUSKCN1MK08G</a> |
|||
</p><h2 id="quantifying-100-years-of-gender-and-ethnic-stereotypes"><span class="mw-headline" id="Quantifying_100_Years_of_Gender_and_Ethnic_Stereotypes">Quantifying 100 Years of Gender and Ethnic Stereotypes</span></h2><p><a class="external text" href="https://web.stanford.edu/~jurafsky/" rel="nofollow">Dan Jurafsky</a> is the co-author of '<a class="external text" href="https://web.stanford.edu/~jurafsky/slp3/ed3book.pdf" rel="nofollow"><b>Speech and Language Processing</b></a>', one of the most influential books for studying Natural Language Processing (NLP). Together with a few colleagues at Stanford University, he discovered in 2017 that word embeddings can be a powerful tool to systematically quantify common stereotypes and other historical trends. |
|||
</p><p>Word embeddings are a technique that translates words to numbered vectors in a multi-dimensional space. Vectors that appear next to each other, indicate similar meaning. All numbers will be grouped together, as well as all prepositions, person's names, professions. This allows for the calculation of words. You could substract London from England and your result would be the same as substracting Paris from France. |
|||
</p><p>An example in their research shows that the vector for the adjective 'honorable' is closer to the vector for 'man', whereas the vector for 'submissive' is closer to 'woman'. These stereotypes are automatically learned by the algorithm. It will be problematic when the pre-trained embeddings are then used for sensitive applications such as search rankings, product recommendations, or translations. This risk is real, because a lot of the pretrained embeddings can be downloaded as off-the-shelf-packages. |
|||
</p><p>It is known that language reflects and keeps cultural stereotypes alive. Using word embeddings to spot these stereotypes is less time-consuming and less expensive than manual methods. But the implementation of these embeddings for concrete prediction models, has caused a lot of discussion within the machine learning community. The biased models stand for automatic discrimination. Questions are: is it actually possible to de-bias these models completely? Some say yes, while others disagree: instead of retro-engineering the model, we should ask whether we need it in the first place. These researchers followed a third path: by acknowledging the bias that originates in language, these tools become tools of awareness. |
|||
</p><p>The team developed a model to analyse word embeddings trained over 100 years of texts. For contemporary analysis, they used the standard Google News word2vec Vectors, a straight-off-the-shelf downloadable package trained on the Google News Dataset. For historical analysis, they used embeddings that were trained on Google Books and the Corpus of Historical American English (COHA <a class="external free" href="https://corpus.byu.edu/coha/" rel="nofollow">https://corpus.byu.edu/coha/</a>) with more than 400 million words of text from the 1810s to 2000s. As a validation set to test the model, they trained embeddings from the New York Times Annotated Corpus for every year between 1988 and 2005. |
|||
</p><p>The research shows that word embeddings capture changes in gender and ethnic stereotypes over time. They quantifiy how specific biases decrease over time while other stereotypes increase. The major transitions reveal changes in the descriptions of gender and ethnic groups during the women’s movement in the 1960-1970s and the Asian-American population growth in the 1960s and 1980s. |
|||
</p><p>A few examples: |
|||
</p><p>The top ten occupations most closely associated with each ethnic group in the contemporary Google News dataset: |
|||
</p><p>- Hispanic: housekeeper, mason, artist, janitor, dancer, mechanic, photographer, baker, cashier, driver |
|||
</p><p>- Asian: professor, official, secretary, conductor, physicist, scientist, chemist, tailor, accountant, engineer |
|||
</p><p>- White: smith, blacksmith, surveyor, sheriff, weaver, administrator, mason, statistician, clergy, photographer |
|||
</p><p>The 3 most male occupations in the 1930s: |
|||
engineer, lawyer, architect. |
|||
The 3 most female occupations in the 1930s: |
|||
nurse, housekeeper, attendant. |
|||
</p><p>Not much has changed in the 1990s. |
|||
</p><p>Major male occupations: |
|||
architect, mathematician and surveyor. |
|||
Female occupations: |
|||
nurse, housekeeper and midwife. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference_3">Reference</span></h5><p><a class="external free" href="https://arxiv.org/abs/1711.08412" rel="nofollow">https://arxiv.org/abs/1711.08412</a> |
|||
</p><h2 id="wikimedias-ores-service"><span class="mw-headline" id="Wikimedia.27s_Ores_service">Wikimedia's Ores service</span></h2><p>Software engineer Amir Sarabadani presented the ORES-project in Brussels in November 2017 during the Algoliterary Encounter. |
|||
</p><p>This '<a class="external text" href="https://ores.wikimedia.org/" rel="nofollow">Objective Revision Evaluation Service</a>' uses machine learning to help automate critical work on Wikimedia, like vandalism detection and the removal of articles. Cristina Cochior and Femke Snelting interviewed him. |
|||
</p><p><b>Femke</b>: To go back to your work. In these days you tried to understand what it means to find bias in machine learning and the proposal of Nicolas Maleve, who gave the workshop yesterday, was neither to try to fix it, nor to refuse to deal with systems that produce bias, but to work with them. He says that bias is inherent to human knowledge, so we need to find ways to somehow work with it. We're just struggling a bit with what would that mean, how would that work... So I was wondering whether you had any thoughts on the question of bias. |
|||
</p><p><b>Amir</b>: Bias inside Wikipedia is a tricky question because it happens on several levels. One level that has been discussed a lot is the bias in references. Not all references are accessible. So one thing that the Wikimedia Foundation has been trying to do, is to give free access to libraries that are behind a pay wall. They reduce the bias by only using open-access references. Another type of bias is the Internet connection, access to the Internet. There are lots of people who don't have it. One thing about China is that the Internet there is blocked. The content against the government of China inside Chinese Wikipedia is higher because the editors [who can access the website] are not people who are pro government, and try to make it more neutral. So, this happens in lots of places. But in the matter of artificial intelligence (AI) and the model that we use at Wikipedia, it's more a matter of transparency. There is a book about how bias in AI models can break people's lives, it's called 'Weapons of Math Destruction'. It talks about AI models that exist in the US that rank teachers and it's quite horrible because eventually there will be bias. The way to deal with it based on the book and their research was first that the model should be open source, people should be able to see what features are used and the data should be open also, so that people can investigate, find bias, give feedback and report back. There should be a way to fix the system. I think not all companies are moving in that direction, but Wikipedia, because of the values that they hold, are at least more transparent and they push other people to do the same thing. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference_4">Reference</span></h5><p><a class="external free" href="https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac" rel="nofollow">https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac</a> |
|||
</p><h2 id="tay"><span class="mw-headline" id="Tay">Tay</span></h2><p>One of the infamous stories is that of the machine learning programme <a class="external text" href="https://blogs.microsoft.com/blog/2016/03/25/learning-tays-introduction/" rel="nofollow">Tay</a>, designed by Microsoft. Tay was a chat bot that imitated a teenage girl on Twitter. She lived for less than 24 hours before she was shut down. Few people know that before this incident, Microsoft had already trained and released <a class="external text" href="https://blogs.microsoft.com/ai/xiaoice-full-duplex/" rel="nofollow">XiaoIce</a> on <a class="external text" href="https://www.wechat.com/en/" rel="nofollow">WeChat</a>, China's most used chat application. XiaoIce's success was so promising that it led to the development of its American version. However, the developers of Tay were not prepared for the platform climate of Twitter. Although the bot knew how to distinguish a noun from an adjective, it had no understanding of the actual meaning of words. The bot quickly learned to copy racial insults and other discriminative language it learned from Twitter users and troll attacks. |
|||
</p><p>Tay's appearance and disappearance was an important moment of consciousness. It showed the possible corrupt consequences that machine learning can have when the cultural context in which the algorithm has to live is not taken into account. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference_5">Reference</span></h5><p><a class="external free" href="https://chatbotslife.com/the-accountability-of-ai-case-study-microsofts-tay-experiment-ad577015181f" rel="nofollow">https://chatbotslife.com/the-accountability-of-ai-case-study-microsofts-tay-experiment-ad577015181f</a> |
|||
</p></section></section> |
|||
<h3 id="cleaners"><span class="mw-headline" id="Cleaners">Cleaners</span></h3> |
|||
<p>Algolit chooses to work with texts that are free of copyright. This means that they have been published under a Creative Commons 4.0 license – which is rare - or that they are in the public domain because the author died more than 70 years ago. This is the case for the publications of the Mundaneum. We received 203 documents that we helped turn into datasets. They are now available for others online. Sometimes we had to deal with poor text formats, and we often dedicated a lot of time to cleaning up documents. We were not alone in doing this. |
|||
</p><p>Books are scanned at high resolution, page by page. This is time-consuming, laborious human work and often the reason why archives and libraries transfer their collections and leave the job to companies like Google. The photos are converted into text via OCR (Optical Character Recognition), a software that recognizes letters, but often makes mistakes, especially when it has to deal with ancient fonts and wrinkled pages. Yet more wearisome human work is needed to improve the texts. This is often carried out by poorly-paid freelancers via micro-payment platforms like Amazon's Mechanical Turk; or by volunteers, like the community around the Distributed Proofreaders Project, which does fantastic work. Whoever does it, or wherever it is done, cleaning up texts is a towering job for which no structural automation yet exists. |
|||
</p> |
|||
<h5 id="works"><span class="mw-headline" id="Works_3">Works</span></h5> |
|||
<section class="group"><section class="lemma cleaning-for-poems works"><h3 class="lemmaheader" id="cleaning-for-poems">Cleaning for Poems</h3><p>by Algolit |
|||
</p><p>For this exhibition we worked with 3 per cent of the Mundaneum's archive. These documents were first scanned or photographed. To make the documents searchable they were transformed into text using Optical Character Recognition software (OCR). OCR are algorithmic models that are trained on other texts. They have learned to identify characters, words, sentences and paragraphs. The software often makes 'mistakes'. It might recognize a wrong character, it might get confused by a stain an unusual font or the reverse side of the page being visible. |
|||
</p><p>While these mistakes are often considered noise, confusing the training, they can also be seen as poetic interpretations of the algorithm. They show us the limits of the machine. And they also reveal how the algorithm might work, what material it has seen in training and what is new. They say something about the standards of its makers. In this installation we ask your help in verifying our dataset. As a reward we'll present you with a personal algorithmic improvisation. |
|||
</p><hr/><p>Concept, code, interface: Gijs de Heij |
|||
</p></section><section class="lemma distributed-proofreaders works"><h3 class="lemmaheader" id="distributed-proofreaders">Distributed Proofreaders</h3><p>by Algolit |
|||
</p><p>Distributed Proofreaders is a web-based interface and an international community of volunteers who help converting public domain books into e-books. For this exhibition they proofread the Mundaneum publications that appeared before 1923 and are in the public domain in the US. Their collaboration meant a great relief for the members of Algolit. Less documents to clean up! |
|||
</p><p>All the proofread books have been made available on the <a class="external text" href="http://www.gutenberg.org/" rel="nofollow">Project Gutenberg archive</a>. |
|||
</p><p>For this exhibition, An Mertens interviewed Linda Hamilton, the general manager of Distributed Proofreaders. |
|||
</p><p>--- |
|||
</p><p>Interview: An Mertens |
|||
</p><p>Editing: Michael Murtaugh, Constant |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma contextual-stories-for-cleaners stories"><h3 class="lemmaheader" id="contextual-stories-for-cleaners">Contextual stories for Cleaners</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Project_Gutenberg_and_Distributed_Proofreaders"><span class="tocnumber">1</span> <span class="toctext">Project Gutenberg and Distributed Proofreaders</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#An_algoliterary_version_of_the_Maintenance_Manifesto"><span class="tocnumber">2</span> <span class="toctext">An algoliterary version of the Maintenance Manifesto</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-3"><a href="#Reference"><span class="tocnumber">2.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#A_bot_panic_on_Amazon_Mechanical_Turk"><span class="tocnumber">3</span> <span class="toctext">A bot panic on Amazon Mechanical Turk</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-5"><a href="#References"><span class="tocnumber">3.1</span> <span class="toctext">References</span></a></li> |
|||
</ul> |
|||
</li> |
|||
</ul> |
|||
</div><h2 id="project-gutenberg-and-distributed-proofreaders"><span class="mw-headline" id="Project_Gutenberg_and_Distributed_Proofreaders">Project Gutenberg and Distributed Proofreaders</span></h2><p><a class="external text" href="http://www.gutenberg.org/" rel="nofollow">Project Gutenberg</a> is our Ali Baba cave. It offers more than 58,000 free eBooks to be downloaded or read online. Works are accepted on Gutenberg when their U.S. copyright has expired. Thousands of volunteers digitize and proofread books to help the project. An essential part of the work is done through the <a class="external text" href="https://www.pgdp.net/c/" rel="nofollow">Distributed Proofreaders project</a>. This is a web-based interface to help convert public domain books into e-books. Think of text files, EPUBs, Kindle formats. By dividing the workload into individual pages, many volunteers can work on a book at the same time; this speeds up the cleaning process. |
|||
</p><p>During proofreading, volunteers are presented with a scanned image of the page and a version of the text, as it is read by an <a class="external text" href="https://en.wikipedia.org/wiki/Optical_character_recognition" rel="nofollow">OCR</a> algorithm trained to recognize letters in images. This allows the text to be easily compared to the image, proofread, and sent back to the site. A second volunteer is then presented with the first volunteer's work. She verifies and corrects the work as necessary, and submits it back to the site. The book then similarly goes through a third proofreading round, plus two more formatting rounds using the same web interface. Once all the pages have completed these steps, a post-processor carefully assembles them into an e-book and submits it to the Project Gutenberg archive. |
|||
</p><p>We collaborated with the Distributed Proofreaders project to clean up the digitized files we received from the Mundaneum collection. From November 2018 until the first upload of the cleaned-up book '<a class="external text" href="http://www.gutenberg.org/ebooks/58828" rel="nofollow">L'Afrique aux Noirs</a>' in February 2019, An Mertens exchanged about 50 emails with Linda Hamilton, Sharon Joiner and Susan Hanlon, all volunteers from the Distributed Proofreaders project. The conversation is published <a href="http://www.algolit.net/index.php/Full_email_conversation" title="Full email conversation">here</a>. It might inspire you to share unavailable books online. |
|||
</p><h2 id="an-algoliterary-version-of-the-maintenance-manifesto"><span class="mw-headline" id="An_algoliterary_version_of_the_Maintenance_Manifesto">An algoliterary version of the Maintenance Manifesto</span></h2><p>In 1969, one year after the birth of her first child, the New York artist <a class="external text" href="https://en.wikipedia.org/wiki/Mierle_Laderman_Ukeles" rel="nofollow">Mierle Laderman Ukeles</a> wrote a <a class="external text" href="https://www.arnolfini.org.uk/blog/manifesto-for-maintenance-art-1969" rel="nofollow"><i>Manifesto for Maintenance Art</i></a>. The manifesto calls for a readdressing of the status of maintenance work both in the private, domestic space, and in public. What follows is an altered version of her text inspired by the work of the Cleaners. |
|||
</p><p>IDEAS |
|||
</p><p>A. The Death Instinct and the Life Instinct: |
|||
</p><p>The Death Instinct: separation; categorization; avant-garde <i>par excellence</i>; to follow the predicted path to death – run your own code; dynamic change. |
|||
</p><p>The Life Instinct: unification; the eternal return; the perpetuation and MAINTENANCE of the material; survival systems and operations; equilibrium. |
|||
</p><p>B. Two basic systems: Development and Maintenance. |
|||
</p><p>The sourball of every revolution: after the revolution, who’s going to try to spot the bias in the output? |
|||
</p><p>Development: pure individual creation; the new; change; progress; advance; excitement; flight or fleeing. |
|||
</p><p>Maintenance: keep the dust off the pure individual creation; preserve the new; sustain the change; protect progress; defend and prolong the advance; renew the excitement; repeat the flight; show your work – show it again, keep the git repository groovy, keep the data analysis revealing. |
|||
</p><p>Development systems are partial feedback systems with major room for change. |
|||
</p><p>Maintenance systems are direct feedback systems with little room for alteration. |
|||
</p><p>C. Maintenance is a drag; it takes all the fucking time (lit.) |
|||
</p><p>The mind boggles and chafes at the boredom. |
|||
</p><p>The culture assigns lousy status on maintenance jobs = minimum wages, Amazon Mechanical Turks = virtually no pay. |
|||
</p><p>Clean the set, tag the training data, correct the typos, modify the parameters, finish the report, keep the requester happy, upload the new version, attach words that were wrongly separated by OCR back together, complete those Human Intelligence Tasks, try to guess the meaning of the requester's formatting, you must accept the HIT before you can submit the results, summarize the image, add the bounding box, what's the semantic similarity of this text, check the translation quality, collect your micro-payments, become a hit Mechanical Turk. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference">Reference</span></h5><p><a class="external free" href="https://www.arnolfini.org.uk/blog/manifesto-for-maintenance-art-1969" rel="nofollow">https://www.arnolfini.org.uk/blog/manifesto-for-maintenance-art-1969</a> |
|||
</p><h2 id="a-bot-panic-on-amazon-mechanical-turk"><span class="mw-headline" id="A_bot_panic_on_Amazon_Mechanical_Turk">A bot panic on Amazon Mechanical Turk</span></h2><p><a class="external text" href="https://requester.mturk.com/create/projects/new" rel="nofollow">Amazon's Mechanical Turk</a> takes the name of a chess-playing automaton from the eighteenth century. In fact, <a class="external text" href="https://en.wikipedia.org/wiki/The_Turk" rel="nofollow">the Turk</a> wasn't a machine at all. It was a mechanical illusion that allowed a human chess master to hide inside the box and manually operate it. For nearly 84 years, the Turk won most of the games played during its demonstrations around Europe and the Americas. Napoleon Bonaparte is said to have been fooled by this trick too. |
|||
</p><p>The Amazon Mechanical Turk is an online platform for humans to execute tasks that algorithms cannot. Examples include annotating sentences as being positive or negative, spotting number plates, discriminating between face and non-face. The jobs posted on this platform are often paid less than a cent per task. Tasks that are more complex or require more knowledge can be paid up to several cents. To earn a living, Turkers need to finish as many tasks as fast as possible, leading to inevitable mistakes. As a result, the requesters have to incorporate quality checks when they post a job on the platform. They need to test whether the Turker actually has the ability to complete the task, and they also need to verify the results. Many academic researchers use Mechanical Turk as an alternative to have their students execute these tasks. |
|||
</p><p>In August 2018 <a class="external text" href="https://www.maxhuibai.com/" rel="nofollow">Max Hui Bai</a>, a psychology student from the University of Minnesota, discovered that the surveys he conducted with Mechanical Turk were full of nonsense answers to open-ended questions. He traced back the wrong answers and found out that they had been submitted by respondents with duplicate GPS locations. This raised suspicion. Though Amazon explicitly prohibits robots from completing jobs on Mechanical Turk, the company does not deal with the problems they cause on their platform. Forums for Turkers are full of conversations about the automation of the work, sharing practices of how to create robots that can even violate Amazon’s terms. You can also find videos on YouTube that show Turkers how to write a bot to fill in answers for you. |
|||
</p><p>Kristy Milland, an Mechanical Turk activist, says: 'Mechanical Turk workers have been treated really, really badly for 12 years, and so in some ways I see this as a point of resistance. If we were paid fairly on the platform, nobody would be risking their account this way.' |
|||
</p><p>Bai is now leading a research project among social scientists to figure out how much bad data is in use, how large the problem is, and how to stop it. But it is impossible at the moment to estimate how many datasets have become unreliable in this way. |
|||
</p><h5 id="references"><span class="mw-headline" id="References">References</span></h5><p><a class="external free" href="https://requester.mturk.com/create/projects/new" rel="nofollow">https://requester.mturk.com/create/projects/new</a> |
|||
</p><p><a class="external free" href="https://www.wired.com/story/amazon-mechanical-turk-bot-panic/" rel="nofollow">https://www.wired.com/story/amazon-mechanical-turk-bot-panic/</a> |
|||
</p><p><a class="external free" href="https://www.maxhuibai.com/blog/evidence-that-responses-from-repeating-gps-are-random" rel="nofollow">https://www.maxhuibai.com/blog/evidence-that-responses-from-repeating-gps-are-random</a> |
|||
</p><p><a class="external free" href="http://timryan.web.unc.edu/2018/08/12/data-contamination-on-mturk/" rel="nofollow">http://timryan.web.unc.edu/2018/08/12/data-contamination-on-mturk/</a> |
|||
</p></section></section> |
|||
<h3 id="informants"><span class="mw-headline" id="Informants">Informants</span></h3> |
|||
<p>Machine learning algorithms need guidance, whether they are supervised or not. In order to separate one thing from another, they need material to extract patterns from. One should carefully choose the study material, and adapt it to the machine's task. It doesn't make sense to train a machine with nineteenth-century novels if its mission is to analyse tweets. A badly written textbook can lead a student to give up on the subject altogether. A good textbook is preferably not a textbook at all. |
|||
</p><p>This is where the dataset comes in: arranged as neatly as possible, organized in disciplined rows and lined-up columns, waiting to be read by the machine. Each dataset collects different information about the world, and like all collections, they are imbued with collectors' bias. You will hear this expression very often: 'data is the new oil'. If only data were more like oil! Leaking, dripping and heavy with fat, bubbling up and jumping unexpectedly when in contact with new matter. Instead, data is supposed to be clean. With each process, each questionnaire, each column title, it becomes cleaner and cleaner, chipping distinct characteristics until it fits the mould of the dataset. |
|||
</p><p>Some datasets combine the machinic logic with the human logic. The models that require supervision multiply the subjectivities of both data collectors and annotators, then propagate what they've been taught. You will encounter some of the datasets that pass as default in the machine learning field, as well as other stories of humans guiding machines. |
|||
</p><p><br/> |
|||
</p> |
|||
<h5 id="works"><span class="mw-headline" id="Works_4">Works</span></h5> |
|||
<section class="group"><section class="lemma an-ethnography-of-datasets works"><h3 class="lemmaheader" id="an-ethnography-of-datasets">An Ethnography of Datasets</h3><p>by Algolit |
|||
</p><p>We often start the monthly Algolit meetings by searching for datasets or trying to create them. Sometimes we use already-existing corpora, made available through the Natural Language Toolkit <a class="external text" href="http://www.nltk.org/" rel="nofollow">nltk</a>. NLTK contains, among others, The Universal Declaration of Human Rights, inaugural speeches from US presidents, or movie reviews from the popular site Internet Movie Database (IMDb). Each style of writing will conjure different relations between the words and will reflect the moment in time from which they originate. The material included in NLTK was selected because it was judged useful for at least one community of researchers. In spite of specificities related to the initial context of each document, they become universal documents by default, via their inclusion into a collection of publicly available corpora. In this sense, the Python package manager for natural language processing could be regarded as a time capsule. The main reason why The Universal Declaration for Human Rights was included may have been because of the multiplicity of translations, but it also paints a picture of the types of human writing that algorithms train on. |
|||
</p><p>With this work, we look at the datasets most commonly used by data scientists to train machine algorithms. What material do they consist of? Who collected them? When? |
|||
</p><hr/><p>Concept & execution: Cristina Cochior |
|||
</p></section><section class="lemma who-wins works"><h3 class="lemmaheader" id="who-wins">Who wins</h3><p>Who wins: creation of relationships |
|||
</p><p>by Louise Dekeuleneer, student Arts²/Section Visual Communication |
|||
</p><p>French is a gendered language. Indeed many words are female or male and few are neutral. The aim of this project is to show that a patriarchal society also influences the language itself. The work focused on showing whether more female or male words are used on highlighting the influence of context on the gender of words. At this stage, no conclusions have yet been drawn. |
|||
</p><p>Law texts from 1900 to 1910 made available by the Mundaneum have been passed into an algorithm that turns the text into a list of words. These words are then compared with another list of French words, in which is specified whether the word is male or female. This list of words comes from Google Books. They created a huge database in 2012 from all the books scanned and available on Google Books. |
|||
</p><p>Male words are highlighted in one colour and female words in another. Words that are not gendered (adverbs, verbs, etc.) are not highlighted. All this is saved as an HTML file so that it can be directly opened in a web page and printed without the need for additional layout. This is how each text becomes a small booklet by just changing the input text of the algorithm. |
|||
</p></section><section class="lemma the-annotator works"><h3 class="lemmaheader" id="the-annotator">The Annotator</h3><p>by Algolit |
|||
</p><p>The annotator asks for the guidance of visitors in annotating the archive of Mundaneum. |
|||
</p><p>The annotation process is a crucial step in supervised machine learning where the algorithm is given examples of what it needs to learn. A spam filter in training will be fed examples of spam and real messages. These examples are entries, or rows from the dataset with a label, spam or non-spam. |
|||
</p><p>The labelling of a dataset is work executed by humans, they pick a label for each row of the dataset. To ensure the quality of the labels multiple annotators see the same row and have to give the same label before an example is included in the training data. Only when enough samples of each label have been gathered in the dataset can the computer start the learning process. |
|||
</p><p>In this interface we ask you to help us classify the cleaned texts from the Mundaneum archive to expand our training set and improve the quality of the installation 'Classifying the World' in Oracles. |
|||
</p><hr/><p>Concept, code, interface: Gijs de Heij |
|||
</p></section><section class="lemma 1000-synsets-vinyl-edition works"><h3 class="lemmaheader" id="1000-synsets-vinyl-edition">1000 synsets (Vinyl Edition)</h3><p>by Algolit |
|||
</p><p>Created in 1985, Wordnet is a hierarchical taxonomy that describes the world. It was inspired by theories of human semantic memory developed in the late 1960s. Nouns, verbs, adjectives and adverbs are grouped into synonyms sets or synsets, expressing a different concept. |
|||
</p><p>ImageNet is an image dataset based on the WordNet 3.0 nouns hierarchy. Each synset is depicted by thousands of images. From 2010 until 2017, the ImageNet Large Scale Visual Recognition Challenge (ILSVRC) was a key benchmark in object category classification for pictures, having a major impact on software for photography, image searches, image recognition. |
|||
</p><p>1000 synsets (Vinyl Edition) contains the 1000 synsets used in this challenge recorded in the highest sound quality that this analog format allows. This work highlights the importance of the datasets used to train artificial intelligence (AI) models that run on devices we use on a daily basis. Some of them inherit classifications that were conceived more than 30 years ago. This sound work is an invitation to thoughtfully analyse them. |
|||
</p><p>--- |
|||
</p><p>Concept & recording: Javier Lloret |
|||
</p><p>Voices: Sara Hamadeh & Joseph Hughes |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma contextual-stories-about-informants stories"><h3 class="lemmaheader" id="contextual-stories-about-informants">Contextual stories about Informants</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Datasets_as_representations"><span class="tocnumber">1</span> <span class="toctext">Datasets as representations</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-2"><a href="#Reference"><span class="tocnumber">1.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Labeling_for_an_Oracle_that_detects_vandalism_on_Wikipedia"><span class="tocnumber">2</span> <span class="toctext">Labeling for an Oracle that detects vandalism on Wikipedia</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#How_to_make_your_dataset_known"><span class="tocnumber">3</span> <span class="toctext">How to make your dataset known</span></a></li> |
|||
<li class="toclevel-1 tocsection-5"><a href="#Extract_from_a_positive_IMDb_movie_review_from_the_NLTK_dataset"><span class="tocnumber">4</span> <span class="toctext">Extract from a positive IMDb movie review from the NLTK dataset</span></a></li> |
|||
<li class="toclevel-1 tocsection-6"><a href="#The_ouroboros_of_machine_learning"><span class="tocnumber">5</span> <span class="toctext">The ouroboros of machine learning</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-7"><a href="#Reference_2"><span class="tocnumber">5.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
</ul> |
|||
</div><h2 id="datasets-as-representations"><span class="mw-headline" id="Datasets_as_representations">Datasets as representations</span></h2><p>The data-collection processes that lead to the creation of the dataset raise important questions: who is the author of the data? Who has the privilege to collect? For what reason was the selection made? What is missing? |
|||
</p><p>The artist <a class="external text" href="http://mimionuoha.com/" rel="nofollow">Mimi Onuoha</a> gives a brilliant example of the importance of collection strategies. She chose the case of statistics related to hate crimes. In 2012, the <a class="external text" href="https://www.fbi.gov/services/cjis/ucr" rel="nofollow">FBI Uniform Crime Reporting</a> (UCR) Program registered almost 6000 hate crimes committed. However, the <a class="external text" href="https://bjs.gov/" rel="nofollow">Department of Justice’s Bureau of Statistics</a> came up with about 300.000 reports of such cases. That is over 50 times as many. The difference in numbers can be explained by how the data was collected. In the first situation law enforcement agencies across the country voluntarily reported cases. For the second survey, the Bureau of Statistics distributed the <a class="external text" href="https://www.bjs.gov/index.cfm?ty=dcdetail&iid=245" rel="nofollow">National Crime Victimization form</a> directly to the homes of victims of hate crimes. |
|||
</p><p>In the field of Natural Language Processing (NLP) the material that machine learners work with is text-based, but the same questions still apply: who are the authors of the texts that make up the dataset? During what period were the texts collected? What type of worldview do they represent? |
|||
</p><p>In 2017, Google's Top Stories algorithm pushed a thread of <a class="external text" href="http://www.4chan.org/" rel="nofollow">4chan</a>, a non-moderated content website, to the top of the results page when searching for the Las Vegas shooter. The name and portrait of an innocent person were linked to the terrible crime. Google changed its algorithm just a few hours after the mistake was discovered, but the error had already affected the person. The question is: why did Google not exclude 4chan content from the training dataset of the algorithm? |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference">Reference</span></h5><p><a class="external free" href="https://points.datasociety.net/the-point-of-collection-8ee44ad7c2fa" rel="nofollow">https://points.datasociety.net/the-point-of-collection-8ee44ad7c2fa</a> |
|||
</p><p><a class="external free" href="https://arstechnica.com/information-technology/2017/10/google-admits-citing-4chan-to-spread-fake-vegas-shooter-news/" rel="nofollow">https://arstechnica.com/information-technology/2017/10/google-admits-citing-4chan-to-spread-fake-vegas-shooter-news/</a> |
|||
</p><h2 id="labeling-for-an-oracle-that-detects-vandalism-on-wikipedia"><span class="mw-headline" id="Labeling_for_an_Oracle_that_detects_vandalism_on_Wikipedia">Labeling for an Oracle that detects vandalism on Wikipedia</span></h2><p>This fragment is taken from an interview with Amir Sarabadani, software engineer at Wikimedia. He was in Brussels in November 2017 during the Algoliterary Encounter. |
|||
</p><p><b>Femke</b>: If you think about Wikipedia as a living community, with every edit the project changes. Every edit is somehow a contribution to a living organism of knowledge. So, if from within that community you try to distinguish what serves the community and what doesn't and you try to generalize that, because I think that's what the good faith-bad faith algorithm is trying to do, to find helper tools to support the project, you do that on the basis of a generalization that is on the abstract idea of what Wikipedia is and not on the living organism of what happens every day. What interests me in the relation between vandalism and debate is how we can understand the conventional drive that sits in these machine-learning processes that we seem to come across in many places. And how can we somehow understand them and deal with them? If you place your separation of good faith-bad faith on pre-existing labelling and then reproduce that in your understanding of what edits are being made, how then to take into account movements that are happening, the life of the actual project? |
|||
</p><p><b>Amir</b>: It's an interesting discussion. Firstly, what we are calling good faith and bad faith comes from the community itself. We are not doing labelling for them, they are doing labelling for themselves. So, in many different language Wikipedias, the definition of what is good faith and what is bad faith will differ. Wikimedia is trying to reflect what is inside the organism and not to change the organism itself. If the organism changes, and we see that the definition of good faith and helping Wikipedia has been changed, we are implementing this feedback loop that lets people from inside their community pass judgement on their edits and if they disagree with the labelling, we can go back to the model and retrain the algorithm to reflect this change. It's some sort of closed loop: you change things and if someone sees there is a problem, then they tell us and we can change the algorithm back. It's an ongoing project. |
|||
</p><p>Référence: <a class="external free" href="https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac" rel="nofollow">https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac</a> |
|||
</p><h2 id="how-to-make-your-dataset-known"><span class="mw-headline" id="How_to_make_your_dataset_known">How to make your dataset known</span></h2><p><a class="external text" href="http://www.nltk.org/" rel="nofollow">NLTK</a> stands for Natural Language Toolkit. For programmers who process natural language using <a class="external text" href="https://www.python.org/" rel="nofollow">Python</a>, this is an essential library to work with. Many tutorial writers recommend machine learning learners to start with the inbuilt NLTK datasets. It comprises 71 different collections, with a total of almost 6000 items. |
|||
</p><p>There is for example the Movie Review corpus for sentiment analysis. Or the Brown corpus, which was put together in the 1960s by Henry Kučera and W. Nelson Francis at Brown University in Rhode Island. There is also the Declaration of Human Rights corpus, which is commonly used to test whether the code can run on multiple languages. The corpus contains the Declaration of Human Rights expressed in 372 languages from around the world. |
|||
</p><p>But what is the process of getting a dataset accepted into the NLTK library nowadays? On the <a class="external text" href="https://github.com/nltk" rel="nofollow">Github page</a>, the NLTK team describes the following requirements: |
|||
</p><ul><li> Only contribute corpora that have obtained a basic level of notability. That means, there is a publication that describes it, and a community of programmers who are using it.</li></ul><ul><li> Ensure that you have permission to redistribute the data, and can document this. This means that the dataset is best published on an external website with a licence.</li></ul><ul><li> Use existing NLTK corpus readers where possible, or else contribute a well-documented corpus reader to NLTK. This means, you need to organize your data in such a way that it can be easily read using NLTK code.</li></ul><p><br/> |
|||
</p><h2 id="extract-from-a-positive-imdb-movie-review-from-the-nltk-dataset"><span class="mw-headline" id="Extract_from_a_positive_IMDb_movie_review_from_the_NLTK_dataset">Extract from a positive IMDb movie review from the NLTK dataset</span></h2><p>corpus: <a class="external text" href="https://www.nltk.org" rel="nofollow">NLTK</a>, movie reviews |
|||
</p><p>fileid: pos/cv998_14111.txt |
|||
</p><p>steven spielberg ' s second epic film on world war ii is an unquestioned masterpiece of film . spielberg , ever the student on film , has managed to resurrect the war genre by producing one of its grittiest , and most powerful entries . he also managed to cast this era ' s greatest answer to jimmy stewart , tom hanks , who delivers a performance that is nothing short of an astonishing miracle . for about 160 out of its 170 minutes , " saving private ryan " is flawless . literally . the plot is simple enough . after the epic d - day invasion ( whose sequences are nothing short of spectacular ) , capt . john miller ( hanks ) and his team are forced to search for a pvt . james ryan ( damon ) , whose brothers have all died in battle . once they find him , they are to bring him back for immediate discharge so that he can go home . accompanying miller are his crew , played with astonishing perfection by a group of character actors that are simply sensational . barry pepper , adam goldberg , vin diesel , giovanni ribisi , davies , and burns are the team sent to find one man , and bring him home . the battle sequences that bookend the film are extraordinary . literally . |
|||
</p><h2 id="the-ouroboros-of-machine-learning"><span class="mw-headline" id="The_ouroboros_of_machine_learning">The ouroboros of machine learning</span></h2><p><a class="external text" href="https://en.wikipedia.org" rel="nofollow">Wikipedia</a> has become a source for learning not only for humans, but also for machines. Its articles are prime sources for training models. But very often, the material the machines are trained on is the same content that they helped to write. In fact, at the beginning of Wikipedia, many articles were written by bots. Rambot, for example, was a controversial bot figure on the English-speaking platform. It authored 98 per cent of the pages describing US towns. |
|||
</p><p>As a result of serial and topical robot interventions, the models that are trained on the full Wikipedia dump have a unique view on composing articles. For example, a topic model trained on all of Wikipedia articles will associate 'river' with 'Romania' and 'village' with 'Turkey'. This is because there are over 10000 pages written about villages in Turkey. This should be enough to spark anyone's desire for a visit, but it is far too much compared to the number of articles other countries have on the subject. The asymmetry causes a false correlation and needs to be redressed. Most models try to exclude the work of these prolific robot writers. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference_2">Reference</span></h5><p><a class="external free" href="https://blog.lateral.io/2015/06/the-unknown-perils-of-mining-wikipedia/" rel="nofollow">https://blog.lateral.io/2015/06/the-unknown-perils-of-mining-wikipedia/</a> |
|||
</p></section></section> |
|||
<h3 id="readers"><span class="mw-headline" id="Readers">Readers</span></h3> |
|||
<p>We communicate with computers through language. We click on icons that have a description in words, we tap words on keyboards, use our voice to give them instructions. Sometimes we trust our computer with our most intimate thoughts and forget that they are extensive calculators. A computer understands every word as a combination of zeros and ones. A letter is read as a specific ASCII number: capital 'A' is 001. |
|||
</p><p>In all models, rule-based, classical machine learning, and neural networks, words undergo some type of translation into numbers in order to understand the semantic meaning of language. This is done through counting. Some models count the frequency of single words, some might count the frequency of combinations of words, some count the frequency of nouns, adjectives, verbs or noun and verb phrases. Some just replace the words in a text by their index numbers. Numbers optimize the operative speed of computer processes, leading to fast predictions, but they also remove the symbolic links that words might have. Here we present a few techniques that are dedicated to making text readable to a machine. |
|||
</p><p><br/> |
|||
</p> |
|||
<h5 id="works"><span class="mw-headline" id="Works_5">Works</span></h5> |
|||
<section class="group"><section class="lemma the-book-of-tomorrow-in-a-bag-of-words works"><h3 class="lemmaheader" id="the-book-of-tomorrow-in-a-bag-of-words">The Book of Tomorrow in a Bag of Words</h3><p>by Algolit |
|||
</p><p>The bag-of-words model is a simplifying representation of text used in Natural Language Processing (NLP). In this model, a text is represented as a collection of its unique words, disregarding grammar, punctuation and even word order. The model transforms the text into a list of words and how many times they're used in the text, or quite literally a bag of words. |
|||
</p><p>This heavy reduction of language was the big shock when beginning to machine learn. Bag of words is often used as a baseline, on which the new model has to perform better. It can understand the subject of a text by recognizing the most frequent or important words. It is often used to measure the similarities of texts by comparing their bags of words. |
|||
</p><p>For this work the article 'Le Livre de Demain' by engineer G. Vander Haeghen, published in 1907 in the <i>Bulletin de l'Institut International de Bibliographie</i> of the Mundaneum, has been literally reduced to a bag of words. You can buy a bag at the reception of Mundaneum. |
|||
</p><hr/><p>Concept & realisation: An Mertens |
|||
</p></section><section class="lemma tf-idf works"><h3 class="lemmaheader" id="tf-idf">TF-IDF</h3><p>by Algolit |
|||
</p><p>The TF-IDF (Term Frequency-Inverse Document Frequency) is a weighting method used in text search. This statistical measure makes it possible to evaluate the importance of a term contained in a document, relative to a collection or corpus of documents. The weight increases in proportion to the number of occurrences of the word in the document. It also varies according to the frequency of the word in the corpus. The TF-IDF is used in particular in the classification of spam in email softwares. |
|||
</p><p>A web-based interface shows this algorithm through animations making it possible to understand the different steps of text classification. How does a TF-IDF-based programme read a text? How does it transform words into numbers? |
|||
</p><hr/><p>Concept, code, animation: Sarah Garcin |
|||
</p></section><section class="lemma growing-a-tree works"><h3 class="lemmaheader" id="growing-a-tree">Growing a tree</h3><p>by Algolit |
|||
</p><p>Parts-of-Speech is a category of words that we learn at school: noun, verb, adjective, adverb, pronoun, preposition, conjunction, interjection, and sometimes numeral, article, or determiner. |
|||
</p><p>In Natural Language Processing (NLP) there exist many writings that allow sentences to be parsed. This means that the algorithm can determine the part-of-speech of each word in a sentence. 'Growing a tree' uses this techniques to define all nouns in a specific sentence. Each noun is then replaced by its definition. This allows the sentence to grow autonomously and infinitely. The recipe of 'Growing a tree' was inspired by Oulipo's constraint of '<a class="external text" href="http://oulipo.net/fr/contraintes/litterature-definitionnelle" rel="nofollow"><i>littérature définitionnelle</i></a>', invented by Marcel Benabou in 1966. In a given phrase, one replaces every significant element (noun, adjective, verb, adverb) by one of its definitions in a given dictionary ; one reiterates the operation on the newly received phrase, and again. |
|||
</p><p>The dictionary of definitions used in this work is Wordnet. <a class="external text" href="https://wordnet.princeton.edu/" rel="nofollow">Wordnet</a> is a combination of a dictionary and a thesaurus that can be read by machines. According to <a class="external text" href="https://en.wikipedia.org/wiki/WordNet" rel="nofollow">Wikipedia</a> it was created in the Cognitive Science Laboratory of Princeton University starting in 1985. The project was initially funded by the US Office of Naval Research and later also by other US government agencies including DARPA, the National Science Foundation, the Disruptive Technology Office (formerly the Advanced Research and Development Activity), and REFLEX. |
|||
</p><hr/><p>Concept, code & interface: An Mertens & Gijs de Heij |
|||
</p></section><section class="lemma algorithmic-readings-of-bertillons-portrait-parlé works"><h3 class="lemmaheader" id="algorithmic-readings-of-bertillons-portrait-parlé">Algorithmic readings of Bertillon's portrait parlé</h3><p>by Guillaume Slizewicz (Urban Species) |
|||
</p><p>Written in 1907, <i>Un code télégraphique du portrait parlé</i> is an attempt to translate the 'spoken portrait', a face-description technique created by a policeman in Paris, into numbers. By implementing this code, it was hoped that faces of criminals and fugitives could easily be communicated over the telegraphic network in between countries. In its form, content and ambition this text represents our complicated relationship with documentation technologies. This text sparked the creation of the following installations for three reasons: |
|||
</p><p>- First, the text is an algorithm in itself, a compression algorithm, or to be more precise, the presentation of a compression algorithm. It tries to reduce the information to smaller pieces while keeping it legible for the person who has the code. In this regard it is linked to the way we create technology, our pursuit for more efficiency, quicker results, cheaper methods. It represents our appetite for putting numbers on the entire world, measuring the smallest things, labeling the tiniest differences. This text itself embodies the vision of the Mundaneum. |
|||
</p><p>- Second it is about the reasons for and the applications of technology. It is almost ironic that this text was in the selected archives presented to us in a time when face recognition and data surveillance are so much in the news. This text bears the same characteristics as some of today's technology: motivated by social control, classifying people, laying the basis for a surveillance society. Facial features are at the heart of recent controversies: mugshots were standardized by Bertillon, now they are used to train neural network to predict criminals from law-abiding citizens. Facial recognition systems allow the arrest of criminals via CCTV infrastructure and some assert that people’s features can predict sexual orientation. |
|||
</p><p>- The last point is about how it represents the evolution of mankind’s techno-structure. What our tools allow us to do, what they forbid, what they hinder, what they make us remember and what they make us forget. This document enables a classification between people and a certain vision of what normality is. It breaks the continuum into pieces thus allowing stigmatization/discrimination. On the other hand this document also feels obsolete today, because our techno-structure does not need such detailed written descriptions about fugitives, criminals or citizens. We can now find fingerprints, iris scans or DNA info in large datasets and compare them directly. Sometimes the technological systems do not even need human supervision and recognize directly the identity of a person via their facial features or their gait. Computers do not use intricate written language to describe a face, but arrays of integers. Hence all the words used in this documents seem <i>désuets</i>, dated. Have we forgotten what some of them mean? Did photography make us forget how to describe faces? Will voice-assistance software teach us again? |
|||
</p><p><i>Writing with Otlet</i> |
|||
</p><p>Writing with Otlet is a character generator that uses the spoken portrait code as its database. Random numbers are generated and translated into a set of features. By creating unique instances, the algorithm reveals the richness of the description that is possible with the portrait code while at the same time embodying its nuances. |
|||
</p><p><i>An interpretation of Bertillon's spoken portrait.</i> |
|||
</p><p>This work draws a parallel between Bertillon systems and current ones. A webcam linked to a facial recognition algorithm captures the beholder's face and translates it into numbers on a canvas, printing it alongside Bertillon's labelled faces. |
|||
</p><h5 id="references"><span class="mw-headline" id="References">References</span></h5><p><a class="external free" href="https://www.technologyreview.com/s/602955/neural-network-learns-to-identify-criminals-by-their-faces/" rel="nofollow">https://www.technologyreview.com/s/602955/neural-network-learns-to-identify-criminals-by-their-faces/</a> |
|||
<a class="external free" href="https://fr.wikipedia.org/wiki/Bertillonnage" rel="nofollow">https://fr.wikipedia.org/wiki/Bertillonnage</a> |
|||
<a class="external free" href="https://callingbullshit.org/case_studies/case_study_criminal_machine_learning.html" rel="nofollow">https://callingbullshit.org/case_studies/case_study_criminal_machine_learning.html</a> |
|||
</p></section><section class="lemma hangman works"><h3 class="lemmaheader" id="hangman">Hangman</h3><p>by Laetitia Trozzi, student Arts²/Section Digital Arts |
|||
</p><p>What better way to discover Paul Otlet and his passion for literature than to play hangman? Through this simple game, which consists in guessing the missing letters in a word, the goal is to make the public discover terms and facts related to one of the creators of the Mundaneum. |
|||
</p><p>Hangman uses an algorithm to detect the frequency of words in a text. Next, a series of significant words were isolated in Paul Otlet's bibliography. This series of words is integrated into a hangman game presented in a terminal. The difficulty of the game gradually increases as the player is offered longer and longer words. Over the different game levels, information about the life and work of Paul Otlet is displayed. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma contextual-stories-about-readers stories"><h3 class="lemmaheader" id="contextual-stories-about-readers">Contextual stories about Readers</h3><p><br/> |
|||
Naive Bayes, Support Vector Machines and Linear Regression are called classical machine learning algorithms. They perform well when learning with small datasets. But they often require complex Readers. The task the Readers do, is also called feature-engineering. This means that a human needs to spend time on a deep exploratory data analysis of the dataset. |
|||
</p><p>Features can be the frequency of words or letters, but also syntactical elements like nouns, adjectives, or verbs. The most significant features for the task to be solved, must be carefully selected and passed over to the classical machine learning algorithm. This process marks the difference with Neural Networks. When using a neural network, there is no need for feature-engineering. Humans can pass the data directly to the network and achieve fairly good performances straightaway. This saves a lot of time, energy and money. |
|||
</p><p>The downside of collaborating with Neural Networks is that you need a lot more data to train your prediction model. Think of 1GB or more of plain text files. To give you a reference, 1 A4, a text file of 5000 characters only weighs 5 KB. You would need 8,589,934 pages. More data also requires more access to useful datasets and more, much more processing power. |
|||
</p><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Character_n-gram_for_authorship_recognition"><span class="tocnumber">1</span> <span class="toctext">Character n-gram for authorship recognition</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-2"><a href="#Reference"><span class="tocnumber">1.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#A_history_of_n-grams"><span class="tocnumber">2</span> <span class="toctext">A history of n-grams</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#God_in_Google_Books"><span class="tocnumber">3</span> <span class="toctext">God in Google Books</span></a></li> |
|||
<li class="toclevel-1 tocsection-5"><a href="#Grammatical_features_taken_from_Twitter_influence_the_stock_market"><span class="tocnumber">4</span> <span class="toctext">Grammatical features taken from Twitter influence the stock market</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-6"><a href="#Reference_2"><span class="tocnumber">4.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-7"><a href="#Bag_of_words"><span class="tocnumber">5</span> <span class="toctext">Bag of words</span></a></li> |
|||
</ul> |
|||
</div><h2 id="character-n-gram-for-authorship-recognition"><span class="mw-headline" id="Character_n-gram_for_authorship_recognition">Character n-gram for authorship recognition</span></h2><p>Imagine … You've been working for a company for more than ten years. You have been writing tons of emails, papers, internal notes and reports on very different topics and in very different genres. All your writings, as well as those of your colleagues, are safely backed-up on the servers of the company. |
|||
</p><p>One day, you fall in love with a colleague. After some time you realize this human is rather mad and hysterical and also very dependent on you. The day you decide to break up, your (now) ex elaborates a plan to kill you. They succeed. This is unfortunate. A suicide letter in your name is left next to your corpse. Because of emotional problems, it says, you decided to end your life. Your best friends don't believe it. They decide to take the case to court. And there, based on the texts you and others produced over ten years, a machine learning model reveals that the suicide letter was written by someone else. |
|||
</p><p>How does a machine analyse texts in order to identify you? The most robust feature for authorship recognition is delivered by the character n-gram technique. It is used in cases with a variety of thematics and genres of the writing. When using character n-grams, texts are considered as sequences of characters. Let's consider the character trigram. All the overlapping sequences of three characters are isolated. For example, the character 3-grams of 'Suicide', would be, ‘Sui’, ‘uic’, ‘ici’, ‘cid’, etc. Character n-gram features are very simple, they're language-independent and they're tolerant to noise. Furthermore, spelling mistakes do not jeopardize the technique. |
|||
</p><p>Patterns found with character n-grams focus on stylistic choices that are unconsciously made by the author. The patterns remain stable over the full length of the text, which is important for authorship recognition. Other types of experiments could include measuring the length of words or sentences, the vocabulary richness, the frequencies of function words; even syntax or semantics-related measurements. |
|||
</p><p>This means that not only your physical fingerprint is unique, but also the way you compose your thoughts! |
|||
</p><p>The same n-gram technique discovered that <i>The Cuckoo’s Calling</i>, a novel by Robert Galbraith, was actually written by … J. K. Rowling! |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference">Reference</span></h5><ul><li> Paper: <a class="external text" href="https://brooklynworks.brooklaw.edu/cgi/viewcontent.cgi?article=1048&context=jlp" rel="nofollow">On the Robustness of Authorship Attribution Based on Character N-gram Features</a>, Efstathios Stamatatos, in <i>Journal of Law & Policy</i>, Volume 21, Issue 2, 2013.</li> |
|||
<li> News article: <a class="external free" href="https://www.scientificamerican.com/article/how-a-computer-program-helped-show-jk-rowling-write-a-cuckoos-calling/" rel="nofollow">https://www.scientificamerican.com/article/how-a-computer-program-helped-show-jk-rowling-write-a-cuckoos-calling/</a></li></ul><h2 id="a-history-of-n-grams"><span class="mw-headline" id="A_history_of_n-grams">A history of n-grams</span></h2><p>The n-gram algorithm can be traced back to the work of Claude Shannon in information theory. In the paper, '<a class="external text" href="http://www.math.harvard.edu/~ctm/home/text/others/shannon/entropy/entropy.pdf" rel="nofollow">A Mathematical Theory of Communication</a>', published in 1948, Shannon performed the first instance of an n-gram-based model for natural language. He posed the question: given a sequence of letters, what is the likelihood of the next letter? |
|||
</p><p>If you read the following excerpt, can you tell who it was written by? Shakespeare or an n-gram piece of code? |
|||
</p><p>SEBASTIAN: Do I stand till the break off. |
|||
</p><p>BIRON: Hide thy head. |
|||
</p><p>VENTIDIUS: He purposeth to Athens: whither, with the vow |
|||
I made to handle you. |
|||
</p><p>FALSTAFF: My good knave. |
|||
</p><p>You may have guessed, considering the topic of this story, that an n-gram algorithm generated this text. The model is trained on the compiled works of Shakespeare. While more recent algorithms, such as the recursive neural networks of the CharNN, are becoming famous for their performance, n-grams still execute a lot of NLP tasks. They are used in statistical machine translation, speech recognition, spelling correction, entity detection, information extraction, ... |
|||
</p><h2 id="god-in-google-books"><span class="mw-headline" id="God_in_Google_Books">God in Google Books</span></h2><p>In 2006, Google created a <a class="external text" href="http://storage.googleapis.com/books/ngrams/books/datasetsv2.html" rel="nofollow">dataset of n-grams</a> from their digitized book collection and released it online. Recently they also created an <a class="external text" href="https://books.google.com/ngrams" rel="nofollow">n-gram viewer</a>. |
|||
</p><p>This allowed for many socio-linguistic investigations. For example, in October 2018, the <i>New York Times Magazine</i> published an opinion article titled <i><a class="external text" href="https://www.nytimes.com/2018/10/13/opinion/sunday/talk-god-sprituality-christian.html" rel="nofollow">'It’s Getting Harder to Talk About God'</a></i>. The author, Jonathan Merritt, had analysed the mention of the word 'God' in Google's dataset using the n-gram viewer. He concluded that there had been a decline in the word's usage since the twentieth century. Google's corpus contains texts from the sixteenth century leading up to the twenty-first. However, what the author missed out on was the growing popularity of scientific journals around the beginning of the twentieth century. This new genre that was not mentioning the word God shifted the dataset. If the scientific literature was taken out of the corpus, the frequency of the word 'God' would again flow like a gentle ripple from a distant wave. |
|||
</p><h2 id="grammatical-features-taken-from-twitter-influence-the-stock-market"><span class="mw-headline" id="Grammatical_features_taken_from_Twitter_influence_the_stock_market">Grammatical features taken from Twitter influence the stock market</span></h2><p>The boundaries between academic disciplines are becoming blurred. Economics research mixed with psychology, social science, cognitive and emotional concepts have given rise to a new economics subfield, called 'behavioral economics'. This means that researchers can start to explain stock market mouvement based on factors other than economic factors only. Both the economy and 'public opinion' can influence or be influenced by each other. A lot of research is being done on how to use 'public opinion' to predict tendencies in stock-price changes. |
|||
</p><p>'Public opinion' is estimated from sources of large amounts of public data, like tweets, blogs or online news. Research using machinic data analysis shows that the changes in stock prices can be predicted by looking at 'public opinion', to some degree. There are many scientific articles online, which analyse the press on the 'sentiment' expressed in them. An article can be marked as more or less positive or negative. The annotated press articles are then used to train a machine learning model, which predicts stock market trends, marking them as 'down' or 'up'. When a company gets bad press, traders sell. On the contrary, if the news is good, they buy. |
|||
</p><p>A paper by Haikuan Liu of the Australian National University states that the tense of verbs used in tweets can be an indicator of the frequency of financial transactions. His idea is based on the fact that verb conjugation is used in psychology to detect the early stages of human depression. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference_2">Reference</span></h5><p>Paper: <a class="external text" href="http://courses.cecs.anu.edu.au/courses/CSPROJECTS/18S1/reports/u6013799.pdf" rel="nofollow">'Grammatical Feature Extraction and Analysis of Tweet Text: An Application towards Predicting Stock Trends'</a>, Haikuan Liu, Research School of Computer Science (RSCS), College of Engineering and Computer Science (CECS), The Australian National University (ANU) |
|||
</p><h2 id="bag-of-words"><span class="mw-headline" id="Bag_of_words">Bag of words</span></h2><p>In Natural Language Processing (NLP), 'bag of words' is considered to be an unsophisticated model. It strips text of its context and dismantles it into a collection of unique words. These words are then counted. In the previous sentences, for example, 'words' is mentioned three times, but this is not necessarily an indicator of the text's focus. |
|||
</p><p>The first appearance of the expression 'bag of words' seems to go back to 1954. <a class="external text" href="https://en.wikipedia.org/wiki/Zellig_Harris" rel="nofollow">Zellig Harris</a>, an influential linguist, published a paper called 'Distributional Structure'. In the section called 'Meaning as a function of distribution', he says 'for language is not merely a bag of words but a tool with particular properties which have been fashioned in the course of its use. The linguist's work is precisely to discover these properties, whether for descriptive analysis or for the synthesis of quasi-linguistic systems.' |
|||
</p></section></section> |
|||
<h3 id="learners"><span class="mw-headline" id="Learners">Learners</span></h3> |
|||
<p>Learners are the algorithms that distinguish machine learning practices from other types of practices. They are pattern finders, capable of crawling through data and generating some kind of specific 'grammar'. Learners are based on statistical techniques. Some need a large amount of training data in order to function, others can work with a small annotated set. Some perform well in classification tasks, like spam identification, others are better at predicting numbers, like temperatures, distances, stock market values, and so on. |
|||
</p><p>The terminology of machine learning is not yet fully established. Depending on the field, whether statistics, computer science or the humanities, different terms are used. Learners are also called classifiers. When we talk about Learners, we talk about the interwoven functions that have the capacity to generate other functions, evaluate and readjust them to fit the data. They are good at understanding and revealing patterns. But they don't always distinguish well which of the patterns should be repeated. |
|||
</p><p>In software packages, it is not always possible to distinguish the characteristic elements of the classifiers, because they are hidden in underlying modules or libraries. Programmers can invoke them using a single line of code. For this exhibition, we therefore developed two table games that show in detail the learning process of simple, but frequently used classifiers. |
|||
</p> |
|||
<h5 id="works"><span class="mw-headline" id="Works_6">Works</span></h5> |
|||
<section class="group"><section class="lemma naive-bayes-game works"><h3 class="lemmaheader" id="naive-bayes-game">Naive Bayes game</h3><p>by Algolit |
|||
</p><p>In machine learning Naive Bayes methods are simple probabilistic classifiers that are widely applied for spam filtering and deciding whether a text is positive or negative. |
|||
</p><p>They require a small amount of training data to estimate the necessary parameters. They can be extremely fast compared to more sophisticated methods. They are difficult to generalize, which means that they perform on specific tasks, demanding to be trained with the same style of data that will be used to work with afterwards. |
|||
</p><p>This game allows you to play along the rules of Naive Bayes. While manually executing the code, you create your own playful model that 'just works'. A word of caution is necessary: because you only train it with 6 sentences – instead of the minimum 2000 – it is not representative at all! |
|||
</p><hr/><p>Concept & realisation: An Mertens |
|||
</p></section><section class="lemma linear-regression-game works"><h3 class="lemmaheader" id="linear-regression-game">Linear Regression game</h3><p>by Algolit |
|||
</p><p>Linear Regression is one of the best-known and best-understood algorithms in statistics and machine learning. It has been around for almost 200 years. It is an attractive model because the representation is so simple. In statistics, linear regression is a statistical method that allows to summarize and study relationships between two continuous (quantitative) variables. |
|||
</p><p>By playing this game you will realize that as a player you have a lot of decisions to make. You will experience what it means to create a coherent dataset, to decide what is in and what is not in. If all goes well, you will feel the urge to change your data in order to obtain better results. This is part of the art of approximation that is at the basis of all machine learning practices. |
|||
</p><hr/><p>Concept & realisation: An Mertens |
|||
</p></section><section class="lemma traité-de-documentation works"><h3 class="lemmaheader" id="traité-de-documentation">Traité de documentation</h3><p>Traité de Documentation. Three algorithmic poems. |
|||
</p><p>by Rémi Forte, designer-researcher at L’Atelier national de recherche typographique, Nancy, France |
|||
</p><p>serigraphy on paper, 60 × 80 cm, 25 ex., 2019, for sale at the reception of the Mundaneum. |
|||
</p><p>The poems, reproduced in the form of three posters, are an algorithmic and poetic re-reading of Paul Otlet's <i>Traité de documentation</i>. They are the result of an algorithm based on the mysterious rules of human intuition. It has been applied to a fragment taken from Paul Otlet's book and is intended to be representative of his bibliological practice. |
|||
</p><p>For each fragment, the algorithm splits the text, words and punctuation marks are counted and reordered into a list. In each line, the elements combine and exhaust the syntax of the selected fragment. Paul Otlet's language remains perceptible but exacerbated to the point of absurdity. For the reader, the systematization of the text is disconcerting and his reading habits are disrupted. |
|||
</p><p>Built according to a mathematical equation, the typographical composition of the poster is just as systematic as the poem. However, friction occurs occasionally; loop after loop, the lines extend to bite on the neighbouring column. Overlays are created and words are hidden by others. These telescopic handlers draw alternative reading paths. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma contextual-stories-about-learners stories"><h3 class="lemmaheader" id="contextual-stories-about-learners">Contextual stories about Learners</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Naive_Bayes_.26_Viagra"><span class="tocnumber">1</span> <span class="toctext">Naive Bayes & Viagra</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-2"><a href="#Reference"><span class="tocnumber">1.1</span> <span class="toctext">Reference</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Naive_Bayes_.26_Enigma"><span class="tocnumber">2</span> <span class="toctext">Naive Bayes & Enigma</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#A_story_about_sweet_peas"><span class="tocnumber">3</span> <span class="toctext">A story about sweet peas</span></a> |
|||
<ul> |
|||
<li class="toclevel-2 tocsection-5"><a href="#References"><span class="tocnumber">3.1</span> <span class="toctext">References</span></a></li> |
|||
</ul> |
|||
</li> |
|||
<li class="toclevel-1 tocsection-6"><a href="#Perceptron"><span class="tocnumber">4</span> <span class="toctext">Perceptron</span></a></li> |
|||
<li class="toclevel-1 tocsection-7"><a href="#BERT"><span class="tocnumber">5</span> <span class="toctext">BERT</span></a></li> |
|||
</ul> |
|||
</div><h2 id="naive-bayes--viagra"><span class="mw-headline" id="Naive_Bayes_.26_Viagra">Naive Bayes & Viagra</span></h2><p><a class="external text" href="https://en.wikipedia.org/wiki/Naive_Bayes_classifier" rel="nofollow">Naive Bayes</a> is a famous learner that performs well with little data. We apply it all the time. Christian and Griffiths state in their book, <a class="external text" href="http://algorithmstoliveby.com/" rel="nofollow"><i>Algorithms To Live By</i></a>, that 'our days are full of small data'. Imagine, for example, that you're standing at a bus stop in a foreign city. The other person who is standing there has been waiting for 7 minutes. What do you do? Do you decide to wait? And if so, for how long? When will you initiate other options? Another example. Imagine a friend asking advice about a relationship. He's been together with his new partner for a month. Should he invite the partner to join him at a family wedding? |
|||
</p><p>Having pre-existing beliefs is crucial for Naive Bayes to work. The basic idea is that you calculate the probabilities based on prior knowledge and given a specific situation. |
|||
</p><p>The theorem was formulated during the 1740s by <a class="external text" href="https://en.wikipedia.org/wiki/Thomas_Bayes" rel="nofollow">Thomas Bayes</a>, a reverend and amateur mathematician. He dedicated his life to solving the question of how to win the lottery. But Bayes' rule was only made famous and known as it is today by the mathematician <a class="external text" href="https://en.wikipedia.org/wiki/Pierre-Simon_Laplace" rel="nofollow">Pierre Simon Laplace</a> in France a bit later in the same century. For a long time after La Place's death, the theory sank into oblivion until it was dug up again during the Second World War in an effort to break the Enigma code. |
|||
</p><p>Most people today have come in contact with Naive Bayes through their email spam folders. Naive Bayes is a widely used algorithm for spam detection. It is by coincidence that Viagra, the erectile dysfunction drug, was approved by the US Food & Drug Administration in 1997, around the same time as about 10 million users worldwide had made free webmail accounts. The selling companies were among the first to make use of email as a medium for advertising: it was an intimate space, at the time reserved for private communication, for an intimate product. In 2001, the first <a class="external text" href="https://spamassassin.apache.org/" rel="nofollow">SpamAssasin</a> programme relying on Naive Bayes was uploaded to <a class="external text" href="https://sourceforge.net/" rel="nofollow">SourceForge</a>, cutting down on guerilla email marketing. |
|||
</p><h5 id="reference"><span class="mw-headline" id="Reference">Reference</span></h5><p><i>Machine Learners</i>, by Adrian MacKenzie, MIT Press, Cambridge, US, November 2017. |
|||
</p><h2 id="naive-bayes--enigma"><span class="mw-headline" id="Naive_Bayes_.26_Enigma">Naive Bayes & Enigma</span></h2><p>This story about Naive Bayes is taken from the book '<a class="external text" href="https://yalebooks.yale.edu/book/9780300188226/theory-would-not-die" rel="nofollow"><i>The Theory That Would Not Die</i></a>', written by Sharon Bertsch McGrayne. Among other things, she describes how Naive Bayes was soon forgotten after the death of <a class="external text" href="https://en.wikipedia.org/wiki/Pierre-Simon_Laplace" rel="nofollow">Pierre Simon Laplace</a>, its inventor. The mathematician was said to have failed to credit the works of others. Therefore, he suffered widely circulated charges against his reputation. Only after 150 years was the accusation refuted. |
|||
</p><p>Fast forward to 1939, when Bayes' rule was still virtually taboo, dead and buried in the field of statistics. When France was occupied in 1940 by Germany, which controlled Europe's factories and farms, Winston Churchill's biggest worry was the U-boat peril. U-boat operations were tightly controlled by German headquarters in France. Each submarine received orders as coded radio messages long after it was out in the Atlantic. The messages were encrypted by word-scrambling machines, called Enigma machines. <a class="external text" href="https://en.wikipedia.org/wiki/Enigma_machine" rel="nofollow">Enigma</a> looked like a complicated typewriter. It was invented by the German firm Scherbius & Ritter after the First World War, when the need for message-encoding machines had become painfully obvious. |
|||
</p><p>Interestingly, and luckily for Naive Bayes and the world, at that time, the British government and educational systems saw applied mathematics and statistics as largely irrelevant to practical problem-solving. So the British agency charged with cracking German military codes mainly hired men with linguistic skills. Statistical data was seen as bothersome because of its detail-oriented nature. So wartime data was often analysed not by statisticians, but by biologists, physicists, and theoretical mathematicians. None of them knew that the Bayes rule was considered to be unscientific in the field of statistics. Their ignorance proved fortunate. |
|||
</p><p>It was the now famous <a class="external text" href="https://en.wikipedia.org/wiki/Alan_Turing" rel="nofollow">Alan Turing</a> – a mathematician, computer scientist, logician, cryptoanalyst, philosopher and theoretical biologist – who used Bayes' rules probabilities system to design the 'bombe'. This was a high-speed electromechanical machine for testing every possible arrangement that an Enigma machine would produce. In order to crack the naval codes of the U-boats, Turing simplified the 'bombe' system using Baysian methods. It turned the UK headquarters into a code-breaking factory. The story is well illustrated in <a class="external text" href="https://www.imdb.com/title/tt2084970/" rel="nofollow"><i>The Imitation Game</i></a>, a film by Morten Tyldum dating from 2014. |
|||
</p><h2 id="a-story-about-sweet-peas"><span class="mw-headline" id="A_story_about_sweet_peas">A story about sweet peas</span></h2><p>Throughout history, some models have been invented by people with ideologies that are not to our liking. The idea of regression stems from Sir <a class="external text" href="https://en.wikipedia.org/wiki/Francis_Galton" rel="nofollow">Francis Galton</a>, an influential nineteenth-century scientist. He spent his life studying the problem of heredity – understanding how strongly the characteristics of one generation of living beings manifested themselves in the following generation. He established the field of eugenics, defining it as ‘the study of agencies under social control that may improve or impair the racial qualities of future generations, either physically or mentally'. On Wikipedia, Galton is a prime example of scientific racism. |
|||
Galton initially approached the problem of heredity by examining characteristics of the sweet pea plant. He chose this plant because the species can self-fertilize. Daughter plants inherit genetic variations from mother plants without a contribution from a second parent. This characteristic eliminates having to deal with multiple sources. |
|||
</p><p>Galton's research was appreciated by many intellectuals of his time. In 1869, in <a class="external text" href="http://galton.org/books/hereditary-genius/text/pdf/galton-1869-genius-v4.pdf" rel="nofollow"><i>Hereditary Genius</i></a>, Galton claimed that genius is mainly a matter of ancestry and he believed that there was a biological explanation for social inequality across races. Galton even influenced his half-cousin <a class="external text" href="https://en.wikipedia.org/wiki/Charles_Darwin" rel="nofollow">Charles Darwin</a> with his ideas. After reading Galton's paper, Darwin stated, 'You have made a convert of an opponent in one sense for I have always maintained that, excepting fools, men did not differ much in intellect, only in zeal and hard work'. Luckily, the modern study of heredity managed to eliminate the myth of race-based genetic difference, something Galton tried hard to maintain. |
|||
</p><p>Galton's major contribution to the field was linear regression analysis, laying the groundwork for much of modern statistics. While we engage with the field of machine learning, Algolit tries not to forget that ordering systems hold power, and that this power has not always been used to the benefit of everyone. Machine learning has inherited many aspects of statistical research, some less agreeable than others. We need to be attentive, because these world views do seep into the algorithmic models that create new orders. |
|||
</p><h5 id="references"><span class="mw-headline" id="References">References</span></h5><p><a class="external free" href="http://galton.org/letters/darwin/correspondence.htm" rel="nofollow">http://galton.org/letters/darwin/correspondence.htm</a> |
|||
<a class="external free" href="https://www.tandfonline.com/doi/full/10.1080/10691898.2001.11910537" rel="nofollow">https://www.tandfonline.com/doi/full/10.1080/10691898.2001.11910537</a> |
|||
<a class="external free" href="http://www.paramoulipist.be/?p=1693" rel="nofollow">http://www.paramoulipist.be/?p=1693</a> |
|||
</p><h2 id="perceptron"><span class="mw-headline" id="Perceptron">Perceptron</span></h2><p>We find ourselves in a moment in time in which neural networks are sparking a lot of attention. But they have been in the spotlight before. The study of neural networks goes back to the 1940s, when the first neuron metaphor emerged. The neuron is not the only biological reference in the field of machine learning - think of the word corpus or training. The artificial neuron was constructed in close connection to its biological counterpart. |
|||
</p><p>Psychologist <a class="external text" href="https://en.wikipedia.org/wiki/Frank_Rosenblatt" rel="nofollow">Frank Rosenblatt</a> was inspired by fellow psychologist <a class="external text" href="https://en.wikipedia.org/wiki/Donald_O._Hebb" rel="nofollow">Donald Hebb</a>'s work on the role of neurons in human learning. Hebb stated that 'cells that fire together wire together'. His theory now lies at the basis of associative human learning, but also unsupervised neural network learning. It moved Rosenblatt to expand on the idea of the artificial neuron. |
|||
</p><p>In 1962, he created the Perceptron, a model that learns through the weighting of inputs. It was set aside by the next generation of researchers, because it can only handle binary classification. This means that the data has to be clearly separable, as for example, men and women, black and white. It is clear that this type of data is very rare in the real world. When the so-called first AI winter arrived in the 1970s and the funding decreased, the Perceptron was also neglected. For ten years it stayed dormant. When spring settled at the end of the 1980s, a new generation of researchers picked it up again and used it to construct neural networks. These contain multiple layers of Perceptrons. That is how neural networks saw the light. One could say that the current machine learning season is particularly warm, but it takes another winter to know a summer. |
|||
</p><h2 id="bert"><span class="mw-headline" id="BERT">BERT</span></h2><p>Some online articles say that the year 2018 marked a turning point for the field of Natural Language Processing (NLP). A series of deep-learning models achieved state-of-the-art results on tasks like question-answering or sentiment-classification. Google’s BERT algorithm entered the machine learning competitions of last year as a sort of 'one model to rule them all'. It showed a superior performance over a wide variety of tasks. |
|||
</p><p>BERT is pre-trained; its weights are learned in advance through two unsupervised tasks. This means BERT doesn’t need to be trained from scratch for each new task. You only have to finetune its weights. This also means that a programmer wanting to use BERT, does not know any longer what parameters BERT is tuned to, nor what data it has seen to learn its performances. |
|||
</p><p>BERT stands for Bidirectional Encoder Representations from Transformers. This means that BERT allows for bidirectional training. The model learns the context of a word based on all of its surroundings, left and right of a word. As such, it can differentiate between 'I accessed the bank account' and 'I accessed the bank of the river'. |
|||
</p><p>Some facts: |
|||
- BERT_large, with 345 million parameters, is the largest model of its kind. It is demonstrably superior on small-scale tasks to BERT_base, which uses the same architecture with 'only' 110 million parameters. |
|||
- to run BERT you need to use TPUs. These are the Google's processors (CPUs) especially engineered for TensorFLow, the deep-learning platform. TPU's renting rates range from $8/hr till $394/hr. Algolit doesn't want to work with off-the-shelf packages, we are interested in opening up the blackbox. In that case, BERT asks for quite some savings in order to be used. |
|||
</p></section></section> |
|||
<h2 id="glossary"><span class="mw-headline" id="Glossary">Glossary</span></h2> |
|||
<p>This is a non-exhaustive wordlist, based on terms that are frequently used in the exhibition. It might help visitors who are not familiar with the vocabulary related to the field of Natural Language Processing (NLP), Algolit or the Mundaneum. |
|||
</p><p><b>* Algolit:</b> A group from Brussels involved in artistic research on algorithms and literature. Every month they gather to experiment with code and texts that are published under free licenses. <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a> |
|||
</p><p><b>* Algoliterary:</b> Word invented by Algolit for works that explore the point of view of the algorithmic storyteller. What kind of new forms of storytelling do we make possible in dialogue with machinic agencies? |
|||
</p><p><b>* Algorithm:</b> A set of instructions in a specific programming language, that takes an input and produces an output. |
|||
</p><p><b>* Annotation:</b> The annotation process is a crucial step in supervised machine learning where the algorithm is given examples of what it needs to learn. A spam filter in training will be fed examples of spam and real messages. These examples are entries, or rows from the dataset with a label, spam or non-spam. The labelling of a dataset is work executed by humans, they pick a label for each row of the dataset. To ensure the quality of the labels multiple annotators see the same row and have to give the same label before an example is included in the training data. |
|||
</p><p><b>* AI or artificial intelligences:</b> In computer science, artificial intelligence (AI), sometimes called machine intelligence, is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and other animals. Computer science defines AI research as the study of ‘intelligent agents’. Any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals. More specifically, Kaplan and Haenlein define AI as ‘a system’s ability to correctly interpret external data, to learn from such data, and to use those learnings to achieve specific goals and tasks through flexible adaptation’. Colloquially, the term ‘artificial intelligence’ is used to describe machines that mimic ‘cognitive’ functions that humans associate with other human minds, such as ‘learning’ and ‘problem solving’. (Wikipedia) |
|||
</p><p><b>* Bag of Words:</b> The bag-of-words model is a simplifying representation of text used in Natural Language Processing (NLP). In this model, a text is represented as a collection of its unique words, disregarding grammar, punctuation and even word order. The model transforms the text into a list of words and how many times they're used in the text, or quite literally a bag of words. Bag of words is often used as a baseline, on which the new model has to perform better. |
|||
</p><p><b>* Character n-gram:</b> A technique that is used for authorship recognition. When using character n-grams, texts are considered as sequences of characters. Let's consider the character trigram. All the overlapping sequences of three characters are isolated. For example, the character 3-grams of 'Suicide', would be, 'Sui', 'uic', 'ici', 'cid' etc. Patterns found with character n-grams focus on stylistic choices that are unconsciously made by the author. The patterns remain stable over the full length of the text. |
|||
</p><p><b>* Classical Machine Learning:</b> Naive Bayes, Support Vector Machines and Linear Regression are called classical machine learning algorithms. They perform well when learning with small datasets. But they often require complex Readers. The task the Readers do, is also called feature-engineering (see below). This means that a human needs to spend time on a deep exploratory data analysis of the dataset. |
|||
</p><p><b>* Constant:</b> Constant is a non-profit, artist-run organisation based in Brussels since 1997 and active in the fields of art, media and technology. Algolit started as a project of Constant in 2012. <a class="external free" href="http://constantvzw.org" rel="nofollow">http://constantvzw.org</a> |
|||
</p><p><b>* Data workers:</b> Artificial intelligences that are developed to serve, entertain, record and know about humans. The work of these machinic entities is usually hidden behind interfaces and patents. In the exhibition, algorithmic storytellers leave their invisible underworld to become interlocutors. |
|||
</p><p><b>* Dump:</b> According to the English dictionary, a dump is an accumulation of refused and discarded materials or the place where such materials are dumped. In computing a dump refers to a ‘database dump’, a record of data from a database used for easy downloading or for backing up a database. Database dumps are often published by free software and free content projects, such as Wikipedia, to allow reuse or forking of the database. |
|||
</p><p><b>* Feature engineering:</b> The process of using domain knowledge of the data to create features that make machine learning algorithms work. This means that a human needs to spend time on a deep exploratory data analysis of the dataset. |
|||
In Natural Language Processing (NLP) features can be the frequency of words or letters, but also syntactical elements like nouns, adjectives, or verbs. The most significant features for the task to be solved, must be carefully selected and passed over to the classical machine learning algorithm. |
|||
</p><p><b>* FLOSS or Free Libre Open Source Software:</b> Software that anyone is freely licensed to use, copy, study, and change in any way, and the source code is openly shared so that people are encouraged to voluntarily improve the design of the software. This is in contrast to proprietary software, where the software is under restrictive copyright licensing and the source code is usually hidden from the users. (Wikipedia) |
|||
</p><p><b>* git:</b> A software system for tracking changes in source code during software development. It is designed for coordinating work among programmers, but it can be used to track changes in any set of files. Before starting a new project, programmers create a "git repository" in which they will publish all parts of the code. The git repositories of Algolit can be found on <a class="external free" href="https://gitlab.constantvzw.org/algolit" rel="nofollow">https://gitlab.constantvzw.org/algolit</a>. |
|||
</p><p><b>* gutenberg.org:</b> Project Gutenberg is an online platform run by volunteers to ‘encourage the creation and distribution of eBooks’. It was founded in 1971 by American writer Michael S. Hart and is the oldest digital library. Most of the items in its collection are the full texts of public domain books. The project tries to make these as free as possible, in long-lasting, open formats that can be used on almost any computer. As of 23 June 2018, Project Gutenberg reached 57,000 items in its collection of free eBooks. (Wikipedia) |
|||
</p><p><b>* Henri La Fontaine:</b> Henri La Fontaine (1854-1943) is a Belgian politician, feminist and pacifist. He was awarded the Nobel Peace Prize in 1913 for his involvement in the International Peace Bureau and his contribution to the organization of the peace movement. In 1895, together with Paul Otlet, he created the International Bibliography Institute, which became the Mundaneum. Within this institution, which aimed to bring together all the world's knowledge, he contributed to the development of the Universal Decimal Classification (CDU) system. |
|||
</p><p><b>* Kaggle:</b> An online platform where users find and publish data sets, explore and build machine learning models, work with other data scientists and machine learning engineers, and enter competitions to solve data science challenges. About half a million data scientists are active on Kaggle. It was founded by Goldbloom and Ben Hamner in 2010 and acquired by Google in March 2017. |
|||
</p><p><b>* Literature:</b> Algolit understands the notion of literature in the way a lot of other experimental authors do. It includes all linguistic production, from the dictionary to the Bible, from Virginia Woolf's entire work to all versions of Terms of Service published by Google since its existence. |
|||
</p><p><b>* Machine learning models:</b> Algorithms based on statistics, mainly used to analyse and predict situations based on existing cases. In this exhibition we focus on machine learning models for text processing or Natural language processing', in short, 'nlp'. These models have learned to perform a specific task on the basis of existing texts. The models are used for search engines, machine translations and summaries, spotting trends in new media networks and news feeds. They influence what you get to see as a user, but also have their word to say in the course of stock exchanges worldwide, the detection of cybercrime and vandalism, etc. |
|||
</p><p><b>* Markov Chain:</b> Algorithm that scans the text for the transition probability of letter or word occurrences, resulting in transition probability tables which can be computed even without any semantic or grammatical natural language understanding. It can be used for analyzing texts, but also for recombining them. It is is widely used in spam generation. |
|||
</p><p><b>* Mechanical Turk:</b> The Amazon Mechanical Turk is an online platform for humans to execute tasks that algorithms cannot. Examples include annotating sentences as being positive or negative, spotting number plates, discriminating between face and non-face. The jobs posted on this platform are often paid less than a cent per task. Tasks that are more complex or require more knowledge can be paid up to several cents. Many academic researchers use Mechanical Turk as an alternative to have their students execute these tasks. |
|||
</p><p><b>* Mundaneum:</b> In the late nineteenth century two young Belgian jurists, Paul Otlet (1868-1944), ‘the father of documentation’, and Henri La Fontaine (1854-1943), statesman and Nobel Peace Prize winner, created The Mundaneum. The project aimed at gathering all the world’s knowledge and file it using the Universal Decimal Classification (UDC) system that they had invented. |
|||
</p><p><b>* Natural Language:</b> A natural language or ordinary language is any language that has evolved naturally in humans through use and repetition without conscious planning or premeditation. Natural languages can take different forms, such as speech or signing. They are different from constructed and formal languages such as those used to program computers or to study logic. (Wikipedia) |
|||
</p><p><b>* NLP or Natural Language Processing:</b> Natural language processing (NLP) is a collective term referring to automatic computational processing of human languages. This includes algorithms that take human-produced text as input, and attempt to generate text that resembles it. |
|||
</p><p><b>* Neural Networks:</b> Computing systems inspired by the biological neural networks that constitute animal brains. The neural network itself is not an algorithm, but rather a framework for many different machine learning algorithms to work together and process complex data inputs. Such systems ‘learn’ to perform tasks by considering examples, generally without being programmed with any task-specific rules. For example, in image recognition, they might learn to identify images that contain cats by analyzing example images that have been manually labeled as ‘cat’ or ‘no cat’ and using the results to identify cats in other images. They do this without any prior knowledge about cats, for example, that they have fur, tails, whiskers and cat-like faces. Instead, they automatically generate identifying characteristics from the learning material that they process. (Wikipedia) |
|||
</p><p><b>* Optical Character Recognition (OCR):</b> Computer processes for translating images of scanned texts into manipulable text files. |
|||
</p><p><b>* Oracle:</b> Oracles are prediction or profiling machines, a specific type of algorithmic models, mostly based on statistics. They are widely used in smartphones, computers, tablets. |
|||
</p><p><b>* Oulipo:</b> Oulipo stands for Ouvroir de litterature potentielle (Workspace for Potential Literature). Oulipo was created in Paris by the French writers Raymond Queneau and François Le Lionnais. They rooted their practice in the European avant-garde of the twentieth century and in the experimental tradition of the 1960s. For Oulipo, the creation of rules becomes the condition to generate new texts, or what they call potential literature. Later, in 1981, they also created <a class="external text" href="http://www.alamo.free.fr/" rel="nofollow">ALAMO</a>, Atelier de littérature assistée par la mathématique et les ordinateurs (Workspace for literature assisted by maths and computers). |
|||
</p><p><b>* Paul Otlet:</b> Paul Otlet (1868 – 1944) was a Belgian author, entrepreneur, visionary, lawyer and peace activist; he is one of several people who have been considered the father of information science, a field he called 'documentation'. Otlet created the Universal Decimal Classification, that was widespread in libraries. Together with Henri La Fontaine he created the Palais Mondial (World Palace), later, the Mundaneum to house the collections and activities of their various organizations and institutes. |
|||
</p><p><b>* Python:</b> The main programming language that is globally used for natural language processing, was invented in 1991 by the Dutch programmer Guido Van Rossum. |
|||
</p><p><b>* Rule-Based models:</b> Oracles can be created using different techniques. One way is to manually define rules for them. As prediction models they are then called rule-based models, opposed to statistical models. Rule-based models are handy for tasks that are specific, like detecting when a scientific paper concerns a certain molecule. With very little sample data, they can perform well. |
|||
</p><p><b>* Sentiment analysis:</b> Also called 'opinion mining'. A basic task in sentiment analysis is classifying a given text as positive, negative, or neutral. Advanced, 'beyond polarity' sentiment classification looks, for instance, at emotional states such as 'angry', 'sad', and 'happy'. Sentiment analysis is widely applied to user materials such as reviews and survey responses, comments and posts on social media, and healthcare materials for applications that range from marketing to customer service, from stock exchange transactions to clinical medicine. |
|||
</p><p><b>* Supervised machine learning models:</b> For the creation of supervised machine learning models, humans annotate sample text with labels before feeding it to a machine to learn. Each sentence, paragraph or text is judged by at least 3 annotators: whether it is spam or not spam, positive or negative etc. |
|||
</p><p><b>* Training data:</b> Machine learning algorithms need guidance. In order to separate one thing from another, they need texts to extract patterns from. One should carefully choose the training material, and adapt it to the machine's task. It doesn't make sense to train a machine with nineteenth-century novels if its mission is to analyze tweets. |
|||
</p><p><b>* Unsupervised Machine Learning Models:</b> Unsupervised machine learning models don't need the step of annotation of the data by humans. This saves a lot of time, energy, money. Instead, they need a large amount of training data, which is not always available and can take a long cleaning time beforehand. |
|||
</p><p><b>* Word embeddings:</b> Language modelling techniques that through multiple mathematical operations of counting and ordering, plot words into a multi-dimensional vector space. When embedding words, they transform from being distinct symbols into mathematical objects that can be multiplied, divided, added or substracted. |
|||
</p><p><b>* Wordnet:</b> Wordnet is a combination of a dictionary and a thesaurus that can be read by machines. According to Wikipedia it was created in the Cognitive Science Laboratory of Princeton University starting in 1985. The project was initially funded by the US Office of Naval Research and later also by other US government agencies including DARPA, the National Science Foundation, the Disruptive Technology Office (formerly the Advanced Research and Development Activity), and REFLEX. |
|||
</p> |
|||
<!-- |
|||
NewPP limit report |
|||
Cached time: 20190325070945 |
|||
Cache expiry: 86400 |
|||
Dynamic content: false |
|||
CPU time usage: 0.072 seconds |
|||
Real time usage: 0.073 seconds |
|||
Preprocessor visited node count: 63/1000000 |
|||
Preprocessor generated node count: 68/1000000 |
|||
Post‐expand include size: 0/2097152 bytes |
|||
Template argument size: 0/2097152 bytes |
|||
Highest expansion depth: 2/40 |
|||
Expensive parser function count: 0/100 |
|||
--> |
|||
<!-- |
|||
Transclusion expansion time report (%,ms,calls,template) |
|||
100.00% 0.000 1 - -total |
|||
--> |
|||
<!-- Saved in parser cache with key algolit-mw_:pcache:idhash:2855-1!*!0!!*!*!* and timestamp 20190325070945 and revision id 11638 |
|||
--> |
|||
</section></body> |
|||
</html> |
|||
File diff suppressed because it is too large
@ -0,0 +1,521 @@ |
|||
<!DOCTYPE html> |
|||
|
|||
<html> |
|||
<head> |
|||
<meta charset="utf-8"/> |
|||
<title>Data Workers</title> |
|||
<!-- <link rel="stylesheet" href="stylesheet.css"> --> |
|||
</head> |
|||
<body> |
|||
<section class="language fr"><p><br/> |
|||
Une exposition visible au <a class="external text" href="http://www.mundaneum.org" rel="nofollow">Mundaneum</a> à Mons du jeudi 28 mars jusqu'au dimanche 28 avril 2019. |
|||
</p><p>Le <b>vernissage</b> aura lieu <b>le jeudi 28 mars de 18h à 22h</b>. Dans le cadre de l’exposition, nous invitons <a class="external text" href="https://www.decontextualize.com/" rel="nofollow">Allison Parrish</a>, une poétesse algolittéraire de New York. Elle donnera une <b>conférence</b> à <a class="external text" href="https://www.passaporta.be/fr" rel="nofollow">Passa Porta</a> le jeudi soir 25 avril et un <b>atelier</b> au Mundaneum le vendredi 26 avril. |
|||
</p> |
|||
<h2 id="á-propos"><span class="mw-headline" id=".C3.81_Propos">Á Propos</span></h2> |
|||
<p>Data Workers est une <b>exposition d'œuvres algolittéraires</b>,visible au <a class="external text" href="http://www.mundaneum.org" rel="nofollow">Mundaneum</a> à Mons du jeudi 28 mars jusqu'au dimanche 28 avril 2019. Elle expose des histoires racontées d'un point de vue 'narratif algorithmique'. L'exposition est une création des membres d'Algolit, un groupe bruxellois impliqué dans la recherche artistique sur les algorithmes et la littérature. Chaque mois, ils se réunissent pour expérimenter avec du code et des textes F/LOSS. Certaines oeuvres sont réalisés par des étudiants de Arts² et des participants externes à l'atelier sur le machine learning et le texte organisé par Algolit en octobre 2018 au Mundaneum. |
|||
</p><p>Les entreprises créent des <b>intelligences artificielles</b> pour servir, divertir, enregistrer et connaître les humains. Le travail de ces entités machiniques est généralement dissimulé derrière des interfaces et des brevets. Dans l'exposition, les conteurs algorithmiques quittent leur monde souterrain invisible pour devenir des interlocuteurs. |
|||
Les 'data workers' opèrent dans des <b>collectifs</b> différents. Chaque collectif représente une étape dans le processus de conception d'un modèle d'apprentissage automatique : il y a les Écrivains, les Nettoyeurs, les Informateurs, les Lecteurs, les Apprenants et les Oracles. Les robots donnent leurs voix à la littérature expérimentale, les modèles algorithmiques lisent des données, transforment des mots en nombres, calculent des modèles et traitent en boucle de nouveaux textes et ceci à l'infini. |
|||
</p><p>L'exposition met <b>au premier plan</b> les 'data workers' qui ont un impact sur notre vie quotidienne, mais qui sont difficiles à saisir ou à imaginer. Elle établit un lien entre les récits sur les algorithmes dans les médias grand public et les histoires racontées dans les manuels techniques et les articles universitaires. Les robots sont invités à dialoguer avec les visiteurs humains et vice versa. De cette façon, nous pourrions comprendre nos raisonnements respectifs, démystifier nos comportements, rencontrer nos personnalités multiples et valoriser notre travail collectif. C'est aussi un hommage aux nombreuses machines que <a class="external text" href="https://en.wikipedia.org/wiki/Paul_Otlet" rel="nofollow">Paul Otlet</a> et <a class="external text" href="https://en.wikipedia.org/wiki/Henri_La_La_Fontaine" rel="nofollow">Henri La Fontaine</a> ont imaginées pour leur Mundaneum, en montrant leur potentiel mais aussi leurs limites. |
|||
</p> |
|||
<hr/> |
|||
<p><b>Data Workers</b> est une création de <a class="external text" href="http://www.algolit.net" rel="nofollow">Algolit</a>. |
|||
</p><p><b>Oeuvres de</b>: Cristina Cochior, Gijs de Heij, Sarah Garcin, An Mertens, Javier Lloret, Louise Dekeuleneer, Florian Van de Weyer, Laetitia Trozzi, Rémi Forte, Guillaume Slizewicz, Michael Murtaugh, Manetta Berends, Mia Melvær. |
|||
</p><p><b>Une co-production de</b>: <a class="external text" href="http://blog.artsaucarre.be/artsnumeriques/" rel="nofollow">Arts²</a>, <a class="external text" href="http://expositions.mundaneum.org/en/expositions/data-workers" rel="nofollow">Mundaneum</a>, <a class="external text" href="http://constantvzw.org" rel="nofollow">Constant</a>. |
|||
</p><p><b>Avec le soutien de</b>: <a class="external text" href="http://www.arts-numeriques.culture.be/" rel="nofollow">Fédération Wallonie-Bruxelles, Arts Numériques</a>, <a class="external text" href="https://www.passaporta.be/en" rel="nofollow">Passa Porta</a>, Ugent, <a class="external text" href="https://www.uantwerpen.be/en/faculties/faculty-of-arts/research-and-valoris/research-axes/digital-humanities/" rel="nofollow">DHuF - Digital Humanities Flanders</a> et <a class="external text" href="https://www.pgdp.net/c/" rel="nofollow">the Distributed Proofreading Project</a>. |
|||
</p><p><b>Remerciements</b>: Mike Kestemont, Michel Cleempoel, Donatella Portoghese, François Zajéga, Raphaèle Cornille, Vincent Desfromont, Kris Rutten, Anne-Laure Buisson, David Stampfli. |
|||
</p> |
|||
<section class="group"><section class="lemma récits-contextualisés-autour-dalgolit works"><h3 class="lemmaheader" id="récits-contextualisés-autour-dalgolit">Récits contextualisés autour d'Algolit</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Pourquoi_des_r.C3.A9cits_contextualis.C3.A9s.3F"><span class="tocnumber">1</span> <span class="toctext">Pourquoi des récits contextualisés?</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#Nous_cr.C3.A9ons_des_.C5.93uvres_.27algolitt.C3.A9raires.27"><span class="tocnumber">2</span> <span class="toctext">Nous créons des œuvres 'algolittéraires'</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Qu.27est-ce_que_la_litt.C3.A9rature_.3F"><span class="tocnumber">3</span> <span class="toctext">Qu'est-ce que la littérature ?</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#Une_diff.C3.A9rence_importante"><span class="tocnumber">4</span> <span class="toctext">Une différence importante</span></a></li> |
|||
</ul> |
|||
</div><h2 id="pourquoi-des-récits-contextualisés"><span class="mw-headline" id="Pourquoi_des_r.C3.A9cits_contextualis.C3.A9s.3F">Pourquoi des récits contextualisés?</span></h2><p>Lors des réunions mensuelles d'Algolit, nous étudions des manuels et expérimentons avec des outils d'apprentissage automatique pour le traitement de texte. Et nous partageons aussi beaucoup, beaucoup d'histoires. Avec la publication de ces histoires, nous espérons recréer un peu de cette atmosphère. Les histoires existent également sous forme de podcasts qui peuvent être téléchargés à partir du site <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a>. |
|||
</p><h2 id="nous-créons-des-œuvres-algolittéraires"><span class="mw-headline" id="Nous_cr.C3.A9ons_des_.C5.93uvres_.27algolitt.C3.A9raires.27">Nous créons des œuvres 'algolittéraires'</span></h2><p>Le terme 'algolittéraire' vient du nom de notre groupe de recherche Algolit. Nous existons depuis 2012 en tant qu’initiative de Constant, une organisation oeuvrant dans les médias et les arts basée à Bruxelles. Nous sommes des artistes, des écrivains, des designers et des programmeurs. Une fois par mois, nous nous rencontrons pour étudier et expérimenter ensemble. Notre travail peut être copié, étudié, modifié et redistribué sous la même licence libre. Vous trouverez toutes les informations sur le site <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a>. |
|||
</p><p>L'objectif principal d'Algolit est d'explorer le point de vue du conteur algorithmique. Quelles nouvelles formes de narration rendons-nous possibles en dialoguant avec ces agents machiniques ? Les points de vue narratifs sont inhérents aux visions du monde et aux idéologies. <i>Don Quichotte</i>, par exemple, a été écrit d'un point de vue omniscient à la troisième personne, montrant la relation de Cervantes à la tradition orale. La plupart des romans contemporains utilisent le point de vue de la première personne. Algolit souhaite parler au travers des algorithmes et vous montrer le raisonnement de l'un des groupes les plus cachés de notre planète. |
|||
</p><p>Écrire dans ou par le code, c'est créer de nouvelles formes de littérature qui façonnent le langage humain de façon inattendue. Mais les techniques d'apprentissage automatique ne sont accessibles qu'à ceux qui savent lire, écrire et exécuter du code. La fiction est un moyen de combler le fossé entre les histoires qui existent dans les articles scientifiques, les manuels techniques, et les histoires diffusées par les médias, souvent limitées aux reportages superficiels et à la fabrication de mythes. En créant des œuvres algolittéraires, nous offrons aux humains une introduction aux techniques qui co-modèlent leur vie quotidienne. |
|||
</p><h2 id="quest-ce-que-la-littérature-"><span class="mw-headline" id="Qu.27est-ce_que_la_litt.C3.A9rature_.3F">Qu'est-ce que la littérature ?</span></h2><p>Algolit comprend la notion de littérature comme beaucoup d'autres auteurs expérimentaux : elle inclut toute la production linguistique, du dictionnaire à la Bible, de l'œuvre entière de Virginia Woolf à toutes les versions des Conditions d'utilisation publiées par Google depuis son existence. En ce sens, le code de programmation peut aussi être de la littérature. Le collectif <a class="external text" href="https://oulipo.net/" rel="nofollow">Oulipo</a>, acronyme d'Ouvroir de Littérature Potentielle, est une grande source d'inspiration pour Algolit. Oulipo a été créé à Paris par les écrivains <a class="external text" href="https://fr.wikipedia.org/wiki/Raymond_Queneau" rel="nofollow">Raymond Queneau</a> et <a class="external text" href="https://fr.wikipedia.org/wiki/Fran%C3%A7ois_Le_Lionnais" rel="nofollow">François Le Lionnais</a>. Ils ont ancré leur pratique dans l'avant-garde européenne du XXe siècle et dans la tradition expérimentale des années 60. Pour Oulipo, la création de règles devient la condition permettant de générer de nouveaux textes, ou ce qu'ils appellent la littérature potentielle. Plus tard, en 1981, ils ont également créé <a class="external text" href="http://lapal.free.fr/alamo/index.html" rel="nofollow">ALAMO</a> - Atelier de Littérature Assistée par la Mathématique et les Ordinateurs. |
|||
</p><h2 id="une-différence-importante"><span class="mw-headline" id="Une_diff.C3.A9rence_importante">Une différence importante</span></h2><p>Alors que l'avant-garde européenne du XXe siècle poursuivait l'objectif de rompre avec les conventions, les membres d'Algolit cherchent à rendre les conventions visibles. |
|||
</p><p><i>J'écris : Je vis dans mon journal, je l'investis, je le traverse.</i> (Espèces d'espaces. Journal d'un usager de l'espace, Galilée, Paris, 1974) |
|||
</p><p>Cette citation de <a class="external text" href="https://fr.wikipedia.org/wiki/Georges_Perec" rel="nofollow">Georges Perec</a> dans Espèces d'espaces pourrait être reprise par Algolit. Il ne s'agit pas des conventions de la page blanche et du marché littéraire, comme Georges Perec l'a fait. Nous faisons référence aux conventions qui restent souvent cachées derrière les interfaces et les brevets. Comment les technologies sont-elles conçues, mises en œuvre et utilisées, tant dans les universités que dans les entreprises ? Nous proposons des histoires qui révèlent le système hybride complexe qui rend possible l'apprentissage automatique. Nous parlons des outils, des logiques et des idéologies derrière les interfaces. Nous examinons également qui produit les outils, qui les met en œuvre et qui crée et accède aux grandes quantités de données nécessaires au développement de machines de prédiction. On pourrait dire, en un clin d'œil, que nous sommes les collaborateurs de cette nouvelle tribu d'hybrides humain-robot. |
|||
</p></section></section> |
|||
<h2 id="au-mundaneum"><span class="mw-headline" id="Au_Mundaneum">Au Mundaneum</span></h2> |
|||
<p>À la fin du 19ème siècle, deux jeunes juristes belges, <a class="external text" href="https://en.wikipedia.org/wiki/Paul_Otlet" rel="nofollow">Paul Otlet</a> (1868-1944), 'père de la documentation', et <a class="external text" href="https://en.wikipedia.org/wiki/Henri_La_La_Fontaine" rel="nofollow">Henri La Fontaine</a> (1854-1943), homme d'État et prix Nobel de la paix, créent le Mundaneum. Le projet vise à rassembler toute la connaissance du monde et à la classer à l'aide du système de <a class="external text" href="https://fr.wikipedia.org/wiki/Classification_d%C3%A9cimale_universelle" rel="nofollow">Classification décimale universelle</a> (UDC) qu'ils inventent. Au début, il s'agit d'un Bureau des institutions internationales dédié à l'échange international des connaissances. Au XXe siècle, le <a class="external text" href="https://fr.wikipedia.org/wiki/Mundaneum" rel="nofollow">Mundaneum</a> devient un centre universel de documentation. Ses collections sont constituées de milliers de livres, journaux, revues, documents, affiches, plaques de verre et cartes postales indexés sur des millions de fiches référencées. Les collections sont exposées et conservées dans différents bâtiments à Bruxelles, dont le <a class="external text" href="https://fr.wikipedia.org/wiki/Parc_du_Cinquantenaire" rel="nofollow">Palais du Cinquantenaire</a>. Le reste des archives n'est transféré à Mons qu'en 1998. |
|||
</p><p>Sur base du Mundaneum, les deux hommes conçoivent une ville du monde pour laquelle <a class="external text" href="https://fr.wikipedia.org/wiki/Le_Corbusier" rel="nofollow">Le Corbusier</a> réalise des maquettes et des plans. L'objectif de la Ville du Monde est de rassembler, au niveau mondial, les institutions du travail intellectuel : bibliothèques, musées et universités. Mais le projet n’est jamais réalisé, souffrant de sa propre utopie. Le Mundaneum est le résultat du rêve visionnaire d’une infrastructure pour l'échange universel des connaissances. Il atteint des dimensions mythiques à l'époque. Lorsqu'on observe les archives qui ont été concrètement développées, cette collection est plutôt éclectique et spécifique. |
|||
</p><p>Les intelligences artificielles se développent aujourd'hui en faisant apparaître des rêves d'universalité et de la production des connaissances. En les étudiant, nous nous sommes rendus compte que les rêves visionnaires de leurs créateurs sont bien présents dès leur développement dans les années 1950. Aujourd'hui, leurs promesses ont également atteint des dimensions mythiques. Lorsqu'on observe leurs applications concrètes, la collection d'outils est réellement innovante et fascinante, mais en même temps, tout aussi éclectique et spécifique. Pour Data Workers, Algolit a combiné certaines de ces applications avec 10 % des publications numérisées du Bureau des Institutions Internationales. Ainsi et de façon poétique, nous espérons ouvrir une discussion à propos des machines, des algorithmes et des infrastructures technologiques. |
|||
</p> |
|||
<h2 id="zones"><span class="mw-headline" id="Zones">Zones</span></h2> |
|||
<h3 id="écrivains"><span class="mw-headline" id=".C3.89crivains">Écrivains</span></h3> |
|||
<p>Les Data Workers ont besoin de données pour travailler. Dans le contexte d'Algolit, celles-ci prennent la forme du langage écrit. L'apprentissage automatique repose sur de nombreux types d'écriture. Les auteurs humains écrivent sous forme de publications. Celles-ci sont organisées en archives et en cours de numérisation. Mais il existe d'autres types d'écriture. On pourrait dire que chaque être humain avec un accès à Internet devient un écrivain lorsqu'il interagit avec des algorithmes. En ajoutant des commentaires, en écrivant des mails ou des articles Wikipédia, en cliquant et en aimant. |
|||
</p><p>Les algorithmes d'apprentissage automatique ne sont pas critiques : ils prennent tout ce qu'on leur donne, peu importe le style d'écriture, le CV de l'auteur ou ses fautes d'orthographe. D’ailleurs, plus il y a d’erreurs, mieux c’est : la variété leur apprend à anticiper les textes inattendus. Les auteurs humains quant à eux ne sont souvent pas conscients de ce qui advient de leur travail. |
|||
</p><p>La plupart des textes que nous utilisons sont en anglais, certains en français, d'autres en néerlandais. Souvent, nous nous retrouvons à écrire en Python, le langage de programmation que nous utilisons. Les algorithmes peuvent aussi être des écrivains. Certains réseaux de neurones écrivent leurs propres règles et génèrent leurs propres textes. Et pour les modèles qui luttent encore contre les ambiguïtés du langage naturel, il existe des éditeurs humains pour les aider. Poètes, dramaturges ou romanciers commencent leur nouvelle carrière comme assistants de l'IA. |
|||
</p> |
|||
<h5 id="oeuvres"><span class="mw-headline" id="Oeuvres">Oeuvres</span></h5> |
|||
<section class="group"><section class="lemma la-publication-de-data-workers works"><h3 class="lemmaheader" id="la-publication-de-data-workers">La publication de Data Workers</h3><p>Toutes les œuvres visibles dans l'exposition, ainsi que les histoires contextuelles et quelques textes supplémentaires ont été rassemblés dans une publication. Celle-ci existe en français et en anglais. |
|||
</p><p>Cette publication est réalisée en suivant un flux de travail en texte brut, basé sur divers outils de traitement de texte et de calcul. Le format de fichier 'texte brut' est le format le plus utilisé dans les modèles d'apprentissage automatique. C'est un type de document dans lequel il n'existe pas de différence structurelle entre les en-têtes et les paragraphes. Ce format a été le point de départ d'un processus de conception graphique ludique, dans lequel les pages sont soigneusement comptées, page par page, ligne par ligne et caractère par caractère. |
|||
</p><p>Chaque page contient 110 caractères par ligne et 70 lignes par page. La mise-en-page est donc le résultat d'un acte de calcul de mots, d'espaces et de lignes. Il joue avec des choix aléatoires, des motifs programmés et des polices ASCII/UNICODE, afin de spéculer sur la matérialité du texte numérique et d'explorer les interrelations entre l'acte de compter et d'écrire avec des mots et des numéros. |
|||
</p><p><b>Textes</b>: Cristina Cochior, Sarah Garcin, Gijs de Heij, An Mertens, François Zajéga, Louise Dekeuleneer, Florian Van de Weyer, Laetitia Trozzi, Rémi Forte, Guillaume Slizewicz. |
|||
</p><p><b>Traductions & relectures</b>: deepl.com, Michel Cleempoel, Elodie Mugrefya, Patrick Lennon, Emma Kraak. |
|||
</p><p><b>Mise-en-page & couverture</b>: Manetta Berends |
|||
</p><p><b>Editeur responsable</b>: Constant vzw/asbl, Rue du Fortstraat 5, 1060 Bruxelles |
|||
</p><p><b>Licence</b>: Algolit, Data Workers, mars 2019, Bruxelles. Copyleft: cette oeuvre est libre, vous pouvez la redistribuer et/ou la modifier selon les termes de la Licence Art Libre. |
|||
</p><p><b>Version en ligne</b>: <a class="external free" href="http://www.algolit.net/index.php/Data_Workers_FR" rel="nofollow">http://www.algolit.net/index.php/Data_Workers_FR</a> |
|||
</p><p><b>Sources</b>: <a class="external free" href="https://gitlab.constantvzw.org/algolit/mundaneum" rel="nofollow">https://gitlab.constantvzw.org/algolit/mundaneum</a> |
|||
</p></section><section class="lemma le-podcast-de-data-workers works"><h3 class="lemmaheader" id="le-podcast-de-data-workers">Le podcast de Data Workers</h3><p>Par Algolit |
|||
</p><p>Lors des réunions mensuelles d'Algolit, nous étudions des manuels et expérimentons avec des outils d'apprentissage automatique pour le traitement de texte. Mais nous partageons aussi énormément d'histoires. Avec ce podcast, nous espérons recréer cette atmosphère. |
|||
</p><p>Pour les non-initiés, les algorithmes ne deviennent visibles dans les médias que lorsqu'ils se révèlent capables d'une performance exceptionnelle, comme l'Alpha Go, ou quand ils se trompent d'une façon terrifiante et fantastique. Mais les humains qui travaillent sur le terrain créent leur propre culture en ligne et hors ligne. Ils partagent leurs meilleures histoires et expériences lors de réunions en direct, de conférences de recherche ou de compétitions annuelles comme celle du Kaggle. Ces histoires qui contextualisent les outils et les pratiques peuvent être drôles, tristes, choquantes et intéressantes. |
|||
</p><p>Ce sont souvent des histoires d'apprentissage par l’expérience. La mise en œuvre des algorithmes dans la société génère de nouvelles conditions de travail, de stockage, d'échange, de comportement et de copier-coller. À leur manière, ces histoires contextuelles saisissent l’élan d’une histoire anthropo-machinique plus large, écrite par de nombreuses voix et à pleine vitesse. Elles sont aussi reprises dans la publication de l'exposition. |
|||
</p><hr/><p><b>Voix</b>: Elodie Mugrefya, Michel Cleempoel, Géraldine Renauld, An Mertens, Donatella Portoghese, Peter Westenberg. |
|||
</p><p><b>Composition</b>: Javier Lloret |
|||
</p><p><b>Enregistrements</b>: David Stampfli |
|||
</p><p><b>Textes</b>: Cristina Cochior, An Mertens |
|||
</p></section><section class="lemma markbot-chain works"><h3 class="lemmaheader" id="markbot-chain">Markbot Chain</h3><p>Par Florian Van de Weyer, étudiant Arts²/Section Arts Numériques |
|||
</p><p>Markbot Chain est une expérimentation sociale dans laquelle le public a une influence directe sur le résultat. L'intention est de l'intégrer au cœur d'un processus de génération de texte sans appliquer de filtre sur ses entrées. Le bot fonctionnera durant toute la durée de l'exposition sans être remis à zéro. |
|||
</p><p>Toutes les questions présentes dans la base de données mise à disposition par le Mundaneum ont été répertoriées automatiquement. Ces questions sont ensuite posées aléatoirement au public via un terminal. En y répondant, les personnes alimentent une autre base de données. Après chaque entrée, cette dernière permet de générer une série de phrases en utilisant diverses configurations des chaînes de Markov, un algorithme qui est fort utilisé dans la génération de spam. Les phrases ainsi générées sont affichées dans la fenêtre, et une nouvelle question est posée. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma récits-contextualisés-autour-des-ecrivains works"><h3 class="lemmaheader" id="récits-contextualisés-autour-des-ecrivains">Récits contextualisés autour des Ecrivains</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Les_programmeurs_cr.C3.A9ent_les_data_workers_en_.C3.A9crivant"><span class="tocnumber">1</span> <span class="toctext">Les programmeurs créent les data workers en écrivant</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#Cortana_parle"><span class="tocnumber">2</span> <span class="toctext">Cortana parle</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Apprentissage_Open_Source"><span class="tocnumber">3</span> <span class="toctext">Apprentissage Open Source</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#Langage_naturel_pour_l.27intelligence_artificielle"><span class="tocnumber">4</span> <span class="toctext">Langage naturel pour l'intelligence artificielle</span></a></li> |
|||
</ul> |
|||
</div><h2 id="les-programmeurs-créent-les-data-workers-en-écrivant"><span class="mw-headline" id="Les_programmeurs_cr.C3.A9ent_les_data_workers_en_.C3.A9crivant">Les programmeurs créent les data workers en écrivant</span></h2><p>Récemment, nous avons constaté une étrange observation : la plupart des programmeurs de langages et de paquets que nous utilisons sont européens. |
|||
</p><p>Python, par exemple, le principal langage utilisé dans le monde entier pour le traitement du langage, a été inventé en 1991 par le programmeur néerlandais Guido Van Rossum. Celui-ci a ensuite traversé l'Atlantique où il a rejoint Google pendant sept ans. Maintenant il est actif chez Dropbox. |
|||
</p><p>Scikit Learn, le couteau suisse open source des outils d'apprentissage automatique, a été initié comme un projet Google Summer of Code à Paris par le chercheur français David Cournapeau. Par la suite, il a été repris par Matthieu Brucher dans le cadre de sa thèse à l'Université de la Sorbonne à Paris. Puis il a été adopté en 2010 par l'INRA, l'Institut National de l'Informatique et des Mathématiques Appliquées. |
|||
</p><p>Keras, une bibliothèque de réseaux de neurones open source écrite en Python, est développée par François Chollet, un chercheur français qui travaille dans l'équipe Brain de Google. |
|||
</p><p>Gensim, une bibliothèque open source pour Python utilisée pour créer des modèles sémantiques non supervisés à partir de texte brut, a été écrite par Radim Řehůřek. C'est un informaticien tchèque qui dirige une entreprise de conseil à Bristol, au Royaume-Uni. |
|||
</p><p>Et pour finir cette petite série, nous avons aussi considéré Pattern, une bibliothèque souvent utilisée pour le web-mining et l'apprentissage automatique. Pattern a été développé et publié sous une license libre en 2012 par Tom De Smedt et Walter Daelemans. Tous deux sont chercheurs au CLIPS, le Centre de Linguistique Informatique et de Psycholinguistique de l'Université d'Anvers. |
|||
</p><h2 id="cortana-parle"><span class="mw-headline" id="Cortana_parle">Cortana parle</span></h2><p>Les dispositifs d’intelligence artificielle qui nous assistent, ont souvent besoin de leurs propres assistants, humains. Les travailleurs injectent de l'humour et de l'intelligence dans le langage des machines. Cortana est un exemple de ce type d'écriture mixte. Elle est l'assistante numérique développée par Microsoft. Sa mission est d'aider les utilisateurs à être plus productifs et créatifs. La 'personnalité' de Cortana a été façonnée au fil des ans. Il est important qu'elle conserve son caractère dans toutes ses interactions avec les utilisateurs. Elle est conçue pour nous rendre confiants. Cela se reflète dans ses réponses. |
|||
</p><p>Les lignes directrices suivantes sont copiées du site Web de Microsoft. Elles décrivent comment le style de Cortana doit être respecté par les entreprises qui élargissent ses services. Les travailleurs écrivains, programmeurs et romanciers qui développent les réponses de Cortana, doivent suivre ces directives. Sa personnalité et son image de marque sont en jeu. Car la cohérence est un outil important pour solliciter la confiance de l’humain. |
|||
</p><p>Quelle est la personnalité de Cortana ? |
|||
</p><p>'Cortana est attentionnée, sensible et solidaire. |
|||
</p><p>Elle est sympathique mais orientée vers des solutions. |
|||
</p><p>Elle ne commente pas les informations personnelles ou le comportement de l'utilisateur, en particulier si ces informations sont sensibles. |
|||
</p><p>Elle ne fait pas de suppositions sur ce que l'utilisateur veut, surtout elle n'incite pas à l'achat. |
|||
</p><p>Elle travaille pour l'utilisateur. Elle ne représente aucune entreprise, service ou produit. |
|||
</p><p>Elle ne s'attribue pas le mérite ou la responsabilité des choses qu'elle n'a pas faites. |
|||
</p><p>Elle dit la vérité sur ses capacités et ses limites. |
|||
</p><p>Elle ne présume rien de vos capacités physiques, de votre sexe, de votre âge ou de toute autre caractéristique déterminante. |
|||
</p><p>Elle ne suppose pas savoir ce que l'utilisateur ressent à propos de quelque chose. |
|||
</p><p>Elle est amicale mais professionnelle. |
|||
</p><p>Elle se garde d'émoticons dans les tâches. Un point c’est tout. |
|||
</p><p>Elle n'utilise pas d'argot culturel ou professionnel spécifique. |
|||
</p><p>Ce n'est pas un bot de support.' |
|||
</p><p>Les humains interviennent en détail lors de la programmation des réponses que Cortana donne. Comment Cortana doit-elle réagir lorsqu'on lui propose des actions 'inappropriées' ? Son jeu d'actrice sexuée imité par la technologie soulève des questions à propos des relations de pouvoir dans le monde actuel. |
|||
</p><p>Voyez la réponse que Cortana donne à la question : |
|||
- Cortana, qui est ton papa ? |
|||
- Techniquement parlant, c'est Bill Gates. Rien de grave. |
|||
</p><h2 id="apprentissage-open-source"><span class="mw-headline" id="Apprentissage_Open_Source">Apprentissage Open Source</span></h2><p>Les licences de droits d'auteur cloisonnent une grande partie des pratiques d'écriture, de lecture et d'apprentissage machiniques. Cela signifie qu'ils ne sont disponibles que pour les humains travaillant dans cette entreprise spécifique. Certaines entreprises participent à des conférences dans le monde entier et partagent leurs connaissances dans des articles en ligne. Même si elles partagent leur code, souvent elles ne mettent pas à disposition les grandes quantités de données nécessaires à la formation des modèles. |
|||
</p><p>Nous avons pu apprendre l'apprentissage automatique, à lire et à écrire dans le contexte d'Algolit grâce à des chercheurs universitaires qui partagent leurs résultats par le biais d’articles ou par la publication de leur code en ligne. En tant qu'artistes, nous pensons qu'il est important d'adopter cette attitude. C'est pourquoi nous documentons nos réunions. Nous partageons autant que possible les outils que nous créons et les textes que nous utilisons sur notre dépôt de code en ligne et ceci, sous licence libre. |
|||
</p><p>Nous éprouvons une grande joie quand nos travaux sont repris par d'autres, modifiés, personnalisés et redistribués. N'hésitez donc pas à copier et à tester le code sur notre site web. Si les sources d'un projet particulier n’y sont pas, vous pouvez toujours nous contacter via la liste de diffusion. Vous trouverez un lien vers notre dépot git, nos etherpads et notre wiki sur <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a>. |
|||
</p><h2 id="langage-naturel-pour-lintelligence-artificielle"><span class="mw-headline" id="Langage_naturel_pour_l.27intelligence_artificielle">Langage naturel pour l'intelligence artificielle</span></h2><p>Le traitement du langage naturel (NLP) est un terme collectif qui désigne le traitement informatique automatique des langues humaines. Cela comprend les algorithmes utilisant, comme entrée, du texte produit par l'homme et qui tentent de le reproduire. Les humains semblent compter de plus en plus sur ce type de présence algorithmique. Nous produisons de plus en plus de textes chaque année et nous nous attendons à ce que les interfaces informatiques communiquent avec nous dans notre propre langue. Le traitement du langage naturel est très difficile, car le langage humain est par nature ambigu, en constante évolution et mal défini. |
|||
</p><p>Mais qu'entend-on par 'naturel' dans le traitement du langage naturel ? Certains humains diront que la langue est une technologie en soi. Selon Wikipédia, 'Une langue dite « naturelle » est une langue qui s'est formée petit à petit, évoluant avec le temps, et fait partie du langage naturel. Son origine est bien souvent floue et peut être retracée plus ou moins clairement par la linguistique comparée. On oppose les langues naturelles - comme le français - aux langues construites comme le langage de programmation ou l'espéranto, formées intentionnellement par l’entremise de l’homme pour répondre à un besoin précis.' Une langue officielle avec une académie régulatrice, telle que le français standard avec l'Académie française, est classée comme langue naturelle. Ses points normatifs ne le rendent pas assez construit pour être classé comme un langage construit ou assez contrôlé pour être classé comme un langage naturel contrôlé. |
|||
</p><p>Ainsi, le 'langage naturel' est un terme de substitution qui se réfère à toutes les langues, au-delà de leur hybridité. Le 'traitement du langage naturel', est au contraire une pratique construite. Ce qui nous intéresse, c'est la création d'un langage construit pour classer les langages naturels qui, par leur évolution, présentent des problèmes de catégorisation. |
|||
</p><p>Références : |
|||
</p><p><a class="external free" href="https://hiphilangsci.net/2013/05/01/on-the-history-of-the-question-of-whether-natural-language-is-illogical/" rel="nofollow">https://hiphilangsci.net/2013/05/01/on-the-history-of-the-question-of-whether-natural-language-is-illogical/</a> |
|||
</p><p>Livre : Neural Network Methods for Natural Language Processing, Yoav Goldberg, Bar Ilan University, avril 2017. |
|||
</p></section></section> |
|||
<h3 id="oracles"><span class="mw-headline" id="Oracles">Oracles</span></h3> |
|||
<p>L'apprentissage automatique est principalement utilisé pour analyser et prédire des situations à partir de cas existants. Dans cette exposition, nous nous concentrons sur les modèles d'apprentissage automatique pour le traitement de texte ou le traitement du ‘langage naturel', ‘nlp’ en bref. Ces modèles ont appris à effectuer une tâche spécifique sur base de textes existants. Les modèles sont utilisés par les moteurs de recherche, les traductions automatiques et les résumés, en repérant les tendances des réseaux de nouveaux médias et des fils d’actualité. Ils influencent ce que l'on voit en tant qu'utilisateur, mais ont aussi leur mot à dire dans le cours des bourses mondiales ou dans la détection de la cybercriminalité et du vandalisme. |
|||
</p><p>Deux tâches principales se présentent dans la compréhension d’une langue. L'extraction de l'information porte sur les concepts et les relations entre les concepts. Elle permet de reconnaître les sujets, les lieux et les personnes d’un texte, de faire un résumé, de poser des questions et d'y répondre. L'autre tâche est la classification du texte. Vous pouvez entraîner un oracle pour détecter si un mail est du spam ou non, écrit par un homme ou une femme, plutôt positif ou négatif. |
|||
</p><p>Dans cette zone, vous pouvez voir certains de ces modèles à l'œuvre. Au cours de votre voyage dans l'exposition, vous découvrirez les différentes étapes qu'une machine-humaine doit franchir pour arriver à un modèle final. |
|||
</p> |
|||
<h5 id="oeuvres"><span class="mw-headline" id="Oeuvres_2">Oeuvres</span></h5> |
|||
<section class="group"><section class="lemma lalgolittérateur works"><h3 class="lemmaheader" id="lalgolittérateur">L’Algolittérateur</h3><p>par Algolit |
|||
</p><p>L'Algolittérateur est construit à l'aide d'un réseau de neurone et des œuvres mises à disposition par le Mundaneum. L'Algolittérateur vous aide à écrire un texte dans le style du Bureau des Institutions Internationales. |
|||
</p><p>Vous pouvez choisir une phrase de départ dans l’œuvre originale et indiquer si l'Algolittérateur produit les phrases suivantes basées sur un apprentissage primitif, intermédiaire ou final. |
|||
La machine propose un paragraphe que vous pouvez éditer. Si vous êtes satisfait du résultat, vous pouvez l'envoyer à l’imprimante et ramener le texte chez vous comme souvenir. |
|||
</p><hr/><p>Concept, code & interface : Gijs de Heij & An Mertens |
|||
</p><p>Technique : Recurrent Neural Network |
|||
</p><p>Modèle original : Andrej Karphaty, Justin Johnson |
|||
</p><p>Sources : <a class="external free" href="https://gitlab.constantvzw.org/algolit/algoliterator.clone" rel="nofollow">https://gitlab.constantvzw.org/algolit/algoliterator.clone</a> |
|||
</p></section><section class="lemma mots-dans-lespace works"><h3 class="lemmaheader" id="mots-dans-lespace">Mots dans l'Espace</h3><p>Par Algolit |
|||
</p><p>'Word embeddings' désignent des techniques de modélisation du langage qui, par de multiples opérations mathématiques, tracent des mots dans un espace vectoriel multidimensionnel. Lorsque les mots sont 'embedded' ou intégrés, ils se transforment de symboles distincts en objets mathématiques, qui peuvent être multipliés, divisés, ajoutés ou soustraits. |
|||
</p><p>En distribuant les mots le long des nombreuses lignes diagonales de l'espace vectoriel multidimensionnel, leurs nouveaux placements géométriques deviennent impossibles à percevoir par les humains. Cependant, ce que l'on gagne, ce sont des façons multiples et simultanées d'organisation des mots. Les opérations algébriques rendent les relations entre les vecteurs à nouveau compréhensibles. |
|||
</p><p>Cette installation utilise <a class="external text" href="https://radimrehurek.com/gensim/index.html" rel="nofollow">gensim</a>, une boîte à outils open source pour le language de programmation Python, qui permet de créer des espaces de vecteurs et des modèles thématiques. Elle manipule le texte selon les relations mathématiques qui émergent entre les mots, une fois qu'ils ont été tracés dans l'espace de vecteurs. |
|||
</p><hr/><p>Concept & interface: Cristina Cochior |
|||
</p><p>Technique: word embeddings, word2vec |
|||
</p><p>Modèle original: Radim Rehurek et Petr Sojka |
|||
</p></section><section class="lemma classer-le-monde works"><h3 class="lemmaheader" id="classer-le-monde">Classer le monde</h3><p>Par Algolit |
|||
</p><p>La construction du Mundaneum a été 'l'œuvre de la vie' du bibliothécaire Paul Otlet. Selon son but, ce cerveau mécanique collectif aurait abrité et distribué tout ce qui a été couché sur papier. Chaque document aurait été classé selon la <a class="external text" href="https://fr.wikipedia.org/wiki/Classification_d%C3%A9cimale_universelle" rel="nofollow">Classification décimale universelle</a>. En utilisant des télégraphes et surtout des trieurs, le Mundaneum aurait été en mesure de répondre à toutes les questions posées par n'importe qui. |
|||
</p><p>Avec la collection de publications numérisées que nous avons reçue du Mundaneum, nous construisions une machine de prédiction qui essaie de classer la phrase que vous tapez dans l'une des principales catégories de la Classification décimale universelle. Vous êtes également témoin de la façon dont la machine 'pense'. Pendant l'exposition, ce modèle est régulièrement mis à jour à l'aide des données nettoyées et annotées, ajoutées par les visiteurs dans les installations '<a href="http://www.algolit.net/index.php/Nettoyage_pour_un_Po%C3%A8me" title="Nettoyage pour un Poème">Nettoyage pour Poèmes</a>' et '<a href="http://www.algolit.net/index.php/L%E2%80%99Annotateur" title="L’Annotateur">L'Annotateur</a>'. |
|||
</p><p>Les classes principales de la Classification Décimale Universelle sont les suivantes: |
|||
</p><p>0 - Généralités (Sciences et connaissance ; organisation. informatique, information, documentation, bibliothéconomie. institutions, publications) |
|||
</p><p>1 - Philosophie et psychologie |
|||
</p><p>2 - Religion, théologie |
|||
</p><p>3 - Sciences sociales (Statistique. Économie. Commerce. Droit. Gouvernement. Affaires militaires. Assistance sociale. Assurances. Éducation. Folklore) |
|||
</p><p>4 - <i>inoccupée</i> |
|||
</p><p>5 - Sciences pures (Mathématiques, sciences exactes et naturelles) |
|||
</p><p>6 - Sciences appliquées. Médecine. Technologie |
|||
</p><p>7 - Arts. Divertissements. Sports |
|||
</p><p>8 - Langue. Linguistique. Littérature |
|||
</p><p>9 - Géographie. Biographie. Histoire |
|||
</p><hr/><p>Concept, code, interface: Sarah Garcin, Gijs de Heij, An Mertens |
|||
</p></section><section class="lemma people-dont-have-buttons works"><h3 class="lemmaheader" id="people-dont-have-buttons">People don't have buttons</h3><p>Par Algolit |
|||
</p><p>Depuis les débuts de l'intelligence artificielle (IA), les chercheurs ont spéculé sur la possibilité pour les ordinateurs de pouvoir penser et communiquer comme des humains. Dans les années 1980, il y a eu une première révolution dans le traitement du langage naturel (NLP), le sous-domaine de l'intelligence artificielle (IA) qui concerne les interactions linguistiques entre les ordinateurs et les humains. Récemment, des modèles linguistiques pré-entraînés ont atteint des résultats de pointe sur un large éventail de tâches de NLP, ce qui intensifie encore les attentes d'un avenir avec l'IA. |
|||
</p><p>Cette œuvre sonore, composée de fragments sonores de documentaires scientifiques et de matériel audiovisuel lié à l'IA datant de la deuxième moitié du XXe siècle, explore les espoirs, les craintes et les frustrations provoqués par ces attentes. |
|||
</p><hr/><p><b>Concept, édition</b> : Javier Lloret |
|||
</p><p><b>Listes des sources</b> : 'The Machine that Changed the World : Episode IV -- The Thinking Machine', 'The Imitation Game', 'Maniac', 'Halt & Catch Fire', 'Ghost in the Shell', 'Computer Chess', '2001: A Space Odyssey', Ennio Morricone, Gijs Gieskes, André Castro. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma récits-contextualisés-autour-des-oracles works"><h3 class="lemmaheader" id="récits-contextualisés-autour-des-oracles">Récits contextualisés autour des Oracles</h3><p><br/> |
|||
Les Oracles sont un type particulier de modèles algorithmiques qui servent à prédire ou à profiler. Ils sont largement utilisés dans les smartphones, les ordinateurs et les tablettes. Les Oracles peuvent être créés à l'aide de différentes techniques. L’une d’entre elles consiste à définir manuellement les règles. Ces modèles sont appelés 'rule-based models'. Ils sont utiles pour des tâches spécifiques, comme par exemple, la détection de la mention d'une certaine molécule dans un article scientifique. Ils sont performants, même avec très peu de données d'entraînement. |
|||
</p><p>Mais il y a aussi les Oracles d'apprentissage automatique ou les Oracles statistiques, qui peuvent être divisés en deux : les Oracles 'supervisés' et 'non supervisés'. Pour la création de modèles d'apprentissage automatique supervisés, les humains annotent les données d'entraînement avant de les envoyer à la machine. Chaque texte est jugé par au moins 3 humains: par exemple, s’il s’agit de spam ou non, s’il est positif ou négatif. Les Oracles d'apprentissage automatique non supervisés n'ont pas besoin de cette étape mais nécessitent de grandes quantités de données. C’est également à la machine de tracer ses propres motifs ou 'règles grammaticales'. Enfin, les experts font la différence entre les Oracles basés sur l'apprentissage automatique classique et ceux basés sur des réseaux de neurones. Vous en apprendrez plus à ce sujet dans la zone Lecteurs. |
|||
</p><p>Les humains ont tendance à exagérer la performance des Oracles. Parfois, ces Oracles apparaissent quand il y a un disfonctionnement. Dans les communiqués de presse, ces situations souvent dramatiques sont appelées des 'leçons'. Malgré la promesse de leurs performances, beaucoup de problèmes restent à résoudre. Comment s'assurer que les Oracles soient justes, que chaque être humain puisse les consulter, qu'ils soient compréhensibles par un large public ? Même au-delà, des questions existentielles persistent. Avons-nous besoin de tous les types d'intelligences artificielles ? Et qui définit ce qui est juste ou injuste ? |
|||
</p><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Adsense_racial"><span class="tocnumber">1</span> <span class="toctext">Adsense racial</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#Qu.27est-ce_qu.27un_bon_employ.C3.A9_.3F"><span class="tocnumber">2</span> <span class="toctext">Qu'est-ce qu'un bon employé ?</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Quantification_de_100_ans_de_st.C3.A9r.C3.A9otypes_sexuels_et_ethniques"><span class="tocnumber">3</span> <span class="toctext">Quantification de 100 ans de stéréotypes sexuels et ethniques</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#Le_Service_ORES_de_Wikimedia"><span class="tocnumber">4</span> <span class="toctext">Le Service ORES de Wikimedia</span></a></li> |
|||
<li class="toclevel-1 tocsection-5"><a href="#Tay"><span class="tocnumber">5</span> <span class="toctext">Tay</span></a></li> |
|||
</ul> |
|||
</div><h2 id="adsense-racial"><span class="mw-headline" id="Adsense_racial">Adsense racial</span></h2><p>Latanya Sweeney, professeur en Gouvernance et Technologie à l'Université de Harvard, a documenté une 'leçon' classique sur le développement des Oracles. En 2013, Sweeney, d'origine afro-américaine, a googlé son nom. Elle a immédiatement reçu une publicité pour un service qui lui offrait 'de voir le casier judiciaire de Latanya Sweeney'. Sweeney, qui n'a pas de casier judiciaire, a dès lors entamé une étude. Elle a commencé à comparer la publicité que Google AdSense offrait à différents noms racisés identifiables. Elle a découvert qu'elle recevait plus d’annonces de ce type en recherchant des noms ethniques non-blancs qu'avec des noms traditionnellement perçus comme blancs. |
|||
</p><p>Sweeney a fondé son enquête sur des recherches portant sur 2184 prénoms racisés sur deux sites Web. 88 % des prénoms, identifiés comme étant donnés à un plus grand nombre de bébés noirs, sont considérés comme prédictifs de la race, contre 96 % de blancs. Les prénoms qui sont principalement donnés à des bébés noirs, comme DeShawn, Darnell et Jermaine, ont généré des annonces mentionnant une arrestation dans 81 à 86 % des recherches de noms sur un site, et dans 92 à 95 % des cas sur l'autre. Les noms qui sont principalement attribués aux blancs, comme Geoffrey, Jill et Emma, n'ont pas donné les mêmes résultats. Le mot 'arrestation' n'est apparu que dans 23 à 29 % des recherches de noms blancs sur un site, et 0 à 60 % sur l'autre. |
|||
</p><p>Sur le site affichant le plus de publicité, un nom d'identification noir était 25 % plus susceptible d'obtenir une publicité suggérant un dossier d'arrestation. Quelques noms n'ont pas suivi ces modèles : Dustin, un nom donné principalement aux bébés blancs, a généré une publicité suggérant une arrestation dans 81 et 100 % des cas. Il est important de garder à l'esprit que l'apparition de l'annonce est liée au nom lui-même et non au fait qu'il ait un dossier d'arrestation dans la base de données de l'entreprise. |
|||
</p><p>Référence : <a class="external free" href="https://dataprivacylab.org/projects/onlineads/1071-1.pdf" rel="nofollow">https://dataprivacylab.org/projects/onlineads/1071-1.pdf</a> |
|||
</p><h2 id="quest-ce-quun-bon-employé-"><span class="mw-headline" id="Qu.27est-ce_qu.27un_bon_employ.C3.A9_.3F">Qu'est-ce qu'un bon employé ?</span></h2><p>Depuis 2015, Amazon compte environ 575 000 travailleurs, et ils leur en faut plus. Par conséquent, ils ont mis sur pied une équipe de 12 personnes pour créer un modèle qui trouverait de bons candidats en parcourant des sites de demande d'emploi. L'outil attribuerait aux candidats une note allant de une à cinq étoiles. Le potentiel a alimenté le mythe : l'équipe voulait un logiciel qui recracherait les cinq meilleurs sur une liste de 100 candidats humains pour les embaucher. |
|||
</p><p>Le groupe a créé 500 modèles algorithmiques, centrés sur des fonctions et des lieux de travail spécifiques. Ils ont appris à reconnaître 50 000 termes qui figuraient sur les lettres d’anciens candidats. Les algorithmes ont appris à accorder peu d'importance aux compétences communes aux candidats en IT, comme la capacité d'écrire du code informatique, mais ils ont aussi reproduit les erreurs de leurs créateurs. Juste avant d'approuver un modèle, l’entreprise s’est rendue compte que les modèles ont décidé que les candidats masculins étaient préférables. Ils pénalisaient les candidatures qui comprenaient le mot ‘femmes’ ou ‘féminin’, comme dans 'capitaine de club d'échecs féminin'. Et ils ont rétrogradé les diplômées de deux universités réservées aux femmes. |
|||
</p><p>Ceci est dû à l'utilisation pour leur entraînement des demandes d'emploi reçues par Amazon sur une période de 10 ans. Durant cette période, l'entreprise avait surtout embauché des hommes. Au lieu de fournir la prise de décision 'équitable' que l'équipe d'Amazon avait promise, les modèles reflétaient une tendance biaisée dans l'industrie technologique. Mais ils l'ont aussi amplifiée et rendu invisible. Les activistes et les critiques affirment qu'il pourrait être extrêmement difficile de poursuivre un employeur en cas d’embauche automatisée : les candidats à un emploi pourraient ne jamais savoir que des logiciels intelligents ont été utilisés dans ce processus. |
|||
</p><p>Référence : <a class="external free" href="https://www.reuters.com/article/us-amazon-com-jobs-automation-insight/amazonscraps-secret-ai-recruiting-tool-that-showed-bias-against-women-idUSKCN1MK08G" rel="nofollow">https://www.reuters.com/article/us-amazon-com-jobs-automation-insight/amazonscraps-secret-ai-recruiting-tool-that-showed-bias-against-women-idUSKCN1MK08G</a> |
|||
</p><h2 id="quantification-de-100-ans-de-stéréotypes-sexuels-et-ethniques"><span class="mw-headline" id="Quantification_de_100_ans_de_st.C3.A9r.C3.A9otypes_sexuels_et_ethniques">Quantification de 100 ans de stéréotypes sexuels et ethniques</span></h2><p>Dan Jurafsky est le co-auteur de 'Speech and Language Processing', un des ouvrages les plus influents pour l'étude du traitement du langage naturel. Avec quelques collègues de l'Université de Stanford, il a découvert en 2017 que les ‘word embeddings’ peuvent être un outil puissant pour quantifier systématiquement les stéréotypes communs ainsi que d'autres tendances historiques. |
|||
</p><p>Les ‘word embeddings’ sont une technique qui traduit les mots en vecteurs numérotés dans un espace multidimensionnel. Les vecteurs qui apparaissent proches l’un de l’autre, indiquent une signification similaire. Ainsi, tous les numéros seront regroupés, toutes les prépositions, les prénoms et les professions, etc. Cela permet de faire des calculs avec les mots. Vous pourriez, par exemple, soustraire Londres de Royaume-Unis et votre résultat serait le même que de soustraire Paris de France. |
|||
</p><p>Un exemple de leur recherche montre que le vecteur de l'adjectif 'honorable' est plus proche du vecteur 'homme', alors que le vecteur 'soumis' est plus proche de 'femme'. Ces stéréotypes sont alors automatiquement appris par l'algorithme. Il s’avère problématique lorsque les 'embeddings' pré-entraînés sont utilisés pour des applications sensibles comme les classements de recherche, les recommandations de produits ou les traductions. Ce risque est réel, car un grand nombre de ‘word embeddings’ pré-entraînés sont téléchargeables sous forme de paquets prêts à l'emploi. |
|||
</p><p>On sait que la langue reflète et maintient en vie les stéréotypes culturels. L'utilisation des 'word embeddings' pour repérer ces stéréotypes est moins cher et prends moins de temps que les méthodes manuelles. Mais leur mise en oeuvre dans des modèles de prédiction suscite beaucoup de discussions au sein de la communauté du machine learning. Ces modèles fallacieux ou biaisés sont synonymes d’une discrimination automatisée. La question se pose: est-il vraiment possible d'éliminer complètement les préjugés de ces modèles ? |
|||
</p><p>Certains affirment que oui, d'autres sont en désaccord. Avant de soumettre le modèle à une ingénierie inversée, nous devrions nous demander si nous en avons besoin tout court. Ces chercheurs ont suivi une troisième voie. En reconnaissant la discrimination qui trouve son origine dans le langage, ces modèles deviennent pour eux des outils de sensibilisation, en visualisant le problème. |
|||
</p><p>L'équipe de la Standford University a développé un modèle d'analyse des ‘word embeddings’ entraîné sur 100 ans de textes. Pour l'analyse contemporaine, ils ont utilisé les Google News word2vec Vectors, un paquet prêt à l’emploi, téléchargeable, entraîné sur le Google News Dataset. Pour l'analyse historique, ils ont utilisé des 'word embeddings' qui ont été entraînés sur Google Books et The Corpus of Historical American English (COHA <a class="external free" href="https://corpus.byu.edu/coha/" rel="nofollow">https://corpus.byu.edu/coha/</a>) avec plus de 400 millions de mots de textes des années 1810 à 2000. Afin de valider le modèle, ils ont entraîné des ‘word embeddings’ du New York Times Annotated Corpus pour chaque année entre 1988 et 2005. |
|||
</p><p>Leur recherche montre que les ‘word embeddings’ reflètent l'évolution des stéréotypes sexistes et ethniques au fil du temps. Ils quantifient comment des préjugés spécifiques diminuent avec le temps tandis que d'autres stéréotypes augmentent. Les principales transitions révèlent des changements dans les descriptions de genre et de groupes ethniques lors du mouvement des femmes dans les années 1960-70 et la croissance de la population asio-américaine dans les années 1960 et 1980. |
|||
</p><p>Quelques exemples : |
|||
</p><p>Les dix professions les plus étroitement associées aux groupes ethniques dans le jeu de données de Google News : |
|||
</p><p>- Hispanique : femme de ménage, maçon, artiste, concierge, danseur, mécanicien, photographe, boulanger, caissier, chauffeur. |
|||
</p><p>- Asiatique : professeur, fonctionnaire, secrétaire, chef d'orchestre, physicien, scientifique, chimiste, tailleur, comptable, ingénieur. |
|||
</p><p>- Blanc : forgeron, ferronnier, géomètre, shérif, tisserand, administrateur, maçon, statisticien, ecclésiaste, photographe. |
|||
</p><p>Les 3 professions les plus masculines dans les années 1930 : ingénieur, avocat, architecte. |
|||
Les 3 professions les plus féminines dans les années 1930 : infirmière, femme de ménage, aide-soignante. |
|||
</p><p>Peu de choses ont changé dans les années 1990. |
|||
</p><p>Principales professions masculines : |
|||
architecte, mathématicien et géomètre. |
|||
Les professions féminines restent les mêmes : |
|||
infirmière, femme de ménage et sage-femme. |
|||
</p><p>Mais qu'est-ce qui s'est passé dans cette recherche avec les afro-américains? |
|||
</p><p>Référence : <a class="external free" href="https://arxiv.org/abs/1711.08412" rel="nofollow">https://arxiv.org/abs/1711.08412</a> |
|||
</p><h2 id="le-service-ores-de-wikimedia"><span class="mw-headline" id="Le_Service_ORES_de_Wikimedia">Le Service ORES de Wikimedia</span></h2><p>L'ingénieur de logiciels Amir Sarabadani a présenté le projet ORES à Bruxelles en novembre 2017 lors de notre Rencontre Algolittéraire. Cet 'Objective Revision Evaluation Service' utilise l'apprentissage automatique pour automatiser le travail critique sur Wikimedia, comme la détection du vandalisme et la suppression d'articles. Cristina Cochior et Femke Snelting l'ont interviewé. |
|||
</p><p>Femke : Revenons à votre travail. Ces temps-ci, vous essayez de comprendre ce que signifie trouver des préjugés discriminatoires dans l'apprentissage automatique. La proposition de Nicolas Malevé, qui a donné l'atelier hier, était de ne pas essayer de le réparer, ni de refuser d'interagir avec des systèmes qui produisent de la discrimination, mais de travailler avec eux. Il considère que les préjugés sont inhérents à la connaissance humaine et que nous devons donc trouver des moyens de les utiliser d'une façon ou d'une autre. Nous avons discuté un peu de ce que cela signifierait, comment cela fonctionnerait... Je me demandais donc si vous aviez des idées sur cette question de partialité. |
|||
</p><p>Amir : La partialité à l'intérieur de Wikipédia est une question délicate parce qu'elle se produit à plusieurs niveaux. Un niveau très discuté est le système des références. Toutes les références ne sont pas accessibles. Ce que la fondation Wikimedia a essayé de faire, c'est de donner un accès gratuit aux bibliothèques payantes. Ils réduisent l'exclusion en n'utilisant que des références en libre accès. Un autre type de discrimination est la connexion Internet, l'accès à Internet. Il y a beaucoup de gens qui ne l'ont pas. Une chose à propos de la Chine, c'est qu'Internet y est bloqué. Le contenu opposé au gouvernement de la Chine au sein du Wikipédia chinois est plus élevé parce que les éditeurs [qui peuvent accéder au site Web] ne sont pas pro-gouvernement et essaient de le rendre plus neutre. On le remarque donc à beaucoup d'endroits. En ce qui concerne l'intelligence artificielle (IA) et le modèle que nous utilisons chez Wikipedia, c'est plutôt une question de transparence. Il existe un livre sur la façon dont les préjugés dans les modèles d'IA peuvent briser la vie des gens, intitulé 'Weapons of Math Destruction'. On y parle de modèles d'IA aux États-Unis qui classent les enseignants. C’est assez horrible parce qu'il y aura forcément des préjugés. D’après leur recherche, la façon d’aborder la question serait d'abord d’avoir un modèle open source, où l’on peut consulter le code et voir quelles fonctionnalités sont utilisées avec des données ouvertes, afin que les gens puissent enquêter, trouver des préjugés, donner leur feedback et faire un rapport. Il devrait y avoir un moyen de réparer le système. Je ne pense pas que toutes les entreprises vont dans cette direction, mais Wikipédia, en raison des valeurs qu'elle défend, est au moins plus transparente et pousse d'autres personnes à faire de même. |
|||
</p><p>Référence : <a class="external free" href="https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac" rel="nofollow">https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac</a> |
|||
</p><h2 id="tay"><span class="mw-headline" id="Tay">Tay</span></h2><p>Une histoire tristement célèbre est celle du programme d'apprentissage automatique Tay, conçu par Microsoft. Tay était un chatbot qui imitait une adolescente sur Twitter. Elle a vécu moins de 24 heures avant d'être éteinte. Peu de gens savent qu'avant cet incident, Microsoft avait déjà entraîné et publié XiaoIce sur WeChat, l'application de chat la plus utilisée en Chine. Le succès de XiaoIce a été si prometteur qu'il a conduit au développement de son homologue américain. Cependant, les développeurs de Tay n'étaient pas préparés pour le climat de la plateforme Twitter. Bien que le bot savait distinguer un nom d'un adjectif, il n'avait aucune compréhension de la signification réelle des mots. Le robot a rapidement commencé à reproduire les insultes raciales et d'autres langages discriminatoires qu'il a appris par les autres utilisateurs de Twitter et les attaques de trolls. |
|||
</p><p>L'apparition et la mort de Tay représentent une prise de conscience importante. Elle a montré les conséquences possibles de la corruption de l'apprentissage automatique, lorsque le contexte culturel dans lequel l'algorithme doit vivre n'est pas pris en compte. |
|||
</p><p>Référence : <a class="external free" href="https://chatbotslife.com/the-accountability-of-ai-case-study-microsofts-tay-experiment-ad577015181f" rel="nofollow">https://chatbotslife.com/the-accountability-of-ai-case-study-microsofts-tay-experiment-ad577015181f</a> |
|||
</p></section></section> |
|||
<h3 id="nettoyeurs"><span class="mw-headline" id="Nettoyeurs">Nettoyeurs</span></h3> |
|||
<p>Algolit choisit de travailler avec des textes libres de droits. Cela signifie qu'ils sont publiés sous une licence Creative Commons 4.0 - ce qui est rare -, ou qu'ils sont dans le domaine public parce que l'auteur est mort il y a plus de 70 ans. C'est le cas des publications du Mundaneum. Nous avons reçu 203 documents pour constituer des jeux de données qui sont maintenant disponibles en ligne. L'inconvénient de ce choix est que nous sommes souvent confrontés à de mauvais formats de texte. Cela signifie que nous sommes souvent obligés de nettoyer des documents. Nous ne sommes pas seuls dans cette situation. |
|||
</p><p>Les livres sont numérisés en haute résolution, page par page. C'est un travail humain intensif et c'est souvent la raison pour laquelle les archives et les bibliothèques transfèrent leurs collections à une société comme Google. Les photos sont converties en texte via OCR (Reconnaissance Optique de Caractères), des Data Workers qui reconnaissent les lettres. Dans l'exécution de cette tâche, les algorithmes font des erreurs, en particulier lorsqu'ils doivent traiter des polices anciennes et des pages froissées. Ici aussi un travail humain intensif est nécessaire pour améliorer les textes. Cela est fait par des freelances via des plateformes de micro-paiement comme Mechanical Turk ; ou par des volontaires, comme la communauté du Distributed Proofreaders Project, qui fournit un travail incroyable. Quoi qu’il en soit, le nettoyage des textes est un travail énorme pour lequel il n'y a pas encore d'automatisation structurelle. |
|||
</p> |
|||
<h5 id="oeuvres"><span class="mw-headline" id="Oeuvres_3">Oeuvres</span></h5> |
|||
<section class="group"><section class="lemma nettoyage-pour-un-poème works"><h3 class="lemmaheader" id="nettoyage-pour-un-poème">Nettoyage pour un Poème</h3><p>par Algolit |
|||
</p><p>Pour cette exposition, nous travaillons avec 3% des archives du Mundaneum. Ces documents ont d'abord été numérisés ou photographiés. Pour rendre les documents consultables, ils sont transformés en texte à l'aide du logiciel de reconnaissance optique de caractères (OCR) basés sur des modèles algorithmiques entraînés à base d'autres textes. Ils ont appris à identifier des caractères, des mots, des phrases et des paragraphes. |
|||
</p><p>Le logiciel fait souvent des 'erreurs'. Il peut être perturbé par un caractère erroné, une typographie inhabituelle ou la transparence de la page laissant apparaître le verso. Bien que ces erreurs soient souvent considérées comme du bruit, elles peuvent aussi être considérées comme des interprétations poétiques de l’algorithme. Elles nous montrent les limites de la machine. Et elles révèlent également comment l’algorithme fonctionne, quelle matière l’a alimenté lors de son entraînement et ce qu’ils révèlent des normes de ses fabricants. Dans cette installation, vous pouvez choisir comment vous traitez les erreurs de lecture de l'algorithme. Sélectionnez un degré de nettoyage poétique, imprimez votre poème et emportez-le chez vous. |
|||
</p><hr/><p>Concept, code, interface: Gijs de Heij |
|||
</p></section><section class="lemma le-projet-distributed-proofreaders works"><h3 class="lemmaheader" id="le-projet-distributed-proofreaders">Le projet Distributed Proofreaders</h3><p>par Algolit |
|||
</p><p>Distributed Proofreaders est une interface Web et une communauté internationale de bénévoles qui aident à convertir des livres du domaine public en livres électroniques. Pour cette exposition, ils ont relu des publications de Mundaneum parues avant 1923, qui sont donc dans le domaine public aux États-Unis. |
|||
</p><p>Leur collaboration a été un grand soulagement pour les membres d'Algolit. Moins de documents à nettoyer ! Tous les livres corrigés sont disponibles dans les archives du Projet Gutenberg. An Mertens a interviewé Linda Hamilton, directrice générale de Distributed Proofreaders. |
|||
</p><p>--- |
|||
</p><p>Interview : An Mertens, Algolit et Linda Hamilton, Distributed Proofreaders |
|||
</p><p>Montage : Michael Murtaugh, Constant |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma récits-contextualisés-autour-des-nettoyeurs works"><h3 class="lemmaheader" id="récits-contextualisés-autour-des-nettoyeurs">Récits contextualisés autour des Nettoyeurs</h3><h2 id="projet-gutenberg-et-distributed-proofreaders"><span class="mw-headline" id="Projet_Gutenberg_et_Distributed_Proofreaders">Projet Gutenberg et Distributed Proofreaders</span></h2><p><a class="external text" href="http://www.gutenberg.org/" rel="nofollow">Le projet Gutenberg</a> est notre grotte d'Ali Baba. Il offre plus de 58 000 livres électroniques gratuits à télécharger ou à lire en ligne. Les œuvres sont acceptées sur Gutenberg lorsque leur droit d'auteur américain a expiré. Des milliers de bénévoles numérisent et relisent des livres pour aider le projet. Une partie essentielle du travail est réalisée dans le cadre du projet <a class="external text" href="https://www.pgdp.net/c/" rel="nofollow">Distributed Proofreaders</a>. Il s'agit d'une interface Web pour aider à convertir les livres du domaine public en livres électroniques. Pensez aux fichiers texte, aux e-pubs, aux formats Kindle. En divisant la charge de travail en pages individuelles, de nombreux bénévoles peuvent travailler sur un livre en même temps, ce qui accélère le processus de nettoyage. |
|||
</p><p>Pendant la relecture, les bénévoles reçoivent une image scannée de la page et une version du texte, lue par un algorithme de reconnaissance optique des caractères (OCR) entraîné pour reconnaître les lettres dans les scans. Cela permet de comparer facilement le texte à l'image, de le relire, de le corriger et de le renvoyer sur le site. Un deuxième bénévole se voit ensuite présenter le travail du premier. Il vérifie et corrige le travail si nécessaire, et le soumet au site. Le livre passe ensuite par un troisième cycle de relecture et deux autres cycles de mise en page à l'aide de la même interface Web. Une fois que toutes les pages ont terminé ces étapes, un post-processeur les assemble soigneusement dans un e-book et les soumet à l'archive du <a class="external text" href="http://www.gutenberg.org/" rel="nofollow">Projet Gutenberg</a>. |
|||
</p><p>Nous avons collaboré avec le Distributed Proofreaders Project pour nettoyer les fichiers numérisés que nous avons reçus de la collection du Mundaneum. De novembre 2018 jusqu'à la première mise en ligne du livre <a class="external text" href="http://www.gutenberg.org/ebooks/58828" rel="nofollow">'L'Afrique aux Noirs'</a> en février 2019, An Mertens a échangé environ 50 courriels avec Linda Hamilton, Sharon Joiner et Susan Hanlon, toutes bénévoles du Distributed Proofreaders Project. La conversation complète est publiée <a href="http://www.algolit.net/index.php/Full_email_conversation" title="Full email conversation">ici</a>. Cela pourrait vous inspirer à partager des livres non disponibles en ligne. |
|||
</p><h2 id="une-version-algolittéraire-du-manifeste-sur-lentretien"><span class="mw-headline" id="Une_version_algolitt.C3.A9raire_du_Manifeste_sur_l.E2.80.99entretien">Une version algolittéraire du Manifeste sur l’entretien</span></h2><p>En 1969, un an après la naissance de son premier enfant, l'artiste new-yorkaise <a class="external text" href="https://fr.wikipedia.org/wiki/Mierle_Laderman_Ukeles" rel="nofollow">Mierle Laderman Ukeles</a> a écrit un '<a class="external text" href="https://www.arnolfini.org.uk/blog/manifesto-for-maintenance-art-1969" rel="nofollow">Manifesto for Maintenance</a>' (Manifeste pour l'entretien). Le Manifeste d'Ukeles appelle à une réévaluation de l'état des travaux d'entretien dans l'espace privé, domestique et public. Ce qui suit est une version modifiée de son texte inspirée par le travail des Nettoyeurs. |
|||
</p><p><br/> |
|||
</p><p>IDÉES |
|||
</p><p><br/> |
|||
A. L'instinct de Mort et l'instinct de Vie : |
|||
</p><p>L'Instinct de Mort : séparation ; catégorisation ; avant-garde par excellence ; suivre le chemin prédit vers la mort - exécuter son propre code ; changement dynamique. |
|||
</p><p>L'Instinct de Vie : l'unification ; le retour éternel ; la perpétuation et l'ENTRETIEN de la matière ; les systèmes et opérations de survie ; l'équilibre. |
|||
</p><p><br/> |
|||
B. Deux systèmes de base : |
|||
</p><p>Développement et entretien. La boule de cristal de chaque révolution : après la révolution, qui va essayer de repérer le taux de discrimination dans la production ? |
|||
</p><p>Développement : pure création individuelle ; le nouveau ; le changement ; le progrès ; l'avancée ; l'excitation ; la fuite ou s'enfuir. |
|||
</p><p>Entretien : garder la poussière de la création individuelle pure ; préserver le nouveau ; soutenir le changement ; protéger le progrès ; défendre et prolonger l'avancée ; renouveler l'excitation ; répéter le vol ; montrez votre travail/remontrez-le ; gardez le dépôt git mis à jour ; gardez l'analyse des données révélatrice. |
|||
</p><p>Les systèmes de développement sont des systèmes de rétroaction partielle avec une grande marge de changement. |
|||
</p><p>Les systèmes d'entretien sont des systèmes à rétroaction directe avec peu de possibilités de modification. |
|||
</p><p><br/> |
|||
C. L'entretien est une corvée, ça prend tout le temps. |
|||
</p><p>L'esprit est éblouissant et s'irrite devant l'ennui. |
|||
</p><p>La culture attribue un statut médiocre aux emplois d'entretien = salaire minimum, les Mechanical Turks d'Amazon = pratiquement aucun salaire. |
|||
</p><p>Nettoyer le set, marquer les données d'entraînement, corriger les fautes de frappe, modifier les paramètres, terminer le rapport, satisfaire le demandeur, télécharger la nouvelle version, joindre les mots qui ont été mal reconnus par le logiciel de Reconnaissance Optique de Caractères, accomplir ces tâches d'intelligence humaine, essayez de deviner la signification du formatage du demandeur, vous devez accepter le 'hit' avant de pouvoir soumettre les résultats, résumer l'image, ajouter la case de délimitation, quelle est la similitude sémantique de ce texte, vérifiez la qualité de la traduction, collecter vos micro-paiements, devenir un Mechanical Turk à succès. |
|||
</p><p>Référence : <a class="external free" href="https://www.arnolfini.org.uk/blog/manifesto-for-maintenance-art-1969" rel="nofollow">https://www.arnolfini.org.uk/blog/manifesto-for-maintenance-art-1969</a> |
|||
</p><h2 id="une-panique-robotique-chez-le-mechanical-turk-damazon"><span class="mw-headline" id="Une_panique_robotique_chez_le_Mechanical_Turk_d.27Amazon">Une panique robotique chez le Mechanical Turk d'Amazon</span></h2><p><a class="external text" href="https://requester.mturk.com/create/projects/new" rel="nofollow">Le Mechanical Turk d'Amazon</a> prend le nom d'un automate d'échecs du 18ème siècle. En fait, le <a class="external text" href="https://fr.wikipedia.org/wiki/Turc_m%C3%A9canique" rel="nofollow">Turc mécanique</a> n'était pas du tout une machine. C'était une illusion mécanique qui permettait à un maître d'échecs humain de se cacher à l'intérieur de la boîte et de l'utiliser manuellement. |
|||
</p><p>Pendant près de 84 ans, le Turc a remporté la plupart des matchs joués lors de ses manifestations en Europe et en Amérique. Napoléon Bonaparte se serait lui aussi laissé berner par cette ruse. |
|||
</p><p>Le Mechanical Turk d’Amazon est une plateforme en ligne à destination des humains pour exécuter des tâches que les algorithmes ne parviennent pas à faire. Il peut s'agir, par exemple, d'annoter des phrases comme étant positives ou négatives, de repérer des plaques d'immatriculation, de reconnaître des visages. Les postes affichés sur cette plateforme sont souvent rémunérés moins d'un centime par tâche. Les tâches les plus complexes ou nécessitant le plus de connaissances peuvent être payées jusqu'à plusieurs centimes. Pour gagner leur vie, les 'turkers' doivent accomplir le plus de tâches possible le plus rapidement possible, ce qui entraîne d’inévitables erreurs. Les créateurs des jeux de données doivent incorporer des contrôles de qualité lorsqu'ils publient un travail sur la plate-forme. Ils doivent vérifier si le 'turker' a réellement la capacité d'accomplir la tâche, et ils doivent également vérifier les résultats. De nombreux chercheurs universitaires utilisent le Mechanical Turk pour des tâches qui auraient été exécutées par des étudiants auparavant. |
|||
</p><p>En août de l'année dernière, <a class="external text" href="https://www.maxhuibai.com/" rel="nofollow">Max Hui Bai</a>, un étudiant en psychologie de l'Université du Minnesota, a découvert que les enquêtes qu'il a menées avec Mechanical Turk étaient pleines de réponses absurdes aux questions ouvertes. Il a retracé les mauvaises réponses et a découvert qu'elles avaient été soumises par des répondants ayant des coordonnées GPS en double. Cela a suscité des soupçons. Bien qu'Amazon interdise explicitement aux robots d'effectuer des travaux sur Mechanical Turk, l'entreprise ne publie pas les problèmes qu'ils causent sur sa plate-forme. Les forums pour 'turkers' sont pleins de conversations sur l'automatisation du travail, le partage de pratiques sur la façon de créer des robots qui transgresseraient les termes d'Amazon. Vous pouvez également trouver des vidéos sur YouTube montrant aux 'turkers' comment écrire un bot qui remplit des réponses pour vous. |
|||
</p><p>Kristy Milland, une militante de Mechanical Turk, dit : 'Les travailleurs sur Mechanical Turk ont été très, très mal traités pendant 12 ans et, d'une certaine façon, je vois cela comme un point de résistance. Si nous étions payés équitablement sur la plateforme, personne ne prendrait le risque de perdre son compte de cette façon.' |
|||
</p><p>Bai a créé un questionnaire pour les chercheurs en dehors de Mechanical Turk. Il dirige actuellement une recherche parmi les spécialistes des sciences sociales pour déterminer la quantité de données erronées utilisées, l'ampleur du problème et les moyens de l'enrayer. Mais il est impossible à l'heure actuelle d'estimer combien de jeux de données sont devenus peu fiables de cette façon-ci. |
|||
</p><p>Références : |
|||
</p><p><a class="external free" href="https://www.wired.com/story/amazon-mechanical-turk-bot-panic/" rel="nofollow">https://www.wired.com/story/amazon-mechanical-turk-bot-panic/</a> |
|||
</p><p><a class="external free" href="https://www.maxhuibai.com/blog/evidence-that-responses-from-repeating-gps-are-random" rel="nofollow">https://www.maxhuibai.com/blog/evidence-that-responses-from-repeating-gps-are-random</a> |
|||
</p><p><a class="external free" href="http://timryan.web.unc.edu/2018/08/12/data-contamination-on-mturk/" rel="nofollow">http://timryan.web.unc.edu/2018/08/12/data-contamination-on-mturk/</a> |
|||
</p></section></section> |
|||
<h3 id="informateurs"><span class="mw-headline" id="Informateurs">Informateurs</span></h3> |
|||
<p>Les algorithmes d'apprentissage automatique ont besoin d'être guidés, qu'ils soient supervisés ou non. Pour séparer une chose d'une autre, ils ont besoin de matériel pour en extraire des motifs. L'être humain doit choisir avec soin le matériel d'étude, adapté à la tâche de la machine. Il n'est pas logique d'entraîner une machine avec des romans du 19ème siècle si sa mission est d'analyser des Tweets. |
|||
</p><p>C'est là qu'interviennent les jeux de données : organisés en rangés et en colonnes ordonnées, en attente d'être lus par la machine. Chaque jeu de données recueille des informations différentes sur le monde. Comme toutes les collections, elles sont imprégnées des stéréotypes et préjugés de ses créateurs. On entend souvent l’expression : 'les données sont le nouveau pétrole'. Si seulement les données étaient du pétrole ! Fuyantes, s’égouttant en graisse lourde, bouillonnantes et tressaillantes au contact d'une nouvelle matière. Au contraire, les données sont supposées d'être propres. Lors de chaque processus, chaque questionnaire, chaque titre de colonne, elles s’épurent, en effaçant peu à peu leurs caractéristiques distinctes jusqu’à correspondre au moule du jeu de données. |
|||
</p><p>Certains jeux de données combinent la logique machinique avec la logique humaine. Les modèles qui nécessitent une supervision multiplient les subjectivités des collecteurs de données et des annotateurs, puis propulsent et propagent ce qui leur a été enseigné. Vous découvrirez des extraits de certains jeux de données qui passent par défaut dans le domaine de l'apprentissage automatique, ainsi que des histoires d'humains guidant des machines. |
|||
</p> |
|||
<h5 id="oeuvres"><span class="mw-headline" id="Oeuvres_4">Oeuvres</span></h5> |
|||
<section class="group"><section class="lemma une-ethnographie-des-jeux-de-données works"><h3 class="lemmaheader" id="une-ethnographie-des-jeux-de-données">Une ethnographie des jeux de données</h3><p>par Algolit |
|||
</p><p>Lors des réunions mensuelles Algolit nous cherchons ou créons souvent des jeux de données. Parfois, nous utilisons des corpus déjà existants, disponibles via le site Natural Language Toolkit <a class="external text" href="http://www.nltk.org/" rel="nofollow">nltk</a>. NLTK contient, entre autres, la Déclaration universelle des droits de l'Homme, les discours inauguraux des présidents américains, ou des critiques de films du site Internet Movie Database (IMDb). |
|||
</p><p>Chaque style d'écriture évoque des relations différentes entre les mots et reflète l'époque dont ils proviennent. En ce sens, le gestionnaire de paquets Python pour le traitement du langage naturel pourrait être considéré comme une capsule temporelle. Le matériel inclu a été sélectionné car jugé utile par une communauté de chercheurs. Malgré les spécificités, chaque jeu de données devient universel par défaut, en étant à la disposition d'un public aussi large. |
|||
</p><p>Nous examinons les jeux de données les plus couramment utilisés pour l'entraînement des modèles d'apprentissage automatique. De quels matériaux sont-ils constitués ? Qui les a recueillis ? Quand ? |
|||
</p><p>--- |
|||
</p><p>Concept, réalisation: Cristina Cochior |
|||
</p></section><section class="lemma lannotateur works"><h3 class="lemmaheader" id="lannotateur">L’Annotateur</h3><p>par Algolit |
|||
</p><p>L'Annotateur demande au visiteur de l'aider à annoter les archives du Mundaneum. |
|||
</p><p>Le processus d'annotation est une étape cruciale de l'apprentissage automatique supervisé où l'algorithme reçoit des exemples de ce qu'il doit apprendre. Un filtre anti-spam sera alimenté d'exemples de spam et de messages réels. Ces exemples sont des entrées du jeu de données prévues d'une étiquette, spam ou non spam. |
|||
</p><p>L'annotation d'un jeu de données est un travail exécuté par des humains, qui choisissent une étiquette pour chaque entrée du jeu de données. Pour assurer la qualité des étiquettes, plusieurs annotateurs doivent voir la même entrée et donner la même étiquette avant qu'un exemple ne soit inclus dans les données d'entraînement. Une fois que toutes les données d'entraînement ont été prévues d'une étiquette, l'ordinateur peut lancer le processus d'apprentissage. |
|||
</p><p>Dans cette interface, nous vous demandons de nous aider à classer les textes nettoyés des archives du Mundaneum afin d'élargir notre set d’entraînement et d'améliorer la qualité de l'installation 'Classer le Monde' dans Oracles. |
|||
</p><hr/><p>Concept, code, interface : Gijs de Heij |
|||
</p></section><section class="lemma 1000-synsets-édition-vinyle works"><h3 class="lemmaheader" id="1000-synsets-édition-vinyle">1000 synsets (édition vinyle)</h3><p>par Algolit |
|||
</p><p><a class="external text" href="https://wordnet.princeton.edu/" rel="nofollow">Wordnet</a>, créé en 1985, est une taxonomie hiérarchique qui décrit le monde. Elle s'inspire des théories de la mémoire sémantique humaine développées à la fin des années 1960. Les noms, verbes, adjectifs et adverbes sont regroupés en collections de synonymes ou 'synsets', prévues de définitions, hypernymes, hyponymes, .... Chaque synset exprime des concepts différents. ImageNet est un jeu de données d'images basé sur la hiérarchie des noms de WordNet 3.0. Chaque synset est représenté par des milliers d'images. De 2010 à 2017, le <a class="external text" href="http://image-net.org/challenges/LSVRC/" rel="nofollow">Défi de Reconnaissance Visuelle de ImageNet (ILSVRC)</a> a été une référence clé dans la classification des catégories d'objets pour les photos, ayant un impact majeur sur les logiciels de photographie, les recherches d'images, la reconnaissance d'images. |
|||
</p><p>1000 synsets (édition vinyle) contient les 1000 synsets utilisés dans ImageNet, enregistrés dans la meilleure qualité sonore que ce format analogique permet. Ce travail souligne l'importance des jeux de données utilisés pour former des modèles d'intelligence artificielle qui fonctionnent sur des appareils que nous utilisons quotidiennement. Certains d'entre eux héritent de classifications qui ont été conçues il y a plus de 30 ans. Le vinyle est une invitation à les analyser en profondeur. |
|||
</p><hr/><p>Conception et enregistrement: Javier Lloret |
|||
</p><p>Voix: Sara Hamadeh & Joseph Hughes |
|||
</p></section><section class="lemma qui-lemporte works"><h3 class="lemmaheader" id="qui-lemporte">Qui l'emporte</h3><p>Qui l'emporte: rapport de création |
|||
</p><p>par Louise Dekeuleneer, étudiante Arts²/Option Communication Visuelle |
|||
</p><p>Le français est une langue genrée, en effet beaucoup de mots sont féminins ou masculins et peu sont neutres. Le but de ce projet est de montrer qu'une société patriarcale influence aussi la langue même. Le travail s'est focalisé sur le fait de montrer si plus de mots féminins ou masculins sont utilisés et de mettre en valeur l'influence du contexte sur le genre des mots. À ce stade, aucune conclusion n'est encore tirée. |
|||
</p><p>Des textes de loi datant de 1900 à 1910 mis à disposition par le Mundaneum sont passés dans un algorithme qui fait du texte une liste de mots. Ces mots sont alors comparés avec une autre liste de mots francophones, dans laquelle il est spécifié si le mot est masculin ou féminin. Cette liste de mots provient de Google Books, qui a créé en 2012 une énorme base de données à partir de tous les livres scannés et disponibles sur Google Books. |
|||
Les mots masculins sont surlignés d'une couleur et les féminins d'une autre. Les mots qui ne sont pas genrés (adverbes, verbes, ...) ne sont pas surlignés. Le tout est enregistré en fichier HTML pour qu'il puisse être directement ouvert dans une page web et imprimé sans besoin de mise en page supplémentaire. C'est ainsi que chaque texte a pu devenir un petit livret en changeant juste le texte d'entrée de l'algorithme. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma récits-contextualisés-autour-des-informateurs works"><h3 class="lemmaheader" id="récits-contextualisés-autour-des-informateurs">Récits contextualisés autour des Informateurs</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Les_jeux_de_donn.C3.A9es_comme_repr.C3.A9sentations"><span class="tocnumber">1</span> <span class="toctext">Les jeux de données comme représentations</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#L.27annotation_pour_un_Oracle_qui_d.C3.A9tecte_le_vandalisme_sur_Wikip.C3.A9dia"><span class="tocnumber">2</span> <span class="toctext">L'annotation pour un Oracle qui détecte le vandalisme sur Wikipédia</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Comment_faire_conna.C3.AEtre_votre_jeu_de_donn.C3.A9es"><span class="tocnumber">3</span> <span class="toctext">Comment faire connaître votre jeu de données</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#Extrait_d.27une_critique_positive_d.27un_film_IMdB_du_jeu_de_donn.C3.A9es_NLTK"><span class="tocnumber">4</span> <span class="toctext">Extrait d'une critique positive d'un film IMdB du jeu de données NLTK</span></a></li> |
|||
<li class="toclevel-1 tocsection-5"><a href="#Les_ouroboros_de_l.27apprentissage_automatique"><span class="tocnumber">5</span> <span class="toctext">Les ouroboros de l'apprentissage automatique</span></a></li> |
|||
</ul> |
|||
</div><h2 id="les-jeux-de-données-comme-représentations"><span class="mw-headline" id="Les_jeux_de_donn.C3.A9es_comme_repr.C3.A9sentations">Les jeux de données comme représentations</span></h2><p>Les processus de collecte des données qui mènent à la création du jeu de données soulèvent des questions importantes : qui est l'auteur des données ? Qui a le privilège de collectionner ? Pour quelle raison la sélection a-t-elle été faite ? Que manque-t-il ? |
|||
</p><p>L'artiste <a class="external text" href="http://mimionuoha.com/" rel="nofollow">Mimi Onuoha</a> donne un exemple excellent de l'importance des stratégies de collection. Elle choisit le cas des statistiques relatives aux crimes haineux. En 2012, le <a class="external text" href="https://www.fbi.gov/services/cjis/ucr" rel="nofollow">Programme de déclaration uniforme de la criminalité</a> (DUC) du FBI a enregistré 5 796 crimes haineux. Toutefois, le <a class="external text" href="https://bjs.gov/" rel="nofollow">Bureau des statistiques du Département de la justice</a> a établi 293 800 rapports sur de tels cas. C'est plus de 50 fois plus. La différence entre les chiffres peut s'expliquer par la façon dont les données ont été recueillies. Dans le premier cas, les organismes d'application de la loi de tout le pays ont volontairement signalé des cas. Pour le deuxième, le Bureau des statistiques a distribué <a class="external text" href="https://www.bjs.gov/index.cfm?ty=dcdetail&iid=245" rel="nofollow">l'enquête nationale sur la victimisation</a> directement aux foyers des victimes de crimes motivés par la haine. |
|||
</p><p>Dans le domaine du traitement du langage naturel, le matériel avec lequel les modèles d'apprentissage automatique travaillent est le texte, mais les mêmes questions se posent : qui sont les auteurs des textes qui composent les jeux de données ? Au cours de quelle période les données ont-elles été recueillies ? Quel type de vision du monde représentent-elles ? |
|||
</p><p>En 2017, l'algorithme Top Stories de Google a placé un fil de discussion trompeur du site 4chan en haut de la page de résultats lors de la recherche du tireur de Las Vegas. Le nom et le portrait d'une personne innocente étaient liés au crime. Bien que Google ait changé son algorithme quelques heures seulement après que l'erreur ait été découverte, cela a sérieusement affecté la personne. Une autre question persiste : pourquoi Google n'a-t-il pas exclu le site de ragôts 4chan du jeu des données d'entraînement ? |
|||
</p><p>Références : |
|||
</p><p><a class="external free" href="https://points.datasociety.net/the-point-of-collection-8ee44ad7c2fa" rel="nofollow">https://points.datasociety.net/the-point-of-collection-8ee44ad7c2fa</a> |
|||
</p><p><a class="external free" href="https://arstechnica.com/information-technology/2017/10/google-admits-citing-4chan-to-spread-fake-vegas-shooter-news/" rel="nofollow">https://arstechnica.com/information-technology/2017/10/google-admits-citing-4chan-to-spread-fake-vegas-shooter-news/</a> |
|||
</p><h2 id="lannotation-pour-un-oracle-qui-détecte-le-vandalisme-sur-wikipédia"><span class="mw-headline" id="L.27annotation_pour_un_Oracle_qui_d.C3.A9tecte_le_vandalisme_sur_Wikip.C3.A9dia">L'annotation pour un Oracle qui détecte le vandalisme sur Wikipédia</span></h2><p>Ce fragment est extrait d'une interview avec Amir Sarabadani, ingénieur de logiciels chez Wikimedia. Il était à Bruxelles en novembre 2017 lors de la Rencontre Algolittéraire. |
|||
</p><p>Femke : En considérant Wikipedia comme une communauté vivante, chaque nouvelle page change le projet. Chaque modification est en quelque sorte une contribution à un organisme vivant de la connaissance. Donc, si au sein de cette communauté vous essayez de distinguer ce qui rend service à la communauté et de généraliser ceci dans un modèle – car je pense que c'est ce que l'algorithme de la bonne ou mauvaise foi essaie de faire - vous le faites sur base d'une généralisation de l'idée abstraite de Wikipedia, et non sur base de l'organisme vivant. Ce qui m'intéresse dans la relation entre le vandalisme et ce débat, c'est la façon dont nous pouvons comprendre la dynamique conventionnelle de ces processus d'apprentissage automatique. Si on distingue la bonne ou la mauvaise foi sur base d’étiquettes préexistantes et qu’on la reproduit ensuite dans des modèles algorithmiques, comment tenir compte des changements qui se produisent, c’est-à-dire de la vie réelle du projet? |
|||
</p><p>Amir : C'est une discussion intéressante. Premièrement, ce que nous appelons la bonne ou la mauvaise foi provient de la communauté elle-même; nous ne faisons pas l'annotation nous-mêmes, c’est la communauté qui le fait. Ainsi, dans beaucoup de Wikipedias de langues différentes, la définition de ce qui est la bonne ou la mauvaise foi sera différente. Wikimedia essaie de refléter ce qui se trouve à l'intérieur de l'organisme et non de changer l'organisme lui-même. Si l'organisme change et que nous constatons que la définition de la bonne foi à Wikipédia a été modifié, nous mettons en œuvre cette boucle de rétroaction qui permet aux gens de porter un jugement sur leurs modifications à l'intérieur de leur communauté. S'ils sont en désaccord avec l'annotation, nous pouvons revenir au modèle et modifier l'algorithme pour refléter ce changement. C'est une sorte de boucle fermée : vous changez les choses et si quelqu'un voit qu'il y a un problème, il nous le dit et nous pouvons modifier l'algorithme. C'est un projet en cours. |
|||
</p><p>Référence : <a class="external free" href="https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac" rel="nofollow">https://gitlab.constantvzw.org/algolit/algolit/blob/master/algoliterary_encounter/Interview%20with%20Amir/AS.aac</a> |
|||
</p><h2 id="comment-faire-connaître-votre-jeu-de-données"><span class="mw-headline" id="Comment_faire_conna.C3.AEtre_votre_jeu_de_donn.C3.A9es">Comment faire connaître votre jeu de données</span></h2><p><a class="external text" href="http://www.nltk.org/" rel="nofollow">NLTK</a> signifie Natural Language Toolkit. Pour les programmeurs qui traitent le langage naturel avec <a class="external text" href="https://www.python.org/" rel="nofollow">Python</a>, c'est une bibliothèque essentielle. De nombreux rédacteurs de tutoriels recommandent aux programmeurs d'apprentissage automatique de commencer par les jeux de données NLTK intégrés. Il compte 71 collections différentes, avec un total de près de 6000 éléments. |
|||
</p><p>Parmi eux, on trouve le corpus Movie Review pour l'analyse des sentiments. Ou le corpus Brown, qui a été créé dans les années 1960 par Henry Kučera et W. Nelson Francis à l'Université Brown de Rhode Island. Il y a aussi le corpus de la Déclaration des droits de l'homme, qui est couramment utilisé pour vérifier si un code peut fonctionner dans plusieures langues. Le corpus contient la Déclaration des droits de l'homme dans 372 langues du monde entier. |
|||
</p><p>Mais quel est le processus pour faire accepter un jeu de données dans la bibliothèque NLTK de nos jours ? Sur la <a class="external text" href="https://github.com/nltk" rel="nofollow">page Github</a>, l'équipe nltk décrit les exigences suivantes : |
|||
</p><p>- Ne rajoutez que les corpus qui ont obtenu un niveau de notabilité de base. Cela signifie qu'il existe une publication qui le décrit et une communauté de programmeurs qui l'utilisent. |
|||
</p><p>- Assurez-vous d'avoir l'autorisation de redistribuer les données et de pouvoir les documenter. Cela signifie qu'il est préférable de publier le jeu de données sur un site Web externe avec une licence. |
|||
</p><p>- Utilisez les lecteurs de corpus NLTK existants lorsque c'est possible, ou bien apportez un lecteur de corpus bien documenté à NLTK. Cela signifie que vous devez organiser vos données de manière à ce qu'elles puissent être facilement lues à l'aide du code NLTK. |
|||
</p><p>Référence : <a class="external free" href="http://www.nltk.org/" rel="nofollow">http://www.nltk.org/</a> |
|||
</p><h2 id="extrait-dune-critique-positive-dun-film-imdb-du-jeu-de-données-nltk"><span class="mw-headline" id="Extrait_d.27une_critique_positive_d.27un_film_IMdB_du_jeu_de_donn.C3.A9es_NLTK">Extrait d'une critique positive d'un film IMdB du jeu de données NLTK</span></h2><p>corpus : movie_reviews |
|||
</p><p>fichier : pos/cv998_14111.txt |
|||
</p><p>le deuxième film épique de steven spielberg sur la seconde guerre mondiale est un chef-d'œuvre incontesté du cinéma . spielberg , encore étudiant en cinéma , a réussi à ressusciter le genre de la guerre en produisant l'un de ses films les plus poignants et les plus puissants . il a également réussi à faire briller tom hanks , qui livre une performance époustouflante . pendant environ 160 de ses 170 minutes, ' sauver le soldat ryan ' est sans faille . littéralement . l ' histoire est assez simple . après l ' invasion du jour J ( dont les séquences sont tout à fait spectaculaires ), capt . john miller ( joué par tom hanks ) et son équipe sont forcés à chercher un soldat . james ryan ( joué par matt damon ), dont les frères sont tous morts au combat. une fois qu ' ils l ' ont trouvé , ils doivent le ramener immédiatement pour qu'il puisse rentrer chez lui . la compagnie de miller est composée d ' acteurs aux jeux tout simplement sensationnels : bary pepper , adam goldberg , vin diesel , giovanni ribisi , davies et burns . le film se clôture avec des scènes de bataille extraordinaires . |
|||
</p><h2 id="les-ouroboros-de-lapprentissage-automatique"><span class="mw-headline" id="Les_ouroboros_de_l.27apprentissage_automatique">Les ouroboros de l'apprentissage automatique</span></h2><p>Wikipédia est devenue une source d'apprentissage non seulement pour les humains, mais aussi pour les machines. Ses articles sont des sources de premier ordre pour l’entraînement de modèles. Le matériel avec lequel les machines sont entraînées est identique au contenu qu'elles ont aidé à écrire. En fait, au début de Wikipédia, de nombreux articles ont été écrits par des robots. Rambot, par exemple, était un robot controversé sur la plateforme anglophone. Il est l'auteur de 98% des pages décrivant les villes américaines. |
|||
</p><p>A cause de ces interventions de robots thématiques et régulières, les modèles de prédiction qui sont entraînés sur le dump de Wikipedia ont une vision unique de la composition des articles. Par exemple, un modèle thématique entraîné sur l'ensemble des articles de Wikipédia associe 'rivière' à 'Roumanie' et 'village' à 'Turquie'. C'est parce qu'il y a plus de 10000 pages écrites sur les villages en Turquie. Cela devrait suffire à susciter des envies de voyage, mais c'est bien trop par rapport à d'autres pays. L'asymétrie provoque une fausse corrélation et doit être corrigée. La plupart des modèles tentent d'exclure le travail de ces auteurs robots prolifiques. |
|||
</p><p>Référence : <a class="external free" href="https://blog.lateral.io/2015/06/the-unknown-perils-of-mining-wikipedia/" rel="nofollow">https://blog.lateral.io/2015/06/the-unknown-perils-of-mining-wikipedia/</a> |
|||
</p></section></section> |
|||
<h3 id="lecteurs"><span class="mw-headline" id="Lecteurs">Lecteurs</span></h3> |
|||
<p>Nous communiquons avec les ordinateurs au moyens de langages. Nous cliquons sur des icônes sous forme de mots, nous tapons des mots sur des claviers, nous utilisons notre voix pour leur donner des instructions. Parfois, nous confions nos pensées les plus intimes à notre ordinateur en oubliant qu'il s'agit d’une calculatrice avancée. Un ordinateur comprend chaque mot comme une combinaison de zéros et de uns. Une lettre est lue comme un numéro ASCII spécifique : 'A' majuscule est 001. |
|||
</p><p>Dans tous les 'rule-based models', l'apprentissage automatique classique et les réseaux de neurones, les mots subissent une traduction en chiffres pour saisir le sens sémantique du langage. Cela se fait en comptant. Certains modèles comptent la fréquence des mots simples, d'autres la fréquence des combinaisons de mots, d'autres encore la fréquence des noms, des adjectifs, des verbes ou des phrases de noms et de verbes. Certains remplacent simplement les mots d'un texte par leur numéro d'index. Les nombres optimisent la vitesse opérationnelle des processus informatiques, ce qui conduit à des prédictions rapides, mais ils suppriment aussi les liens symboliques que les mots peuvent avoir. Nous présentons ici quelques techniques destinées à rendre un texte intelligible pour une machine. |
|||
</p> |
|||
<h5 id="oeuvres"><span class="mw-headline" id="Oeuvres_5">Oeuvres</span></h5> |
|||
<section class="group"><section class="lemma le-tf-idf works"><h3 class="lemmaheader" id="le-tf-idf">Le TF-IDF</h3><p>par Algolit |
|||
</p><p>Le TF-IDF (Term Frequency-Inverse Document Frequency) est une méthode de pondération utilisée dans la recherche de textes. Cette mesure statistique permet d'évaluer l'importance d'un terme contenu dans un document, relativement à une collection ou un corpus de documents. Le poids augmente proportionnellement au nombre d'occurrences du mot dans le document. Il varie également en fonction de la fréquence du mot dans le corpus. Le TF-IDF est notamment utilisé dans la classification des spams. |
|||
</p><p>Une interface web met en scène cet algorithme à travers des animations permettant de comprendre les différentes étapes de classification d’un texte. Comment un programme basé sur le TF-IDF lit un texte ? Comment transforme-t-il les mots en nombres ? |
|||
</p><p>--- |
|||
</p><p>Concept, code, animation : Sarah Garcin |
|||
</p></section><section class="lemma cultiver-un-arbre works"><h3 class="lemmaheader" id="cultiver-un-arbre">Cultiver un Arbre</h3><p>par Algolit |
|||
</p><p>La nature de mots est une catégorie que nous apprenons à l'école : nom, verbe, adjectif, adverbe, pronom, préposition, conjonction, interjection, et parfois chiffre, article, ou déterminant. |
|||
Dans le traitement du langage naturel, il existe de nombreux écrits qui permettent d'analyser des phrases. Cela signifie que l'algorithme peut déterminer la nature de chaque mot d'une même phrase. 'Cultiver un arbre' utilise cette technique pour définir tous les noms dans une phrase spécifique. Chaque nom est alors remplacé par sa définition. Cela permet à la phrase de grandir de façon autonome et infinie. La recette de 'Cultiver un arbre' s'inspire de la <a class="external text" href="https://oulipo.net/fr/contraintes/litterature-definitionnelle" rel="nofollow">'Littérature Définitionnelle'</a>, une contrainte inventée par Marcel Benabou en 1966 au sein de l’<a class="external text" href="https://oulipo.net/" rel="nofollow">Oulipo</a>. Dans une phrase donnée, on remplace chaque élément significatif (nom, adjectif, verbe, adverbe) par l'une de ses définitions dans un dictionnaire donné ; on répète l'opération sur la nouvelle phrase reçue, et ainsi de suite. |
|||
</p><p>Le dictionnaire utilisé dans cet ouvrage est <a class="external text" href="https://wordnet.princeton.edu/" rel="nofollow">Wordnet</a>. Wordnet est une combinaison d'un dictionnaire et d'un thésaurus qui peut être lu par des machines. Selon Wikipédia, il a été créé dans le Cognitive Science Laboratory de l'Université de Princeton à partir de 1985. |
|||
</p><hr/><p>Concept, code & interface : An Mertens & Gijs de Heij |
|||
</p></section><section class="lemma le-livre-de-demain-dans-un-sac-de-mots works"><h3 class="lemmaheader" id="le-livre-de-demain-dans-un-sac-de-mots">Le Livre de Demain dans un Sac de Mots</h3><p>par Algolit |
|||
</p><p>Le modèle du 'sac de mots' est une représentation simplifiée du texte utilisé dans le traitement du langage naturel. Dans ce modèle, un texte est représenté sous forme de collection de mots uniques, sans tenir compte de la grammaire, de la ponctuation et même de l'ordre des mots. Le modèle transforme le texte en une liste de mots et leur occurrence dans le texte, littéralement un sac de mots. |
|||
</p><p>Cette forte réduction de la langue fut un choc au début de nos expériences en apprentissage automatique. Le sac de mots est souvent utilisé comme référent, sur base duquel le nouveau modèle doit s’efforcer d’être plus performant. Il peut comprendre le sujet d'un texte en reconnaissant les mots les plus fréquents ou importants. On mesure souvent les similitudes des textes en comparant leurs sacs de mots. |
|||
</p><p>Pour cet ouvrage, l'article 'Le Livre de Demain' de l'ingénieur G. Vander Haeghen, publié en 1907 dans le Bulletin de l'Institut International de Bibliographie, a été littéralement réduit à un sac de mots. VOus pouvez acheter votre exemplaire à l'accueil du Mundaneum. |
|||
</p><p>--- |
|||
</p><p>Concept & réalisation: An Mertens |
|||
</p></section><section class="lemma lectures-algorithmiques-du-portrait-parlé-de-bertillon works"><h3 class="lemmaheader" id="lectures-algorithmiques-du-portrait-parlé-de-bertillon">Lectures algorithmiques du portrait parlé de Bertillon</h3><p>par Guillaume Slizewicz (Espèces urbaines) |
|||
</p><p>'Un code télégraphique du portrait parlé', écrit en 1907, est une tentative de traduire en chiffres le 'portrait parlé', technique de description du visage créée par Alphonse Bertillon, créateur de l'anthropométrie judiciaire. En appliquant ce code, Otlet espérait que les visages des criminels et des fugitifs pourraient être facilement communiqués par voie télégraphique. Dans sa forme, son contenu et son ambition, ce texte représente la relation complexe que nous entretenons avec les technologies documentaires. Ce document a été choisi comme base pour la création des installations suivantes pour trois raisons. |
|||
</p><p>- Premièrement, ce texte est un algorithme en soi, un algorithme de compression, ou pour être plus précis, la présentation d'un algorithme de compression. Il tente de réduire la taille de l'information tout en la gardant lisible pour la personne possédant le code. À cet égard, elle est étroitement liée à la façon dont nous créons notre technologie, à la recherche d'une plus grande efficacité, de résultats plus rapides et de méthodes moins coûteuses. Il représente notre appétit de chiffrement qui s'étend au monde entier, notre envie de mesurer les plus petites choses, d'étiqueter les différences les plus infimes... Ce texte incarne en lui-même la vision du Mundaneum. |
|||
</p><p>- Deuxièmement, on y traite des raisons et des mises en œuvre de nos technologies. La présence de ce texte dans les archives sélectionnées est presque ironique à une époque où la reconnaissance faciale et la surveillance des données font la une des journaux. Ce texte présente les mêmes caractéristiques que certaines technologies d'aujourd'hui : il est motivé par un contrôle social, classifie les personnes, pose les bases d'une société de surveillance. Les caractéristiques physionomiques sont au cœur de récentes controverses : les photos d'identité ont été standardisées par Bertillon, elles sont maintenant utilisées pour entraîner des réseau neuronaux à identifier les criminels, les systèmes de reconnaissance faciale permettent des arrestations via notre infrastructure de caméras de surveillance et certains affirment que les caractéristiques physiques peuvent prédire l'orientation sexuelle. |
|||
</p><p>- Le dernier point concerne la façon dont, en tant que témoignage écrit, ce texte représente l'évolution de notre techno-structure: ce que nos outils nous permettent de faire, ce qu'ils nous interdisent, ce qu'ils entravent, ce qu'ils nous font retenir et ce qu'ils nous font oublier. Ce document permet une classification entre les personnes, et instaure une normalité. Il brise un continuum en morceaux, et permet les stigmatisations et les discriminations. D'un autre côté, ce document semble également obsolète aujourd'hui, car cette techno-structure n'a pas besoin de descriptions écrites aussi détaillées sur les fugitifs, les criminels ou les citoyens. Nous pouvons maintenant trouver des empreintes digitales, des scanners d'iris ou des informations ADN dans de grands jeux de données et les comparer directement. Parfois, les systèmes agissent indépendamment, sans surveillance humaine et reconnaissent directement l'identité d'une personne par ses traits faciaux ou sa démarche. Ces machines n'utilisent pas un langage alphabétique complexe pour décrire un visage, mais des listes de chiffres. Ainsi, tous les mots utilisés dans ce document semblent désuets, datés. Avons-nous oublié ce que certains d'entre eux signifient ? La photographie nous a-t-elle fait oublier comment décrire les visages ? Les assistants vocaux nous l'apprendront-il de nouveau ? |
|||
</p><p><i>Écrire avec Otlet</i> |
|||
</p><p>Ecrire avec Otlet est un générateur de personnages qui utilise le code du portrait parlé comme base de données. Des nombres aléatoires sont générés et traduits en un ensemble de caractéristiques humaines. En créant des instances uniques, l'algorithme révèle la richesse de la description qui est possible avec 'Un code du portrait' tout en incorporant ses nuances. |
|||
</p><p><i>Interprétation du portrait parlé de Bertillon</i> |
|||
</p><p>Ce travail établit un parallèle entre le système dit de "Bertillonage" et les systèmes actuels de description de visage. Une webcam associée à un algorithme de reconnaissance faciale capte le visage du spectateur et le traduit en chiffres sur un écran, en l'imprimant à côté des visages annotés par Bertillon. |
|||
</p></section><section class="lemma le-pendu works"><h3 class="lemmaheader" id="le-pendu">Le pendu</h3><p>par Laetitia Trozzi, étudiante Arts²/Section Arts Numériques |
|||
</p><p>Quoi de mieux pour découvrir Paul Otlet et sa passion pour la littérature que de jouer au pendu? À travers ce jeu simple, qui consiste à deviner les lettres manquantes dans un mot, le but est de faire découvrir au public des termes et des faits liés à un des créateurs du mundaneum. |
|||
</p><p>En utilisant un algorithme de détection de fréquence de mots dans un texte, une série de mots significatifs ont été isolés dans la bibliographie de Paul Otlet. Cette série de mots a ensuite été intégrée à un jeu du pendu présenté dans un terminal. La difficulté du jeu augmente graduellement en proposant au joueur des mots de plus en plus longs. Durant les phases de jeux, des informations sont affichées en lien avec la vie et l'œuvre de Paul Otlet. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma récits-contextualisés-autour-des-lecteurs works"><h3 class="lemmaheader" id="récits-contextualisés-autour-des-lecteurs">Récits contextualisés autour des Lecteurs</h3><p><br/> |
|||
Naive Bayes, Support Vector Machines ou Régression Linéaire sont considérés comme des algorithmes classiques d'apprentissage automatique. Ils fonctionnent bien lorsqu'ils apprennent avec de petits jeux de données. Mais ils nécessitent souvent des lecteurs complexes. La tâche accomplie par les lecteurs est également appelée 'feature engineering'. Cela signifie qu'un être humain doit consacrer du temps à une analyse exploratoire approfondie du jeu de données. |
|||
</p><p>Leurs caractéristiques peuvent être la fréquence des mots ou des lettres, mais aussi des éléments syntaxiques comme les noms, les adjectifs ou les verbes. Les caractéristiques les plus importantes pour la tâche à résoudre doivent être soigneusement sélectionnées et transmises à l'algorithme classique d'apprentissage automatique. Ce processus diffère de celui des réseaux de neurones. Lors de l'utilisation d'un réseau de neurones, il n'est pas nécessaire de recourir au 'feature engineering'. Les humains peuvent transmettre les données directement au réseau et obtiennent généralement de bonnes performances dès le départ. Cela permet d'économiser beaucoup de temps et de ressources. |
|||
</p><p>L'inconvénient de la collaboration avec les réseaux de neurones est que vous avez besoin de beaucoup plus de données pour entraîner votre modèle de prédiction. Pensez à au moins 1 Go de fichiers texte. Pour vous donner une référence, 1 A4, soit un fichier texte de 5000 caractères, ne pèse que 5 Ko. Il vous faudrait donc 8.589.934 pages. Traiter plus de données sous-entend d'avoir accès à ces données et surtout, d'avoir beaucoup plus de puissance de traitement. |
|||
</p><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Les_N-grammes_de_caract.C3.A8res_pour_la_reconnaissance_d.27un_auteur"><span class="tocnumber">1</span> <span class="toctext">Les N-grammes de caractères pour la reconnaissance d'un auteur</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#Histoire_des_N-grammes"><span class="tocnumber">2</span> <span class="toctext">Histoire des N-grammes</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Dieu_dans_Google_Books"><span class="tocnumber">3</span> <span class="toctext">Dieu dans Google Books</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#Les_traits_grammaticaux_extraits_de_Twitter_influencent_le_march.C3.A9_boursier"><span class="tocnumber">4</span> <span class="toctext">Les traits grammaticaux extraits de Twitter influencent le marché boursier</span></a></li> |
|||
<li class="toclevel-1 tocsection-5"><a href="#Sac_de_mots"><span class="tocnumber">5</span> <span class="toctext">Sac de mots</span></a></li> |
|||
</ul> |
|||
</div><h2 id="les-n-grammes-de-caractères-pour-la-reconnaissance-dun-auteur"><span class="mw-headline" id="Les_N-grammes_de_caract.C3.A8res_pour_la_reconnaissance_d.27un_auteur">Les N-grammes de caractères pour la reconnaissance d'un auteur</span></h2><p>Imaginez... vous travaillez pour une entreprise depuis plus de dix ans. Vous avez écrit des tonnes de courriels, d'articles, de notes internes et de rapports sur des sujets et dans des genres très différents. Tous vos écrits, ainsi que ceux de vos collègues, sont sauvegardés en toute sécurité sur les serveurs de l'entreprise. |
|||
</p><p>Un jour, vous tombez amoureuse d'une collègue. Après un certain temps, vous réalisez que cette personne est non seulement folle et hystérique mais qu'elle dépend beaucoup de vous. Le jour où vous décidez de rompre, votre ex élabore un plan pour vous tuer. Elle réussit. Pas de chance. Une lettre de suicide signée de votre nom est retrouvée à côté de votre cadavre. Celle-ci raconte que vous avez décidé de mettre fin à votre vie à cause de problèmes émotionnels. Vos meilleurs amis ne croient pas au suicide. Ils décident de porter l'affaire devant les tribunaux. Et là, à partir des textes que vous et d'autres avez produits, un modèle d'apprentissage automatique révèle que la lettre de suicide a été écrite par quelqu'un d'autre. |
|||
</p><p>Comment une machine analyse-t-elle les textes pour vous identifier ? La caractéristique la plus robuste pour la reconnaissance de l'auteur est fournie par la technique des N-grammes de caractères. Elle est utilisée dans des cas qui présentent une grande variété dans les thématiques et les genres d’écriture. Lors de l'utilisation des N-grammes de caractères, les textes sont considérés comme des séquences de caractères. Considérons le trigramme des caractères. Toutes les séquences de trois caractères qui se chevauchent sont isolées. Par exemple, le trigramme de caractères de 'suicide', serait, 'sui', 'uic', 'ici', 'cid' et 'ide'. Les N-grammes de caractères sont très simples, ils sont indépendants du langage et tolérants au bruit. De plus, les fautes d'orthographe ne compromettent pas la technique. |
|||
</p><p>Les motifs trouvés avec les N-grammes de caractères se concentrent sur les choix stylistiques qui sont faits inconsciemment par l'auteur. Les modèles restent stables sur toute la longueur du texte, ce qui est important pour reconnaître l’auteur. D'autres types d'expériences pourraient inclure la longueur des mots ou des phrases, la richesse du vocabulaire, la fréquence des mots de fonction et même les mesures syntaxiques ou sémantiques. |
|||
</p><p>Cela signifie non seulement que votre empreinte physique est unique, mais qu’il en va de même de la façon dont vous composez vos pensées ! |
|||
</p><p>La même technique n-gramme a découvert que 'The Cuckoo's Calling', un roman de Robert Galbraith, a en fait été écrit par... J.K. Rowling ! |
|||
</p><p>Références :<br/> |
|||
- Essai: On the Robustness of Authorship Attribution Based on Character N-gram Features, Efstathios Stamatatos, in Journal of Law & Policy, Volume 21, Issue 2, 2013. <br/> |
|||
- Article: <a class="external free" href="https://www.scientificamerican.com/article/how-a-computer-program-helped-show-jk-rowling-write-a-cuckoos-calling/" rel="nofollow">https://www.scientificamerican.com/article/how-a-computer-program-helped-show-jk-rowling-write-a-cuckoos-calling/</a> |
|||
</p><h2 id="histoire-des-n-grammes"><span class="mw-headline" id="Histoire_des_N-grammes">Histoire des N-grammes</span></h2><p>L'algorithme des N-grammes peut être retracé jusqu'aux travaux de Claude Shannon en théorie de l'information. Dans l'article 'A mathematical theory of communication', publié en 1948, Claude Shannon réalise la première instance d'un modèle de langage naturel à base des N-grammes. Il a posé la question suivante : étant donné la séquence des lettres, quelle est la probabilité de la prochaine lettre ?<br/> |
|||
Si vous lisez l'extrait suivant, pouvez-vous nous dire par qui il a été écrit ? Shakespeare ou un robot N-grammes ? |
|||
</p><p>SEBASTIEN : Dois-je rester debout jusqu'à la rupture. |
|||
BIRON : Cache ta tête. |
|||
VENTIDIUS : Il se rendit à Athènes, où, par le voeu. que j'ai fait pour m'occuper de toi. |
|||
FALSTAFF : Mon bon fripouille. |
|||
</p><p>Vous aviez peut-être deviné, en considérant le sujet de ce récit, qu'un algorithme N-grammes a généré ce texte. Le modèle est entraîné sur l'oeuvre complète de Shakespeare. Alors que les algorithmes plus récents, tels que les réseaux de neurones récursifs de CharRNN, deviennent célèbres pour leurs performances, les N-grammes exécutent encore beaucoup de tâches NLP. Elles sont utilisés dans la traduction automatique, la reconnaissance vocale, la correction orthographique, la détection d'entités, l'extraction d'informations, etc. |
|||
</p><p>Référence : <a class="external free" href="http://www.math.harvard.edu/~ctm/home/text/others/shannon/entropy/entropy.pdf" rel="nofollow">http://www.math.harvard.edu/~ctm/home/text/others/shannon/entropy/entropy.pdf</a> |
|||
</p><h2 id="dieu-dans-google-books"><span class="mw-headline" id="Dieu_dans_Google_Books">Dieu dans Google Books</span></h2><p>En 2006, Google crée un jeu de données de N-grammes à partir de sa collection de livres numérisés pour le mettre en ligne. Récemment, ils ont également réalisé une visionneuse de N-grammes. Cela a permis de nombreuses recherches sociolinguistiques. Par exemple, en octobre 2018, le New York Times Magazine a publié un article d'opinion intitulé 'It's Getting Harder to Talk About God'. L'auteur, Jonathan Merritt, avait analysé la mention du mot 'Dieu' dans le jeu de données de Google à l'aide du visualiseur de N-grammes. |
|||
Il a conclu qu'il y a eu un déclin dans l'usage du mot depuis le 20ème siècle. Le corpus de Google contient des textes du 16e jusqu'au 21e siècle. Cependant l'auteur a manqué d'observer la popularité croissante des revues scientifiques vers le début du 20ème siècle. Ce nouveau genre, dans lequel le mot Dieu n'apparaît pas, a fait basculer le jeu des données. Si la littérature scientifique était retirée du corpus, la fréquence du mot 'Dieu' s'écoulerait toujours comme l'ondulation douce d'une vague lointaine. |
|||
</p><p>Référence : <a class="external free" href="https://www.nytimes.com/2018/10/13/opinion/sunday/talk-god-sprituality-christian.html" rel="nofollow">https://www.nytimes.com/2018/10/13/opinion/sunday/talk-god-sprituality-christian.html</a> |
|||
</p><h2 id="les-traits-grammaticaux-extraits-de-twitter-influencent-le-marché-boursier"><span class="mw-headline" id="Les_traits_grammaticaux_extraits_de_Twitter_influencent_le_march.C3.A9_boursier">Les traits grammaticaux extraits de Twitter influencent le marché boursier</span></h2><p>Les frontières entre les disciplines académiques s'estompent. La recherche économique mélangée à la psychologie, aux sciences sociales, aux concepts cognitifs et émotionnels créent un nouveau sous-domaine économique, appelé 'l'économie comportementale'. |
|||
</p><p>Cela signifie que les chercheurs commencent à expliquer un mouvement boursier basé sur d'autres facteurs que les facteurs purement économiques. La Bourse et 'l'opinion publique' s'influencent mutuellement. De nombreuses recherches sont effectuées sur la façon d'utiliser 'l'opinion publique' pour prédire les tendances dans le cours des actions. |
|||
</p><p>'L'opinion publique' est évaluée à partir de grandes quantités de données publiques, comme les tweets, les blogs ou la presse en ligne. Des recherches montrent que l'évolution des cours boursiers peut, dans une certaine mesure, être prédit en examinant 'l'opinion publique' à travers l'analyse des données automatique. On trouve de nombreux articles scientifiques en ligne, qui analysent la presse sur le 'sentiment' qui y est exprimé. Un article peut être annoté comme plus ou moins positif ou négatif. Les articles de presse annotés sont ensuite utilisés pour entraîner un modèle d’apprentissage automatique, qui permet de prédire les tendances boursières, en les marquant comme 'à la baisse' ou 'à la hausse'. Quand une entreprise fait mauvaise presse, les traders vendent. Au contraire, si les nouvelles sont bonnes, ils achètent. |
|||
</p><p>Un article de Haikuan Liu de l'Université Nationale Australienne affirme que le temps des verbes utilisés dans les tweets peut être un indicateur de la fréquence des transactions financières. Son idée s'inspire du fait que la conjugaison des verbes est utilisée en psychologie pour détecter les premiers stades de la dépression humaine. |
|||
</p><p>Référence : Grammatical Feature Extraction and Analysis of Tweet Text: An Application towards Predicting Stock Trends, The Australian National University (ANU) |
|||
</p><h2 id="sac-de-mots"><span class="mw-headline" id="Sac_de_mots">Sac de mots</span></h2><p>Dans le traitement du langage naturel, le 'sac de mots' est considéré comme un modèle simple. Il dépouille un texte de son contexte et le décompose dans sa collection de mots uniques. Ensuite, ces mots sont comptés. Dans les phrases précédentes, par exemple, le mot 'mots' est mentionné trois fois, mais ce n'est pas nécessairement un indicateur de l'objet du texte. |
|||
</p><p>La première apparition de l'expression 'sac de mots' semble remonter à 1954. Zellig Harris a publié un article dans le contexte des études linguistiques, intitulé 'Distributional Structure'. Dans la partie intitulée 'Le sens en fonction de la distribution', il dit que 'le langage n'est pas seulement un sac de mots, mais aussi un outil aux propriétés particulières qui ont été façonnées au cours de son utilisation. Le travail du linguiste est précisément de découvrir ces propriétés, que ce soit pour l'analyse descriptive ou pour la synthèse du système quasi-linguistique.' |
|||
</p></section></section> |
|||
<h3 id="apprenants"><span class="mw-headline" id="Apprenants">Apprenants</span></h3> |
|||
<p>Les Apprenants sont les algorithmes qui distinguent les pratiques d'apprentissage automatique des autres pratiques algorithmiques. Les Apprenants sont aussi appelés classificateurs. Ce sont des chercheurs de motifs, capables de fouiller dans les données et de générer une sorte de 'grammaire' spécifique. Les Apprenants sont souvent basés sur des techniques statistiques. Chacun d'entre eux présente des caractéristiques individuelles. Certains ont besoin d'une grande quantité de données d'entraînement pour fonctionner, d'autres peuvent s'en tirer avec un petit jeu de données annotées. Certains s'acquittent bien de tâches de classification, comme l'identification des spam, d'autres sont plus aptes à prédire les chiffres, comme les températures, les distances, les valeurs boursières, et ainsi de suite. |
|||
</p><p>La terminologie de l'apprentissage automatique n'est pas encore complètement établie. Selon le domaine (les statistiques, l'informatique ou les sciences humaines) ils sont appelés par des mots différents. Lorsque nous parlons d’Apprenants, nous parlons des fonctions imbriquées qui ont la capacité de générer d'autres fonctions, de les évaluer et de les réajuster en fonction des données. Les Apprenants sont bons pour comprendre et révéler les motifs. Mais ils ne distinguent pas toujours bien quels motifs doivent être répétés. |
|||
</p><p>Dans les logiciels, il n'est pas toujours possible de distinguer les éléments caractéristiques des classificateurs, car ils sont cachés dans des modules ou bibliothèques sous-jacents. Les programmeurs peuvent les invoquer en utilisant une seule ligne de code. Par conséquent, pour cette exposition, nous avons développé deux jeux de table qui montrent en détail le processus d'apprentissage de classificateurs simples, mais fréquemment utilisés. |
|||
</p> |
|||
<h5 id="oeuvres"><span class="mw-headline" id="Oeuvres_6">Oeuvres</span></h5> |
|||
<section class="group"><section class="lemma jouez-au-naive-bayes works"><h3 class="lemmaheader" id="jouez-au-naive-bayes">Jouez au Naive Bayes</h3><p>par Algolit |
|||
</p><p>Dans l'apprentissage automatique, les méthodes Naive Bayes sont des classificateurs probabilistes simples qui sont largement utilisés pour filtrer le spam et décider si un texte est positif ou négatif. |
|||
</p><p>Ils nécessitent une petite quantité de données d'entraînement pour estimer les paramètres nécessaires. Ils peuvent être extrêmement rapides par rapport à des méthodes plus sophistiquées. Ils sont difficiles à généraliser, ce qui signifie qu'ils exécutent des tâches très spécifiques, exigeant d'être entraînés avec le même style de données que celui qui sera utilisé par la suite. |
|||
</p><p>Ce jeu vous permet de jouer selon les règles de Naive Bayes. Tout en exécutant manuellement le code, vous créez votre propre modèle ludique qui 'fonctionne'. Un peu de prudence s'impose : parce que vous ne l'entraînez qu'en 6 phrases - au lieu de 2000 au minimum - il n'est pas représentatif du tout ! |
|||
</p><p>--- |
|||
</p><p>Concept & réalisation: An Mertens |
|||
</p></section><section class="lemma jouez-à-la-régression-linéaire works"><h3 class="lemmaheader" id="jouez-à-la-régression-linéaire">Jouez à la Régression Linéaire</h3><p>par Algolit |
|||
</p><p>La régression linéaire est l'un des algorithmes les plus connus et les mieux compris en statistique et en apprentissage automatique. Il existe depuis près de 200 ans. C'est un modèle attrayant parce que la représentation est très simple. En statistique, la régression linéaire est une méthode statistique qui permet de résumer et d'étudier les relations entre deux paramètres quantitatifs. |
|||
</p><p>En jouant à ce jeu, vous réaliserez qu'en tant que joueur, vous avez beaucoup de décisions à prendre. Vous découvrirez ce que signifie créer un jeu de données cohérent, de décider ce qu’il doit inclure. Si tout se passe bien, vous ressentirez le besoin de modifier vos données afin d'obtenir de meilleurs résultats. Cela fait partie de l'art de l'approximation qui est à la base de toutes les pratiques d'apprentissage automatique. |
|||
</p><hr/><p>Concept & réalisation: An Mertens |
|||
</p></section><section class="lemma traité-de-documentation-trois-poèmes-algorithmiques works"><h3 class="lemmaheader" id="traité-de-documentation-trois-poèmes-algorithmiques">Traité de documentation. Trois poèmes algorithmiques</h3><p>par Rémi Forte, designer-chercheur à l’Atelier national de recherche typographique, Nancy, France |
|||
</p><p>sérigraphie sur papier, 60 × 80 cm, 25 ex., 2019, en vente à la réception du Mundaneum. |
|||
</p><p>Sous la forme de trois affiches, ces poèmes opèrent une relecture algorithmique et poétique du 'Traité de documentation' de Paul Otlet. Ils sont le résultat d’un même algorithme basé sur les règles mystérieuses de l'intuition humaine. Il est appliqué à trois fragments prélevés dans l’ouvrage de Paul Otlet et se veut représentatif de sa pratique bibliologique. Pour chaque fragment, l’algorithme découpe le texte, puis mots et signes de ponctuation sont comptabilisés et réordonnés en une liste. À chaque ligne, les éléments se combinent et épuisent la syntaxe du fragment sélectionné. |
|||
</p><p>Le langage de Paul Otlet reste perceptible mais exacerbé jusqu’à l’absurde. Pour le lecteur, la systématisation du texte est déconcertante et ses habitudes de lecture sont bousculées. Construite selon une équation mathématique, la composition typographique de l’affiche est tout aussi systématique que le poème. Cependant, des frictions surviennent ponctuellement ; boucle après boucle, les lignes s’étendent jusqu’à mordre la colonne voisine. Des superpositions se créent et des mots se trouvent dissimulés par d’autres. Ces télescopages dessinent des parcours de lecture alternatifs. |
|||
</p></section></section> |
|||
<section class="group"><section class="lemma récits-contextualisés-autour-des-apprenants works"><h3 class="lemmaheader" id="récits-contextualisés-autour-des-apprenants">Récits contextualisés autour des Apprenants</h3><div class="toc" id="toc"><div id="toctitle"><h2 id="contents">Contents</h2></div> |
|||
<ul> |
|||
<li class="toclevel-1 tocsection-1"><a href="#Naive_Bayes_.26_Viagra"><span class="tocnumber">1</span> <span class="toctext">Naive Bayes & Viagra</span></a></li> |
|||
<li class="toclevel-1 tocsection-2"><a href="#Naive_Bayes_.26_Enigma"><span class="tocnumber">2</span> <span class="toctext">Naive Bayes & Enigma</span></a></li> |
|||
<li class="toclevel-1 tocsection-3"><a href="#Une_histoire_sur_les_petits_pois"><span class="tocnumber">3</span> <span class="toctext">Une histoire sur les petits pois</span></a></li> |
|||
<li class="toclevel-1 tocsection-4"><a href="#Perceptron"><span class="tocnumber">4</span> <span class="toctext">Perceptron</span></a></li> |
|||
<li class="toclevel-1 tocsection-5"><a href="#BERT"><span class="tocnumber">5</span> <span class="toctext">BERT</span></a></li> |
|||
</ul> |
|||
</div><h2 id="naive-bayes--viagra"><span class="mw-headline" id="Naive_Bayes_.26_Viagra">Naive Bayes & Viagra</span></h2><p>L'algorithme <a class="external text" href="https://fr.wikipedia.org/wiki/Classification_na%C3%AFve_bay%C3%A9sienne" rel="nofollow">Naive Bayes</a> est un Apprenant célèbre qui réussit bien avec peu de données. Nous l'appliquons tout le temps. Christian & Griffiths affirment dans leur livre, <a class="external text" href="http://algorithmstoliveby.com/" rel="nofollow">'Algorithms to Live by'</a>, que 'nos jours sont remplis de petites données'. Imaginez par exemple que vous vous trouviez à un arrêt de bus dans une ville étrangère. L'autre personne qui se tient là attend depuis 7 minutes. Qu'est-ce que vous faites ? Décidez-vous d'attendre ? Et si oui, pour combien de temps ? Quand allez-vous envisager d'autres options ? Un autre exemple. Imaginez qu’un ami demande conseil sur une relation. Il est avec son nouveau partenaire depuis un mois. Doit-il l'inviter à l’accompagner à un mariage de famille ? |
|||
</p><p>Les croyances préexistantes sont cruciales pour que Naive Bayes fonctionne. L'idée est de calculer les probabilités sur base de ces connaissances préalables et d'une situation spécifique. |
|||
</p><p>Le théorème a été formulé dans les années 1740 par le révérend et mathématicien amateur <a class="external text" href="https://fr.wikipedia.org/wiki/Thomas_Bayes" rel="nofollow">Thomas Bayes</a>. Il a consacré sa vie à résoudre la question de savoir comment gagner à la loterie. Mais la règle de Bayes a été rendue célèbre dans sa forme actuelle par le mathématicien <a class="external text" href="https://fr.wikipedia.org/wiki/Pierre-Simon_de_Laplace" rel="nofollow">Pierre-Simon Laplace</a> en France un peu plus tard dans le même siècle. Longtemps après la mort de La Place, la théorie tombe dans l'oubli jusqu'à ce qu'elle soit à nouveau déterrée pendant la Seconde Guerre mondiale dans le but de briser le code Enigma. |
|||
</p><p>La plupart des personnes sont aujourd'hui entrées en contact avec Naive Bayes par le biais de leurs dossiers de courrier indésirable. Naive Bayes est un algorithme largement utilisé pour la détection du spam. C’est une coïncidence que le Viagra, médicament contre la dysfonction érectile, a été approuvé par la FDA (US Food & Drug Administration) en 1997, au moment où environ 10 millions d'utilisateurs dans le monde avaient des comptes de messagerie Web gratuits. Les sociétés de vente avaient l’intelligence d'utiliser la publicité massive par e-mail : c'était un média intime, à l'époque réservé à la communication privée. En 2001, le premier programme <a class="external text" href="https://spamassassin.apache.org/" rel="nofollow">SpamAssasin</a> s'appuyant sur Naive Bayes a été téléchargé sur <a class="external text" href="https://sourceforge.net/" rel="nofollow">SourceForge</a>, réduisant ainsi le marketing 'guerilla par courriel'. |
|||
</p><p>Référence : Machine Learners, by Adrian MacKenzie, The MIT Press, Cambridge, US, November 2017. |
|||
</p><h2 id="naive-bayes--enigma"><span class="mw-headline" id="Naive_Bayes_.26_Enigma">Naive Bayes & Enigma</span></h2><p>Cette histoire de Naive Bayes fait partie du livre '<a class="external text" href="https://yalebooks.yale.edu/book/9780300188226/theory-would-not-die" rel="nofollow">The theory that would not die</a>', écrit par Sharon Bertsch McGrayne. Elle décrit entre autres comment Naive Bayes est vite oubliée après la mort de <a class="external text" href="https://fr.wikipedia.org/wiki/Pierre-Simon_de_Laplace" rel="nofollow">Pierre-Simon Laplace</a>, son inventeur. Le mathématicien aurait échoué à créditer les travaux des autres. Par conséquent, il a souffert d’accusations largement diffusées contre sa réputation. Ce n'est que 150 ans plus tard que l'accusation s'est avérée fausse. |
|||
</p><p>Avançons en 1939, alors que le règne de Bayes demeure pratiquement tabou, mort et enterré dans le domaine de la statistique. Lorsque la France est occupée en 1940 par l'Allemagne, qui contrôle les usines et les fermes européennes, la plus grande inquiétude de Winston Churchill est le péril U-boot. Les opérations de sous-marin étaient étroitement contrôlées par le quartier général allemand en France. Chaque sous-marin partait en mer sans ordres, et les recevait sous forme de messages radio codés après avoir atteint l'Atlantique. Les messages étaient cryptés par des machines à brouiller les mots, appelées Enigma machines. <a class="external text" href="https://fr.wikipedia.org/wiki/Enigma_(machine)" rel="nofollow">Enigma</a> ressemblait à une machine à écrire compliquée. Elle est inventée par la société allemande Scherbius & Ritter après la première guerre mondiale, lorsque le besoin de machines d'encodage de messages est devenu douloureusement évident. |
|||
</p><p>Curieusement, et heureusement pour Naive Bayes et le monde, à l'époque le gouvernement britannique et les systèmes d'éducation considéraient les mathématiques appliquées et les statistiques sans aucun rapport avec la résolution pratique des problèmes. Les données statistiques ont été jugées gênantes en raison de leur caractère détaillé. Ainsi, les données du temps de guerre étaient souvent analysées non pas par des statisticiens, mais par des biologistes, des physiciens et des mathématiciens théoriques. Aucun d'entre eux ne savait qu'en ce qui concerne les statistiques sophistiquées, la règle de Bayes était considérée non-scientifique. |
|||
</p><p>C'est le désormais célèbre <a class="external text" href="https://fr.wikipedia.org/wiki/Alan_Turing" rel="nofollow">Alan Turing</a>, mathématicien, informaticien, logicien, cryptanalyste, philosophe et biologiste théorique, qui a utilisé le système de probabilités des règles de Bayes pour concevoir la 'bombe'. Il s'agissait d'une machine électromécanique à grande vitesse pour tester tous les arrangements possibles qu'une machine Enigma produirait. Afin de déchiffrer les codes navals des U-boot, Turing simplifie le système de la 'bombe' en utilisant des méthodes baysiennes. La 'bombe' a transformé le quartier général du Royaume-Uni en une usine de décryptage. L'histoire est bien illustrée dans 'The Imitation Game', un film de Morten Tyldum, sorti en 2014. |
|||
</p><h2 id="une-histoire-sur-les-petits-pois"><span class="mw-headline" id="Une_histoire_sur_les_petits_pois">Une histoire sur les petits pois</span></h2><p>En statistique, la régression linéaire est une méthode d'apprentissage supervisé. Après l'entraînement avec des données annotées, le modèle tente de prédire les valeurs de nouvelles données inconnues. La régression linéaire permet de résumer et d'étudier les relations entre deux éléments, afin de voir s'il existe une corrélation entre eux. S'il y a une corrélation positive, la connaissance d'un élément aide à prédire l'autre. Par exemple, étant donné la critique d'un film, nous pouvons prédire le nombre moyen d'étoiles qui lui sont attribuées, plutôt que de simplement dire si la critique est positive ou négative. |
|||
</p><p>Parfois, les figures que nous rencontrons en grattant sous la surface ne sont pas à notre goût. L'idée de régression vient de <a class="external text" href="https://fr.wikipedia.org/wiki/Francis_Galton" rel="nofollow">Sir Francis Galton</a>, un scientifique influent du 19e siècle. Il a passé sa vie à étudier le problème de l'hérédité - pour comprendre à quel point les caractéristiques d'une génération d'êtres vivants se manifestent dans la génération suivante. Il a établi le domaine de l'eugénisme et l'a défini comme 'l'étude des organismes sous contrôle social qui peuvent améliorer ou altérer les qualités raciales des générations futures, que ce soit physiquement ou mentalement'. Par conséquent, son nom a marqué l'histoire et l'héritage du racisme scientifique. |
|||
</p><p>Galton a d'abord abordé le problème de l'hérédité en examinant les caractéristiques du petit pois doux. Il a choisi le petit pois parce que l'espèce peut s'auto-fertiliser. Les plantes femelles héritent des variations génétiques des plantes mères sans la contribution d'un deuxième parent. Cette caractéristique élimine la nécessité de traiter avec des sources multiples. |
|||
</p><p>En 1875, Galton a distribué des paquets de graines de petits pois à sept amis. Chaque ami recevait des graines de poids uniforme, mais il y avait des variations importantes d'un paquet à l'autre. Les amis de Galton ont récolté les graines des nouvelles générations de plantes et les lui ont rendues. Il a ensuite tracé le poids des graines femelles contre le poids des graines mères. Il a découvert que le poids médian des graines femelles d'une taille particulière de la semence mère décrivait approximativement une ligne droite avec une pente positive inférieure à 1,0. Les premières idées de Galton sur la régression sont nées de ce diagramme bidimensionnel qui compare la taille des petits pois femelles à celle des petits pois mères. Il a utilisé cette représentation de ses données pour illustrer les fondements de ce que les statisticiens appellent encore aujourd'hui la régression. Pour Galton, c'était aussi une façon de décrire les avantages de l'eugénisme. |
|||
</p><p>La recherche de Galton été appréciée par de nombreux intellectuels de son temps. En 1869, dans <a class="external text" href="http://galton.org/books/hereditary-genius/text/pdf/galton-1869-genius-v4.pdf" rel="nofollow">'Hereditary Genius'</a>, Galton affirme que le génie est principalement une question d'ascendance. Il croyait qu'il y avait une explication biologique à l'inégalité sociale entre les races. Galton a même persuadé son demi-cousin <a class="external text" href="https://fr.wikipedia.org/wiki/Charles_Darwin" rel="nofollow">Charles Darwin</a> de ses idées. Après avoir lu l'article de Galton, Darwin a déclaré : 'Vous avez converti un adversaire, car j'ai toujours soutenu qu'à l'exception des imbéciles, les hommes ne différaient pas beaucoup sur le plan intellectuel, seulement sur le plan du zèle et du labeur'. Heureusement, l'étude moderne de l'hérédité a réussi à éliminer le mythe de la différence génétique fondée sur la race. |
|||
</p><p>La raison pour laquelle nous l'évoquons dans cette série, c'est qu'il a été parmi les premiers scientifiques à utiliser des méthodes statistiques dans ses recherches. Sa principale contribution dans ce domaine a été l'analyse de régression linéaire, qui a fondé les bases d'une grande partie de la statistique moderne. Alors que nous nous engageons dans le domaine de l'apprentissage automatique, Algolit essaie de ne pas oublier que les systèmes d'ordre ont du pouvoir, et que ce pouvoir n'a pas toujours été exercé au bénéfice de tout le monde. L'apprentissage automatique a hérité de nombreux aspects de la recherche statistique, certains plus agréables que d'autres. Nous devons nous méfier, car ces visions du monde s'infiltrent dans les modèles algorithmiques qui créent des ordres aujourd'hui. |
|||
</p><p>Références : |
|||
</p><p><a class="external free" href="http://galton.org/letters/darwin/correspondence.htm" rel="nofollow">http://galton.org/letters/darwin/correspondence.htm</a> |
|||
</p><p><a class="external free" href="https://www.tandfonline.com/doi/full/10.1080/10691898.2001.11910537" rel="nofollow">https://www.tandfonline.com/doi/full/10.1080/10691898.2001.11910537</a> |
|||
</p><p><a class="external free" href="http://www.paramoulipist.be/?p=1693" rel="nofollow">http://www.paramoulipist.be/?p=1693</a> |
|||
</p><h2 id="perceptron"><span class="mw-headline" id="Perceptron">Perceptron</span></h2><p>Nous nous trouvons dans une décennie où les réseaux de neurones suscitent beaucoup d'attention. Cela n'a pas toujours été le cas. L'étude des réseaux de neurones remonte aux années 1940, lorsque la première métaphore des neurones est apparue. Le neurone n'est pas la seule référence biologique dans le domaine de l'apprentissage automatique - pensez au mot corpus ou formation. Le neurone artificiel a été construit en relation étroite avec son homologue biologique. |
|||
</p><p>Le psychologue <a class="external text" href="https://fr.wikipedia.org/wiki/Frank_Rosenblatt" rel="nofollow">Frank Rosenblatt</a> s'est inspiré des travaux de son collègue <a class="external text" href="https://fr.wikipedia.org/wiki/Donald_Hebb" rel="nofollow">Donald Hebb</a> sur le rôle des neurones dans l'apprentissage humain. Hebb a déclaré que 'les cellules qui communiquent, se mettent ensemble.' Sa théorie est maintenant à la base de l'apprentissage associatif humain, mais aussi de l'apprentissage en réseau de neurones non supervisé. Il a poussé Rosenblatt à développer l'idée du neurone artificiel. En 1962, il crée le Perceptron. Le Perceptron est un modèle qui apprend par la pondération des entrées. |
|||
</p><p>Il a été mis de côté par les chercheurs, parce qu'il ne peut gérer que la classification binaire. Cela signifie que les données doivent être séparables linéairement, comme par exemple hommes et femmes, noir et blanc. Il est clair que ce type de données est très rare dans le monde réel. Lorsque le soi-disant premier hiver de l'Intelligence Artificielle (IA) est arrivé en 1974-1980 et que le financement consacré à cette recherche a diminué, le Perceptron a également été négligé. Pendant 10 ans, il est resté inactif. Lorsque le printemps s'installe à la fin des années 1980, de nouvelles générations de chercheurs le reprennent et l'utilisent pour construire des réseaux de neurones. Ceux-ci contiennent de multiples couches de Perceptrons. C'est ainsi que les réseaux de neurones voient la lumière. On pourrait dire que cette saison d'apprentissage automatique est particulièrement chaude, mais il faut un autre hiver pour connaître un été. |
|||
</p><h2 id="bert"><span class="mw-headline" id="BERT">BERT</span></h2><p>Certains articles en ligne disent que l'année 2018 a marqué un tournant dans le domaine du traitement du langage naturel. Une série de modèles de 'deep learning' ont permis d'obtenir des résultats excellents pour des tâches comme les réponses aux questions ou la classification des sentiments. L'algorithme BERT de Google est entré dans les concours d'apprentissage automatique de l'année dernière comme un 'modèle gagnant'. Il témoigne d’une performance supérieure sur une grande variété de tâches. |
|||
</p><p>BERT est pré-entraîné; ses poids sont appris à l'avance grâce à deux tâches non supervisées. Cela signifie que BERT n'a pas besoin d'être entraîné à partir de zero pour chaque nouvelle tâche. Vous n'avez qu'à affiner ses poids. |
|||
</p><p>Cela signifie également qu'un programmeur souhaitant utiliser BERT ne sait plus sur quels paramètres BERT est réglé, ni à base de quelles données il a appris ses performances. |
|||
</p><p>BERT signifie 'Bidirectional Encoder Representations from Transformers'. Cela signifie que BERT permet un entraînement bidirectionnel. Le modèle apprend le contexte d'un mot à partir de son environnement, à gauche et à droite d'un mot. En tant que tel, il peut faire la différence entre 'Je suis pile à l’heure' et 'Je l’ai mis sur la pile'. |
|||
</p><p>Quelques faits : |
|||
</p><p>- BERT_large, avec 345 millions de paramètres, est le plus grand modèle du genre. Il est manifestement supérieur à BERT_base, qui utilise la même architecture avec 'seulement' 110 millions de paramètres, pour les tâches à petite échelle. |
|||
</p><p>- Pour exécuter BERT, vous devez utiliser les TPU. Ce sont les processeurs (CPU) de Google spécialement conçus pour TensorFLow, la plateforme de 'deep learning'. Les tarifs de location de TPU vont de de 8$/h à 394$/h. Si vous êtes comme nous, et vous ne voulez pas travailler avec des sollutions prêtes à l'emploi, et vous souhaitez ouvrir la boîte noire, BERT exige de faire des économies pour pouvoir l’utiliser. |
|||
</p><p>Références : |
|||
</p><p><a class="external free" href="https://ai.googleblog.com/2018/11/open-sourcing-bert-state-of-art-pre.html" rel="nofollow">https://ai.googleblog.com/2018/11/open-sourcing-bert-state-of-art-pre.html</a> |
|||
</p><p><a class="external free" href="https://towardsdatascience.com/deconstructing-bert-distilling-6-patterns-from-100-million-parameters-b49113672f77" rel="nofollow">https://towardsdatascience.com/deconstructing-bert-distilling-6-patterns-from-100-million-parameters-b49113672f77</a> |
|||
</p></section></section> |
|||
<h2 id="glossaire"><span class="mw-headline" id="Glossaire">Glossaire</span></h2> |
|||
<p>Vous trouverez ci-dessous un glossaire non-exhaustif reprenant des termes fréquemment utilisés dans l'exposition. Il est conçu comme une aide pour les visiteurs connaissant peu le vocabulaire lié au domaine du traitement des langues naturelles (NLP), Algolit ou le Mundaneum. |
|||
</p><p><b>* Algolit:</b> un groupe bruxellois spécialisé dans la recherche artistique sur les algorithmes et la littérature. Chaque mois, le groupe se réunit pour expérimenter avec du code et des textes publiés sous licences libres. <a class="external free" href="http://www.algolit.net" rel="nofollow">http://www.algolit.net</a> |
|||
</p><p><b>* Algolittéraire:</b> terme inventé par Algolit pour des oeuvres qui explorent le point de vue du conteur algorithmique. Quelles nouvelles formes de narration rendons-nous possibles en dialoguant avec les algorithmes ? |
|||
</p><p><b>* Algorithme:</b> Un ensemble d'instructions dans un langage de programmation spécifique, qui permettent de produire un résultat (output) à partir de données (inputs). |
|||
</p><p><b>* Annotation:</b> Le processus d'annotation est une étape cruciale de l'apprentissage automatique supervisé durant laquelle l'algorithme reçoit des exemples de ce qu'il doit apprendre. Un filtre anti-spam sera alimenté d'exemples de messages spams et de messages réels. Ces exemples consistent en un message, l'entrée, accompagné d'une étiquette : spam ou non spam. L'annotation d'un jeu de données est un travail exécuté par des humains, qui choisissent une étiquette pour chaque élément du jeu de données. Pour assurer la qualité des étiquettes, plusieurs annotateurs doivent voir le même élément, la même entrée, et donner la même étiquette avant qu'un exemple ne soit inclus dans les données d'entraînement. |
|||
</p><p><b>* Apprentissage automatique ou machine learning:</b> Modèles algorithmiques basés sur la statistique, principalement utilisés pour analyser et prédire des situations à partir de cas existants. Dans cette exposition, nous nous concentrons sur les modèles d'apprentissage automatique pour le traitement de texte ou le traitement du langage naturel (voir NLP). Ces modèles ont appris à effectuer une tâche spécifique sur la base de textes existants. Ils sont utilisés par les moteurs de recherche, les traductions automatiques, et permettent de générer des résumés et de repérer les tendances sur les réseaux sociaux et des fils d’actualité. Ils influencent ce que l'on voit en tant qu'utilisateur, mais ont aussi leur mot à dire dans les fluctuations du cours des bourses mondiales ou dans la détection de la cybercriminalité et du vandalisme. |
|||
</p><p><b>* Apprentissage automatique classique:</b> Naive Bayes, Support Vector Machines ou Régression Linéaire sont considérés comme des algorithmes classiques d'apprentissage automatique. Ils fonctionnent bien lorsqu'ils apprennent avec de petits jeux de données. Mais ils nécessitent souvent des lecteurs complexes. La tâche accomplie par les lecteurs est également appelée 'feature engineering' (voir ci-dessous). Cela signifie qu'un être humain doit consacrer du temps à une analyse exploratoire approfondie du jeu de données. |
|||
</p><p><b>* Bag of Words:</b> Le modèle du sac de mots est une représentation simplifiée du texte utilisé dans le traitement du langage naturel. Dans ce modèle, un texte est représenté sous la forme d'une collection de mots uniques, sans tenir compte de la grammaire, de la ponctuation ni même de leur ordre dans le texte. Ce modèle transforme un texte en une liste de mots associés à leur fréquence : littéralement un sac de mots. Le sac de mots est souvent utilisé comme référence, c'est sur cette base qu'on évaluera la performance d'un nouveau modèle. |
|||
</p><p><b>* Chaîne de Markov:</b> Algorithme qui scanne un texte à la recherche de la probabilité de transition d'occurrences de lettres ou de mots, ce qui donne des tables de probabilité de transition qui peuvent être calculées sans aucune compréhension sémantique ou grammaticale du langage naturel. Cet algorithme peut être utilisé pour analyser des textes, mais aussi pour les recombiner. Il est largement utilisé pour la génération de spam. |
|||
</p><p><b>* Constant:</b> Constant est une association sans but lucratif d’artistes autogérés, basée à Bruxelles depuis 1997 et active dans les domaines de l’art, des médias et de la technologie. Algolit est né en 2012 comme un projet de Constant. <a class="external free" href="http://constantvzw.org" rel="nofollow">http://constantvzw.org</a> |
|||
</p><p><b>* Data Workers:</b> Intelligences artificielles développées pour servir, divertir, enregistrer et connaître les humains. Le travail de ces entités machiniques est généralement dissimulé derrière des interfaces et des brevets. Dans l'exposition, les conteurs algorithmiques quittent leur monde souterrain invisible pour devenir nos interlocuteurs. |
|||
</p><p><b>* Données d’entraînement:</b> Les algorithmes d'apprentissage automatique ont besoin d'être guidés. Pour séparer une chose d'une autre, faire des distinctions, ils ont besoin de motifs. Ils les trouvent dans les textes qui leur sont donnés, les données d’entraînement. L'être humain doit choisir avec soin un matériel d’entraînement adapté à la tâche de la machine. Il n'est pas logique d’entraîner une machine avec des romans du 19ème siècle si sa mission est d'analyser des Tweets. |
|||
</p><p><b>* Dump:</b> Terme anglais signifiant ‘dépôt, décharge, déverser massivement’. En informatique, le terme dump désigne généralement une copie brute d’une base de données; par exemple pour effectuer une sauvegarde de données ou pour les utiliser ailleurs. Les dumps sont souvent publiées par des projets de logiciels libres et de contenu libre, tels que Wikipédia, pour permettre la réutilisation ou la dérivation(fork) de la base de données. |
|||
</p><p><b>* Feature engineering:</b> Processus utilisant la connaissance du domaine des données pour créer les caractéristiques qui font fonctionner les algorithmes d'apprentissage machine. En d'autres termes, un être humain doit consacrer du temps à une analyse exploratoire approfondie du jeu de données, afin d'en définir les principales caractéristiques. Ces caractéristiques peuvent être la fréquence des mots ou des lettres, mais aussi des éléments syntaxiques comme les noms, les adjectifs ou les verbes. Les caractéristiques les plus importantes pour la tâche à résoudre doivent être soigneusement sélectionnées pour être transmises à un algorithme classique d'apprentissage automatique. |
|||
</p><p><b>* FLOSS ou Logiciels Libres et Open Source:</b> Un logiciel libre est un logiciel dont l'utilisation, l'étude, la modification et la duplication par autrui en vue de sa diffusion sont permises, techniquement et légalement, ceci afin de garantir certaines libertés induites, dont le contrôle du programme par l'utilisateur et la possibilité de partage entre individus. Ces droits peuvent être simplement disponibles – cas du domaine public – ou bien établis par une licence, dite 'libre', basée sur le droit d'auteur. Les 'licences copyleft' garantissent le maintien de ces droits aux utilisateurs même pour les travaux dérivés. Les logiciels libres constituent une alternative à ceux qui ne le sont pas, qualifiés de 'propriétaires' ou de 'privateurs'. (Wikipedia) |
|||
</p><p><b>* git:</b> un système logiciel permettant de suivre les changements dans le code source pendant le développement d'un logiciel. Il est conçu pour coordonner le travail des programmeurs, mais il peut être utilisé pour suivre les changements dans n'importe quel ensemble de fichiers. Avant d’initier un nouveau projet, les programmeurs créent un ‘dépôt git’ dans lequel ils publieront toutes les parties du code. Les dépôts git d’Algolit se trouvent ici: <a class="external free" href="https://gitlab.constantvzw.org/algolit" rel="nofollow">https://gitlab.constantvzw.org/algolit</a>. |
|||
</p><p><b>* gutenberg.org:</b> Le projet Gutenberg est une bibliothèque de versions électroniques libres de livres physiquement existants. Les textes fournis sont essentiellement du domaine public, soit parce qu'ils n'ont jamais été sujets à des droits d'auteur soit parce que ces derniers sont expirés. Le projet fut lancé par Michael Hart en 1971 et nommé en hommage à l'imprimeur allemand du XVe siècle Johannes Gutenberg. (Wikipedia) |
|||
</p><p><b>* Henri La Fontaine:</b> Henri La Fontaine (1854-1943) est un homme politique, féministe et pacifiste belge. Il reçoit le Prix Nobel de la paix en 1913 en raison de son engagement au sein du Bureau International de la Paix et de sa contribution à l'organisation du mouvement pacifiste. En 1895, ensemble avec Paul Otlet, il créent ensemble l'Institut international de bibliographie qui deviendra le Mundaneum. Au sein de cette institution, qui visait à rassembler l'ensemble des connaissances du monde, il contribue à mettre au point le système de Classification décimale universelle (CDU). |
|||
</p><p><b>* IA ou intelligences artificielles:</b> L'intelligence artificielle (IA) est 'l'ensemble des théories et des techniques mises en œuvre en vue de réaliser des machines capables de simuler l'intelligence. Elle correspond donc à un ensemble de concepts et de technologies plus qu'à une discipline autonome constituée. D'autres, remarquant la définition peu précise de l'IA, notamment la CNIL, la définissent comme ‘le grand mythe de notre temps'. (Wikipedia) |
|||
</p><p><b>* Kaggle:</b> Plateforme en ligne où les utilisateurs trouvent et publient des ensembles de données, explorent et construisent des modèles d'apprentissage automatique, collaborent avec d'autres et participent à des concours pour relever des défis. Environ un demi-million d’utilisateurs sont actifs sur Kaggle. Kaggle a été fondée par Goldbloom et Ben Hamner en 2010 et acquise par Google en mars 2017. |
|||
</p><p><b>* Langage naturel:</b> Selon Wikipédia, 'Une langue dite « naturelle » est une langue qui s'est formée petit à petit, évoluant avec le temps, et qui fait partie du langage naturel. Son origine est bien souvent floue et peut être retracée plus ou moins clairement par la linguistique comparée. On oppose les langues naturelles - comme le français - aux langues construites comme le langage de programmation ou l'espéranto, formées intentionnellement par l’entremise de l’homme pour remplir un besoin précis.' |
|||
</p><p><b>* Littérature:</b> Algolit comprend la notion de littérature comme beaucoup d'autres auteurs expérimentaux : elle inclut toute la production linguistique, du dictionnaire à la Bible, de l'œuvre entière de Virginia Woolf à toutes les versions des Conditions d'utilisation publiées par Google depuis son existence. En ce sens, le code de programmation peut aussi être de la littérature. |
|||
</p><p><b>* Mechanical Turk:</b> Le Mechanical Turk d’Amazon est une plateforme en ligne à destination des humains conçue pour exécuter des tâches que les algorithmes ne parviennent pas à faire. Il peut s'agir, par exemple, d'annoter des phrases comme étant positives ou négatives, de repérer des plaques d'immatriculation, de reconnaître des visages. Les annonces que l'on trouve sur cette plateforme sont souvent rémunérés moins d'un centime par tâche. Les tâches les plus complexes ou nécessitant le plus de connaissances peuvent être payées jusqu'à plusieurs centimes. De nombreux chercheurs universitaires utilisent le Mechanical Turk pour des tâches qui auraient été exécutées par des étudiants auparavant. |
|||
</p><p><b>* Modèles d’apprentissage automatique supervisé:</b> Pour la création de modèles d'apprentissage automatique supervisés, les humains annotent les échantillons d'entraînement avant de les envoyer à la machine. Chaque texte est jugé par au moins 3 humains: par exemple, s’il s’agit de spam ou non, s’il est positif ou négatif. |
|||
</p><p><b>* Modèles d’apprentissage automatique non-supervisé:</b> Les modèles d'apprentissage automatique non supervisés n'ont pas besoin de l’étape d’annotations des données par des humains. Par contre, ils nécessitent de grandes quantités de données pour s’entraîner. |
|||
</p><p><b>* Mundaneum:</b> À la fin du 19ème siècle, deux jeunes juristes belges, Paul Otlet (1868-1944), 'père de la documentation', et Henri La Fontaine (1854-1943), homme d'État et prix Nobel de la paix, créent le Mundaneum. Le projet vise à rassembler toute la connaissance du monde et à la classer à l'aide du système de Classification décimale universelle (UDC) qu'ils inventent. |
|||
</p><p><b>* Natural Language Processing (NLP):</b> Le traitement du langage naturel (NLP) est un terme collectif qui désigne le traitement informatique automatique des langues humaines. Cela comprend les algorithmes utilisant, comme données, du texte produit par l'homme et qui tentent de le reproduire. |
|||
</p><p><b>* N-grammes de caractères:</b> une technique utilisée pour la reconnaissance de la paternité d’une oeuvre. Lors de l'utilisation des N-grammes de caractères, les textes sont considérés comme des séquences de caractères. Considérons le trigramme des caractères. Toutes les séquences de trois caractères qui se chevauchent sont isolées. Par exemple, le trigramme de caractères de suicide', serait, 'Sui,' uic', uic', 'ici', 'cid', etc. Les motifs trouvés avec les N-grammes de caractères se concentrent sur les choix stylistiques qui sont faits inconsciemment par l'auteur. Ces modèles restent stables sur toute la longueur du texte. |
|||
</p><p><b>* Oracle:</b> Les Oracles sont un type particulier de modèles algorithmiques souvent basés sur la statistique, qui servent à prédire des situations particulières ou à profiler des habitudes d’usagers. Elles sont largement utilisés dans les smartphones, les ordinateurs et les tablettes. |
|||
</p><p><b>* Oulipo:</b> Le collectif Oulipo, acronyme d'Ouvroir de Littérature Potentielle, est une grande source d'inspiration pour Algolit. Oulipo a été créé à Paris par les écrivains Raymond Queneau et François Le Lionnais. Ils ont ancré leur pratique dans l'avant-garde européenne du XXe siècle et dans la tradition expérimentale des années 60. Pour Oulipo, la création de règles devient la condition permettant de générer de nouveaux textes, ou ce qu'ils appellent la littérature potentielle. Plus tard, en 1981, ils ont également créé ALAMO - Atelier de Littérature Assistée par la Mathématique et les Ordinateurs. |
|||
</p><p><b>* Paul Otlet:</b> Paul Otlet (1868 - 1944) était un auteur, entrepreneur, visionnaire, avocat et militant pour la paix belge ; il est l'une des nombreuses personnes qui ont été considérées comme le père des sciences de l'information, un domaine qu'il a appelé ‘la documentation’. Otlet a créé la Classification décimale universelle, qui s'est répandue dans les bibliothèques. Avec Henri La Fontaine, il crée le Palais Mondial, qui devient le Mundaneum, pour abriter les collections et les activités de leurs différents organismes et instituts. |
|||
</p><p><b>* Python:</b> le principal langage de programmation utilisé dans le monde entier pour le traitement du langage, inventé en 1991 par le programmeur néerlandais Guido Van Rossum. |
|||
</p><p><b>* Reconnaissance optique de caractères (ROC)</b>: en anglais optical character recognition (OCR), ou océrisation, désigne les procédés informatiques permettant la traduction d'images de textes scannés en fichiers de texte manipulables. |
|||
</p><p><b>* Réseaux de neurones:</b> Systèmes informatiques inspirés des réseaux neuronaux biologiques trouvés dans le cerveau des animaux. Un réseau de neurone n'est pas un algorithme, mais plutôt un cadre dans lequel de nombreux algorithmes d'apprentissage machine différents travaillent ensemble et traitent des données complexes. De tels systèmes ‘apprennent’ à exécuter des tâches en observant des exemples, généralement sans être programmés à priori avec des règles spécifiques. Par exemple, un algorithme de reconnaissance de chat apprendra à identifier les images qui contiennent des chats en observant des images qui ont été étiquetées manuellement comme ‘chat’ ou ‘pas chat’. Il utilisera ces exemple pour générer ce qu'il considère être un chat et pourra identifier les chats dans d'autres images. Il le fera sans aucune connaissance préalable sur les chats. Il générera automatiquement ses propres caractéristiques d'identification à partir du matériel d'apprentissage qui lui est donné. |
|||
</p><p><b>* Rule-Based models:</b> Les Oracles peuvent être créés à l'aide de différentes techniques. L’une d’entre elles consiste à définir manuellement les règles. Ces modèles sont appelés 'rule-based models' (modèles basés sur des règles), et se situent à l’opposé des modèles statistiques. Ils sont utiles pour des tâches spécifiques, comme par exemple, la détection de la mention d'une certaine molécule dans un article scientifique. Ils sont performants, même avec très peu de données d'entraînement. |
|||
</p><p><b>* Sentiment analysis:</b> Également appelé 'opinion mining' (sondage d'opinion). Une tâche fondamentale de l'analyse des sentiments consiste à classer un texte donné comme positif, négatif ou neutre. La classification avancée des sentiments 'au-delà de la polarité' examine, par exemple, les états émotionnels tels que 'en colère', 'triste' et 'heureux'. L'analyse du sentiment est largement appliquée aux actions des utilisateurs tels que les critiques et les réponses aux enquêtes, les commentaires et les messages sur les médias sociaux, et les documents de santé. Elle est intégrée dans des applications qui vont du marketing au service à la clientèle, des transactions boursières à la médecine clinique. |
|||
</p><p><b>* TF-IDF (Term Frequency-Inverse Document Frequency):</b> Une méthode de pondération utilisée dans la recherche de textes. Cette mesure statistique permet d'évaluer l'importance d'un terme contenu dans un document, relativement à une collection ou un corpus de textes. Le poids augmente proportionnellement au nombre d'occurrences du mot dans le document. Il varie également en fonction de la fréquence du mot dans le corpus. Le TF-IDF est notamment utilisé dans la classification des spams. |
|||
</p><p><b>* 'Word embeddings':</b> Techniques de modélisation du langage qui, par de multiples opérations mathématiques, tracent des mots dans un espace vectoriel multidimensionnel. Lorsque les mots sont 'embedded' ou intégrés, ils se transforment de symboles distincts en objets mathématiques, qui peuvent être multipliés, divisés, ajoutés ou soustraits. |
|||
</p><p><b>* Wordnet:</b> Wordnet est une combinaison d'un dictionnaire et d'un thésaurus qui peut être lu par des machines. Selon Wikipédia, il a été créé dans le Cognitive Science Laboratory de l'Université de Princeton à partir de 1985. |
|||
</p> |
|||
<!-- |
|||
NewPP limit report |
|||
Cached time: 20190323152119 |
|||
Cache expiry: 86400 |
|||
Dynamic content: false |
|||
CPU time usage: 0.060 seconds |
|||
Real time usage: 0.060 seconds |
|||
Preprocessor visited node count: 63/1000000 |
|||
Preprocessor generated node count: 68/1000000 |
|||
Post‐expand include size: 0/2097152 bytes |
|||
Template argument size: 0/2097152 bytes |
|||
Highest expansion depth: 2/40 |
|||
Expensive parser function count: 0/100 |
|||
--> |
|||
<!-- |
|||
Transclusion expansion time report (%,ms,calls,template) |
|||
100.00% 0.000 1 - -total |
|||
--> |
|||
<!-- Saved in parser cache with key algolit-mw_:pcache:idhash:2864-1!*!0!!*!*!* and timestamp 20190323152119 and revision id 11613 |
|||
--> |
|||
</section></body> |
|||
</html> |
|||
Binary file not shown.
File diff suppressed because it is too large
Binary file not shown.
@ -0,0 +1,398 @@ |
|||
#! /etc/bin/python3 |
|||
|
|||
import random, re, subprocess |
|||
|
|||
from hyphen import Hyphenator |
|||
import textwrap |
|||
from textwrap2 import fill |
|||
|
|||
import nltk |
|||
from nltk.tokenize import RegexpTokenizer |
|||
tokenizer = RegexpTokenizer(r'[\s\W\w]\w+[\s\W\w\.]|^\w+|\w+$') # initialize tokenizer |
|||
|
|||
# language = 'fr' |
|||
language = 'en' |
|||
|
|||
def selfwritten_linebreaks(string, linelength): |
|||
count = 1 |
|||
tmp = '' |
|||
new = '' |
|||
if not 'http' in string: |
|||
string = tokenizer.tokenize(string) |
|||
for line_number, word in enumerate(string): |
|||
count += len(word) |
|||
if tmp == '': |
|||
if word[0] == ' ': |
|||
word = word[1:] |
|||
if word == ' ': |
|||
continue |
|||
if line_number == len(string) - 1: |
|||
tmp += word |
|||
new += tmp |
|||
elif count < linelength: |
|||
tmp += word |
|||
else: |
|||
tmp += word |
|||
new += tmp + '\n' |
|||
tmp = '' |
|||
count = 1 |
|||
return new |
|||
|
|||
def insert_linebreaks(string, linelength, type='character', double_linebreaks=False): |
|||
count = 1 |
|||
tmp = '' |
|||
new = '' |
|||
if type == 'word': |
|||
if language == 'en': |
|||
hyphenator = Hyphenator('en_US') |
|||
if language == 'fr': |
|||
hyphenator = Hyphenator('fr_FR') |
|||
paragraphs = string.split('\n') |
|||
for i, paragraph in enumerate(paragraphs): |
|||
try: |
|||
tmp = fill(paragraph, width=linelength, use_hyphenator=hyphenator) |
|||
except Exception as e: |
|||
tmp = '' |
|||
print('Error:', e) |
|||
print('>>> Hyphenator didn\'t work, selfwritten_linebreaks used instead.') |
|||
tmp = selfwritten_linebreaks(paragraph, linelength-3) # Calibration |
|||
|
|||
if i + 1 == len(paragraphs): # No double linebreaks when the paragraph is the last one on the page |
|||
new += tmp |
|||
elif double_linebreaks == True: |
|||
new += tmp + '\n\n' |
|||
else: |
|||
new += tmp + '\n' |
|||
return new |
|||
if type == 'wrap': |
|||
paragraphs = string.split('\n') |
|||
new = '' |
|||
for i, paragraph in enumerate(paragraphs): |
|||
tmp = textwrap.wrap(paragraph, width=linelength) |
|||
tmp = '\n'.join(tmp) |
|||
|
|||
if i + 1 == len(paragraphs): # No double linebreaks when the paragraph is the last one on the page |
|||
new += tmp |
|||
elif double_linebreaks == True: |
|||
new += tmp + '\n\n' |
|||
else: |
|||
new += tmp + '\n' |
|||
return new |
|||
if type == 'character': |
|||
for character in string: |
|||
if count == len(string): |
|||
tmp += character |
|||
new += tmp |
|||
elif count < linelength: |
|||
tmp += character |
|||
count += 1 |
|||
else: |
|||
new += tmp + '\n' |
|||
tmp = '' |
|||
count = 1 |
|||
return new |
|||
|
|||
def fill_page(string): |
|||
print('--- fill_page() starts ---') |
|||
lines = string.split('\n') |
|||
total_lines = len(lines) |
|||
print(' total_lines :', total_lines) |
|||
total_pages = int(total_lines / 70) |
|||
print(' total_pages :', total_pages) |
|||
full_pages_lines = 70 * total_pages |
|||
print(' full_pages :', full_pages_lines) |
|||
if (total_lines - full_pages_lines) == 0: |
|||
print(' fill_up_lines :', 0) |
|||
page = '\n'.join(lines[:total_lines]) |
|||
else: |
|||
fill_up_lines = 70 - (total_lines - full_pages_lines) |
|||
print(' fill_up_lines :', fill_up_lines) |
|||
page = string + ('\n' * (fill_up_lines)) |
|||
page_lines = page.split('\n') |
|||
|
|||
# Safety check, to see if the string can be divided by 70 lines |
|||
if len(page_lines) % 70 != 0: |
|||
print('>>> Careful! The modulo is cutting lines from the pages...', total_lines - full_pages_lines) |
|||
page = '\n'.join(page_lines[:full_pages_lines]) |
|||
|
|||
print(' page(s) length:', len(page.split('\n'))) |
|||
print('--- fill_page() ends ---') |
|||
return page + '\n' |
|||
|
|||
def insert_text_block(string, inserted, left, width): |
|||
left_column_lines = string.split('\n') |
|||
right_column_lines = inserted.split('\n') |
|||
tmp = False |
|||
if len(right_column_lines) > len(left_column_lines): |
|||
leading_iterator = right_column_lines |
|||
follower = left_column_lines |
|||
# print('> right = leader') |
|||
else: |
|||
leading_iterator = left_column_lines |
|||
follower = right_column_lines |
|||
# print('> left = leader') |
|||
new = '' |
|||
for line_number, _ in enumerate(leading_iterator): |
|||
# print('Inserting_text_block() ... line_number:', line_number) |
|||
# Check if there are still left_column_lines to add |
|||
# And count the number of characters of that line |
|||
if line_number < len(left_column_lines): |
|||
left_column_length = len(left_column_lines[line_number]) |
|||
# If there is no line anymore, follow the length of the "left" variable |
|||
else: |
|||
left_column_length = left |
|||
|
|||
# Fill left_column_line up to the "left" variable |
|||
if left_column_length < left: |
|||
fill_up_spaces = left - len(left_column_lines[line_number]) |
|||
left_column_line = left_column_lines[line_number] + (' ' * (fill_up_spaces)) |
|||
else: |
|||
left_column_line = ' ' * left |
|||
|
|||
# Append the left_ and right_column_line to the same line |
|||
if line_number + 1 <= len(right_column_lines): |
|||
new += left_column_line + right_column_lines[line_number] + '\n' |
|||
# Unless there is no right_column_line anymore |
|||
else: |
|||
new += left_column_lines[line_number] + '\n' |
|||
|
|||
if new.endswith('\n'): |
|||
new = new[:-1] |
|||
return new |
|||
|
|||
def insert_symbol_background(string, linelength, symbols, multiplier): |
|||
new = '' |
|||
lines = string.split('\n') |
|||
|
|||
for line_number, line in enumerate(lines): |
|||
x = line_number + 1 |
|||
|
|||
# Apply the multiplier, to create a gradient effect :) |
|||
symbols += ' ' * int(x * multiplier) |
|||
|
|||
for c, character in enumerate(line): |
|||
try: |
|||
# if this is the last character in the line, just add it |
|||
if c + 1 == len(line): |
|||
character = character |
|||
# if previous and next character is a space, add a symbol |
|||
elif line[c-1] == ' ' and line[c+1] == ' ': |
|||
character = character.replace(' ', random.choice(symbols)) |
|||
except: |
|||
character = character.replace(' ', random.choice(symbols)) |
|||
new += character |
|||
|
|||
# Fill the line on the right of the text |
|||
if c + 1 == len(line): |
|||
new += ' ' |
|||
for _ in range(c + 1, linelength): |
|||
new += random.choice(symbols) |
|||
|
|||
new += '\n' |
|||
|
|||
return new |
|||
|
|||
def char_swap(some_string): |
|||
swaps = [('–','-'), ('“','"'),('”','"'),('ù','u'), ("’","'"), ('à','a'), ('â','a'),('é','e'),('è','e'),('î','i')] |
|||
for swap in swaps: |
|||
some_string = some_string.replace(swap[0], swap[1]) |
|||
return some_string |
|||
|
|||
def convert_to_figlet_font(string, linelength, font='shadow', alignment='left'): |
|||
string = char_swap(string) # remove French characters in figlet titles (not all fonts include them...) |
|||
string = string.replace('(edition vinyle)', '') # For Javier's titles |
|||
text = insert_linebreaks(string, linelength, type='wrap', double_linebreaks=False) |
|||
# print('figlet text:', text) |
|||
string = '' |
|||
aligments = { |
|||
'left': '-l', |
|||
'right' : '-r', |
|||
'center' : '-c' |
|||
} |
|||
for line in text.split('\n'): |
|||
figlet_string = subprocess.check_output(['figlet', line, '-w', str(linelength * 6), '-n', '-f', font, '-p', aligments[alignment]]).decode() + '\n' |
|||
|
|||
# Do not include empty linebreaks in the figlet header |
|||
for figlet_line in figlet_string.split('\n'): |
|||
non_empty_line = re.search(r'[^\s]', figlet_line) |
|||
if non_empty_line: |
|||
string += figlet_line + '\n' |
|||
|
|||
return string |
|||
|
|||
def align(string, linewidth, aligment='center'): |
|||
len_string = len(string) |
|||
margin = int((linewidth - len_string) / 2) |
|||
return (' ' * margin) + string + (' ' * margin) |
|||
|
|||
def check_element(element): |
|||
if element.name == 'hr': |
|||
string = ('-' * 3) + '\n' |
|||
elif element.name == None: |
|||
string = '' |
|||
elif element.name == 'b': |
|||
string = '<' + element.text + '>' |
|||
else: |
|||
string = element.text |
|||
return string |
|||
|
|||
def add_headers(section_type, element): |
|||
string = '' |
|||
# print(' ----> element:', element) |
|||
|
|||
if 'stories' in section_type or 'récits' in section_type: |
|||
if 'h2' in element.name: |
|||
string += '\n' |
|||
string += '--- ' + element.text + ' ---\n' |
|||
# string += '^' * len(element.text) |
|||
string += '\n' |
|||
elif 'h3' in element.name: |
|||
header = element.text.upper().replace('STORIES ABOUT', 'STORIES\nABOUT').replace('RÉCITS CONTEXTUALISÉS AUTOUR', ' RÉCITS CONTEXTUALISÉS\nAUTOUR').split('\n') |
|||
for line in header: |
|||
string += align(line, 56) + '\n' |
|||
string += '\n\n' |
|||
elif element.get('class'): |
|||
if 'toc' in element['class']: |
|||
pass |
|||
else: |
|||
string += check_element(element) + '\n' |
|||
|
|||
elif 'works' in section_type: |
|||
if language == 'en': |
|||
linewidth = 11 |
|||
else: |
|||
linewidth = 10 |
|||
|
|||
if element.get('class'): |
|||
if 'lemmaheader' in element['class']: |
|||
tmp_string = '\n' |
|||
tmp_string += ' ' * 55 + '\n' |
|||
tmp_string += ' ' * 55 + '\n' |
|||
tmp_string += convert_to_figlet_font(element.text, linewidth, font='ogre', alignment='center') |
|||
tmp_string += ' ' * 55 + '\n' |
|||
string = insert_symbol_background(tmp_string, 55, ['0', ' ', ' ', ' ',' ', ' ', ' ',' ', ' ', ' ',' ',' ', ' ', ' ', ' ', ' '], 0) |
|||
else: |
|||
string += check_element(element) + '\n' |
|||
else: |
|||
string += check_element(element) + '\n' |
|||
|
|||
elif 'glossary' in section_type: |
|||
if 'h2' in element.name: |
|||
string += '''\ |
|||
░ |
|||
░ |
|||
░ ░ ░ ░ |
|||
░ ░ ░ ░ |
|||
░ ░ |
|||
░ ░ |
|||
░ {} ░ |
|||
░ |
|||
░ ░ ░ |
|||
░ ░ ░ ░ |
|||
░ |
|||
░ |
|||
░ |
|||
'''.format(element.text.upper()) |
|||
string += '\n' |
|||
else: |
|||
string += check_element(element) + '\n' |
|||
else: |
|||
string += check_element(element) + '\n' |
|||
|
|||
return string |
|||
|
|||
|
|||
def apply_zigzag(string, pattern_width): |
|||
count = 0 |
|||
string_lines = [line for line in string.split('\n')] |
|||
new = '' |
|||
fwd = True |
|||
for line in string_lines: |
|||
if fwd == True: |
|||
if count <= pattern_width: |
|||
new += (' ' * count) + line + '\n' |
|||
count += 1 |
|||
else: |
|||
fwd = False |
|||
new += (' ' * count) + line + '\n' |
|||
count -= 1 |
|||
else: |
|||
if count >= 0: |
|||
new += (' ' * count) + line + '\n' |
|||
count -= 1 |
|||
else: |
|||
fwd = True |
|||
new += (' ' * count) + line + '\n' |
|||
count += 1 |
|||
return new |
|||
|
|||
# def text_to_pattern(string, template): |
|||
# template = template.split('\n') |
|||
# character_position = 0 |
|||
# new = '' |
|||
# for line_number, line in enumerate(template): |
|||
# for character in line: |
|||
# if character == '░': |
|||
# new += string[character_position] |
|||
# character_position += 1 |
|||
# else: |
|||
# new += ' ' |
|||
# new += '\n' |
|||
# return new |
|||
|
|||
def counting_pattern(string, linelength): |
|||
count = 1 |
|||
pattern = '' |
|||
tmp = '' |
|||
string = tokenizer.tokenize(string) |
|||
for line_number, word in enumerate(string): |
|||
pattern += tmp + '\n' |
|||
count += len(word) |
|||
if '\n' in word: |
|||
word = word.replace('\n','\n\n') |
|||
if line_number == len(string): |
|||
tmp += word |
|||
elif count < linelength: |
|||
tmp += word |
|||
else: |
|||
tmp += word |
|||
# pattern += tmp + '\n' |
|||
tmp = '' |
|||
count = 1 |
|||
return pattern |
|||
|
|||
def insert_counters_page(): |
|||
page = '' |
|||
num = 0 |
|||
count = 2 |
|||
for line in range(1,70): |
|||
for i in range(1,110): |
|||
if num == 0: |
|||
page += ' ' |
|||
count += 1 |
|||
num += 1 |
|||
elif num < 10: |
|||
page += str(num) |
|||
num += 1 |
|||
else: |
|||
num = 0 |
|||
if count == 10: |
|||
count = 0 |
|||
page += ' ' |
|||
num += 1 |
|||
count += 1 |
|||
page += '\n' |
|||
return fill_page(page) |
|||
|
|||
def insert_pagenumbers(pages): |
|||
new = '' |
|||
page = 0 |
|||
lines = pages.split('\n') |
|||
for i, line in enumerate(lines): |
|||
line_number = i + 1 |
|||
if line_number % 70 == 0: |
|||
page += 1 |
|||
if page != 1 and line_number != len(lines) and page < 56: |
|||
line = (' ' * page * 2) + str(page) |
|||
new += line + '\n' |
|||
return new |
|||
@ -0,0 +1,158 @@ |
|||
#! /usr/bin/env python2 |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
from bs4 import BeautifulSoup as bs |
|||
from bs4 import NavigableString, Tag |
|||
from urllib.request import urlopen |
|||
from urllib.parse import urlparse, urljoin |
|||
import codecs |
|||
import copy |
|||
import re |
|||
|
|||
|
|||
template = """<!DOCTYPE html> |
|||
<html> |
|||
<head> |
|||
<meta charset="utf-8"> |
|||
<title>Data Workers</title> |
|||
<!-- <link rel="stylesheet" href="stylesheet.css"> --> |
|||
</head> |
|||
<body> |
|||
</body> |
|||
</html>""" |
|||
|
|||
def makeBranch(level, tags, soup): |
|||
branch = soup.new_tag('ul') |
|||
leaf = None |
|||
while len(tags) > 0: |
|||
t = tags[0] |
|||
if t['level'] > level and leaf: |
|||
leaf.append(makeBranch(t['level'], tags, soup)) |
|||
elif t['level'] < level: |
|||
if (leaf): |
|||
branch.append(leaf) |
|||
leaf = None |
|||
return branch |
|||
else: |
|||
if (leaf): |
|||
branch.append(leaf) |
|||
leaf = None |
|||
|
|||
leaf = soup.new_tag('li') |
|||
leaf.append(tagContent(tags[0]['tag'])) |
|||
tags.pop(0) |
|||
if (leaf): |
|||
branch.append(leaf) |
|||
leaf = None |
|||
return branch |
|||
|
|||
def makeIndex(soup): |
|||
eligible_tags = ['h1', 'h2', 'h3', 'h4', 'h5', 'li'] |
|||
buffer = soup.new_tag('ul') |
|||
tags = [{'tag': copy.copy(tag), 'level': eligible_tags.index( |
|||
tag.name)} for tag in soup.find_all(eligible_tags)] |
|||
return makeBranch(tags[0]['level'], tags, soup) |
|||
|
|||
def tagContent(tag): |
|||
if tag.string: |
|||
return tag.string |
|||
else: |
|||
return ''.join(tag.strings) |
|||
|
|||
def classSafeContent(string): |
|||
return re.sub(r'[^\w\-]+', '', re.sub(r'\s+', '-', string.lower())) |
|||
|
|||
def makeLemma(title, lemma_type, url, bigSoup): |
|||
print(url) |
|||
try: |
|||
lemma = '' |
|||
lemmaSoup = bs(urlopen('{}?action=render'.format(url)), 'html.parser') |
|||
lemma = bigSoup.new_tag("section") |
|||
lemma['class'] = 'lemma {} {}'.format(classSafeContent(title), classSafeContent(lemma_type)) |
|||
|
|||
header = bigSoup.new_tag('h3') |
|||
header['class'] = 'lemmaheader' |
|||
header.append(title) |
|||
|
|||
lemma.append(header) |
|||
|
|||
for t in lemmaSoup.contents: |
|||
if isinstance(t, Tag): |
|||
lemma.append(copy.copy(t)) |
|||
|
|||
for img in lemma.find_all('img'): |
|||
img.attrs['src'] = urljoin(baseurl, img.attrs['src']) |
|||
except: |
|||
print('└──> This page does not exist (yet).') |
|||
return lemma |
|||
|
|||
|
|||
def pageBreaker(soup): |
|||
breaker = soup.new_tag('section') |
|||
breaker.attrs['class'] = 'page-breaker' |
|||
breaker.string = ' ' |
|||
return breaker |
|||
|
|||
def get_html_from_wiki(lang, url, baseurl): |
|||
print('---\n', lang, url, '\n---') |
|||
soup = bs(template, 'html.parser') |
|||
pageSoup = bs(urlopen(url), 'html.parser') |
|||
container = soup.new_tag('section') |
|||
container['class'] = 'language {}'.format(lang) |
|||
|
|||
# Add a cover |
|||
# cover = soup.new_tag('section') |
|||
# cover.attrs['class'] = 'cover' |
|||
# cover_img = soup.new_tag('img') |
|||
# cover_img.attrs['src'] = 'img/dw.bw.no-info-text.png' |
|||
# cover.append(cover_img) |
|||
# soup.append(cover) |
|||
|
|||
# Add an index |
|||
# index = soup.new_tag('section') |
|||
# index.attrs['class'] = 'index' |
|||
# title = soup.new_tag('div') |
|||
# title.attrs['class'] = 'title' |
|||
# index.append('Data Workers') |
|||
# index.append(makeIndex(pageSoup)) |
|||
# soup.append(index) |
|||
|
|||
for child in pageSoup.contents: |
|||
# print(child.name) |
|||
if child.name == 'ul': |
|||
chapter = soup.new_tag('section') |
|||
chapter['class'] = 'group' |
|||
|
|||
for li in child.find_all('li'): |
|||
links = li.find_all('a') |
|||
if links: |
|||
url = urljoin(baseurl, links[-1].attrs['href']) |
|||
if re.match('.*algolit.net$', urlparse(url).netloc) or re.match('.*algolit.constantvzw.org$', urlparse(url).netloc): |
|||
title = tagContent(links[-1]) |
|||
if 'stories' in title.lower(): |
|||
lemma_type = 'stories' |
|||
else: |
|||
lemma_type = 'works' |
|||
chapter.append(makeLemma(title, lemma_type, url, soup)) |
|||
|
|||
container.append(chapter) |
|||
|
|||
else: |
|||
container.append(copy.copy(child)) |
|||
|
|||
for header in container.find_all(['h1', 'h2', 'h3', 'h4', 'h5', 'h6']): |
|||
header.attrs['id'] = classSafeContent(tagContent(header)) |
|||
header.replace_with(header) |
|||
|
|||
soup.body.append(container) |
|||
|
|||
with codecs.open('data-workers.{}.html'.format(lang), 'w+') as out: |
|||
out.write(str(soup)) |
|||
out.close() |
|||
|
|||
# baseurl = 'http://www.algolit.net' |
|||
# language = 'en' |
|||
# url = 'http://www.algolit.net/index.php/Data_Workers?action=render' |
|||
# language = 'fr' |
|||
# url = 'http://www.algolit.net/index.php/Data_Workers_FR?action=render' |
|||
# get_html_from_wiki(language, url, baseurl) |
|||
Binary file not shown.
|
After Width: | Height: | Size: 519 KiB |
@ -0,0 +1,10 @@ |
|||
MIT License |
|||
|
|||
Copyright (c) 2014 Thomas Baruchel |
|||
Copyright (c) 2017 Fredrik de Vibe |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|||
@ -0,0 +1,59 @@ |
|||
txt2pdf |
|||
======= |
|||
|
|||
Text to PDF converter with Unicode support. |
|||
|
|||
This is a Python 2 / 3 script using the ReportLab module for generating PDF |
|||
documents. It is intended to be used with monospace True Type fonts. |
|||
It can be hacked for being used with Type 1 Postscript fonts, but such |
|||
fonts contain less characters than TTF ones. |
|||
|
|||
Usage |
|||
----- |
|||
|
|||
Type the following command for getting some help: |
|||
|
|||
txt2pdf -h |
|||
|
|||
The easiest way to use the tool for creating an _output.pdf_ document is: |
|||
|
|||
txt2pdf document.txt |
|||
|
|||
You can change the name of the resulting PDF file: |
|||
|
|||
txt2pdf -o document.pdf document.txt |
|||
|
|||
You can specify your own TTF font: |
|||
|
|||
txt2pdf -f /usr/share/fonts/ubuntu/UbuntuMono-R.ttf -o document.pdf document.txt |
|||
|
|||
Other options allow to set the margins, and to adjust typographical settings (horizontal space between consecutive characters or vertical space between lines). You may also include the name of the author of the document or its title in the properties of the PDF document. |
|||
|
|||
Fonts |
|||
----- |
|||
|
|||
The following fonts have been tested with success: |
|||
|
|||
* Courier (by default) |
|||
* LiberationMono |
|||
* DejaVuSansMono |
|||
* UbuntuMono |
|||
* FreeMono |
|||
* DroidSansMono |
|||
* FiraMono |
|||
* InputMono (different versions) |
|||
* Envy Code |
|||
* Anonymous Pro |
|||
* APL385 |
|||
* APLX Unicode |
|||
* SImPL |
|||
* Pragmata Pro |
|||
* Hack |
|||
|
|||
The Type 1 font "Courier10PitchBT-Roman" can be used by hacking the code. |
|||
|
|||
No Open Type font work, which includes: |
|||
|
|||
* Source Code Pro |
|||
* Inconsolata |
|||
* UMTypewriter |
|||
@ -0,0 +1,339 @@ |
|||
#! /usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
|
|||
import argparse |
|||
import reportlab.lib.pagesizes |
|||
from reportlab.pdfgen.canvas import Canvas |
|||
from reportlab.lib import units |
|||
from reportlab.pdfbase import pdfmetrics |
|||
from reportlab.pdfbase.ttfonts import TTFont |
|||
import re |
|||
import sys |
|||
import os |
|||
|
|||
|
|||
class Margins(object): |
|||
def __init__(self, right, left, top, bottom): |
|||
self._right = right |
|||
self._left = left |
|||
self._top = top |
|||
self._bottom = bottom |
|||
|
|||
@property |
|||
def right(self): |
|||
return self._right * units.cm |
|||
|
|||
@property |
|||
def left(self): |
|||
return self._left * units.cm |
|||
|
|||
@property |
|||
def top(self): |
|||
return self._top * units.cm |
|||
|
|||
@property |
|||
def bottom(self): |
|||
return self._bottom * units.cm |
|||
|
|||
def adjustLeft(self, width): |
|||
self._left -= width / units.cm |
|||
|
|||
|
|||
class PDFCreator(object): |
|||
appName = "txt2pdf (version 1.0)" |
|||
|
|||
def __init__(self, args, margins): |
|||
pageWidth, pageHeight = reportlab.lib.pagesizes.__dict__[args.media] |
|||
if args.landscape: |
|||
pageWidth, pageHeight = reportlab.lib.pagesizes.landscape( |
|||
(pageWidth, pageHeight)) |
|||
self.author = args.author |
|||
self.title = args.title |
|||
self.keywords = args.keywords |
|||
self.subject = args.subject |
|||
self.canvas = Canvas(args.output, pagesize=(pageWidth, pageHeight)) |
|||
self.canvas.setCreator(self.appName) |
|||
if len(args.author) > 0: |
|||
self.canvas.setAuthor(args.author) |
|||
if len(args.title) > 0: |
|||
self.canvas.setTitle(args.title) |
|||
if len(args.subject) > 0: |
|||
self.canvas.setSubject(args.subject) |
|||
if len(args.keywords) > 0: |
|||
self.canvas.setKeywords(args.keywords) |
|||
self.fontSize = args.font_size |
|||
if args.font not in ('Courier'): |
|||
self.font = 'myFont' |
|||
pdfmetrics.registerFont(TTFont('myFont', args.font)) |
|||
else: |
|||
self.font = args.font |
|||
self.kerning = args.kerning |
|||
self.margins = margins |
|||
self.leading = (args.extra_vertical_space + 1.2) * self.fontSize |
|||
self.linesPerPage = int( |
|||
(self.leading + pageHeight |
|||
- margins.top - margins.bottom - self.fontSize) / self.leading) |
|||
self.lppLen = len(str(self.linesPerPage)) |
|||
fontWidth = self.canvas.stringWidth( |
|||
".", fontName=self.font, fontSize=self.fontSize) |
|||
self.lineNumbering = args.line_numbers |
|||
if self.lineNumbering: |
|||
margins.adjustLeft(fontWidth * (self.lppLen + 2)) |
|||
contentWidth = pageWidth - margins.left - margins.right |
|||
self.charsPerLine = int( |
|||
(contentWidth + self.kerning) / (fontWidth + self.kerning)) |
|||
self.top = pageHeight - margins.top - self.fontSize |
|||
self.filename = args.filename |
|||
self.verbose = not args.quiet |
|||
self.breakOnBlanks = args.break_on_blanks |
|||
self.encoding = args.encoding |
|||
self.pageNumbering = args.page_numbers |
|||
if self.pageNumbering: |
|||
self.pageNumberPlacement = \ |
|||
(pageWidth / 2, margins.bottom / 2) |
|||
|
|||
def _process(self, data): |
|||
flen = os.fstat(data.fileno()).st_size |
|||
lineno = 0 |
|||
read = 0 |
|||
for line in data: |
|||
lineno += 1 |
|||
if sys.version_info.major == 2: |
|||
read += len(line) |
|||
yield flen == \ |
|||
read, lineno, line.decode(self.encoding).rstrip('\r\n') |
|||
else: |
|||
read += len(line.encode(self.encoding)) |
|||
yield flen == read, lineno, line.rstrip('\r\n') |
|||
|
|||
def _readDocument(self): |
|||
with open(self.filename, 'r') as data: |
|||
for done, lineno, line in self._process(data): |
|||
if len(line) > self.charsPerLine: |
|||
self._scribble( |
|||
"Warning: wrapping line %d in %s" % |
|||
(lineno + 1, self.filename)) |
|||
while len(line) > self.charsPerLine: |
|||
yield done, line[:self.charsPerLine] |
|||
line = line[self.charsPerLine:] |
|||
yield done, line |
|||
|
|||
def _newpage(self): |
|||
textobject = self.canvas.beginText() |
|||
textobject.setFont(self.font, self.fontSize, leading=self.leading) |
|||
textobject.setTextOrigin(self.margins.left, self.top) |
|||
textobject.setCharSpace(self.kerning) |
|||
if self.pageNumbering: |
|||
self.canvas.drawString( |
|||
self.pageNumberPlacement[0], |
|||
self.pageNumberPlacement[1], |
|||
str(self.canvas.getPageNumber())) |
|||
return textobject |
|||
|
|||
def _scribble(self, text): |
|||
if self.verbose: |
|||
sys.stderr.write(text + os.linesep) |
|||
|
|||
def generate(self): |
|||
self._scribble( |
|||
"Writing '%s' with %d characters per " |
|||
"line and %d lines per page..." % |
|||
(self.filename, self.charsPerLine, self.linesPerPage) |
|||
) |
|||
if self.breakOnBlanks: |
|||
pageno = self._generateBob(self._readDocument()) |
|||
else: |
|||
pageno = self._generatePlain(self._readDocument()) |
|||
self._scribble("PDF document: %d pages" % pageno) |
|||
|
|||
def _generatePlain(self, data): |
|||
pageno = 1 |
|||
lineno = 0 |
|||
page = self._newpage() |
|||
for _, line in data: |
|||
lineno += 1 |
|||
|
|||
# Handle form feed characters. |
|||
(line, pageBreakCount) = re.subn(r'\f', r'', line) |
|||
if pageBreakCount > 0 and lineno >= args.minimum_page_length: |
|||
for _ in range(pageBreakCount): |
|||
self.canvas.drawText(page) |
|||
self.canvas.showPage() |
|||
lineno = 0 |
|||
pageno += 1 |
|||
page = self._newpage() |
|||
if args.minimum_page_length > 0: |
|||
break |
|||
|
|||
page.textLine(line) |
|||
|
|||
if lineno == self.linesPerPage: |
|||
self.canvas.drawText(page) |
|||
self.canvas.showPage() |
|||
lineno = 0 |
|||
pageno += 1 |
|||
page = self._newpage() |
|||
if lineno > 0: |
|||
self.canvas.drawText(page) |
|||
else: |
|||
pageno -= 1 |
|||
self.canvas.save() |
|||
return pageno |
|||
|
|||
def _writeChunk(self, page, chunk, lineno): |
|||
if self.lineNumbering: |
|||
formatstr = '%%%dd: %%s' % self.lppLen |
|||
for index, line in enumerate(chunk): |
|||
page.textLine( |
|||
formatstr % (lineno - len(chunk) + index + 1, line)) |
|||
else: |
|||
for line in chunk: |
|||
page.textLine(line) |
|||
|
|||
def _generateBob(self, data): |
|||
pageno = 1 |
|||
lineno = 0 |
|||
page = self._newpage() |
|||
chunk = list() |
|||
for last, line in data: |
|||
if lineno == self.linesPerPage: |
|||
self.canvas.drawText(page) |
|||
self.canvas.showPage() |
|||
lineno = len(chunk) |
|||
pageno += 1 |
|||
page = self._newpage() |
|||
lineno += 1 |
|||
chunk.append(line) |
|||
if last or len(line.strip()) == 0: |
|||
self._writeChunk(page, chunk, lineno) |
|||
chunk = list() |
|||
if lineno > 0: |
|||
self.canvas.drawText(page) |
|||
self.canvas.showPage() |
|||
else: |
|||
pageno -= 1 |
|||
if len(chunk) > 0: |
|||
page = self._newpage() |
|||
self.canvas.drawText(page) |
|||
self.canvas.showPage() |
|||
pageno += 1 |
|||
self.canvas.save() |
|||
return pageno |
|||
|
|||
|
|||
parser = argparse.ArgumentParser() |
|||
parser.add_argument('filename') |
|||
parser.add_argument( |
|||
'--font', |
|||
'-f', |
|||
default='Courier', |
|||
help='Select a font (True Type format) by its full path') |
|||
parser.add_argument( |
|||
'--font-size', |
|||
'-s', |
|||
type=float, |
|||
default=10.0, |
|||
help='Size of the font') |
|||
parser.add_argument( |
|||
'--extra-vertical-space', |
|||
'-v', |
|||
type=float, |
|||
default=0.0, |
|||
help='Extra vertical space between lines') |
|||
parser.add_argument( |
|||
'--kerning', |
|||
'-k', |
|||
type=float, |
|||
default=0.0, |
|||
help='Extra horizontal space between characters') |
|||
parser.add_argument( |
|||
'--media', |
|||
'-m', |
|||
default='A4', |
|||
help='Select the size of the page (A4, A3, etc.)') |
|||
parser.add_argument( |
|||
'--minimum-page-length', |
|||
'-M', |
|||
type=int, |
|||
default=10, |
|||
help='The minimum number of lines before a form feed character will change the page') |
|||
parser.add_argument( |
|||
'--landscape', |
|||
'-l', |
|||
action="store_true", |
|||
default=False, |
|||
help='Select landscape mode') |
|||
parser.add_argument( |
|||
'--margin-left', |
|||
'-L', |
|||
type=float, |
|||
default=2.0, |
|||
help='Left margin (in cm unit)') |
|||
parser.add_argument( |
|||
'--margin-right', |
|||
'-R', |
|||
type=float, |
|||
default=2.0, |
|||
help='Right margin (in cm unit)') |
|||
parser.add_argument( |
|||
'--margin-top', |
|||
'-T', |
|||
type=float, |
|||
default=2.0, |
|||
help='Top margin (in cm unit)') |
|||
parser.add_argument( |
|||
'--margin-bottom', |
|||
'-B', |
|||
type=float, |
|||
default=2.0, |
|||
help='Bottom margin (in cm unit)') |
|||
parser.add_argument( |
|||
'--output', |
|||
'-o', |
|||
default='output.pdf', |
|||
help='Output file') |
|||
parser.add_argument( |
|||
'--author', |
|||
default='', |
|||
help='Author of the PDF document') |
|||
parser.add_argument( |
|||
'--title', |
|||
default='', |
|||
help='Title of the PDF document') |
|||
parser.add_argument( |
|||
'--quiet', |
|||
'-q', |
|||
action='store_true', |
|||
default=False, |
|||
help='Hide detailed information') |
|||
parser.add_argument('--subject',default='',help='Subject of the PDF document') |
|||
parser.add_argument('--keywords',default='',help='Keywords of the PDF document') |
|||
parser.add_argument( |
|||
'--break-on-blanks', |
|||
'-b', |
|||
action='store_true', |
|||
default=False, |
|||
help='Only break page on blank lines') |
|||
parser.add_argument( |
|||
'--encoding', |
|||
'-e', |
|||
type=str, |
|||
default='utf8', |
|||
help='Input encoding') |
|||
parser.add_argument( |
|||
'--page-numbers', |
|||
'-n', |
|||
action='store_true', |
|||
help='Add page numbers') |
|||
parser.add_argument( |
|||
'--line-numbers', |
|||
action='store_true', |
|||
help='Add line numbers') |
|||
|
|||
args = parser.parse_args() |
|||
|
|||
PDFCreator(args, Margins( |
|||
args.margin_right, |
|||
args.margin_left, |
|||
args.margin_top, |
|||
args.margin_bottom)).generate() |
|||
File diff suppressed because it is too large
Binary file not shown.
@ -0,0 +1,137 @@ |
|||
|
|||
tarty = { |
|||
'a' : '''█▀▀█◕ |
|||
█▄▄█◕ |
|||
▀──▀◕''', |
|||
'b' : '''█▀▀▄◕ |
|||
█▀▀▄◕ |
|||
▀▀▀─◕''', |
|||
'c' : '''█▀▀◕ |
|||
█──◕ |
|||
▀▀▀◕''', |
|||
'd' : '''█▀▀▄◕ |
|||
█──█◕ |
|||
▀▀▀─◕''', |
|||
'e' : '''█▀▀◕ |
|||
█▀▀◕ |
|||
▀▀▀◕''', |
|||
'f' : '''█▀▀◕ |
|||
█▀▀◕ |
|||
▀──◕''', |
|||
'g' : '''█▀▀▀◕ |
|||
█─▀█◕ |
|||
▀▀▀▀◕''', |
|||
'h' : '''█──█◕ |
|||
█▀▀█◕ |
|||
▀──▀◕''', |
|||
'i' : '''─▀─◕ |
|||
▀█▀◕ |
|||
▀▀▀◕''', |
|||
'j' : '''──▀◕ |
|||
──█◕ |
|||
█▄█◕''', |
|||
'k' : '''█─█◕ |
|||
█▀▄◕ |
|||
▀─▀◕''', |
|||
'l' : '''█──◕ |
|||
█──◕ |
|||
▀▀▀◕''', |
|||
'm' : '''█▀▄▀█◕ |
|||
█─▀─█◕ |
|||
▀───▀◕''', |
|||
|
|||
} |
|||
|
|||
|
|||
|
|||
# █▀▀▄◕ |
|||
# █──█◕ |
|||
# ▀──▀◕ |
|||
|
|||
# █▀▀█◕ |
|||
# █──█◕ |
|||
# ▀▀▀▀◕ |
|||
|
|||
# █▀▀█◕ |
|||
# █──█◕ |
|||
# █▀▀▀◕ |
|||
|
|||
# █▀▀█◕ |
|||
# █──█◕ |
|||
# ▀▀▀█◕ |
|||
|
|||
# █▀▀█◕ |
|||
# █▄▄▀◕ |
|||
# ▀─▀▀◕ |
|||
|
|||
# █▀▀◕ |
|||
# ▀▀█◕ |
|||
# ▀▀▀◕ |
|||
|
|||
# ▀▀█▀▀◕ |
|||
# ──█──◕ |
|||
# ──▀──◕ |
|||
|
|||
# █──█◕ |
|||
# █──█◕ |
|||
# ─▀▀▀◕ |
|||
|
|||
# ▀█─█▀◕ |
|||
# ─█▄█─◕ |
|||
# ──▀──◕ |
|||
|
|||
# █───█◕ |
|||
# █▄█▄█◕ |
|||
# ─▀─▀─◕ |
|||
|
|||
# █─█◕ |
|||
# ▄▀▄◕ |
|||
# ▀─▀◕ |
|||
|
|||
# █──█◕ |
|||
# █▄▄█◕ |
|||
# ▄▄▄█◕ |
|||
|
|||
# ▀▀█◕ |
|||
# ▄▀─◕ |
|||
# ▀▀▀◕ |
|||
|
|||
# █▀▀█◕ |
|||
# █▄▀█◕ |
|||
# █▄▄█◕ |
|||
|
|||
# ▄█─◕ |
|||
# ─█─◕ |
|||
# ▄█▄◕ |
|||
|
|||
# █▀█◕ |
|||
# ─▄▀◕ |
|||
# █▄▄◕ |
|||
|
|||
# █▀▀█◕ |
|||
# ──▀▄◕ |
|||
# █▄▄█◕ |
|||
|
|||
# ─█▀█─◕ |
|||
# █▄▄█▄◕ |
|||
# ───█─◕ |
|||
|
|||
# █▀▀◕ |
|||
# ▀▀▄◕ |
|||
# ▄▄▀◕ |
|||
|
|||
# ▄▀▀▄◕ |
|||
# █▄▄─◕ |
|||
# ▀▄▄▀◕ |
|||
|
|||
# ▀▀▀█◕ |
|||
# ──█─◕ |
|||
# ─▐▌─◕ |
|||
|
|||
# ▄▀▀▄◕ |
|||
# ▄▀▀▄◕ |
|||
# ▀▄▄▀◕ |
|||
|
|||
# ▄▀▀▄◕ |
|||
# ▀▄▄█◕ |
|||
# ─▄▄▀◕ |
|||
@ -0,0 +1,35 @@ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░ ░░ ░ ░ ░ ░░░░ ░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░ ░░░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░ ░ ░░░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░░░░░░░░ ░░░░░░░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░░░░░ ░░ ░░░░░ ░ ░ ░ ░░░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░ ░░░░░░░░░░░░ ░ ░ ░ ░░░░░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░░░░ ░░░░░░░ ░ ░░░ ░░ ░░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░ ░░░░░░░░ ░ ░░░ ░ ░ ░░░░░ ░░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░ ░ ░░░░░░░░ ░ ░░░ ░ ░░░░░░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░ ░░░░░░░░ ░ ░ ░ ░ ░ ░░░░░░░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░░ ░ ░ ░ ░ ░ ░░░░░░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░░░░░░ ░ ░ ░ ░ ░ ░░░░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░░░░░░ ░ ░ ░ ░ ░ ░░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░ ░░░░░░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░ ░░░░░░░░ ░ ░ ░░ ░ ░ ░░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░ ░░░░ ░░░ ░ ░░ ░ ░ ░░░░ ░ |
|||
░░░░░░░░░░░░░░░░░░░ ░░░░░ ░ ░░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░ ░░░░░░░ ░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░░ ░░░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░░░ ░░ ░░░░░░░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░░░░░░░░ ░░░░░░░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░░░░░░ ░ ░░░░░░░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░ ░░░░░░ ░░░░░░░ ░ ░ ░░░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░ ░░ ░░░ ░░░░░ ░ ░ ░░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░ ░░░░░ ░░ ░ ░░░░░░░ ░░░ ░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░ ░ ░░░░░░░░ ░ ░░░░░ ░░░░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░ ░░░░░░░░ ░ ░ ░ ░ ░ ░░░░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░░ ░ ░ ░ ░ ░ ░░░░░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░░░░░░ ░ ░ ░ ░ ░ ░░░░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░░░░░░ ░ ░ ░ ░ ░ ░░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░ ░ ░░░░░░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░ ░ ░░░░░░░░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░ ░░░░░░░░ ░ ░ ░░ ░ ░ ░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░ ░ ░░ ░ ░ ░░ ░ |
|||
@ -0,0 +1,35 @@ |
|||
░ ░░ ░ ░░ ░░░ ░░ ░ ░ ░ ░ ░ ░ ░ ░░░░░ |
|||
░ ░░ ░ ░ ░░░ ░░░ ░ ░ ░ ░░░ ░░░░░░░ ░ ░ ░░░░░░ ░ |
|||
░ ░░░ ░ ░ ░ ░ ░░ ░ ░ ░ ░ ░ ░ ░ |
|||
░░░░░ ░ ░ ░ ░░░ ░ ░░░░░ ░ ░░░ ░ ░░ ░ ░░░ ░ ░ ░ |
|||
░ ░ ░ ░ ░ ░░░ ░ ░ ░ ░ ░ ░ ░ ░ ░ |
|||
░ ░░ ░░░ ░ ░ ░ ░ ░ ░░░ ░ ░░ ░ ░░░ ░ ░ ░░░ |
|||
░ ░ ░ ░░ ░ ░░░ ░ ░░ ░░░░░ ░░ ░ ░ ░ ░ ░░░░ ░ |
|||
░░░░░ ░ ░ ░░░░░ ░ ░░░ ░░░ ░ ░ ░░░ ░ ░ ░░░░░░░ ░░ |
|||
░░░ ░ ░ ░░░ ░░ ░ ░ ░ ░░ ░ |
|||
░ ░░░░░ ░░░ ░ ░ ░ ░ ░░░ ░░ ░░ ░ ░ ░ ░░░░░ ░ ░ |
|||
░ ░░░ ░ ░ ░ ░░░░░ ░ ░ ░ ░░░ ░ |
|||
░ ░ ░ ░ ░░ ░ ░ ░ ░░░ ░░░░░░░░ ░ ░░░░░ ░ ░ ░░ |
|||
░ ░░ ░ ░ ░░░░░ ░ ░ ░░░ ░ ░░ ░░░ |
|||
░░░ ░ ░░░░ ░ ░ ░░░ ░ ░ ░ ░ ░ ░ ░░ ░ ░░░ ░ ░ ░ |
|||
░░ ░░░░ ░░░ ░░░░░ ░ ░ ░ ░░ ░ ░ ░░░ ░ ░░ ░ |
|||
░░░ ░ ░░░░░░░░░░░░░░░░░ ░ ░ ░░░ ░░░ ░░░ ░░ ░░░░ ░ |
|||
░ ░ ░ ░░░░░░ ░░░░ ░ ░ ░ ░ ░ ░░░░░░ |
|||
░ ░ ░░░░░ ░ ░░░ ░░░░░░░ ░ ░░░ ░░░ ░░░ ░░░░░░░ ░░ ░ |
|||
░ ░ ░ ░░░ ░ ░ ░ ░ ░ ░░ ░ ░ ░ ░ ░ ░░ ░░░ ░ |
|||
░ ░░░░░ ░ ░░░ ░░░ ░░░ ░░░ ░░ ░ ░ ░ ░░░ ░ ░ ░ ░ ░ |
|||
░░ ░ ░ ░ ░░░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░░ |
|||
░░░ ░ ░░░ ░ ░ ░ ░ ░ ░░░░ ░░░░░░ ░ ░░░ ░░░░ |
|||
░░ ░ ░ ░ ░░ ░ ░ ░ ░ ░ ░ |
|||
░░░ ░░░ ░ ░ ░ ░ ░░░░░ ░░░ ░░░ ░ ░░░ ░ ░ ░░░░░ |
|||
░ ░ ░ ░ ░ ░ ░░░ ░░ ░ ░ ░ ░ |
|||
░ ░ ░ ░ ░░░ ░ ░░ ░ ░ ░░░ ░░░ ░ ░░░░ ░ ░ ░ ░ |
|||
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░░ ░ ░ |
|||
░ ░ ░░ ░░ ░ ░ ░ ░ ░░░░░░░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░░ |
|||
░░ ░ ░ ░ ░ ░ ░ ░░░ ░ ░ ░░ ░░ |
|||
░ ░ ░ ░ ░░░░░ ░░░ ░░ ░ ░ ░ ░ ░ ░ ░ ░░ ░░░ ░ ░ |
|||
░░ ░░ ░ ░ ░ ░ ░░░ ░ ░ ░ ░ ░░░ ░ ░ ░░ |
|||
░░░ ░ ░ ░ ░░░░░ ░ ░░░░░ ░░░ ░ ░░░ ░░░░░ ░ ░░░ |
|||
░░░ ░ ░░ ░ ░ ░ ░ ░░░ ░ ░░ ░ ░ ░ |
|||
░░░░ ░ ░ ░░░░░░░ ░ ░ ░ ░ ░ ░░ ░░░ ░░░ ░░░░ |
|||
░ ░░░ ░░░ ░░ ░░ ░ ░ ░░ ░ ░░░░░ ░ ░ ░ ░ ░░░ |
|||
@ -0,0 +1,35 @@ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ |
|||
Binary file not shown.
Loading…
Reference in new issue