CSC345编程代写、代做Python语言程序

日期：2023-12-07 09:24

CSC345/M45 Big Data and Machine Learning

Coursework: Object Recognition

Policy

1. To be completed by students working individually.

2. Feedback: Individual feedback on the report is given via the rubric within Canvas.

3. Learning outcome: The tasks in this assignment are based on both your practical

work in the lab sessions and your understanding of the theories and methods. Thus,

through this coursework, you are expected to demonstrate both practical skills and

theoretical knowledge that you have learned through this module. You also learn to

formally present your understandings through technical writing. It is an opportunity

to apply analytical and critical thinking, as well as practical implementation.

4. Unfair practice: This work is to be attempted individually. You may get help from

your lecturer, academic tutor, and lab tutor, but you may not collaborate with your

peers. Copy and paste from the internet is not allowed. Using external code

without proper referencing is also considered as breaching academic integrity.

5. University Academic Integrity and Academic Misconduct Statement: By

submitting this coursework, electronically and/or hardcopy, you state that you fully

understand and are complying with the university's policy on Academic Integrity and

Academic Misconduct.

The policy can be found at https://www.swansea.ac.uk/academic-services/academicguide/assessment-issues/academic-integrity-academic-misconduct.

6. Submission deadline: Both the report and your implemented code in Python need to

be submitted electronically to Canvas by 11AM 14

th December.

1. Task

The amount of image data is growing exponentially, due in part to convenient and cheap camera

equipment. Teaching computers to recognise objects within a scene has tremendous application

prospects, with applications ranging from medical diagnostics to Snapchat filters. Object

recognition problems have been studied for years in machine learning and computer vision

fields; however, it is still a challenging and open problem for both academic and industry

researchers. The following task is hopefully your first small step on this interesting question

within machine learning.

You are provided with a small image dataset, where there are 100 different categories of objects,

each of which has 500 images for training and 100 images for testing. Each individual image

only contains one object. The task is to apply machine learning algorithms to classify the testing

images into object categories. Code to compute image features and visualize an image is

provided, you can use it to visualize the images and compute features to use in your machine

learning algorithms. You will then use a model to perform classification and report quantitative

results. You do not have to use all the provided code or methods discussed in the labs so far.

You may add additional steps to the process if you wish. You are encouraged to use the

implemented methodology from established Python packages taught in the labsheets (i.e.

sklearn, skimage, keras, scipy,…). You must present a scientific approach, where you make

suitable comparison between at least two methods.

2. Image Dataset – Subset of CIFAR-100

We provide the 100 object categories from the complete CIFAR-100 dataset. Each category

contains 500 training images and 100 testing images, which are stored in two 4D arrays. The

corresponding category labels are also provided. The objects are also grouped into 20 “superclasses”. The size of each image is fixed at 32x32x3, corresponding to height, width, and colour

channel, respectively. The training images will be used to train your model(s), and the testing

images will be used to evaluate your model(s). You can download the image dataset and

relevant code for visualization and feature extraction from the Canvas page.

There are six numpy files provided, as follows:

• trnImage, 32x32x3x50000 matrix, training images (RGB image)

• trnLabel_fine, 50000 vector, training labels (fine granularity)

• trnLabel_coarse, 50000 vector, training labels (coarse granularity)

• tstImage, 32x32x3x10000 matrix, testing images (RGB image)

• tstLabel_fine, 10000 vector, testing labels (fine granularity)

• tstLabel_coarse, 10000 vector, testing labels (coarse granularity)

The data is stored within a 4D matrix, and for many of you this will be the first time seeing a

high dimensionality tensor. Although this can seem intimidating, it is relatively

straightforward. The first dimension is the height of the image, the second dimension is the

width, the third dimension is the colour channels (RGB), and the fourth dimension is the

samples. Indexing into the matrix is like as with any other numeric array in Python, but now

we deal with the additional dimensions. So, in a 4D matrix ‘X’, to index all pixels in all

channels of the 5th image, we use the index notation X[:, :, :, 4]. So, in a generic form, if we

want to index into the i,j,k,lth element of X we use X[i, j, k, l].

Figure 1. Coarse Categories of CIFAR-100 Dataset

aquatic mammals

fish

flowers

food containers

fruit and vegetables

household electrical devices

household furniture

insects

large carnivores

large man-made outdoor things

large natural outdoor scenes

large omnivores and herbivores

medium-sized mammals

non-insect invertebrates

people

reptiles

small mammals

trees

vehicles 1

vehicles 2

3. Computing Features and Visualizing Images

A notebook, RunMe.ipynb, is provided to explain the concept of computing image features.

The notebook is provided to showcase how to use the skimage.feature.hog() function to obtain

features we wish to train our models on, how to visualize these features as an image, and how

to visualize a raw image from the 4D array. You do not need to use this if your experiments

do not require it! You should also consider the dimensionality of the problem and the features

being used to train your models, this may lead to some questions you might want to explore.

The function utilises the Histogram of Orientated Gradients method to represent image domain

features as a vector. You are NOT asked to understand how these features are extracted from

the images, but feel free to explore the algorithm, underlying code, and the respective Python

package APIs. You can simply treat the features as the same as the features you loaded from

Fisher Iris dataset in the Lab work. Note that the hog() method can return two outputs, the first

are the features, the second is an image representation of those features. Computing the second

output is costly and not needed, but RunMe.ipynb provides it for your information.

4. Learning Algorithms

You can find all relative learning algorithms in the lab sheets and lecture notes. You can use

the following algorithms (Python (and associated packages) built-in functions) to analyse the

data and carry out the classification task. Please note: if you feed certain algorithms with a

large chunk of data, it may take a long time to train. Not all methods are relevant to the task.

• Lab sheet 2:

o K-Means

o Gaussian Mixture Models

• Lab sheet 3:

o Linear Regression

o Principal Component Analysis

o Linear Discriminative Analysis

• Lab sheet 4:

o Support Vector Machine

o Neural Networks

o Convolutional Neural Networks

5. Benchmark and Discussion

Your proposed method should be trained on the training set alone, and then evaluated on the

testing set. To evaluate: you should count, for each category, the percentage of correct

recognition (i.e., classification), and report the confusion matrix. Note that the confusion matrix

can be large, and so you may need to think of ways to present appropriately; you can place it

in your appendices if you wish, or show a particularly interesting sub-region.

The benchmark to compare your methods with is 39.43%, averaged across all 20 super

categories, and 24.49% for the finer granularity categories. Note: this is a reference, not a

target. You will not lose marks for being slightly under this target, but you should be aware of

certain indicative results (very low or very high) that show your method/implementation may

not be correct. Your report will contain a section in which you discuss your results.

6. Assessment

You are required to write a 3-page conference/publication style report to summarize your

proposed method and the results. Your report should contain the following sections:

1. Introduction. Overview of the problem, proposed solution, and experimental results.

2. Method. Present your proposed method in detail. This should cover how the features

are extracted, any feature processing you use (e.g., clustering and histogram generation,

dimensionality reduction), which classifier(s) is/are used, and how they are trained and

tested. This section may contain multiple sub-sections.

3. Results. Present your experimental results in this section. Explain the evaluation

metric(s) you use and present the quantitative results (including the confusion matrix).

4. Conclusion. Provide a summary for your method and the results. Provide your critical

analysis; including shortcomings of the methods and how they may be improved.

5. References. Include correctly formatted references where appropriate. References are

not included in the page limit.

6. Appendices. You may include appendix content if you wish for completeness,

however the content you want graded must be in the main body of the report.

Appendices are not included in the page limit.

Page Limit: The main body of the report should be no more than 3 pages. Font size should be

no smaller than 10, and the text area is approximately 9.5x6 inches. You may use images but

do so with care; do not use images to fill up the pages. You may use an additional cover sheet,

which has your name and student number.

Source Code: Your submission should be professionally implemented and must be formatted

as an ipynb notebook. You may produce your notebook either locally (Jupyter, VSCode etc.),

or you may utilize Google Colab to develop your notebook, however your submission must be

an ipynb notebook. Remember to carefully structure, comment, and markdown your

implementation for clarity.

7. Submission

You will be given the marking rubric in advance of the submission deadline. This assignment

is worth 20% of the total module credit.

Submit your work electronically to Canvas. Your report should be in PDF format only.

Your code must be in a .ipynb format. Both files should be named with your student number,

i.e. 123456.pdf and 123456.ipynb, where 123456 is your student number.

There are two submission areas on Canvas, one for the report and another for the .ipynb

notebook. You must upload both submissions to the correct area by the deadline.

The deadline for this coursework is 11AM 14

th December.