COMP3009J代做、代写Python程序设计

日期：2024-05-28 08:45

COMP3009J – Information Retrieval

Programming Assignment

This assignment is worth 30% of the final grade for the module.

Due Date: Friday 31th May 2024 at 23:55 (i.e. end of Week 14)

Before you begin, download and extract the files ``small_corpus.zip’’ and ``large_corpus.zip’’

from Brightspace. These contain several files that you will need to complete this assignment.

The README.md file in each describes the files contained in the archive and their format

1

.

The main objective of the assignment is to create a basic Information Retrieval system that

can perform preprocessing, indexing, retrieval (using BM25) and evaluation.

The small corpus is intended to show the correctness of your code. The large corpus is

intended to show the efficiency. Efficiency is only important if the code is firstly correct.

Both corpora are in the same format, except for the relevance judgments. For the small

corpus, all documents not included in the relevance judgments have been judged nonrelevant.

For the large corpus, documents not included in the relevance judgments have not

been judged.

For this assignment, you should write several independent programs, each of which is

contained in one file2. The list of programs is below, with descriptions of each. You may

choose not to implement all the programs (see the “Grading” section below). However, an A+

grade can only be awarded if all these programs have been written correctly and efficiently.

It is ESSENTIAL that all programs can be run as a standalone command-line program, without

requiring an IDE/environment such as IDLE, PyCharm, Jupyter, etc.

Non-standard libraries (other than the Porter stemmer provided) may not be used. Do not

use absolute paths (the path to the corpus will always be provided to your program).

What you should submit

Submission of this assignment is through Brightspace. You should submit a single .zip archive

containing the programs you have written.

1 This is a Markdown file. Although you can open and read it as plain text, proper

programming editor (e.g. Visual Studio Code) will provide syntax highlighting for better

readability.

2 Here, “independent programs” means that they should not import anything from one

another. If you write a function that is helpful in multiple programs, copy/paste it. This is, of

course, not good programming practice in terms of reusability of code. However, it helps

with the grading process. Programs:

index_small_corpus.py

This program is intended to read the small corpus, process its contents and create an index.

It must be possible to pass the path to the (unzipped) small corpus to this program as a

command-line argument named “-p”3:

./index_small_corpus.py -p /path/to/comp3009j-corpus-small

This program must perform the following tasks:

1. Extract the documents contained in the corpus provided. You must divide the documents

into terms in an appropriate way (these are contained in the ``documents’’ directory of the

corpus. The strategy must be documented in your source code comments.

2. Perform stopword removal. A list of stopwords to use can be loaded from the

stopwords.txt file that is provided in the ``files’’ directory of the corpus.

3. Perform stemming. For this task, you may use the porter.py code in the ``files’’

directory.

4. Create an appropriate index so that IR using the BM25 method may be performed. Here,

an index is any data structure that is suitable for performing retrieval later.

This will require you to calculate the appropriate weights and do as much pre-calculation as

you can. This should be stored in a single external file in some human-readable4 format. Do

not use database systems (e.g. MySQL, SQL Server, SQLite, etc.) for this.

The output of this program should be a single index file, stored in the current working

directory, named “21888888-small.index” (replacing “21888888” with your UCD

student number).

3 This path might, for example be “/Users/david/datasets/comp3009j-corpussmall”

or “C:/Users/datasets/comp3009j-corpus-small”.

4 Here, “human-readable” means some text-based (i.e. non-binary) format. It should be

possible to see the contents and the structure of the index using a standard text editor. query_small_corpus.py

This program allows a user to submit queries to retrieve from the small corpus, or to run the

standard corpus queries so that the system can be evaluated. The BM25 model must be used

for retrieval.

Every time this program runs, it should first load the index into memory (named “21888888-

small.index” in the current working directory, replacing “21888888” with your UCD student

number), so that querying can be as fast as possible.

This program should offer two modes, depending on a command-line argument named “-

m”. These are as follows:

1. Interactive mode

In this mode, a user can manually type in queries and see the first 15 results in their

command line, sorted beginning with the highest similarity score. The output should have

three columns: the rank, the document’s ID, and the similarity score. A sample run of the

program is contained later in this document. The user should continue to be prompted to

enter further queries until they type “QUIT”.

Example output is given below.

Interactive mode is activated by running the program in the following way:

./query_small_corpus.py -m interactive -p /path/to/comp3009j-corpus-small

2. Automatic mode

In this mode, the standard queries should be read from the ``queries.txt’’ file (in the

``files’’ directory of the corpus). This file has a query on each line, beginning with its

query ID. The results5 should be stored in a file named “218888880-small.results"

in the current working directory (replacing “21888888” with your UCD student number),

which should include four columns: query ID, document ID, rank and similarity score. A

sample of the desired output can be found in the “sample_output.txt” file in the

“files” directory in the corpus.

Automatic mode is activated by running the program in the following way:

./query_small_corpus.py -m automatic -p /path/to/comp3009j-corpus-small

5 You will need to decide how many results to store for each query. evaluate_small_corpus.py

This program calculates suitable evaluation metrics, based on the output of the automatic

mode of query_small_corpus.py (stored in “218888880-small.results" in the

current working directory (replacing “21888888” with your UCD student number).

The program should calculate the following metrics, based on the relevance judgments

contained in the ``qrels.txt’’ file in the ``files’’ directory of the corpus):

- Precision

- Recall

- R-Precision

- P@15

- NDCG@15

- MAP

The program should be run in the following way:

./evaluate_small_corpus.py -p /path/to/comp3009j-corpus-small

index_large_corpus.py

This program should perform the same tasks as index_small_corpus.py, except that the

output file should be named “21888888-large.index” (replacing “21888888” with your

UCD student number).

query_large_corpus.py

This program should perform the same tasks as query_small_corpus.py, except that the

output results file should be named “21888888-large.results” (replacing “21888888”

with your UCD student number).

evaluate_large_corpus.py

In addition to the evaluation metrics calculated by evaluate_small_corpus.py, this

program should also calculate bpref (since the large corpus has incomplete relevance

judgments).

Otherwise, this program should perform the same tasks as evaluate_small_corpus.py,

except that the input results file should be named “21888888-large.results” (replacing

“21888888” with your UCD student number).

Sample Run (Interactive)

$ ./query_small_corpus.py -m interactive -p /Users/david/comp3009j-corpus-small

Loading BM25 index from file, please wait.

Enter query: library information conference

Results for query [library information conference]

1 928 0.991997

2 1109 0.984280

3 1184 0.979530

4 309 0.969075

5 533 0.918940

6 710 0.912594

7 388 0.894091

8 1311 0.847748

9 960 0.845044

10 717 0.833753

11 77 0.829261

12 1129 0.821643

13 783 0.817639

14 1312 0.804034

15 423 0.795264

Enter query: QUIT

Note: In all of these examples, the results, and similarity scores were generated at random for

illustration purposes, so they are not correct scores.

Sample Run (Evaluation)

$ ./evaluate_large_corpus.py -p /Users/david/comp3009j-corpus-large

Evaluation results:

Precision: 0.138

Recall: 0.412

R-precision: 0.345

P@15: 0.621

NDCG@15 0.123

MAP: 0.253

bpref: 0.345

Grading

Grading is based on the following (with the given weights)6:

- Document reading and preprocessing: 15%

- Indexing: 20%

- Retrieval with BM25: 20%

- Evaluation: 15%

- Efficiency: 15% (as evidenced by the performance on the large corpus)

- Programming style (comments/organisation): 15%

Other notes

1. This is an individual assignment. All code submitted must be your own work. Submitting the work

of somebody else or generated by AI tools such as ChatGPT is plagiarism, which is a serious

academic offence. Be familiar with the UCD Plagiarism Policy and the UCD School of Computer

Science Plagiarism Policy.

2. If you have questions about what is or is not plagiarism, ask!

Document Version History

v1.0: 2024-04-26, Initial Version.

6This assignment will be graded using the “Alternative Linear Conversion Grade Scale 40%

Pass” Mark to Grade Conversation Scale: