Decision Science: Programming

面向逻辑思维的程序设计方法——分析世界模型 本文提出基于七层认知模型的"物理-社会-文明"三维分析世界模型(AWM),突破现有世界模型仅关注物理域仿真的局限。研究将LOPD七层认知架构映射为AWM的物理栈(L1-L4整合感知-决策闭环)、社会栈(L5-L6嵌入规范引擎与道德推理)、文明栈(L7构建知识图谱),形成结构化认知框架。通过冯胤清测试验证表明,该方法显著提升类人机器人的社会适应能力,使世界模型推理覆盖率从38%提升至92%,为具身智能的社会化发展提供新范式。 阅读详情


Decision Science: Programming Assignment
Haide College, Autumn Semester 2024
Due dates:
• Milestone (quiz): 7 November 2024, 23:59. [5% course mark]
• Submission (code): 14 November 2024, 23:59 [20% course mark]
Purpose
The purpose of this assessment is to create a fully functional simulation of a more complex system. Building
simulations is one of the key objectives of this course. You will need to be able to do this in an industry or
government job working in decision sciences. Building a simulation is also the best way to absorb and gain a
deep understanding of the ideas and topics that are discussed in this course. Even if you are just managing
simulations projects, you should have some experience in creating the simulation itself.
This is quite a large and difficult task, but the assessment will provide considerable structure.
Outcomes
This Task addresses the following Course Learning Outcomes:
• communicate how randomness and controlled variation can be used to model complex systems in a range
of application domains such as industry, health, and transportation;
• create a model of a real-world problem specified in words and implement it as a discrete-event simulation;
• validate results from a discrete-event simulation.
Scenario
You will be simulating a passport (immigration) control queuing system at an airport. This is based on the
queuing system for foreign travelers arriving at Qingdao airport.
Passengers get off their flight, walk to the passport checkpoint area and join a single primary queue. When
they get near the front of this queue they are organised into several short secondary queues. Each secondary
queue leads to a counter staffed by an attendant, who checks the passenger’s passport and clears them to their
journey.
Additional features. The airport uses some strategies to make this process more efficient. This includes:
1. extra counters open when the system is busy, and close when it is less busy
2. attendants regularly rotate so they can take breaks
3. passengers may be served at a counter not corresponding to their outside their allocated secondary queue
in some circumstances
Assumptions
You should assume the following:
• all queues operates in a First in First Out (FIFO) basis
• there are 2 counters open at the start of the simulation
• Times: all times are independent and
– The interarrival time between flights is exponential with an expected value of 45 minutes
– The number of passengers on each flight who will pass through this passport control area is uniformly
distributed between 15 and 25 passengers (similar to the number of foreign arrivals on a plane to
Qingdao)
– The transit time for a passenger to walk from the plane to the queueing system is uniformly
distributed between 5 and 30 minutes
– The service time for passengers once they reach a counter is Pareto distributed with a minimum
time of 2 minutes and an expected value of 4 minutes
The following assumptions relate to the additional features of the system.
1
• Additional feature 1. Extra counters open when the system is busy, and close when it is less busy
– Let ncounters be the number of counters currently open, and N be the total number of passengers
in the queuing system (main queue, all secondary queues and in service). An extra counter will
open if N > 10 × ncounters. A counter will close if N < 10 × (ncounters − 2).
– There are a minimum of 2 counters and a maximum of 5 counters
– When a counter “closes” this mean that no more passengers are accepted into its secondary queue.
Any passengers currently in the secondary queue will be served as usual.
• Additional feature 2. Attendants regularly rotate so they can take breaks
– Some of the counter attendants rotate at an interval of 30 minutes, during which time service at
the counter is paused for 1 minute. This means that the service time for any passenger at a rotating
counter will increase by 1 minute.
– For odd numbered counters, the first rotation is at 30 minutes from the start of the simulation
(and then every 2 × 30 = 60 minutes)
– For even numbered counters, the first rotation is at 60 minutes from the start of the simulation
(and then every 2 × 30 = 60 minutes)
• Additional feature 3. Passengers may be served at a counter not corresponding to their allocated
secondary queue in some circumstances.
– A passenger at the front of their secondary queue, who has been in their secondary queue for more
than 20 minutes will be served next at any available open counter. In the case of multiple passengers
in this situation, priority is given to the passenger who has spent the longest waiting time in their
secondary queue.
– If an open counter is available and its secondary queue is empty, they will serve a passenger from
another secondary queue. Priority is given to the passenger with the longest secondary queue
waiting time.
• The airport is open 24 hours, 7 days a week.
– The behaviour of the system is not influenced by the time of day.
• The airport has specified that they consider a single simulation running for one day of simulated time
(1440 minutes) to be sufficient for statistical relevance.
Questions
The airport’s management would like to plan for an anticipated increase in passenger numbers, as the number
of arrivals using this passport queueing system is expected to double in the next five years. They would like
to understand how best to manage their staff, if additional counters need to be built, and whether their are
any aspects of the queuing system that can be fine-tuned. Based upon passenger feedback, passengers are
concerned with total amount of time they must spend in this queuing system.
The airport’s management wish to identify the minimum number of counters that will ensure the expected
total time in the queuing system when the number of customers double is no worse than the current level.
Airport management is also concerned with the well-being of their attendants, so would like to understand how
the frequency and length of their rotation impacts passenger experience.
Note. You do not have to answer these questions as part of this assignment, but this motivates the
use of parameters so we can vary the assumptions of our model.
Your Task
This assessment is scaffolded into three parts:
• Part 1: Modelling (Module 2)
• Part 2: Programming (Module 3)
• Part 3: Verification and testing (Module 4)
The details of each part are outlined in later in this brief. It is suggested you work through each of these in
order, although there may be some back and forth between Parts 2 & 3.
2
Requirements
This assessment is worth 25% of your course mark. This is split between two parts:
Milestone online quiz (5%). Answer a series of short multiple choice/numerical answer questions to
demonstrate your understanding of the queuing model and functionality of the simulation.
• Submission requirement: Submit online quiz via Cloudcampus.
Julia code (20%). Write a simulation code in Julia according to the specification provided in this document.
There are a total of 80 marks for this part of the assessment, broken down as follows:
• Basic functionality: code implements the basic functionality of this queuing system, as per the specification.
[40 marks]
• Additional feature 1: code implements this feature correctly. [12 marks]
• Additional feature 2: code implements this feature correctly. [12 marks]
• Additional feature 3: code implements this feature correctly. [12 marks]
• Code style: submission meets general style guidelines for good Julia code. [4 marks]
All the above are detailed in the rubric at the end of this document. Here you are required to submit a single
.jl file, which contains type definitions, data structures and functions to run the simulation.
• Submission requirement: Submit Julia file via Cloudcampus.
• Submission requirement: An include command on your file must not give an error, if it does give an
you will get 0 marks (since this prevents your code from being automatically tested).
If you need clarification about any of the above, please ask course staff during workshop, via email or via the
course discussion board.
3
Part 1: Modelling
In this part, you will model the system that you will be implementing.
The system
You will be simulating a passport (immigration) control queuing system at an airport. This is based on the
queuing system for foreign travelers arriving at Qingdao airport.
See page 1 (“Scenario”) of this document for a detailed description of the system.
Tasks for Part 1
Before you commence coding you should perform a series of modelling tasks. These tasks will prepare you for
Part 2, when you will implement a simulation in Julia. You should work through these tasks and complete the
online milestone quiz. Note you are not required to submit written responses to these points.
1. Draw a schematic of the system. This can be a rough sketch on a piece of paper - this is a great way to
get an initial understanding of the system.
2. Describe the state(s) of the system.
Hint: What state details are needed to answer supermarket owner’s questions?
3. Describe the number of entities in the system in relation to the state(s).
Hint: A simple equation may be helpful in this description.
4. Assume there are four events in the simulation: passengers leaves the aircraft after landing
(FlightDisembarks), passenger arrives at queue (Arrival), passenger departs queue (Departure)
and attendants rotating for a break (for additional feature 2, RotateAttendants). For each event:
• describe how each event changes the state of the system.
• describe the new events that may be created as a result of this event.
5. Draw a state diagram, illustrating the possibly states of the system and how the state changes in response
to the various events.
6. Draw a flow chart illustrating your simulation structure.
To be clear, you will not be asked to submit written responses to the above but your understanding of these
points will be assessed via the milestone quiz (worth 5% of your course mark).
It is not possible to write a simulation code working through the above detail, so take your time here to get
some clear ideas about what you need to code before you start Part 2.
4
Part 2: Programming
In this part, you will start to program the model.
Reminder
The system to be modelled is described in page 1 of this document (“Scenario”)
Tasks for Part 2
Before starting the process of coding up your simulation, go back to your work from Part 1 and think about if
there are any further modelling details needed here. In particular you might like to carefully think about how to
model/implement the three “Additional features”.
The main task here is to write code to implement a discrete-event simulation of the system.
• The code should follow the style of some other codes presented in this course. You might like to use
these as a starting point, or perhaps find it easier to start from an empty file.
• The process you need to follow is outlined below under the heading Specification.
By the end of this part, you should have a working simulation that can output results.
In Part 3 you will test it and use it to create some data with a simulation harness.
As part of your assessment, you will be required to submit one .jl file with your code for implementing the
discrete-event simulation.
Specification
This week you will start coding your simulation. A good deal of the structure of the code is provided.
• This is to help you! There is a lot written below, but by following it carefully you will get a big start
towards developing your simulation.
• It ensure that everyone has a common starting point.
• It makes it easier to review and assess your progress by ensuring that everyone adopts the same basic
structure for their implementation.
The last point is important. Your mark is be based on automated testing of your code. Hence you must set up
your code in the manner given, paying particular attention to setting up the data types exactly as described
below, otherwise these test will fail and you will lose marks.
Here are the required specification details:
1. Filenames. Your code must be included in a single .jl files. These should be named:
• AirportOverseasPassports.jl
This should contain all of your data structures and functions. You will be provided with a file to run
this code AirportOverseasPassports_run.jl which will include the first file and run the simulation
for a set of parameters.
2. You should use the standard packages that you have been using in this course.
These include:
• DataStructures
• Distributions
• StableRNGs
• CSV
You may wish to use a small set of additional packages such as Dates or Printf.
Do not use any packages other than these or those that have been discussed in the course.
3. Your code must specify three data structures:
abstract type Event end
mutable struct Passenger
...
5
mutable struct State ...
Each will contain fields as required. The state structure should contain any queues or lists required, for
instance, the event list. More detail about each follows.
4. The abstract type Event will have the following subtypes:
• FlightDisembarks . . . an aircraft lands and unloads passengers
• Arrival . . . a passenger arrives at the queuing system
• Departure . . . a passenger finish their passport check and leaves
• RotateAttendants . . . the counter attendants take a break
Each subtype of Event must be a mutable struct and must contain the following fields (with the
types indicated):
• FlightDisembarks
– id . . . an integer valued event ID number (Int64)
– flight_id . . . the ID of the flight (Int64)
– no_passengers . . . the number of passengers from the flight that will be processed by the
queuing system, or nothing if the flight has not yet unloaded (Union{Nothing,Int64})
• Arrival
– id . . . an integer valued event ID number (Int64)
– flight_id . . . the ID of the passenger’s flight
– disembark_time . . . the time the passenger’s flight was unloaded (Float64)
– passenger_id . . . an integer valued passenger ID number, or nothing if the event does not
yet have a customer allocated (Union{Nothing,Int64})
• Departure
– id . . . an integer valued event ID number (Int64)
– passenger_id . . . the ID of the departing passenger (Int64)
– counter_id . . . the counter that serviced that serviced the passenger, or nothing if they
have not yet been served (Union{Nothing,Int64})
• RotateAttendants
– id . . . an integer valued event ID number (Int64)
– odd_attendants . . . true if odd numbered counters are rotating, false if even numbered
counters are rotating (Bool)
You may optionally define constructor functions for each of these above subtypes (to initialise some fields
with nothing or a particular value as appropriate).
5. The data structure Passenger should contain fields to record important event times in the lifetime of
the passenger. These are
• id . . . an integer valued customer ID number (Int64)
• flight_id . . . the ID of the passenger’s flight (Int64)
• disembark_time . . . the time the passenger’s flight was unloaded (Float64)
• enter_primary_time . . . the time the passenger entered the primary queue (Float64)
• enter_secondary_time . . . the time the passenger entered the primary queue (Union{Float64,
Nothing})
• start_service_time . . . the time the passenger starts service (Union{Float64, Nothing})
• end_service_time . . . the time the passenger ends service (Union{Float64, Nothing})
• secondary_id . . . the ID of the passenger’s allocated secondary queue (Union{Int64, Nothing})
• counter_id . . . the ID of the counter the passenger was served by (Union{Int64, Nothing})
• attendant_rotated . . . true if the attendant rotated during service, false if not (Bool)
Initially unknown values above should be set to nothing when the Passenger is created. Similarly,
attendant_rotated should be initialised as false.
6. The data structure State will contain an event list (priority queue), queues for all resources in the system
and a few other details. These must be
• time . . . the current system time (Float64)
• event_list . . . the list of scheduled event (PriorityQueue{Event,Float64}, here priority is
the time of the event)
• primary_queue . . . queue of passengers waiting in the primary queue (Queue{Passenger})
• secondary_queues . . . vector of queues of passengers waiting in the secondary queues
(Vector{Queue{Passenger}})
6
• in_service . . . vector of passengers currently being served, or nothing if there is no passenger
at a given counter (Vector{Union{Passenger,Nothing}})
• n_entities . . . a counter of the number of entities in the simulation so far (Int64)
• n_events . . . a counter of the number of events in the simulation so far (Int64)
• n_flights . . . a counter of the number of flights that have unloaded passengers (Int64)
• n_open_counters . . . the number of currently open counter (Int64)
The constructor function for State should initialise all queues with empty queues of the correct type,
time to 0.0 and the counters to 0.
7. Parameters
Your code should have a data structure struct Parameters for passing parameters as given in the
below table
parameter
type description
seed Int64 random seed for the simulation
min_counters Int64 minimum number of counters
max_counters Int64 maximum number of counters
secondary_queue_length Int64 length of the secondary queues
mean_interflight Float64 mean time between planes unloading
min_no_passengers Int64 minimum number of passengers from plane to queue
max_no_passengers Int64 maximum number of passengers from plane to queue
min_passenger_transit_time Float64 minimum time to get from plane to queuing system
max_passenger_transit_time Float64 minimum time to get from plane to queuing system
min_service_time Float64 minimum time for passenger to complete service
expected_service_time Float64 expected time for passenger to complete service
final_time Float64 the final time for the simulation
attendant_rotation_interval Float64 the time between attendant rotations
attendant_rotation_time Float64 the time it takes for attendants to rotate
secondary_rush_time Float64 waiting time for a passenger to go to the next available counter
helpful_attendants Bool counter will serve passenger from outside their secondary queue
Note some of these parameters are important to implementing some of the additional features:
• Additional feature 1: min_counters and max_counters; feature switched off if these are equal.
• Additional feature 2: attendant_rotation_interval and attendant_rotation_time; feature
can be switched off if the interval is set to be greater than the total simulation time.
• Additional features 3: secondary_rush_time and helpful_attendants; feature switched off if
helpful_attendants is false.
8. Random number generators
Your code will use three random number generators. Store these as functions in a data structure struct
RandomNGs. For convenience, also store here a function that returns the resolution time. The code to
define this data structure is as follows
struct RandomNGs
rng::StableRNGs.LehmerRNG
interflight_time::Function
no_passengers::Function
transit_times::Function
service_time::Function
end
You should define a constructor function with
function RandomNGs(P::Parameters)
that takes the parameters structure as input and returns the random number generator and the four
functions. Initialise the random number generator as follows
rng = StableRNG( P.seed )
The four functions should similarly use variables from the parameters structure, and be consistent with
the modelling assumptions given earlier in this document.
7
9. Initialisation function
Your code have an initialise function that takes as input the parameters of the system and returns
an initial system state and creates the random number generators you are going to use.
The initialisation function should also create a new system state and inject an initial FlightDisembarks
at time 0.0. If you are implementing additional feature 2 the function should add an initial
FlightDisembarks at t=P.attendant_rotation_interval (this is 30 minutes in the example output).
The function should return the system state and the random number structure.
function initialise(P::Parameters)
R = RandomNGs(P)
system = State(P)
# add an arrival at time 0.0
t0 = 0.0
system.n_events += 1
system.n_flights += 1
enqueue!( system.event_list, FlightDisembarks(system.n_events,system.n_flights),t0)
# add the first attendant rotation
system.n_events += 1
enqueue!( system.event_list, RotateAttendants(system.n_events,true),P.attendant_rotation_interval)
return (system, R)
end
All you need to do here is copy and paste the above function into your code.
10. Update functions (overall)
Your code must have a set of update! functions with signatures:
function update!( S::State, P::Parameters, R::RandomNGs, E::SomeEvent )
Each update function should process one of your event types so you will need one function per event
type.
Each update! function should modify the state S appropriately, including
• update any state variables
• allocate a passenger to the event (if appropriate)
• add any new events created from this one to the event list
• move entities between the various queues as appropriate (for example, primary to secondary).
These functions must not have side effects. That is, they should not write out any information to files,
or interact with global variables. However, your functions may throw an error if the input is invalid.
Some additional details of the behaviour of these function can be inferred from the provided example
output files.
11. Update function (for Arrival)
This function should process an Arrival event in a manner consistent with the system description and
assumptions.
As in example codes from the course, you may find it helpful to write an additional function to use here
to move a customers around the various queues or into service (common to this and the Departure
update function).
12. Update function (Departure)
This function should process a Departure event in a manner consistent with the system description and
assumptions.
13. Update function (FlightDisembarks)
This function should process a FlightDisembarks event in a manner consistent with the system
description and assumptions.
14. Update function (RotateAttendant)
This function should process a RotateAttendant event in a manner consistent with the system description
and assumptions.
8
15. State-based and entity-based output files
Your code must output two CSV files. The files should both begin with some metadata and parameters
(you can include comments preceded with a #). These should be stored in subfolders named for the
random seed and some parameter values.
• The first file state.csv should contain a time-ordered list of all events that are processed in the
simulation.
This should be written from the point of view after the event. For instance, you should report the
system that an arriving passenger sees immediately after their arrival.
The CSV file should have columns titled:
event_ID,time,event,upcoming_arrivals,primary_length,secondary_lengths,in_service,n_total,n_open_counters
Here upcoming_arrivals should be a count of Arrival events in the event_list, and n_total is
the total number of people checking out, including those in service and those with a problem. See the
provided example files for formatting of the vectors in secondary_lengths and in_service.
• The second file entities.csv should contain a list of all entities that have completed service. The
CSV file should have columns titled (note the header should be one line as in the example output):
```
passenger_id,flight_id,disembark_time,enter_primary,enter_secondary,start_service,end_service,secondary_id,...
counter_id,attendant_rotated
```
You will need to write and construct these CSV files line by line. This is most easily done with println
statements, but you may use a package like CSV or Printf if you prefer.
16. Run function(s)
You code should contain a top-level function run_checkout_sim with the signature
run_checkout_sim(P::Parameters)
This function should take the parameters structure as its input. It should then
• initialise the system state,
• create the output files (and subfolders)
• write metadata, parameters and the header to the output files
• run the simulation by calling the run! function (see below)
• close the output files
The run! should have the signature
run!(system::State, P::Parameters, R::RandomNGs, fid_state::IO, fid_entities::IO)
This function should run the main simulation loop up to the final time given in the Parameters. It
should write output to the state.csv file for all events and to the entities.csv for Departure events
only. It should also update the system time before the update! function is called.
17. Code style
Your code must be written with good style. See Julia’s style guidelines for further information.
In particular:
• use comments (in English) efficiently and effectively
• store commonly used code as functions
9
Further Julia hints on PriorityQueue
When a problem occurs, the depature time of the customer will be extended. That is, you need to change the
time, i.e. the priority, of the corresponding departure event.
You can modify the priority of an object in a priority queue in Julia as follows:
using DataStructures
pq = PriorityQueue()
pq["a"] = 10; pq["b"] = 5; pq["c"] = 7;
pq
Output:
PriorityQueue{Any, Any, Base.Order.ForwardOrdering} with 3 entries:
"b" => 5
"c" => 7
"a" => 10
To change the priority of an object:
pq["a"] = 0 # change the priority of "a"
pq
Output:
PriorityQueue{Any, Any, Base.Order.ForwardOrdering} with 2 entries:
"a" => 0
"b" => 5
"c" => 7
Note that the order of the items in the queue has now changed. However, be careful here since the above
approch would not update the time stored in the Event structure.
Additionally, you may find it useful to iterate over the keys of a PriorityQueue as follows (continuing from
the above code):
for k in keys(pq)
if k == "c"
pq[k] = 3
end
end
pq
Output:
PriorityQueue{Any, Any, Base.Order.ForwardOrdering} with 2 entries:
"a" => 0
"c" => 3
"b" => 5
This last piece of code may seem overly complex for this example, but can be adapted for the purposes here.
Additionally, you may find it helpful to use the dequeue_pair!, peek and delete! functions for priority
queues. Try using these on the above example as follows:
key, priority = dequeue_pair!(pq) # dequeue, return key and priority
peek(pq) # look at the top of the queue, without removing
delete(pq, "c") # delete an item with a given key
10
Part 3: Verification and testing
Note that no marks are directly associated with the activities described below. This is all about
testing your code thoroughly to ensure it works as expected!
In this part, you will test your implementation to make sure it can output results and is consistent with some
provided output.
Tasks for Part 3
Although you might not need to modify the code in AirportOverseasPassports.jl, you may need to modify
it in response to bugs found in testing.
The main tasks will be to verify that your code works correctly (as described in Module 3: Verification), and to
construct a small simulation harness in which to run a set of comparison simulations (as described in Module 4:
Tools to Automate Simulation). Following these steps will help to detect any issues/bugs and ensure you get
the maximum number of marks for the code you have written.
1. Test and verify your code.
Compare the output of your code to the provided sample outputs:
• state_all.csv and entities_all.csv . . . output for the simulation with all additional features
implemented (parameters in metadata)
• state_basic.csvandentities_basic.csv‘ . . . output for simulation with no additional features (param eters in metadata)
If you have implemented your code exactly as specified, and used the same seed and random number
generation, your output should look very, very similar (the only differences should be in details such as
numbers of decimal points, white-spacing or ID numbers).
However, your code may result in some differences. Some are important and others less so. You need to
be quite analytical to understand which. That is, what differences occur because of a minor change in
the order of actions, and what differences are caused by bugs. If there are differences, you should create
some of your own tests to understand what is different from the code that produced the above results.
2. Create a test harness that will run your code for 100 different seed values ranging from 1–100. This
could simply be a script that looped over these values.
This will create 100 versions of the simulation, so by selectively examining the output and/or computing
summary statistics you can get a better sense of how well your simulation functions. In particular,
changing the seed can reveal “edge cases”, that is a situation that occurs rarely (and might not have
been in the sample output), which may lead to an error in your code.
Additionally, from these outputs, you could perform some statistical analysis to inform the airport’s
management about their questions. Note you do not need to answer these questions as part of this
assessment (that process will be part of the Project Report for a different problem).
11
Detailed rubric
You will be assessed on the following components of your work. [80 marks total]
• Basic functionality: code implements the basic functionality of this queuing system, as per the specification.
[40 marks]
• Additional feature 1: code implements this feature correctly. [12 marks]
• Additional feature 2: code implements this feature correctly. [12 marks]
• Additional feature 3: code implements this feature correctly. [12 marks]
• Code style: submission meets general style guidelines for good Julia code. [4 marks]
The marking scheme for each component is given in detail below.
Basic functionality

数据科学书单:2022年能力跃迁型阅读路线图 数据科学不是知识堆砌,而是从问题定义、代码实现到业务归因的系统性能力构建。理解统计学习原理与机器学习模型本质,是跨越‘能跑通’到‘可解释、可交付’的关键断层;而免费资源有效性、理论-代码-业务三阶对齐,正成为现代数据工程师的核心筛选标准。本书单聚焦真实工业场景中的认知缺口——如AB测试指标设计偏差、模型上线后归因失效、特征工程与业务约束错位等,通过能力缺口反推法,匹配覆盖pandas 2.0、scikit-learn 1.3、Hugging Face、DVC等2022主流技术栈的实战读物,助力读者在金融风控 阅读详情

相关推荐

面向逻辑思维的程序设计方法概论

本文提出面向逻辑思维的程序设计方法(LOPD),以七层分析模型为核心框架,将智能系统划分为基因层、肢体层、感觉层、神经层、个体层、社会层和文明层。该研究通过形式化定义和定理证明建立了LOPD的数学基础,并提供了工程实现模板。实验表明,LOPD在类人机器人开发中显著降低了系统耦合度(47.3%)、代码侵入量(76%)和开发时间(44.4%)。研究还提出了"冯胤清测试"作为智能系统逻辑完备性的评估框架,填补了传统面向对象编程在智能系统开发中的方法论局限。

peakk918的博客 438

Python编程从入门到实践:手把手教你写出第一个程序!!!

当年我学编程时在C++和Python之间纠结了好久。# Python版Hello Worldprint("你好,世界!")# C++版Hello World(密集恐惧症慎入!return 0;(灵魂拷问):哪个看着更想学?反正我当时果断选了Python!(后来才知道这语言还能用来写网站、做数据分析、搞人工智能…)还记得我第一次用Python成功抓取网站数据时,兴奋得半夜三点给室友发消息(结果被拉黑了…)。编程最神奇的地方在于——你写的每一行代码,都在创造一个新世界。")

progalchemist的博客 908

【信息科学与工程学】【产品体系】第二十篇 CDN网络 04

国内 CDN 厂商在多租户隔离场景下实现 μ_c 求解与 LRU 淘汰的结合,公开资料中并未确认任何一家直接部署了 AdaptSize 原版的完整组合。最接近的公开生产级方案是腾讯 CDN 的LACA,通过异常租户检测 + 局部 MRC + DP 搜索实现轻量多租户缓存分配,但其不直接求解 μ_c,而是通过调整租户配额 K_t 间接控制。外层(LACA 式):异常租户检测 → 局部 MRC → DP 搜索租户配额 K_t中层(AdaptSize 式)

weixin_49199313的博客 158

零基础入门数据科学:通过GitHub加速计划掌握Python与机器学习核心技能

GitHub加速计划(项目路径:gh_mirrors/co/Courses-)是一个专为数据科学初学者设计的优质学习资源库,汇集了多门顶级课程的测验答案与作业解析。无论你是编程新手还是希望转行数据科学的职场人,这个项目都能帮助你系统掌握Python编程、数据分析与机器学习的核心技能,轻松开启数据科学之旅。 ## 为什么选择GitHub加速计划? 数据科学领域正以惊人的速度发展,而系统学习资源的

gitblog_00366的博客 850

SpringBoot+Vue+MySQL 高校学科竞赛平台 完整可运行版(源码+文档)

本项目基于SpringBoot+Vue+MySQL构建高校学科竞赛管理平台,覆盖学生、教师、领队教师、管理员四大角色,实现竞赛发布、报名、刷题、评分、公示等全流程闭环管理。系统架构清晰,技术主流,配套完整源码、数据库脚本、万字论文、开题报告、答辩PPT及部署文档,支持一键运行,适用于毕业设计、课程设计及院系二次开发,真正实现“开箱即用”。

招风的黑耳优快云 324

RGB接口电容触摸屏驱动(一)模块介绍

RGB接口电容触摸屏驱动(一)模块介绍

杰克拉力船长个人博客 7883

GOTO 语句有害论 | 反对 GOTO 语句的理由

……

u013669912的博客 1882

REST-meta-MDD Data总结

sMRI数据使用:nwc1、nwc2、nwc3(同样数据集相关论坛中有相关信息指向需要使用wc1、wc2、wc3)多方咨询与讨论后决定使用nwc数据,这里说明wc数据相对wc数据要大的多如wc1的大小为1.33GB,而nwc1的数据却有6.90GB。VBM文件:/REST-meta-MDD/Sharing/REST-meta-MDD-VBM- phase1 -Sharing.tar.gz。1、Excel中的表型信息:1-男,2-女;-9999或空白表示缺少数据。

2404_88295660的博客 1542

大型CAx(CAD/CAE/CAPP/CAM)工业软件开发中的关键组件

通过对FreeCAD、SALOME等多款代码的分析研究,发现这些软件在架构设计、模块实现等方面,存在许多相似(同)的技术思想。因此,有必要对这些共性、主流的技术予以总结分析。

国产CAx(CAD/CAE/CAM)软件研发 1万+

PX4 磁罗盘干扰分析

无人机上的电机电流会干扰无人机上搭载的磁罗盘,PX4官方提供了一些方式,通过分析飞行日志,判断电机是否对磁罗盘有严重影响。

Zecet的博客 3359

ENVI5.6 自动化流程:GF系列卫星影像批处理与质量优化

本文详细介绍了如何利用ENVI5.6构建针对GF-2、GF-6、GF-7系列卫星影像的自动化批处理流水线。通过配置Batch Processing工具,实现从正射校正到图像融合的全流程批量处理,并分享参数设置、质量监控与故障排查的实战经验,旨在显著提升海量遥感影像的处理效率与成果质量。

efc1234567的博客 604

GLM-5 论文理解记录

GLM-5 论文阅读记录

qq_42563807的博客 662

qt医疗信息系统(HIS)

**UI 组件**: QWidget、QTextBrowser、QTableWidget、QGraphicsView 等。- **网络通信**: Qt Network (TCP/IP)- **DICOM 处理**: DCMTK 3.6.7。- **数据库**: SQLite (轻量、跨平台)**数据库文件**: `hospital.db`- **开发框架**: Qt 6 (C++)- 医疗影像 (DICOM) 查看器。**医疗影像 (DICOM) 查看器****电子病历 (EMR) 浏览器**

寒寒豆豆软件公司的博客 340

图学习会议 2024 笔记(四)

在本教程中,我们将学习几何生成模型。我们将从现代生成模型的基础知识开始,然后深入探讨如何将几何概念融入这些模型,最后学习如何实际构建和实现几何生成模型。本教程旨在为初学者提供一个清晰、实用的入门指南。在本节中,我们一起学习了如何利用流匹配框架构建生成模型。其核心步骤是:给定目标分布 ( Q ) 的样本,构建一个概率路径 ( p_t ),使其在 ( t=0 ) 时为源分布,在 ( t=1 ) 时近似 ( Q )。通过构建条件流(如仿射条件流)来定义该路径。

龙哥盟 77

171、运动控制中的标定:摩擦力与死区补偿标定

摘要(149字) 运动控制系统中的摩擦力与死区补偿是提升精度的关键。摩擦力分为静摩擦、库仑摩擦和粘滞摩擦,其中Stribeck效应是低速抖动的主因;死区则表现为控制信号的无效区间。有效标定方法包括恒速测试(摩擦力)和斜坡响应法(死区)。补偿策略需采用分段前馈和动态调整,避免过度补偿导致振荡。实践中要注意机械状态检查、补偿量限幅,并定期重新标定。硬件升级配合算法补偿才能实现最优控制,标定工作应优先于PID参数调整。

m0_50546716的博客 232

31、编程中的循环控制:从基础到应用

本文深入探讨了编程中的循环控制结构,涵盖从基础概念到实际应用的多个方面。内容包括预测试与后测试循环的区别、For...Next语句的语法与执行流程、计数器变量的作用域及循环条件的控制机制,并通过太空飞船、学生成绩统计等实例演示了循环在真实场景中的使用。同时提供了常见错误分析、优化建议和拓展应用思路,帮助读者全面掌握循环结构的编程技巧。

swift5iosmith的博客 39

InnoDB 内存结构总览:Change Buffer、AHI 与 Log Buffer

本文系统梳理InnoDB内存结构中的ChangeBuffer、Adaptive Hash Index(AHI)与LogBuffer。ChangeBuffer缓存二级索引页不在内存时的变更,减少随机IO,仅在页加载时合并;聚簇索引修改立即执行,因数据本身不可延后。AHI基于高频等值查询自动构建哈希索引,加速定位,仅支持等值操作。LogBuffer为redo log内存缓冲,配合磁盘日志实现崩溃恢复。三者均服务于性能优化,其中ChangeBuffer与AHI共享BufferPool空间,而LogBuffer独立

bksczm的博客 309

2026.3.21:Ubuntu26.04 apt换国内源 清华源 阿里源 中科大源 163源

作为 LTS 版本,它会有 5 年的常规维护和安全更新。如果订阅 Ubuntu Pro,还能享受额外7年的支持。也就是说, Ubuntu Pro将享有长达 12 年的系统更新保障!接下来,我们将重点介绍 Ubuntu 24.04 LTS 中那些值得关注的新特性,以方便你决定是否进行升级。Ubuntu 24.04 LTS,代号 「Noble Numbat」,即将与我们见面!Canonical 已经宣布, Ubuntu 24.04 LTS。源文件地址 已经更换为。

拥抱具身智能,昇腾Ascend C 9080

信创环境下PageOffice文档控件适配与实践

信创适配做到文档控件这一层,拼的已经不是"有没有国产版本",而是同一个功能在两类终端上是否真的等价。等价的标准很具体:同一次点击能得到同样的结果,同一份公文能得到同样的版式,同一个项目不需要维护两套代码。这背后是三件并不轻松的工作:服务端用一套接口同时支撑两类终端,客户端把两种系统与四种芯片的安装包分发清楚,文档内核层由产品侧跟着 WPS 的版本走。浏览器这一层的压力,则被收进了产品自己的窗口里——升级节奏由产品掌握,不再交给运气。

zi_wu_xian的专栏 336

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

第三篇 第 6 课

前置:第三篇第 1 课(stdx 引入),第二篇第 1 课(std.regex)。环境:仓颉 SDK 1.2.0。本文所有代码与输出均逐行实测。

weixin_41618057的博客 557

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 614

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

pcl2启动器下载(Minecraft PCL2 启动器 最新版 安装与使用说明)

摘要:PCL2(Plain Craft Launcher 2)是一款面向 Minecraft 的第三方启动器,支持正式版与快照版本管理、模组与整合包安装、Java 运行时自动匹配,绿色免安装、双击即可运行。适合在 Windows 上玩单机整合包、需要多版本共存或离线启动的用户使用

2611_96675819的博客 226

spring boot 4集成SQLLite,及其SQLLite的建库

spring boot 4集成SQLLite,及其SQLLite的建库

weixin_41463944的博客 231

Java 集合容器高频面试题全解:HashMap 树化阈值、1.7 死循环与 ConcurrentHashMap 演进(2026 招聘 JD 真题复盘)

HashMap 树化阈值 8 的泊松分布依据、退化阈值 6 的防抖设计、JDK 1.7 头插成环死循环的排查与修复、1.8 尾插后为何仍线程不安全、ConcurrentHashMap 放弃分段锁的原因与 ForwardingNode 协作扩容、computeIfAbsent 死锁陷阱、大集合找重复的场景题选型,附三层追问链自测。题目来源为 38 期公开招聘 JD 样本与字节、拼多多、建行、美团、快手公开面经。

蒙眼过河 427

spdlog 同步日志库使用详解

spdlog是一个轻量级 C++ 日志库,支持同步日志、异步日志、多线程日志、日志文件轮转和自定义日志格式。对于嵌入式 Linux 应用开发,我建议先使用。它可以帮我们完成:日志级别过滤。时间戳和线程 ID 输出。日志格式化。终端和文件输出。多线程安全写入。日志文件按大小或时间轮转。我们不需要自己实现互斥锁、文件写入、日志格式化和轮转等底层功能。

zengjiajun2006的博客 1124

JavaSE通关手册:数据类型与变量

代码无需额外处理,编译时编译器自动完成转换。

xys_678的博客 236
上一篇: COMP0035 Data exploration and preparation
下一篇: Design Space Exploration
wx____codinghelp
博客等级 码龄2年 771粉丝 115原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值