NEWAY

NAME: Li Wei

SID: 1155062148

Criteria design

In this section, I will introduce and justify my criteria and state my assumptions I make when designing this kind of criteria. Typically, fuzzy criteria will be highlighted.

• The stock with highest PE in same type will be excluded. This criteria is inspired by the introduction of PE in the specification:

  PE(Price-Earning Ratio) = Market price / EPS(earning per share). Usually lower is better, but it depends on the PE ratio of the similar stocks. (However, if some types contain only one stock in the database, then this special stock won’t be excluded.)

• high buying level. High buying level means more stable and has less risk. The following is the corresponding fuzzy membership function.

  Buying level	1	2	3	4	5
  $\mu_{high_buy_lv}$	0.1	0.3	0.5	0.7	0.9

• high difference. High difference level means that the stock may have more profit but also more risk. The following is the corresponding fuzzy membership function. However, the difference between ‘too high’ and ‘very high’ is not huge. Therefore the fuzzy memebership function is not linear.

  Difference	0	25	50	75	100	125	150	175	200	225	250
  $\mu_{high_diff}$	0.0	0.2	0.4	0.6	0.75	0.8	0.85	0.9	0.95	0.98	1.0

Query

This section is to introduce the query we design:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

STOCK_CLASS(NAME) (or ((and (= Type SEMI) (< PE 31))
                       (and (= Type WWW) (< PE 66.4))
                       (= Type TECH)
                       (= Type FOOD)
                       (= Type GAME)
                   )
                   (and 
                   	   (High_BUY_LV
                       (1 2 3 4 5)
                       (0.1 0.3 0.5 0.7 0.9)1)
                   	   (High_DIFF_LV
                       (0 25 50 75 100 125 150 175 200 225 250)
                       (0.0	0.2	0.4 0.6 0.75 0.8 0.85 0.9 0.95 0.98 1.0)1)
                   )

Calculation

Non-fuzzy criteria

The stock with highest PE in same type will be excluded.

Fuzzy criteria

high buying level and high difference level.

Conclusion

Therefore, the system will select BABA to buy from our calculation.

ER model

a collection of entities and relationships

Entity

• an object in the real world that is distinguishable from other objects. ( can be same category)
• described using a set of attributes.

Entity set is a collection of entities of the same type. All entities in a given entity set have the same attributes ( the values may be different).

Domain: domain of possible values of each attribute in an entity set.

Key

superkey: any set of attributes which can uniquely identify an entity

key (candidate key): a minimal set of attributes whose values can uniquely identify an entity in the set. (should depend on the real life possibility 即使还有entity 加入/删除， 这个key永远identify an entity)

primary key: a candidate key chosen to serve as the key for the entity set

Relationships

an association among two or more entities.

eg. Teach: (John,CENG4567) ,(David, CSCI1234)

relationship set: a set of similar relationships: {(John,CENG4567) ,(David, CSCI1234)}

relationships can also have descriptive attributes

Recursive Relationship: relationship两边entity其实一样

One to many

Tenary：aggregation把3个变成2个

One to One

similar with one to many, but have two arrows

Key for relationship set

• Many-many union of the primary keys for E1,…Ek
• One-many 找many的那个primary key就行。（知道一个孩子的ID就能确定是哪个‘mother-of’）
• One-one 随便找个primary key就行。

Participation constraint

• total –each entity in the entity set must participate in at least one relationship. （对应的entity——relation的线加粗）
• partial- 不需要

Weak entities

strong entity , an entity which has a super key

weak entity 相反

若需要identify一个weak entity： –by considering some of its attributes in conjunction with the primary key of employee (identifying owner).

partial key 例如：教授家属需要identify就需要（教授id，家属名字）

Class hierarchies

Overlap constraint 两个subclass能否包含相同entity （default：no）

Cover constraint 是否subclass包含了superclass里所有entity （ default：no）

Aggregation

A relationship between a collection of entities and relationships

Relational Model

main construct: a set of relations

relation consists of relation schema and relation instance

Relation instance

Simply a table with rows and columns

• row = tuple/record, no two rows are identical
• column = field/attribute

Relation schema

specifies relation’s name, name of each field(primary key should be underlined), domain of each field

Degree/arity of a relation: number of fields

Cardinality of a relation instance: number of tuples

Relational database : a collection of relations

Instance: a collection of relation instances (one per relation schema).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

CREATE TABLE Students
	(sid	CHAR(20),
	 name	CHAR(30),
	 login	CHAR(20),
	 age	INTEGER,
	 gpa	REAL)

INSERT
INTO	 Students  (sid, name, login, age, gpa)
VALUES (‘53688’, ‘Smith’, ‘smith@ee’, 18, 3.2)

DELETE 
FROM	  Students S
WHERE  S.name = ‘Smith’

UPDATE Students S
SET 	  S.age = S.age + 1, S.gpa = S.gpa – 1
WHERE  S.sid = ‘53688’

Integrity constraints

restricts the data that can be stored in an instance of the database on a database schema

• Specified when the schema is defined.
• **Checked **when relations are modified.

Key constraints

Certain minimal subset of the fields (candidate key) of a relation is a unique identifier for a tuple (instance).

设计者可以自己identify a primary key（比如index）

1
2
3
4
5
6
7
8

CREATE TABLE Students
	(sid	CHAR(20),
	 name	CHAR(30),
	 login	CHAR(20),
	 age	INTEGER,
	 gpa	REAL,
	 UNIQUE (name, age),//declare a key
	 CONSTRAINT StudentsKey PRIMARY KEY ( sid)) //StudentKey: Constraint name(opt)

Foreign key constraints

Sometimes, the information stored in a relation is linked to the information stored in another relation.

Enrolled(sid: string, cid: string, grade: string) sid就是Enrolled这个relation的 foreign key and refer to Students

Formally, a foreign key is a set of fields （the primary key of s） in one relation r that is used to “refer” to a tuple in another relation s.

1
2
3
4
5
6

CREATE TABLE Enrolled (
		sid       CHAR(20),
		cid       CHAR(20),
		grade   CHAR(10),
		PRIMARY KEY (sid, cid),
		FOREIGN KEY (sid) REFERENCES Students)

four options on DELETE and UPDATE.

• NO ACTION (DEFAULT) rejected
• CASCADE（级联） 如果被删除，那么相关联的所有row也全被删除
• SET DEFAULT 如果被删除，那么相关联的所有row设置为DEFAULT
• SET NULL

ER to Relational

• entity sets -> tables

• relationship sets(without constraints) -> tables，attributes包括

  • 每个entity的primary key
  • relationship set的descriptive attributes

• with constraints

  • arrow: arrow对应的m个entity，因此又m个candidate key，随便选一个作为primary key

• weak entity

  将weak entity及对应relation 统一为一个table 并且（ON DELETE CASCADE)

• Class hierarchies

  • different relations (父母孩子都有)

    more general。

  • (仅有孩子)

    not always possible。can be accessible easily

• Aggregation

Relational Algebra

Baisc Operators

selection $\sigma$

a boolean combination (an expression using logical connectives $\wedge \vee$)

Projection $\Pi(fileds)$

extract columns from a relation

duplicated row will be eliminated

Union $U$

must be union-compatible:

• same number of fields
• corresponding fields have the same domains

Set Difference $-$

also union-compatible

Intersection $\cap$

also union-compatible

$R\cap S = R-(R-S)$

Rename $\rho$

$\rho (R(F),E) \ or\ \rho(R,E)$

E: arbitrary relation algebra ,F:renaming list, R= E 除了F rename的东西

Cartesian product (cross product) $\times$

Join $\Join$

Join can be defined as a cross-product followed by selections and sometimes with projections.

• Join condition $\Join_c =\sigma_c(R\times S)$
• Equi join c is R.name1 = S.name2, S.name2 will be droped in the final resulting relation
• Natural join: C 是R S所有fields相同的

Example

Division /

Example

SQL

1. 先计算 relation list的cross product
2. 考虑是否满足 qualifications
3. 选取target list里面的attributes
4. 如果有 DISTINCT, 把duplicated rows删掉（默认不删）

Natural Join

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

SELECT  S.sname
FROM     Sailors S, Reserves R
WHERE  S.sid=R.sid AND R.bid=103
=
SELECT  S.sname
FROM     Sailors S NATURAL JOIN Reserves R
WHERE  R.bid=103

#IN operator
SELECT  B.bname
FROM  Boats B
WHERE  B.color  IN  (‘red’,  ‘blue’,  ’green’)

#Nested Queries
Find names of sailors who’ve reserved boat #103:
SELECT  S.sname
FROM  Sailors S
WHERE  S.sid IN  (SELECT  R.sid
                  FROM  Reserves R
                  WHERE  R.bid=103) #inner function can use the relation in outer function
> ANY : 比某一些大就行

Expressions and string

LIKE for string matching. _ = any one character, % = 0 or more arbitrary characters

Aggregate Operators

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

COUNT([DISTINCT] A)
SUM ( [DISTINCT] A)
AVG ([DISTINCT] A)
MAX (A)
MIN (A) A: any column of a relation
# cannot be netsted! MIN(AVG(A)) is not allowed!
eg.Find the name and age of the oldest sailor
SELECT  S.sname, S.age
FROM  Sailors S
WHERE  S.age =
              (SELECT  MAX (S2.age)
               FROM  Sailors S2)
eg.Find the names of sailors who are older than the oldest sailor with a rating of 10.
SELECT 	S.name
FROM	Sailors S
WHERE	S.age > (	SELECT	MAX (S2.age)
					FROM	Sailors S2
					WHERE	S2.rating = 10)

GROUP BY and Having

1
2
3
4
5
6
7
8
9
10

eg Find the age of the youngest sailor for each rating level.
SELECT 	       S.rating, MIN (S.age)
FROM  	       Sailors S
GROUP BY   S.rating

SELECT        [DISTINCT]  target-list STEP 2 //target list = attribute names + terms with ahhregate operations, The attribute names must be a subset of grouping-list.  
FROM         relation-list STEP 1
WHERE        qualification STEP 2
GROUP BY  grouping-list STEP3
HAVING      group-qualification STEP 4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

SELECT  R.day
FROM  Reserves R
GROUP BY  R.day
HAVING COUNT(DISTINCT R.sid) = 1

Example: Find the average age of sailors for each rating level that has at least two sailors.
SELECT  S.rating, AVG(S.age) AS avgage
FROM  Sailor S
GROUP BY S.rating
HAVING COUNT (*) > 1

Example:Find those ratings for which the average age is the minimum over all ratings
SELECT  Temp.rating, Temp.avgage
FROM  (SELECT  S.rating, AVG (S.age) AS avgage
       FROM  Sailors S
       GROUP BY  S.rating) AS Temp
WHERE  Temp.avgage = (SELECT  MIN (Temp.avgage)
                      FROM  Temp)

Division

CREATE VIEW

Delete view：DROP VIEW Temp

Outer Join

S LEFT OUTER JOIN R: S 中不对应 R的也会加进去。 只是R的field就是 NULL

FULL OUTER JOIN： both

ENGG5189 FUZZY EXPERT SYSTEM REPORT

Li Wei 1155062148

Background

There are hundreds of programming languages to use now, which make it difficult for programmers to decide which language is the most suitable for them.

Below picture (cited from Quora) also shows that many people, no matter they are experienced programmers or not, have the question:

Which programming language should I learn next?

Motivation

Motivated by the wide range of discussion: “ best programming language to learn” and our former hesitant experience when deciding which programming course to enroll, we decided to design a Fuzzy expert system to solve these kinds of problems.

Problem Definition

The users do not have a clear knowledge on different programming language, which make them hard to select the best/ most suitable programming language for them to learn.

System Design

The Fuzzy system is designed for recommending suitable programming languages for users to learn. And rules are provided for inference so that users need to answer some simple programming habits questions, which are used as facts in the system.

Implementation

Fuzzy type

• Difficulty the expected difficulty of programming language.
• Time the expected time spent to learn programming language every week.
• Resource the expected learning resource of programming language.
• Experience the former programming experience of the user.
• Efficiency the expected efficiency of programming language.
• Package the expected package(eg. numpy in python) requirements of programming language.
• Debug the debugging ability and willing of user.

Objects

• (conclusion)

  preset values of the result

• expectation_of_difficulty

• time_spent_on_learning

• available_resource

• experience

• package_requirement

• efficiency_requirement

• upset_when_debug

• market_requirement

  whether the reason user learns programming is for finding a job.

• company_orientation

  the expected IT companies the user wants to work for.

• interest_field

  the expected programming field the user wants to work in.

• compiled_language_or_not

  whether the user is suitable for compiled language or not.

Rules

Rules in the system is divided into two perspectives: Facts and languages.

For the facts perspective, the rules help to inference the conclusion and other objects such as expectation of difficulty by facts. Here are some examples:

1
2
3
4
5
6
7
8
9
10
11

RULE CODE:difficulty_rule_easy_111
IF time_spent_on_learning is little AND available_resource is little AND experience is little
THEN expectation_of_difficulty is easy
WITH CERTAINTY: 0.9
//help to inference expectation_of_difficulty

RULE CODE:difficulty_rule_1
IF expectation_of_difficulty is easy
THEN programming_language is Python
WITH CERTAINTY: 0.75
//help to inference programming_language

For the languages perspective, the rules help to inference the conclusion by languages, this kind of rule makes use of the key features of different programming language. Here is one example:

1
2
3
4

RULE CODE:js_rule_2
IF  expectation_of_difficulty is easy AND efficiency_requirement is high AND interest_field is Web_programming
THEN programming_language is Javascript
WITH CERTAINTY: 0.95

Inference structure


Results

Given these facts:

• time_spent_on_learning much (1.0)
• **available_resource **much (1.0)
• experience much (1.0)
• **package_requirement **high (1.0)
• efficiency_requirement high (1.0)
• upset_when_debug No (1.0)
• market_requirement Yes (1.0)
• company_orientation Apple (1.0)
• interest_field No_preference (1.0)

The results are:

Discussion and conclusion

Pros and cons

Our system has done a basic programming language recommendation task, which covers almost all possibilities. And the result is really practical for uses.

However, the system can not solve a few specific language requirements well, such as Database programmer and so on.

Further improvements

According to what we mentioned above, the system can be still improved by importing more language-based rules so that the system can handle some specific language requirements better.

Work distribution

一个人的命运 固然要靠个人的奋斗 但是也要考虑历史的进程 —呱呱呱

中大四载，明白的最深刻的道理就是上面这条了。

放大来说，先人杜甫，比我们不知道高到哪里去了，在那个年代也会沦落到被几个小毛孩欺负。

从小了来说，我们每个20出头的愣头青，有的人拼死拼活还是在B，有的人混一混就能拿个A leve。姑且先不说是不是学校差别，比如一个来自人大（苏州），一个来自中大。我们就拿中大自己人来说的话，有个深刻的道理:

选课 也是一门学问。

有的时候不是说好好上课努力学习final感觉满分就一定能拿A（说你呢 4430），因此本文是我们用拍死在沙滩上的泪水

献给 年轻的学弟学妹们，愿天堂没有GPA。

注意：本文纯属个人见解，如有冒犯，请联系。

格式：

课程代码，课程名称，课程教授

description

workload

grade

给分好，工作量小（或 难度低）

CCAN1703/CCAN2703 初阶粤语/中阶粤语 Dr LEE Siu Lun

我那个年代（14-15）内地生给分福利。老师上课有趣。

只有一些粤语阅读 和 演讲。

据说 最低A-

ESTR3108 人工智能 Prof Leung

梁老教授快退休了，但是为人和善，也是我最尊敬的几位教授之一，每次大家的weekly presentation 他都听的特别认真，真的是肃然起敬。

ELITE的AI比一般的会多一个DNN的project，不过之前有过经验的话倒是挺简单的。

如果有过DNN经验，final前好好复习（pastpaper！) 一般A level是没问题的。

大一 数学物理

基本都是高中学过的，有一些没学过的也是奥赛（自主招生）会学的。总之基本上大一的数理课是相当简单。

一般都是 weekly assignment + mid term + final

只要别完全划水，A level也是OK的

UGEB2401 天文

讲的东西特别有趣！感觉自己是当代诸葛，上知天文了哈哈哈，小时候很多为什么都是那个时候了解的。

忘了。

有兴趣的话 拿A还算没毛病。

UGEC2020 澳门历史

挺不错的一门课，看得出来老师在试图讲的有趣哈哈哈。

一篇paper + 一次开卷考试

我拿的是A-。。因为感觉基本就写了篇paper就拿了A level，有点受之有愧

IERG3280 / ESTR3302

BY Li Qi:

IE出名的给分好颓课，唯一要注意的是教授会尝试记住每个人，尤其ELITE，所以千万别翘课。他会给每个人照相，然后打印出一张座位相片名字表。。。。。。

homework + mid-term + project

反正我认识的都是A…没选这门课真是气死我了！

给分好，工作量大（或 难度高）

CSCI3100 软件工程

考试和project没有任何关系。。mid-term有点理科的感觉，final完全就是文科考试了，不过和TA拉好关系是有帮助的！

assignment + mid-term + final + project（4人抱团把天赋带到搭网站。。。那段时间连续通顶一个星期）

其实一般CS的major， final 和mid term才是关键。project大家分数差不多。所以final好好复习 A level也是没问题的。

CSCI3130/CSCI3160 Automata theory/ fund of Alg

两门课其实差别挺大的，放一起是因为给分，workload都是类似的。而且两位教授之前在中大是师生关系哈哈哈哈。

正常的weekly assignment + mid term + final，不过挺多人吐槽比较难。（不过相信我，你听到的大部分内地生吐槽难，炸了都是在装！）我反正觉得还OK。

好好学习A- 是有的，A就是可遇不可求了。

ENGG2420C/ESTR2000 复数分析 Prof Pascal

当时为了凑ELITE分数选这门课，同时想着复数应该还有点用。现在特别后悔。。是我上过workload最大！的一门课！

weekly assignment + mid term + final + presentation + paper

emm。。。虽然ELITE后面的都没听懂了，不过final好像考的并不难 基本都会做。所以A-还是可以的。

CSCI4430 Computer network

怎么说呢。。其实我是想把他放在 给分烂 难度低里面的哈哈哈。课挺有意思的，也解答了我很多最开始玩电脑时候的问题，全程顺风顺水，但最后拿个A-还是不满意的。毕竟我难得有一门专业课这么扎实的学啊。

workload一般 主要还是final得考好把。。

我前面都是满分，final估分满分，最后拿个A-。。哎。

给分烂，工作量大（或 难度高）

CSCI3150 Intro to OS Prof.Eric

Welcome to 3150! 也是出名的workload巨大。不过OS这种课本来就基础而且难，所以也怨不了Eric，而且教授讲课也是特别仔细，一个问题会整的明明白白的。不过。。final 考一个一百行代码找一个bug是什么鬼啊！！！

code assignment + mid term（巨难）+final（巨难）

带没啥好说的。CS内地生我只清楚两个拿A level的。

CSCI3180 programming language Prof.Jimmy

Whose bell rings? 这个梗懂得就懂。Jimmy是我印象里对教书最认真负责的一名教授，也难怪拿了两次 best teacher。不过必须要diss一下jimmy的是。。他那个code作业真的是太难了。。。

code assignment + mid term + final

给分已经不重要了，我只知道前面两次code assignment我是生不如死。

以上就是所有印象深刻的课程。如有遗漏/新的见解 欢迎补充~

Full Automatic Micro Calcification Detection in Mammogram Images Using Artificial Neural Network and Gabor Wavelets

Preprocess

remove seeds from images and increase contrast between normal and abnormal brain tissues

• Histogram equalization
• Median filter
• Un sharp mask
• thresholding
• Mean filter

Feature extraction

Networks in their Surrounding Contexts

Homophily Test

计算不同category相连edge比例 与 理论比例的大小关系。如果”significantly less than”，那么就叫做同质化。

Conv sppedup

Accurate compu

Approximatation computation

Low-rank

sparse

Activation function (ReLU)

Yuzhe

$min\sum||Y_i-r((A+B)\cdot X_i)||_F^2, st.rank(A)<T_1, ||B||_0<T_2$

A is a low-rank tensor, while B is a sparse tensor

Speaker:

1	`Prof. Xiang Chen`

Low power

power barrier ( battery capacity size)

OLED

• 不同颜色能耗比不同，相比降低亮度，可以增加红绿的比例（oled）
• 对不同label的视频（游戏，电影，新闻——。。）可以有不同的处理方式。

GPS:

• 不持续发送信号

GPU

• fps： 手机越小，距离越大。需求越小。GGG
  • 距离：用camera（间歇性）+sensor(持续性)

DNN

• FC （ memory sensitive）
  • sparsity -> cluster?
• CNN(computational sensitive)
  • layer partition of different nodes(distributed computation)

Mobile security

• Gesture (velocity pressure area) is different

Continuous Random Variables/Distributions

Exponential

Gamma

Normal

Chi-square

typical type of Gamma, $\alpha = r/2, \theta = 2 = 1/\lambda$

where r is called the degree of freedom

eg: Brown motion: $x = Normal,y = Normal, then, r = \sqrt{x^2 + y^2} = \sqrt{chi-square}$

Pareto distribution

$\alpha$ = power (decay) law

Future

• Processor
  • many cores
  • heterogeneous(APU)/specialized(AI chips) hardware
• Disk dead. Locality is still the king.
• Cluster as a personal supercomputer

Questions

• Can software system fully optimize for the hw
• How to decide which hw is suitable for a new sw
• How to transform a hw into a practical sw use

Challenge 1 -> Q1

• Parallel alh design
• HW features

C2 from prototype to production

• practical / technical constrains
  • hw: power,space,costs
  • sw: maintenance
  • workload: deep learning

C3 millions of lines of legacy code

how to solve: modular code?