Format of bbox

Currently, we use a ndarray whose shape is (5,) for the format of bbox.
https://github.com/pfnet/chainercv/blob/master/chainercv/transforms/bbox/flip_bbox.py#L13
However,  it has two cons.

We have to use a magic index 4 when we want to access the label_id.
label_id is always integer. But coordinates sometimes take float values.

A structured array seems a good solution for me.
bbox_dtype = [('rect', 'f8', 4), ('label', 'u4')]
bbox = np.array(((1.2, 3.4, 4.5, 5.6), 3), dtype=bbox_dtype)

bbox['rect']  # array([ 1.2,  3.4,  4.5,  5.6])
bbox['label']  # array(3, dtype=uint32)

label_id is always integer. But coordinates sometimes take float values.

I understand that this is a problem.
Currently, this is handled by making a bounding box to be float type (e.g. https://github.com/pfnet/chainercv/blob/master/chainercv/datasets/pascal_voc/voc_detection_dataset.py#L100), and asking user to convert it to integer type whenever a user needs integer data.
Personally, I do not like to add additional type (bbox_dtype = [('rect', 'f8', 4), ('label', 'u4')]), as it would be cumbersome for users to import or copy this dtype project every time to their own projects. Also, I am not sure if this dtype is a standard convention in the community or not.
How about changing type of tuple returned by Dataset?
Currently, it returns
img (CHW)  and bbox (R, 5)
Instead,
img (CHW),   bbox_no_label (R, 4),   and  Label (R,)

Also, it is important that DetectionVisReport is easy enough for users to use.
http://chainercv.readthedocs.io/en/latest/reference/extensions.html#chainercv.extensions.DetectionVisReport

I understand why you do not want to use a structured array. I agree that an additional dtype is a little cumbersome.
As you suggested, to return img (CHW), bbox_no_label (R, 4), and Label (R,) seems a better solution.

By defining bbox as a set of four coordinates, we can replace the name bbox_no_label with bbox.
This definition is natural because bbox of Pascal VOC does not contain class information.

Does img (CHW), bbox (R, 4), label (R,) sound good to you?

Yes. It looks good to me.

OK.
I will change specification of bbox related functionalities.

@furushchev
What do you think about this proposal?

LGTM because:

For resizing bounding box according to image size, (R, 4) would be better.
labels are integer, values of bbox may be float.

I find the same issue in keypoint.
https://github.com/pfnet/chainercv/blob/master/chainercv/transforms/keypoint/resize_keypoint.py#L4
vaild is always bool while x and y may be float.

Solved #47.


Test: UT140701 ; using stdstar=''

>>> spectra.autoreduce('objlist.txt','flatlist.txt','biaslist.txt','henear.0018r.fits',stdstar='')
Running HeNeAr_fit function.
Doing automatic wavelength calibration on HeNeAr.
Note, this is not very robust. Suggest you re-run with interac=True
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/astro/users/twilki/research/mdwarf/spectra/spectra.py", line 1190, in autoreduce
    display=displayHeNeAr, tol=HeNeAr_tol, fit_order=HeNeAr_order)
  File "/astro/users/twilki/research/mdwarf/spectra/spectra.py", line 833, in HeNeAr_fit
    popt,pcov = curve_fit(_gaus, xline, yline, p0=pguess)
  File "/astro/apps6/anaconda/lib/python2.7/site-packages/scipy/optimize/minpack.py", line 586, in curve_fit
    raise RuntimeError(msg)
RuntimeError: Optimal parameters not found: Number of calls to function has reached maxfev = 1000.

Not sure what the issue is here. Looks like it doesn't like the curve fit function?

This is a failing of the terrible HeNeAr auto-fit, which works especially bad on DIS-low... I'm not quite sure why this particular crash happened, but it's probably making a bad guess as the wavelength of a HeNeAr line near one side of the chip.
I vote we don't fix this, because the HeNeAr auto is so shitty it's not worth fixing.
Suggest you set HeNeAr_interac=True, which I have just switched to the default setting. Identify as many lines as you can, and it will save an output file that stores the locations of the lines you identified. On subsequent runs of this night, you can then use these previous identifications by setting HeNeAr_prev=True


adds default port to sparkswap

Description
This PR adds a default port to rpc addresses specified on the cli.
Example:
sparkswap wallet balance --rpc-address my.address.com is the equivelant as sparkswap wallet balance --rpc-address my.address.com:27492
If a port is specified in the url, we will use that specific port. This change is also applicable to the address used in the configuration file. A port must be explicitly specified in configuration.
Related PRs
List related PRs if applicable
Todos

[x] Tests
[n/a] Documentation
[x] Link to Trello

 Default rpc port number when specifying address for --rpc-address on cli


EAS update Stuck at uploading

Build/Submit details page URL
No response
Summary
Running eas update get stuck at the uploading phase.
Stuck at:
Uploading (49/51)
Managed or bare?
Managed
Environment
npx expo-env-info
expo-env-info 1.0.5 environment info:
    System:
      OS: macOS 13.2
      Shell: 5.8.1 - /bin/zsh
    Binaries:
      Node: 18.14.0 - ~/.nvm/versions/node/v18.14.0/bin/node
      Yarn: 1.22.19 - ~/.nvm/versions/node/v18.14.0/bin/yarn
      npm: 9.6.4 - ~/.nvm/versions/node/v18.14.0/bin/npm
    SDKs:
      iOS SDK:
        Platforms: DriverKit 22.4, iOS 16.4, macOS 13.3, tvOS 16.4, watchOS 9.4
    IDEs:
      Android Studio: 2022.1 AI-221.6008.13.2211.9619390
      Xcode: 14.3/14E222b - /usr/bin/xcodebuild
    npmPackages:
      @expo/webpack-config: ^0.17.2 => 0.17.4
      expo: ~47.0.12 => 47.0.14
      react: 18.1.0 => 18.1.0
      react-dom: 18.1.0 => 18.1.0
      react-native: 0.70.8 => 0.70.8
      react-native-web: ~0.18.9 => 0.18.12
    npmGlobalPackages:
      eas-cli: 3.9.0
      expo-cli: 6.3.2
    Expo Workflow: managed

expo doctor
 Didn't find any issues with the project!

Error output
No response
Reproducible demo or steps to reproduce from a blank project

✔ Exported bundle(s)
missingAsset {
  fileExtension: '.bundle',
  contentType: 'application/javascript',
  path: '/Users/filippofinke/Desktop/Progetti/C4110Z.1-2023-Team-5/dist/bundles/ios-ccfe2a3b3c5f3ffbc7d4818269fd3f8c.js',
  storageKey: 'XXXXXXXXX'
}
missingAsset {
  fileExtension: '.bundle',
  contentType: 'application/javascript',
  path: '/Users/filippofinke/Desktop/Progetti/C4110Z.1-2023-Team-5/dist/bundles/android-f07e7edb15136495e505f6d7e94ad63d.js',
  storageKey: 'XXXXXXXXXXXXXX'
}
⠧ Uploading (49/51)

It is stuck uploading these bundles files.

I have the same actually, don't think it is the upload speed, but maybe still related to the size of the bundle?
.js file is 30mb and .map is 14.3mb

@filippofinke can you share:

your package.json
size of your bundle (ie) ls -lh /Users/filippofinke/Desktop/Progetti/C4110Z.1-2023-Team-5/dist/bundles/ios-ccfe2a3b3c5f3ffbc7d4818269fd3f8c.js

{
  "name": "c4110z.1-2023-team-5",
  "version": "1.0.0",
  "main": "node_modules/expo/AppEntry.js",
  "scripts": {
    "start": "expo start",
    "android": "expo start --android",
    "ios": "expo start --ios",
    "web": "expo start --web",
    "test": "jest --watchAll",
    "deploy": "cd appwrite && node deploy.js"
  },
  "jest": {
    "preset": "jest-expo"
  },
  "dependencies": {
    "@expo/vector-icons": "^13.0.0",
    "@expo/webpack-config": "^0.17.2",
    "@gorhom/bottom-sheet": "^4.4.5",
    "@miblanchard/react-native-slider": "^2.3.1",
    "@react-native-async-storage/async-storage": "~1.17.3",
    "@react-native-community/datetimepicker": "6.5.2",
    "@react-navigation/bottom-tabs": "^6.0.5",
    "@react-navigation/native": "^6.0.2",
    "@react-navigation/native-stack": "^6.1.0",
    "@reduxjs/toolkit": "^1.9.3",
    "@turf/boolean-point-in-polygon": "^6.5.0",
    "@turf/helpers": "^6.5.0",
    "expo": "~47.0.12",
    "expo-asset": "~8.7.0",
    "expo-barcode-scanner": "~12.1.0",
    "expo-constants": "~14.0.2",
    "expo-font": "~11.0.1",
    "expo-linking": "~3.3.1",
    "expo-location": "~15.0.1",
    "expo-notifications": "~0.17.0",
    "expo-splash-screen": "~0.17.5",
    "expo-status-bar": "~1.4.2",
    "expo-system-ui": "~2.0.1",
    "expo-updates": "~0.15.6",
    "expo-web-browser": "~12.0.0",
    "i18next": "^22.4.13",
    "native-base": "^3.4.25",
    "openfoodfac-ts": "^0.3.1",
    "react": "18.1.0",
    "react-dom": "18.1.0",
    "react-i18next": "^12.2.0",
    "react-native": "0.70.8",
    "react-native-autocomplete-dropdown": "github:filippofinke/react-native-autocomplete-dropdown",
    "react-native-gesture-handler": "~2.8.0",
    "react-native-maps": "1.3.2",
    "react-native-onboarding-swiper": "^1.2.0",
    "react-native-open-maps": "^0.4.0",
    "react-native-reanimated": "~2.12.0",
    "react-native-safe-area-context": "4.4.1",
    "react-native-screens": "~3.18.0",
    "react-native-svg": "13.4.0",
    "react-native-web": "~0.18.9",
    "react-redux": "^8.0.5",
    "redux-persist": "^6.0.0",
    "expo-image-picker": "~14.0.2",
    "@react-native-community/netinfo": "9.3.5"
  },
  "devDependencies": {
    "@babel/core": "^7.12.9",
    "@types/react": "~18.0.24",
    "@types/react-native": "~0.70.6",
    "@types/react-native-onboarding-swiper": "^1.1.4",
    "jest": "^26.6.3",
    "jest-expo": "~47.0.1",
    "react-test-renderer": "18.1.0",
    "typescript": "^4.6.3"
  },
  "private": true
}

ls -lh /Users/filippofinke/Desktop/Progetti/C4110Z.1-2023-Team-5/dist/bundles/ios-fe8149e88fd47d0f5370c581bea091e1.js
-rw-r--r--  1 filippofinke  staff    25M Apr 19 13:14 /Users/filippofinke/Desktop/Progetti/C4110Z.1-2023-Team-5/dist/bundles/ios-fe8149e88fd47d0f5370c581bea091e1.js

I'm also having this problem since a week

@filippofinke thank you for sharing. We will work on fixing this

We've found the problem and deployed a fix on our servers that should allow you to upload large assets now. Could you try running the update command again to see if it runs successfully? I'll keep this issue open a bit longer so folks can report back.
@filippofinke @AronBe

Can confirm, it is now working!
✔ Exported bundle(s)
✔ Uploaded 2 app bundles
✔ Uploading assets skipped - no new assets found
✔ Channel: master pointed at branch: master
✔ Published!

Thank you 👍

Published on my side as well, thank you!!

Thanks for the speedy replies everyone :) Glad to know it works for you all now, closing this issue.


Add MvNormalMeanScalePrecision node

This PR adds MvNormalMeanScalePrecision that implements a multivariate normal distribution node with a "scaled" diagonal precision matrix, i.e.
N(y|x, γI) where γ ~ Gamma(a, b) and I is the identity matrix.
The main difference between this node and the MvNormalMeanPrecision is the update equation for the precision parameter. Unlike MvNormalMeanPrecision, which sends a message proportional to Wishart, the MvNormalMeanScalePrecision will send a Gamma-like message.
When defining the model, I expect the user to add this node in the following way, i.e.
...
τ ~ Gamma(1.0, 1.0) # prior
y ~ MvNormal(μ=ones(2), γ=τ)
...

Great @albertpod , thanks!


"Active" balance observer doesn't work on Solana

base version 0.4.0.
As per the title of the issue, when using the Active balance observer, balance updates are not triggered at all. Neither for earns nor spends.
When using Passive, the balance reduces when spending, but never goes back up when earning.
This issue only occurs when using the Solana blockchain. i.e. When using testMigration() and Environment.KinStellarTestNet.

a fix is currently being worked to resolve it. and will not require and update of the SDKs.

a fix is currently being worked to resolve it. and will not require and update of the SDKs.


Feature descriptions and common-gulp behavior

Allow descriptions to (optionally) be added for any task by passing a string description as the second argument to gulp.task. These can be displayed by calling gulp help or gulp ?.
Added an about task that displays the LK banner, biggulp version, and the license
Updated default common-gulp tasks:

gulp test now runs jshint, format, and coverage then exits
gulp test-and-exit now runs jshint before tests
gulp (default task) is still an alias to watch coverage

Other things:

Fixed call to renamed processhost method (this was a bug)
Fixed test and testOnce so they could be called with default spec paths (this was a bug)

@arobson This looks good to me....I haven't merged yet, though, b/c I you had been managing this one up until recently and didn't want to presume in case you'd like a chance to look as well...


Fixes for profile creation and rpc providers

Added retry logic for profile creation
Added http provider for parachain

We are not only calling create profile, we are also calling increase and decrease allowance, so i didn't want to retry those calls. If increase allowance fails it will probably be because user doesn't have enough funds, and we don't need to retry that call automatically until user add enough tokens to his wallet.


when restart nodeos，cleos wallet list shows no wallet?

I use the command below to start test network:
nodeos -e -p eosio --plugin eosio::wallet_api_plugin --plugin eosio::chain_api_plugin --plugin eosio::account_history_api_plugin
And I create a wallet, use command:
cleos wallet create -n test
I could find my wallet, use command:
cleos wallet list
then I stop the test network, use ctrl+c.
when I restart the test network, use cleos wallet list, there is no wallet list? why??

I think you forgot to re-open the wallet with 'cleos wallet open -n test'

Yes, it's a bit confusing that command only shows you open wallets. Not all wallets that exist / have been created. One you open the wallet it'll show up in the list. Note that an open wallet still needs to be unlocked ... unless you see a * after then name of the wallet, it's not unlocked.
./cleos wallet list
Wallets:
[
  "default *"
]

Thanks all, the problem has been solved.


fixed responsiveness of about section

Hello PA @Manaregr8
Fixed issue- #331
Note: space in right of text is still more but it will be fixed in another issue since it is connected with another section
When both of the PR will be merged it will automatically get fixed. THANKYOU.

@Manaregr8  It was assigned level 2, in this i have only fixed the about section not anything else, in another PR  which is assigned level 3 in which i have to fix "animation logo responsiveness" i am fixing the whole remaining page and its done too.

@Manaregr8 kindly review

responsive PR are more than 5. so downgraded few of them


[occm] No deterministc way of providing Node addresses

What happened:
We have been relying on the node-ip flag of Kubelet to specify the IPs the Nodes Addresses would contain. However, the external cloud provider does not support dual-stack addresses defined in the node-ip. The following error happens:
kubelet exited: failed to run Kubelet: dual-stack --node-ip \"....\" not supported when using a cloud provider"
While there is a KEP that will add support for that, it would be beneficial to instead rely on the provisioner of the resources to identify, which addresses the Nodes should use.
CCM already provides two options  that at first glance made sense to use, but seems to have drawbacks:

internal-network-name: This options uses the name of a Network to filter the addresses to provide. This becomes problematic because OpenStack allows to have multiple Networks with the same name in the cluster, so we could end up exposing Networks on the Node that are not meant to.
address-sort-order: Seems to only specify a preferable order of addresses to use and does really exclude addresses that are not meant to be exposed.

Are those drawbacks of those options valid? If yes, would it make sense to add support to only provide addresses from the Server's interfaces that are marked with a certain tag?
What you expected to happen:
CCM provides a deterministic way to define the addresses the Nodes should use.
How to reproduce it:
Deploy a dual-stack cluster with Kubelet not defining any node-ip and the Nodes having multiple interfaces attached.
Is this a BUG REPORT or FEATURE REQUEST?:
/kind bug

is this really bug or feature? In my opinion its missing feature

I also think this is a feature.
Whatever solution we settle on we expect to develop and test it ourselves. We'd like to discuss what folks are currently doing and what solutions others may have already come up with for the same problem.

/kind feature

cancel /kind bug

@MaysaMacedo: This thing sounds like something that got fixed?

This would be a nice improvement to have, but we decided to remain using node-ip from kubelet. So I will be closing this bug.

pushed wrong button

Looks like I'm not allowed to close as not planned, so I will let someone else handle it.


Pronunciation assessment - Extra words issue

Describe the bug
When using PronunciationAssessmentConfig with the referenceText "女は可愛いです" and then recoding "女と男は可愛いです" via microphone input, the recognized text in e.Result.Text is still "女は可愛いです", which makes it impossible to check if the recognized text matches the expected text.
To Reproduce
config = SpeechConfig.FromSubscription(getSubscriptionKey(), getSubscriptionRegion());
config.SetServiceProperty("punctuation", "explicit", ServicePropertyChannel.UriQueryParameter);
config.SpeechRecognitionLanguage = "ja-JP";
config.OutputFormat = OutputFormat.Detailed;

var configPronunciation = new PronunciationAssessmentConfig("女は可愛いです", GradingSystem.HundredMark, Granularity.Word, true);

stopRecognition = new TaskCompletionSource<int>();

using(var recognizer = new SpeechRecognizer(config, AudioConfig.FromDefaultMicrophoneInput()))
{
                configPronunciation.ApplyTo(recognizer);

                recognizer.Recognized += recognizedSentence;
                recognizer.Canceled += canceled;
                recognizer.SessionStopped += sessionStopped;

                await recognizer.StartContinuousRecognitionAsync().ConfigureAwait(false);
                Task.WaitAny(new[] { stopRecognition.Task });
                await recognizer.StopContinuousRecognitionAsync().ConfigureAwait(false);
}

Expected behavior
A way to identify that the recorded input doesn't match the expected text.
Version of the Cognitive Services Speech SDK
C# SDK 1.20.0
Platform, Operating System, and Programming Language

OS: Windows, Android
Hardware - x64, x86
Programming language: C#

Hi, @Nyankoo
Our API currently has constraint which can only recognize the words that appear in reference text.
e.g. referenceText "女は可愛いです", recording "女は可愛いです可愛", then the second "可愛" will be recognized.
Thanks,
Yinhe

Hi @yinhew
thank you for looking into this!
Is there any other way or a workaround to at least check if what the user recorded is different from what is expected?
Currently, a wrong but similar sentence like the example above will result in an ok-ish accuracy score, so it is hard to differentiate if the recording is simply pronounced wrong or actually something different.

@Nyankoo to work around, you can set reference text to empty when sending the request, and then use the recognized text to compare to the reference text.

@yinhew This doesn't seem to work, as PronunciationAssessmentResult.FromResult(e.Result).Words seems to only have the full sentence instead of each individual word.
I need the accuracy score of each individual work AND to be able to check if the recording of the user is correct.

@yinhew Any update on this?

@Nyankoo looks I cannot repro your issue. I got 4 words in PronunciationAssessmentResult.FromResult(e.Result).Words

@yulin-li Yes, that isn't the issue. The issue is that when using PronunciationAssessmentConfig, I can say something similar or with additional words, and the SDK will not recognize that.
For example:
"女は可愛いです" results in what you have on your screenshot and equals what we wanted the user to say.
"女と男は可愛いです" will also result in what you have in your screenshot, but with less AccuracyScore. The AccuracyScore is not low enough to determine whenever the user has trouble pronouncing the sentence or if he said words that aren't in the sentence. An example for this would be when the user would need to translate from English to Japanese, were he then adds an extra word or uses a word that's wrong but similar.
So what I already said in a previous message: I need the accuracy score of each individual word AND to be able to check if the recording of the user is correct.

@Nyankoo  can you share your audio file for "女と男は可愛いです" ?

@yulin-li @yinhew There is no audio file, only microphone input.

Hi @Nyankoo as we are not Japanese speakers... would you like to share a audio that could repro this issue?

@yulin-li We can't share an audio file right now, but this behavior should also be reproduceable with any other language, eg. English.
Simply test the following:

new PronunciationAssessmentConfig("The woman is beautiful", GradingSystem.HundredMark, Granularity.Word, true)
Audio input/recoding: "The woman and the man are beautiful".

This should result in a low Accuracy Score, but with no actual indication that the input/recoding is different from what is expected.

@Nyankoo to work around, you can set reference text to empty when sending the request, and then use the recognized text to compare to the reference text.

@Nyankoo looks you didn't follow my guidance above. The reference text need be set to empty.

@yinhew maybe you didn't read my replies above, but setting the reference text to empty doesn't work. See the quote below.

@yinhew This doesn't seem to work, as PronunciationAssessmentResult.FromResult(e.Result).Words seems to only have the full sentence instead of each individual word.
I need the accuracy score of each individual work AND to be able to check if the recording of the user is correct.

@Nyankoo I tried below config and can see the accuracy score on individual word:

new PronunciationAssessmentConfig("", GradingSystem.HundredMark, Granularity.Word, true)

Audio input/recording: "good morning"

Output:

@yinhew I tested a little bit more, and it seems the issue is caused by using a phrase list and the fact that Japanese doesn't have spaces between words.
When adding spaces in between words, we can reliably get each word's accuracy score. Without the spaces, the SDK recognizes everything as one word. Saying the sentence very slowly fixes this issue, but is not really a solution.
Thank you for assisting me with this. When you don't have any follow-up questions, you can close the issue.

@Nyankoo I tried below config and can see the accuracy score on individual word:
new PronunciationAssessmentConfig("", GradingSystem.HundredMark, Granularity.Word, true)
Audio input/recording (synthesized by our TTS API): "女と男は可愛いです"

@yinhew Did you also use a phrase list with "女と可愛いです"?

@Nyankoo no, I didn't use any phrase list.

@yinhew Like I mentioned in my previous message, to reproduce this issue, you need to use a phrase list.

@Nyankoo why you need set phrase list?
Phrase list is not recommended for pronunciation assessment API

@yinhew Because we expect specific sentences and without a phrase list, recognition is not accurate enough. This is mostly a problem with names, as the API recognizes other words that are similar instead of the name.

@yinhew Are there still open pending items on this? Please update, othewise we'll close the issue.

Closed since no further updates since March, please open a new issue if more support is needed.


5 Assets out of all Assets

How can i get the best 5 Stocks with their weights out of all Stocks i have?
There is a new Bank Product, which i want to use for my retirement preperation.
-Once every month i can invest in 5 ETFs without buying costs.
-Once every month i can reorganize all the money i have invested before and invest it to other ETFs (also without costs).
Therefore i trying to optimize a Portfolio with all available ETF Stocks and take just 5 of it for my reorganization.
Is there a way i can do this?
Greetings
Adam

Does this mean that every month you want to optimise a portfolio s.t. the constraint that num assets = 5?

That seems like a reasonable heuristic. Alternatively, you could try a constraint on the number of assets (discussed in the FAQs) and in several of the issues.
Best of luck!

Thank you!


Add basic auth support for http DELETE command

Forgot to add this when I added support to the PUT command.

Thanks!


chore: update to latest version of provider

Purpose
Updated version of the terraform provider from 1.4.0 to 1.5.0
Pull Request Type
What kind of change does this Pull Request introduce?

[ ] Bugfix
[ ] Feature
[ ] Documentation content changes
[ ] Other... Please describe:

Other Information

closing this PR due to the fmt errors on the files updated.


Issue: Unable to define "output_key" param of the LLM chain class for a csv agent while binding to SequentialChain class

Issue you'd like to raise.
Currently, I'm using SequentialChain class to combine two steps in my workflow.
Step1: I'm using the LLM through prompt to identify the intent of the question posed by the user.
Step2: I'm using the csv based agent to answer the question posed by the user based on the csv file, but my aim is to answer the question only if the intent of the question is a textual response.
Below is the code snippets I have used to create the SequentialChain
model = AzureOpenAI(temperature=0,deployment_name="",openai_api_key="",openai_api_version="",openai_api_base="", )
template = """         You will help me identify the intent with the following examples and instructions.         Give your response in this format {{"Intent":"<identified intent>",                             "Question":"<Input question>"}}         ### Instructions         # Different possible intents are textResponse, BarChart, LineChart.         # If the question doesn't come under any of the intents, identify it as a None intent.         ####         ### Examples         Question: What is the total count of stores in 2022?         Intent: textResponse         Question: What is the split of sale amount for each sale type?         Intent: BarChart         Question: What is the monthly trend of sales amount in 2022?         Intent: LineChart         Question: {input}         """
prompt = PromptTemplate(         input_variables=["input"],         template=template,         )
chain_one = LLMChain(llm=model, prompt=prompt, output_key = "intent")
agent = create_csv_agent(     AzureOpenAI(temperature=0.5,top_p = 0.5,deployment_name="",openai_api_key="",openai_api_version="",openai_api_base="",),     <csv file path>,     verbose=True,     agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,     handle_parsing_errors=True )
agent.agent.llm_chain.prompt.template = """ You are a friendly assistant who is warm and thoughtful and never rude or curt. Possible Intents are: textResponse, LineChart, BarChart, None You will act further only if the {intent} is textResponse, else your Final Answer will be I cannot respond to your query. If {intent} is textResponse use the python_repl_ast to answer the question. You should use the tools below to answer the question posed of you: python_repl_ast: A Python shell. Use this to execute python commands. You should use the python_repl_ast to answer the question posed of you. You are working with a pandas dataframe in Python.  The name of the dataframe is df. Input to python_repl_ast should be a valid python command. Give your Final Answer in this format {{"output":"Final Answer"}} Use the following format: Question: the input question you must answer Thought: you should always think about what to do. Action: the action to take, should be one of [python_repl_ast] Action Input: the input to the action Observation: the result of the action ... (this Thought/Action/Action Input/Observation can repeat N times) Thought: I now know the final answer Final Answer: the final answer to the original input question. This is the result of print(df.head()):{df_head} Begin! Question: {input} {agent_scratchpad}     """
input_var = agent.agent.llm_chain.prompt.input_variables
input_var.append("intent")
This was done to append my input variables to already pre-defined ones for the csv agent.
agent.agent.llm_chain.output_key = "FinalAnswer"
chain_two = agent
overall_chain = SequentialChain(chains=[chain_one, chain_two],input_variables=["input"],                   output_variables=["intent","FinalAnswer"],verbose=True)
overall_chain.run(input = "count of total stores in 2022")
Now, when I run the above code I get the following error:
validation error for SequentialChain root Expected output variables that were not found: {'FinalAnswer'}. (type=value_error)
As far as I understood the langchain documentation [(https://python.langchain.com/docs/modules/chains/foundational/sequential_chains)]
the output_key must be defined for each LLM hit for the model to tag the response to that key, hence here I have provided the output key to the agent through the llm_chain.output_key property. But still the code throws error that output variables were not found.
Is this a bug in langchain while binding the csv agents to SequentialChain class or am I missing something? Can someone please help?
Suggestion:
No response

Answer generated by a 🤖
Answer
Hello,
From your code and the error message, it seems like the issue is with the output key of the second chain in your SequentialChain. The error message indicates that the SequentialChain is expecting an output variable 'FinalAnswer' which it is not able to find.
In your code, you have set the output key of the first chain (LLMChain) as 'intent' and the output key of the second chain (CSV agent) as 'FinalAnswer'. However, the output key of the CSV agent should be set in the prompt template of the CSV agent, not by setting the llm_chain.output_key property.
The output key of the CSV agent should be the key in the final dictionary that the CSV agent returns. In your case, it should be 'output' as per the prompt template of the CSV agent:
You should use the python_repl_ast to answer the question posed of you. You are working with a pandas dataframe in Python.
The name of the dataframe is `df`.
Input to python_repl_ast should be a valid python command.
Give your Final Answer in this format {{"output":"Final Answer"}}

So, you should set the output key of the CSV agent as 'output' and also include 'output' in the output variables of the SequentialChain:
overall_chain = SequentialChain(chains=[chain_one, chain_two],input_variables=["input"],
                  output_variables=["intent","output"],verbose=True)

Please try this and let me know if it resolves your issue. If not, I would be happy to assist you further.
Sources

libs/langchain/langchain/chains/sequential.py

This response is meant to be useful, save you time, and share context. It is not meant to be a precise solution, but rather a starting point for your own research.
Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

Thank you this helped.


Hotfix/tcp whitelist remote locators

Backport of #762

Tests passed on all platforms (see Windows, Linux, and Mac), but overall result was marked as failure.


Azure - Support blob output for logs/resources

Works roughly the same way as S3 output with azure:// prefix.
Documentation incoming in a separate PR as I have quite a few doc changes to do together.

Ok I believe I covered all feedback, and updated a test to show that we can do arbitrary paths provided by user for blob.

Having some build issues that don't repro at all locally - will get it investigated.

closes #2280


ci: Add code coverage computation with Codecov

Welcome to Codecov :tada:
Once you merge this PR into your default branch, you're all set! Codecov will compare coverage reports and display results in all future pull requests.
Thanks for integrating Codecov - We've got you covered :open_umbrella:


refactor: use primordials

Modules in Node.js use primordial helpers, so that core APIs continue working if prototypes are mutated. By moving to using this same approach it will be easier to drop this module into Node.js once ready.
I believe we will want to do some similar work as part of the resolution to #6, to make the errors we generate follow Node's conventions -- my hope is we can keep this module a direct mirror of the code in utils/parseargs.js (in the Node codebase).

You may want to use https://npmjs.com/call-bind, and call-bind/callBound, for something published - node's own patterns only work because node can guarantee first execution for its primordials file, which this package can not.

Ideally I would like to keep index.js able to be dropped in to the Node.js codebase, to prevent the two diverging significantly the second we open a PR on Node.js.
Could you submit a patch after this that modifies our primordials.js to use call-bind?
Now that I think of it, having a separately published shim with the same exports as primordials.js in the Node.js codebase would be very handy for future work where a polyfill is developed in parallel.

That’s a good idea. I’ll make such a package today or tomorrow, and then I’ll make a PR here to use it - that way index.js still can be drop-in (which was my thinking with the suggestion anyways; that call-bind would be used in primordials.js), but it’ll actually be robust when used outside of node core.

Sometime this week, I'll make a PR removing primordials.js and replacing the require from it with a package that does things properly for "not node core".

@ljharb sounds great, I think this repo will give us a good pattern we can copy for other work.


More efficient AssetCache keying system

AssetCache introduction
AssetCache is one of the core storage abstractions which a piece of data can be persisted into. Note the word "Asset" has no relation to the "Asset Pipeline", because this asset cache can store anything, including the handle to the GPU instance, an HTTP client, and so on. Accessing this cache is going to happen frequently enough that it is worth considering more efficient solutions.
To load something into the cache, one needs to create a type that implements SyncAssetKey or AsyncAssetKey trait. This trait implements the interface to the cache. To form the actual key, these traits assume that the type which implements *AssetKey trait also implements the Debug trait. The asset cache then uses calls format!("{self:?}") to create the key. The key itself is going to be a dynamically allocated String of the length of the Debug formatting output. Finally, the String key is wrapped into an Arc, yielding yet another dynamic allocation, presumably to make it more convenient to use in async contexts.

One issue is that there is no way to get something from the cache without going through the Debug-formatter, even if we already have the key when we did the initial insertion.
Another issue is the requirement that the type implements Debug. Depending on the fields in the type this might be a significant amount of work, which requires the type to "optimize" the Debug implementation, for example not Debug formatting every vertex in a mesh. It is also simply the wrong tool for the job.
This is also clearly inefficient in both execution time and memory usage. Strings are individually allocated and are variable length and the fact they are stored in an Arc causes a pointer indirection, hurting CPU cache performance. The effect on frame rate might currently be low, but on larger games with more assets, this system will scale towards the worst case.

An alternative
An alternative way to do keying is to use content hashing instead. We can keep all the *AssetKey types mostly intact, but make them implement a hashing trait that produces an u128 for example. This u128 should be returned to the user so any future accesses to the cache don't have to re-hash the key. We could also make it strongly typed by new-typing u128 into something like:
#[derive(Clone, Copy)]
struct CacheKey<T> {
    hash: u128,
    _phantom: std::marker::PhantomData<T>,
}

let hash: CacheKey<PixelTextureKey> = // created by hashing `PixelTextureKey`

This fixes all three issues listed above.
However, this presents an interesting issue for "singleton assets" like the GPU itself. The current solution is to Debug-format a unit struct like pub struct GpuKey;, which returns the string "GpuKey". We could workaround it by doing the same thing by hashing the string GpuKey and everything continues to work. It does however feel a bit silly when these singleton resources should be directly accessible (without hashmap lookup), but that's a separate issue.

@VinhTruongAmbient We discussed this on a chat; I think this just stemmed from misunderstanding of the asset cache right?

Originally yes when I thought we could replace the keys with ULID, this was incorrect. However, after the improved understanding, I still feel like the keying system can be made more efficient through content-hashing. Is my explanation of asset cache incorrect or incomplete?

(Sorry removed my comment because I thought this was an old issue :) @VinhTruongAmbient answer was to that comment)

How would the hashing trait work for f32?
the std::hash::Hash, and in extension hashmaps don't work for structs using f32s (or f32s) directly for that matter.
Additionally: how would we guarantee sufficient entropy for the hashed u128? Since it is not pure random there is a high chance that collisions occur

@VinhTruongAmbient Hm so honestly this just seems "different" rather than strictly "better" to me. But the bigger problem here is that I don't see what real-world problem we're addressing here? You mentioned performance (cpu and memory), but I don't see any data to back that up? "Optimizing performance" without measuring is not something we should indulge in. There's a million different ways to do things, so I'm hesitant to change things unless it's very clear it's actually making something better.

How would the hashing trait work for f32?
the std::hash::Hash, and in extension hashmaps don't work for structs using f32s (or f32s) directly for that matter.
Additionally: how would we guarantee sufficient entropy for the hashed u128? Since it is not pure random there is a high chance that collisions occur

We might need to create our own hash trait which can hash f32 by reinterpreting it as a u32. This should be a sound operation because floats are standardized in Rust.
128 bits is a lot of entropy so collisions should be exceedingly rare, but if we wanted to be really paranoid a 256-bit would definitely be enough. In my previous company, we had databases with billions of elements with SHA256 as the key.

We're also doing things like loading a model, which points to a material, which points to a texture, all of which is loaded through the asset cache right now and de-duplicated (you can load the same model and/or material and/or texture from multiple locations in code and it still resolves to the same load), which I don't think content-addressed could solve at all (it would need a separate system, which would bring us back to square one).

@VinhTruongAmbient Hm so honestly this just seems "different" rather than strictly "better" to me. But the bigger problem here is that I don't see what real-world problem we're addressing here? You mentioned performance (cpu and memory), but I don't see any data to back that up? "Optimizing performance" without measuring is not something we should indulge in. There's a million different ways to do things, so I'm hesitant to change things unless it's very clear it's actually making something better.

I do think this improves how the developer interacts with the asset cache, for example not needing to go through Debug trait which is in my opinion a pretty unorthodox way to implement keying. Also because the hash key is Copy, there is no need to wrap it into Arc or clone it every time it crosses a thread boundary, which is nicer to the CPU but also simplifies the developer experience. For example, a struct that holds this key doesn't also need to be Arc or Clone.
As for performance, I think we have different viewpoints on what it means to "optimize performance". I wouldn't count this as actual optimization but rather it's about not doing work that doesn't give anything beneficial to us unless I am missing something from my understanding. As for providing data, I can set up a benchmark that really stresses the asset cache, but this feels like a pointless exercise because the cost of string formatting and allocations are real given that we understand how the processor and memory work. I grant that the title says "more efficient" which maybe is focused too much on the performance, but the points in the larger posts still hold.

We're also doing things like loading a model, which points to a material, which points to a texture, all of which is loaded through the asset cache right now and de-duplicated (you can load the same model and/or material and/or texture from multiple locations in code and it still resolves to the same load), which I don't think content-addressed could solve at all (it would need a separate system, which would bring us back to square one).

I think this should scenario behave the same right? Because the AssetKey is hashed, not the actual data that gets loaded with the key.

How would the hashing trait work for f32?
the std::hash::Hash, and in extension hashmaps don't work for structs using f32s (or f32s) directly for that matter.
Additionally: how would we guarantee sufficient entropy for the hashed u128? Since it is not pure random there is a high chance that collisions occur

We might need to create our own hash trait which can hash f32 by reinterpreting it as a u32. This should be a sound operation because floats are standardized in Rust.
128 bits is a lot of entropy so collisions should be exceedingly rare, but if we wanted to be really paranoid a 256-bit would definitely be enough. In my previous company, we had databases with billions of elements with SHA256 as the key.

My question was rather the entropy of the hash functions, as (especially if we write our own) has functions tend to sacrifice some entropy/ for speed. Using or reusing the existing hasher would be very problematic since the hashing algorithm and stabilty and usage of quality over speed is subject to change.
Using random with u128 is fine, but not string hashing or similar

How would the hashing trait work for f32?
the std::hash::Hash, and in extension hashmaps don't work for structs using f32s (or f32s) directly for that matter.
Additionally: how would we guarantee sufficient entropy for the hashed u128? Since it is not pure random there is a high chance that collisions occur

We might need to create our own hash trait which can hash f32 by reinterpreting it as a u32. This should be a sound operation because floats are standardized in Rust.
128 bits is a lot of entropy so collisions should be exceedingly rare, but if we wanted to be really paranoid a 256-bit would definitely be enough. In my previous company, we had databases with billions of elements with SHA256 as the key.

My question was rather the entropy of the hash functions, as (especially if we write our own) has functions tend to sacrifice some entropy/ for speed. Using or reusing the existing hasher would be very problematic since the hashing algorithm and stabilty and usage of quality over speed is subject to change.
Using random with u128 is fine, but not string hashing or similar

Ah, I wasn't suggesting we write our own hash function, but just the trait that uses some other hash implementation to do it. There should be a plenty of options out there we can experiment with. SHA-256 works for sure since that's what I have used before for gigantic datasets, but the performance is not great compared to non-cryptographic hashes.

Should we perhaps convert this to a discussion?

We're also doing things like loading a model, which points to a material, which points to a texture, all of which is loaded through the asset cache right now and de-duplicated (you can load the same model and/or material and/or texture from multiple locations in code and it still resolves to the same load), which I don't think content-addressed could solve at all (it would need a separate system, which would bring us back to square one).

I think this should scenario behave the same right? Because the AssetKey is hashed, not the actual data that gets loaded with the key.

Ah ok, I see, I misunderstood the proposal then; so basically this is just to move from debug to hashing for asset keys and to cache the result of that hashing?

We're also doing things like loading a model, which points to a material, which points to a texture, all of which is loaded through the asset cache right now and de-duplicated (you can load the same model and/or material and/or texture from multiple locations in code and it still resolves to the same load), which I don't think content-addressed could solve at all (it would need a separate system, which would bring us back to square one).

I think this should scenario behave the same right? Because the AssetKey is hashed, not the actual data that gets loaded with the key.

Ah ok, I see, I misunderstood the proposal then; so basically this is just to move from debug to hashing for asset keys and to cache the result of that hashing?

Yeah, that's right. Sorry for being misleading, I updated my original post for clarification.

Yeah, I didn't intend this to be a hugely different API that forces significant rewrites. I think the change can be implemented pretty easily because it's pretty much the same idea as Debug-formatting your struct and using the formatted String as the key. I do think the fact that the proposed u128 hash type is Copy makes it a lot easier to work with in async contexts.
Also, I proposed that you should be able to keep this u128 hash key when you insert the asset for the first time. Any subsequent accesses to the asset cache can then re-use the same key and skip the hashing routine. Yes, it improves performance, but why do the same work again when you don't need to 🙂.

Alright, so in that case there are two things to consider here:
First; I'm not 100% sure but I think you might get collisions if you just use the hash. I suspect that you would anyway need to be able to fall back to a full PartialEq, but then you'll have to bring the key with you (so you won't get Copy anyway).
Second; On the performance part, I want to make sure we don't get into the habit of assuming things when it comes to performance. That this is called a "More efficient AssetCache keying system" or that it talks about "Clearly inefficient" is premature; we really don't know that at this point. This suggestion is in my mind a hypothesis or an idea that might improve performance, and we should talk about it in those terms; i.e. "Here's something I think we should test to see if we can improve performance". Until we've measured I don't think we should ever say that something is actually better.

Alright, so in that case there are two things to consider here:
First; I'm not 100% sure but I think you might get collisions if you just use the hash. I suspect that you would anyway need to be able to fall back to a full PartialEq, but then you'll have to bring the key with you (so you won't get Copy anyway).

Yes, you might get collisions with hashing operation due to the pigeonhole principle. But what are the chances of that happening? A hash length of 256 bits already makes it so that the universe will end sooner than we will find a collision.
If we are talking about the theoretical chance of collisions, remember that there is nothing in Debug that guarantees that there won't be cases where two different Debug implementors won't produce the same string. One easy example is floating point NaN's. There are many possible NaN's, but all of them get formatted into NaN, while hashing (or anything else that worked on bits directly) would have produced the correct result.
Then there is the case of having to "optimize" Debug printing just to make this keying system work. Here is one example that I have already removed from the code base:

Here meshes with the same number of vertices, but at different positions would produce the same key. The name is the only thing that could have saved this case, but there is no guarantee that name is unique across all meshes.
If we still wanted to be perfectly no-collision, then at the very least the Debug should be switched to something like bincode and serialize the type into a Vec<u8> and store that as the key instead.

Second; On the performance part, I want to make sure we don't get into the habit of assuming things when it comes to performance. That this is called a "More efficient AssetCache keying system" or that it talks about "Clearly inefficient" is premature; we really don't know that at this point. This suggestion is in my mind a hypothesis or an idea that might improve performance, and we should talk about it in those terms; i.e. "Here's something I think we should test to see if we can improve performance". Until we've measured I don't think we should ever say that something is actually better.

I agree with this principle, especially on anything that is more complicated or non-obvious. In this specific case, however, I disagree that we don't know whether or not a fixed 128/256-bit value is more efficient than a string of 455 characters long:
BackgroundKey(AnimationClipRetargetedFromModel { clip: TypedAssetUrl(http://<IP_ADDRESS>:8999/content/assets/Robot%20Hip%20Hop%20Dance.fbx/animations/mixamo.com.anim, PhantomData<ambient_std::uncategorized::asset_url::AnimationAssetType>), translation_retargeting: None, retarget_model: Some(TypedAssetUrl(http://<IP_ADDRESS>:8999/content/assets/Peasant%20Man.fbx/models/main.json, PhantomData<ambient_std::uncategorized::asset_url::ModelAssetType>)) })

Or whether allocating something is more efficient than not allocating something. I feel like this is clear enough that it doesn't need further elaboration. Even if allocations only took 1 cycle (they do not), 1 is still greater than 0.
I'll grant that you are probably right that even with these inefficiencies you are not able to see them in the profiler, because other systems are likely to dominate (although we don't have large enough realistic benchmarks to demonstrate this either way). And I'll also grant that it might be premature to change this now because we have better things to do. But ultimately the inefficiencies are still real and won't go away because we decided that it is not a big deal right now.

Side-topic: we are currently assuming that a specific key always maps to a specific value, but this assumption might be false if, for example, the file under the URL has changed. I don't know if the plan is to implement change detection into AssetCache specifically or if will it be a completely separate system, but regardless a true content-hashing will be required at some point.


add docstring for metrics.py

Codecov Report

Merging #664 (eaccf8d) into training (b7aebc9) will not change coverage.
The diff coverage is n/a.

@@            Coverage Diff            @@
##           training     #664   +/-   ##
=========================================
  Coverage     60.62%   60.62%
=========================================
  Files           147      147
  Lines          6331     6331
  Branches        975      975
=========================================
  Hits           3838     3838
  Misses         2196     2196
  Partials        297      297

Impacted Files
Coverage Δ

towhee/trainer/metrics.py
96.12% <ø> (ø)

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update b7aebc9...eaccf8d. Read the comment docs.


Preview of celo4 branch (do not merge)

I have done a few changes to the code during the rebase to make it work. Please have a look at the comments I created and the following commits:

https://github.com/celo-org/optimism/pull/100/commits/ba6b969af004a8a982aff0e98828cf345f473dd1
https://github.com/celo-org/optimism/pull/100/commits/3bedc9674a114950d199b95f2a171e65803fd4b6
https://github.com/celo-org/optimism/pull/100/commits/61982e7c7b44d25a29c29b21ddc7c0f89946b611

The rest should just be merging, squashing and minor cleanups.

Codecov Report
All modified and coverable lines are covered by tests :white_check_mark:

Project coverage is 25.40%. Comparing base (1d5a982) to head (063933d).
Report is 4666 commits behind head on develop.

Additional details and impacted files
@@             Coverage Diff              @@
##           develop     #100       +/-   ##
============================================
- Coverage    64.18%   25.40%   -38.78%
============================================
  Files           16      184      +168
  Lines         1410     8136     +6726
  Branches         0     1415     +1415
============================================
+ Hits           905     2067     +1162
- Misses         465     5948     +5483
- Partials        40      121       +81

Flag
Coverage Δ

cannon-go-tests
62.56% <ø> (-1.63%)
:arrow_down:

chain-mon-tests
27.14% <ø> (?)

common-ts-tests
26.72% <ø> (?)

contracts-bedrock-tests
0.49% <ø> (∅)

contracts-ts-tests
12.25% <ø> (?)

core-utils-tests
44.03% <ø> (?)

sdk-next-tests
41.53% <ø> (?)

sdk-tests
41.53% <ø> (?)

Flags with carried forward coverage won't be shown. Click here to find out more.

Files
Coverage Δ

...ages/contracts-bedrock/src/L1/L1StandardBridge.sol
0.00% <ø> (ø)

...ages/contracts-bedrock/src/L2/L2StandardBridge.sol
0.00% <ø> (ø)

...ckages/contracts-bedrock/src/celo/CeloRegistry.sol
0.00% <ø> (ø)

...ontracts-bedrock/src/celo/FeeCurrencyWhitelist.sol
0.00% <ø> (ø)

packages/contracts-bedrock/src/celo/FeeHandler.sol
0.00% <ø> (ø)

...es/contracts-bedrock/src/celo/FeeHandlerSeller.sol
0.00% <ø> (ø)

packages/contracts-bedrock/src/celo/GoldToken.sol
0.00% <ø> (ø)

...ntracts-bedrock/src/celo/MentoFeeHandlerSeller.sol
0.00% <ø> (ø)

...racts-bedrock/src/celo/UniswapFeeHandlerSeller.sol
0.00% <ø> (ø)

...kages/contracts-bedrock/src/celo/UsingRegistry.sol
0.00% <ø> (ø)

... and 10 more

... and 151 files with indirect coverage changes


ScopedCSSRules[] on css function

As mentioned in issue #28:

This change will allow accept ScopedCSSRules and ScopedCSSRules[] on css function. E.g.:

css({ margin: 0 })

// or

const btnBase: ScopedCSSRules  = ({ margin: 0, padding: 10, color: '#0088cc' })
css([btnBase, { padding: 0 }])

// { margin: 0, padding: 0, color: '#0088cc' }

This change also avoids the use of !import, since there will not be 2 styles with the same property.

And last but not least, this change does not break the current use of the css function

Thanks for the submission! I would be curious to see how this differs from using object spreading on the parameter of css. A discussion about composability has been going on in #3. Please join the conversation over there! 🤗

I would be curious to see how this differs from using object spreading on the parameter of css.

It doesn't really differ, only Object.assign is backwards compatible and used with javascript without babel / typescript. I have some customers who still support iOS 10, so sometimes it's just more convenient to choose Object.assign.
But I fully understand the option of not adding Object.assign, even refusing to add ScopedCSSRules[] to otion, since iOS 11 onwards already has compatibility with object spreading and we cannot stick to past systems.

But I would like to have access to ScopedCSSRules to type css classes, so I would like to close this pull request and open a new one to export ScopedCSSRules.
Let me know your opinion so that I can move forward with the new pull request.

Sounds reasonable, thank you! 😊


Import alias for Lux applications

We should use rollup-plugin-alias to allow for apps built with Lux to do the following:
import { Controller } from 'lux-framework';

import Post from 'app/models/post';

class PostsController extends Controller {
  show({ params: { id } }) {
    return Post.find(id);
  }
}

Notice the Post Model is being imported from app/models/post rather than ../models/post. This will be extremely beneficial once we introduce router namespaces since that involves more deeply nested directories.

Added in #293


Authentication is reading 2 bytes at a time

connect(48, {sa_family=AF_UNIX, sun_path="/var/run/dbus/system_bus_socket"}, 34) = 0
ioctl(48, FIONBIO, [1])                 = 0
getpid()                                = 61
sendto(48, "\0", 1, 0, NULL, 0)         = 1
getuid()                                = 0
sendto(48, "AUTH EXTERNAL 30\r\n", 18, 0, NULL, 0) = 18
recvfrom(48, "OK", 2, 0, NULL, NULL)    = 2
recvfrom(48, " 2", 2, 0, NULL, NULL)    = 2
recvfrom(48, "7e", 2, 0, NULL, NULL)    = 2
recvfrom(48, "cd", 2, 0, NULL, NULL)    = 2
recvfrom(48, "1c", 2, 0, NULL, NULL)    = 2
recvfrom(48, "33", 2, 0, NULL, NULL)    = 2
recvfrom(48, "de", 2, 0, NULL, NULL)    = 2
recvfrom(48, "69", 2, 0, NULL, NULL)    = 2
recvfrom(48, "bc", 2, 0, NULL, NULL)    = 2
recvfrom(48, "a6", 2, 0, NULL, NULL)    = 2
recvfrom(48, "1b", 2, 0, NULL, NULL)    = 2
recvfrom(48, "ca", 2, 0, NULL, NULL)    = 2
recvfrom(48, "f9", 2, 0, NULL, NULL)    = 2
recvfrom(48, "1b", 2, 0, NULL, NULL)    = 2
recvfrom(48, "e3", 2, 0, NULL, NULL)    = 2
recvfrom(48, "76", 2, 0, NULL, NULL)    = 2
recvfrom(48, "fc", 2, 0, NULL, NULL)    = 2
recvfrom(48, "6\r", 2, 0, NULL, NULL)   = 2
recvfrom(48, "\n", 2, 0, NULL, NULL)    = 1
sendto(48, "NEGOTIATE_UNIX_FD\r\n", 19, 0, NULL, 0) = 19
recvfrom(48, "AG", 2, 0, NULL, NULL)    = 2
recvfrom(48, "RE", 2, 0, NULL, NULL)    = 2
recvfrom(48, "E_", 2, 0, NULL, NULL)    = 2
recvfrom(48, "UN", 2, 0, NULL, NULL)    = 2
recvfrom(48, "IX", 2, 0, NULL, NULL)    = 2
recvfrom(48, "_F", 2, 0, NULL, NULL)    = 2
recvfrom(48, "D\r", 2, 0, NULL, NULL)   = 2
recvfrom(48, "\n", 2, 0, NULL, NULL)    = 1
sendto(48, "BEGIN\r\n", 7, 0, NULL, 0)  = 7

    async def _auth_readline(self) -> str:
        buf = b""
        while buf[-2:] != b"\r\n":
            buf += await self._loop.sock_recv(self._sock, 2)
        return buf[:-2].decode()

we can actually mis align the buffer here since we should only read up to 1 if we have b"BEGIN\r"

So we should read 1024, and then when we expect BEGIN\r\n we need to only read the missing bytes


Passed data to customImageComponent

This allows one pass custom data into customImageComponent, just like renderHeader and renderFooter. This also fixes #53 because one could pass custom dimensions in the data attribute and also fixes #75 because you can pass key in the data attribute as well.

@Mohamed-Abo-El-Soud Great didn't realize data wasn't accessible to the customImageComponent itself! This should solve that issue. 👍


Week 3 Review Ticket

App Lab Quiz
App Lab Overview

2.8 - Sarah completed the assignment by creating the required quiz and blog, although she added 3 extra questions to show her expertise.


Why do I get compilation results of tslib imports containing native absolute path?

I use rollup and @rollup/plugin-typescript to compile ts and tsx codes containing annotations. I found the code that uses absolute paths to reference tslib from the outpu files. Can anyone tell me how to solve it? What did I miss?

tsconfig.json:
{
  "compilerOptions": {
    "baseUrl": "./",
    "rootDir": "./",
    "target": "esnext",
    "module": "esnext",
    "moduleResolution": "node",
    "strict": false,
    "jsx": "react",
    "jsxFactory": "QuarkElement.h",
    "jsxFragmentFactory": "QuarkElement.Fragment",
    "sourceMap": false,
    "declaration": false,
    "removeComments": true,
    "resolveJsonModule": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "strictNullChecks": true,
    "experimentalDecorators": true,
    "lib": ["esnext", "dom"],
    "types": ["vite/client", "./index.d.ts"],
  },
  "include": [
    "src/**/*.ts",
    "src/**/*.d.ts",
    "src/**/*.tsx",
    ".eslintrc.cjs",
    ".prettierrc.cjs",
    ".stylelintrc.cjs",
    "postcss.config.cjs",
    "babel.config.cjs",
    "rollup.config.mjs",
    "vite.config.mts",
    "typesGenerat.mjs"
  ],
  "exclude": ["node_modules", "lib", "umd"]
}

I don't think this has anything to do with tslib, but with your bundler. You should ask on the rollup or rollup-typescript trackers.

Thanks for your reply.


MB-4744 Add tag indicating pending service item approvals to move task order page

Description
Adds a visual cue to the move task order page informing the TOO of how many service items there are awaiting approval per shipment.
Setup
Get your office app up and running
make server_run
make office_client_run
make db_dev_e2e_populate

Get a move into a state where there's a some service items on a shipment that need approval. One easy way to do that is to approve a new move and then go into the DB and flip the status over to SUBMITTED for a couple of them. Alternatively you can simulate the Prime requesting one using this tool: https://github.com/transcom/mymove/wiki/How-to-Test-the-Prime-API-(Local,-Staging,-and-Experimental)
Code Review Verification Steps

[ ] If the change is risky, it has been tested in experimental before merging.
[ ] Code follows the guidelines for Logging
[ ] The requirements listed in Querying the Database Safely have been satisfied.
Any new migrations/schema changes:

[ ] Follow our guidelines for zero-downtime deploys (see Zero-Downtime Deploys)
[ ] Have been communicated to #g-database
[ ] Secure migrations have been tested following the instructions in our docs

[ ] There are no aXe warnings for UI.
[ ] This works in Supported Browsers and their phone views (Chrome, Firefox, IE, Edge).
[ ] Tested in the Experimental environment (for changes to containers, app startup, or connection to data stores)
[ ] User facing changes have been reviewed by design.
[ ] Request review from a member of a different team.
[ ] Have the Jira acceptance criteria been met for this change?

Screenshots

Messages

:book:
:link: MB-4744

  Generated by :no_entry_sign: dangerJS against a9e620bcd7a091c28fc9a39409fb2820035e9b25


Document enums

Maybe to be used like this:
expose :enum_one, documentation: { ..., values: [1, 2, 3] }
expose :enum_two, documentation: { ..., values: Model.enum_twos.keys }

https://github.com/bsm/grape-apidoc/pull/21#issuecomment-933285892

Most likely, both entity fields and route params could use the same 4-column table (with Values col): https://github.com/ruby-grape/grape#values

To be addressed as part of this issue, but later.


filter_transformer: add renew_time_key option

Same thing with https://github.com/sonots/fluent-plugin-record-reformer/pull/21

:+1:

Thanks!


Fix Travis for PHP 5.4.

The container used by Travis for PHP 5.4 has problems with PHPUnit. You can use the one installed by composer instead.

Tightened up travis and composer a bit more.


Clean PDF2 styling and move legacy styling plugin

Clean PDF2 to remove styling that is almost always overridden or are ugly, and move legacy styling to a separate plugin to reproduce them.

Legacy plugin repository

We should remove descriptions from related links. Right now the output is

Related reference
JavaHelp parameters on page 82
Certain parameters are specific to the JavaHelp transformation.

The problem may unsuitable <shortdesc> descriptions in our documentation, but IMO they make the flow of the page much worse and don't improve the content that much.

:+1: This looks like a good direction to me. Cleaning up this code has been needed for a long time.
FWIW we discussed this item in last week's contributor call -- particularly to get feedback from Leigh White, who has written so much about this transform, and everybody on the call seemed to be on board with this move. Not sure if any others want to chime in. Minutes from that call are here: https://github.com/dita-ot/dita-ot/wiki/Meeting-minutes-2017-02-02

We should remove descriptions from related links.

👍 I think this is worth doing, especially since they are currently rendered inconsistently.
Some links in a collection are augmented with the <shortdesc> content, whereas others in the same collection are not — even though the target topics include short descriptions. Upon closer inspection, it appears as though link descriptions are currently dropped if the short descriptions of the target topics contain any inline markup.

Since this PR removes indents and borders for <example>, we might also want to consider doing the same for long quote <lq> elements.


fatal error while processing file invalid syntax

hi @jonnenauha! first of all, thanks for this tool. looks great and fast.
I encountered an issue with this tool throwing fatal error
[FATAL] line:381459 Found invalid number from "-1.#IND00 -1.#IND00 -1.#IND00": strconv.ParseFloat: parsing "-1.#IND00": invalid syntax

when trying to simplify the object. note that I am not very knowledgeable about the .obj format or any other 3d format. I bought model of my Mazda6 and got obj file with lines like:
vt  0.673680 0.303679 0.000000
vt  1.000000 0.303948 0.000000
vt  0.250000 0.661712 0.000000
vt  0.250000 0.161712 0.000000
vt  -1.#IND00 -1.#IND00 -1.#IND00
vt  0.205604 0.321078 0.000000
vt  0.794396 0.321078 0.000000
vt  0.481795 0.692745 0.000000
vt  0.329577 0.631309 0.000000

so I am not sure if there's a problem with obj-simplify tool or with my .obj file.
Also, note that this file can be opened with the online 3dviewer or tools like blender.
I would appreciate any help on this one, thanks!

got it working, converted with fbx converter tool and .obj file did not include lines like -1.#IND00.

Yeah, I think its best for my tool to report the problem and line number and let the user fix how he thinks is best. Silently ignoring or doing some other special stuff would be imo worse than just fataling out. Warnings can be and most likely will be ignored by users :)
Good that you got it figured out.


Theme not changing automatically.

Hello,
Great extension!
Running Manjaro with WPGTK and pywal. Theme is not getting set automatically. However, if I click the set theme button, it's working. It's also not changing font colors. Any ideas? What other information can I get you to help? Thanks!

I am a fool and didn't see the option I was supposed to choose for "bordered" or not. Sorry!


Terminal suggest: Completions on multi-line inputs don't complete correct text

Testing #210394

This is fixed


How to do Text editor convert to Text Widget?

Type question here.

You can use enable and disable.
HtmlEditorController controller = HtmlEditorController();
//Text widget
widget.curController.disable();
//Text editor
widget.curController.enable();

A TextField Widget that allow you to convert easily what's in the TextField to with custom texteditor toolbar

A TextField Widget that allow you to convert easily what's in the TextField to with custom texteditor toolbar @Ashish-Raturi

@DazzlingCVa
I got it, you want a text field and the user can change font style, bold italic, and other stuff. right?
You need a custom HTML editor then.


Add -q/--quiet option to suppress all but the most important output

Sometimes I just really don't care that some line is too long or whatever...

We have this now


MM-15220 Document Interactive Dialog submission error field

This adds the documentation for the feature being implemented in https://github.com/mattermost/mattermost-server/issues/12043.
Ticket links
https://mattermost.atlassian.net/browse/MM-15220

/cc @lieut-data @hanzei

Thanks for taking care of the documentation @pbitty :+1:

@hanzei No prob!  Feedback addressed.

@amyblais Would you be fine to merge this after the reviews, given that it's clearly documented that this will be in 5.16?

@hanzei I think it's fine. Is there a specific reason why we want to get this merged before v5.16 is released?

I think it's fine. Is there a specific reason why we want to get this merged before v5.16 is released

@amyblais This allows integration developers to already learn about this feature and use it.

Thank you, it should be fine,

@aaronrothschild Would you please give this a review?


feat: return matchedName in non-OFAC results

matchedName is populated with the highest scoring term from the search query.

Codecov Report

Merging #521 (61506fe) into master (6ae4577) will decrease coverage by 0.02%.
Report is 1 commits behind head on master.
The diff coverage is 0.00%.

:exclamation: Current head 61506fe differs from pull request most recent head 17e8360. Consider uploading reports for the commit 17e8360 to get more accurate results

:exclamation: Your organization needs to install the Codecov GitHub app to enable full functionality.
Additional details and impacted files
@@            Coverage Diff            @@
##           master    #521      +/-   ##
=========================================
- Coverage    8.25%   8.23%   -0.02%
=========================================
  Files          44      44
  Lines        3503    3509       +6
=========================================
  Hits          289     289
- Misses       3191    3197       +6
  Partials       23      23


First HARK model opens with jargon

I understand that:

HARK is currently mainly used to teach a specific field of consumption theory
HARK is intended to grow to be for a somewhat more general audience, including programmers and economics from adjacent fields

In light of that:

As somebody not trained in consumption theory, I could use a little more background in the "Gentle Introduction" and related onboarding materials
-Specifically:

If you spelled out CRRA utility as "constant relative risk aversion" the first time it's used, rather than use the acronym, it would be easier to follow
It's not immediately clear to this non-specialist why 'risk aversion' is relevant in this case, when all the values are deterministic.

A link to lecture notes or some reliable source about this would go a long way to making this more approachable. I've been picking my way through Wikipedia, but that's not ideal.

It's meant for entry into computational methods and research using
consumption-saving models, but not (at this time) for teaching the models
themselves.  The materials (mostly) assume that the reader has been through
(roughly) the first year of an economics PhD or MS program.
I thought I did spell out CRRA in the gentle introduction notebook, but
it's been edited a lot.  We can fix that.
In a model with no risk, being "risk averse" isn't meant to capture risk
preferences per se.  Mathematically, we need the utility function to be
concave so that there is an interior solution to the consumption problem:
the agent wants to consume some today and some tomorrow.  With linear (risk
neutral) utility, the solution to a consumption-saving problem with no risk
and no artificial borrowing constraint would be to consume everything in
one particular period-- probably the very first period or the very last
period (if there is one), but it's possible to structure the parameters so
that the agent prefers to consume all of their wealth and (future) income
in some particular period.  Economically, the parameter rho can also be
interpreted as the reciprocal of the intertemporal elasticity of
subsitution-- the agent's willingness to reallocate between consumption
today and consumption next period.  When rho --> 0 and we have linear
utility, intertemporal elasticity goes to infinity and the agent will shift
all consumption into whatever period of time is "best".  This is analogous
maximizing a linear function subject to a linear constraint: if a unique
solution exists, it is guaranteed to be at a corner.
The other piece of it is that the perfect foresight model is a special case
/ limiting solution of the more general (and interesting) models with real
risk.  We want to be able to work with the relationships between the risky
models and the simple risk free model.
On Sun, Oct 20, 2019 at 3:24 PM Sebastian Benthall<EMAIL_ADDRESS>wrote:

I understand that:

HARK is currently mainly used to teach a specific field of
consumption theory
HARK is intended to grow to be for a somewhat more general audience,
including programmers and economics from adjacent fields

In light of that:

As somebody not trained in consumption theory, I could use a little
more background in the "Gentle Introduction" and related onboarding
materials
-Specifically:

If you spelled out CRRA utility as "constant relative risk
aversion" the first time it's used, rather than use the acronym, it would
be easier to follow
It's not immediately clear to this non-specialist why 'risk
aversion' is relevant in this case, when all the values are deterministic.

A link to lecture notes or some reliable source about this would go a long
way to making this more approachable. I've been picking my way through
Wikipedia, but that's not ideal.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=ADKRAFKBUWJZV7H46GHY6GDQPSV5RA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFUVEXG43VMWVGG33NNVSW45C7NFSM4HTAPQ2A,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/ADKRAFPUYNTUMW2XWOAN7Y3QPSV5RANCNFSM4JCVWAMA
.

To clarify the last sentence of the large paragraph: "...maximizing a
linear function on R^n_+ subject to a linear constraint..."  With n
non-negativity constraints and 1 linear constraint, the solution to this
problem will be all zeros in all index except one (if it's unique).
On Sun, Oct 20, 2019 at 5:24 PM Matthew White<EMAIL_ADDRESS>wrote:

It's meant for entry into computational methods and research using
consumption-saving models, but not (at this time) for teaching the models
themselves.  The materials (mostly) assume that the reader has been through
(roughly) the first year of an economics PhD or MS program.
I thought I did spell out CRRA in the gentle introduction notebook, but
it's been edited a lot.  We can fix that.
In a model with no risk, being "risk averse" isn't meant to capture risk
preferences per se.  Mathematically, we need the utility function to be
concave so that there is an interior solution to the consumption problem:
the agent wants to consume some today and some tomorrow.  With linear (risk
neutral) utility, the solution to a consumption-saving problem with no risk
and no artificial borrowing constraint would be to consume everything in
one particular period-- probably the very first period or the very last
period (if there is one), but it's possible to structure the parameters so
that the agent prefers to consume all of their wealth and (future) income
in some particular period.  Economically, the parameter rho can also be
interpreted as the reciprocal of the intertemporal elasticity of
subsitution-- the agent's willingness to reallocate between consumption
today and consumption next period.  When rho --> 0 and we have linear
utility, intertemporal elasticity goes to infinity and the agent will shift
all consumption into whatever period of time is "best".  This is analogous
maximizing a linear function subject to a linear constraint: if a unique
solution exists, it is guaranteed to be at a corner.
The other piece of it is that the perfect foresight model is a special
case / limiting solution of the more general (and interesting) models with
real risk.  We want to be able to work with the relationships between the
risky models and the simple risk free model.
On Sun, Oct 20, 2019 at 3:24 PM Sebastian Benthall <
<EMAIL_ADDRESS>wrote:

I understand that:

HARK is currently mainly used to teach a specific field of
consumption theory
HARK is intended to grow to be for a somewhat more general
audience, including programmers and economics from adjacent fields

In light of that:

As somebody not trained in consumption theory, I could use a little
more background in the "Gentle Introduction" and related onboarding
materials
-Specifically:

If you spelled out CRRA utility as "constant relative risk
aversion" the first time it's used, rather than use the acronym, it would
be easier to follow
It's not immediately clear to this non-specialist why 'risk
aversion' is relevant in this case, when all the values are deterministic.

A link to lecture notes or some reliable source about this would go a
long way to making this more approachable. I've been picking my way through
Wikipedia, but that's not ideal.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=ADKRAFKBUWJZV7H46GHY6GDQPSV5RA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFUVEXG43VMWVGG33NNVSW45C7NFSM4HTAPQ2A,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/ADKRAFPUYNTUMW2XWOAN7Y3QPSV5RANCNFSM4JCVWAMA
.

Thank you very much for all this explanation.
It's very helpful (to me) to know that concavity is there to make it better to consume some today, then some tomorrow. That makes sense. Spelling that out, in terms of concavity (as opposed to risk aversion, though I realize these mathematically amount to the same thing), might make the introduction even gentler.
This is a fascinating project to me in part because it gets to the heart of a criticism of formal economics: that it sometimes favors analytical tractability rather than realism in its models. Fixing the analytical tractability problem with software is a great solution to that. But maybe that should lead to a corresponding higher standard in how well motivated the models are

To be clear: this project is not meant to teach heterogeneous
agents macroeconomics (or structural micro) in itself.  HARK is not the
beginning of HA macro, nor do these models represent a new frontier of
economics.  There's a lot of foundational work on models of
consumption-saving under risk from the late 80's to mid 90's, a good chunk
of it by Chris Carroll, the PI of this project.  We aren't trying to
provide an entry point into theory, nor justify why these models are a
"good" approximation of an individual or household's problem (or at least a
better one than prior models).  The intent of HARK is to provide a common
software package for researchers to work in, rather than everyone
handcrafting their own bespoke code for each project.  We want to foster
interoperability of code between economists; we're starting from nearly
zero on that front.
The second goal of HARK (and Econ-ARK more broadly) is to provide teaching
tools for computational methods for solving these models.  Another
project, QuantEcon, provides extensive (and excellent) resources for
learning the "building blocks" of computational economics-- numeric methods
that are applicable in a wide variety of fields-- and then begins to apply
them to some models.  Our instructional notebooks are extremely sparse
right now, but our intent on that front is to be the next step beyond the
QuantEcon material.
I forgot to write in my prior post: Chris' (outstanding) lecture notes are
linked several times from Econ-ARK materials; things have been edited a
lot, so I don't know off the top of my head where those links are.
On Mon, Oct 21, 2019 at 7:35 AM Sebastian Benthall<EMAIL_ADDRESS>wrote:

Thank you very much for all this explanation.
It's very helpful (to me) to know that concavity is there to make it
better to consume some today, then some tomorrow. That makes sense.
Spelling that out, in terms of concavity (as opposed to risk aversion,
though I realize these mathematically amount to the same thing), might make
the introduction even gentler.
This is a fascinating project to me in part because it gets to the heart
of a criticism of formal economics: that it sometimes favors analytical
tractability rather than realism in its models. Fixing the analytical
tractability problem with software is a great solution to that. But maybe
that should lead to a corresponding higher standard in how well motivated
the models are
—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=ADKRAFMTBMQOHGHCAOLRTS3QPWHWZA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOEB2AJSI#issuecomment-544474313,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/ADKRAFNRWJKTQJOAFTPYZK3QPWHWZANCNFSM4JCVWAMA
.

Thanks so much for this clarification and introduction to the field.
I've been tasked just now (in the roadmapping meeting) with working on synthesizing/reconciling the introductory materials. I'll keep all this in mind as I do that.
This is one of the documents that made me think that HARK might have a broader aspirational scope, accessible to a somewhat broader audience than the one you indicate, and capable of facilitating more more ambitious intellectual or educational agenda:
https://github.com/econ-ark/PARK/blob/master/Elevator-Spiels.md

I'm editing the introductory materials (see #409 ) This task is taking me back to this issue.
I think a source of confusion is that there are many imagined audiences/potential users of HARK.
I.e., the pool of potential community members is heterogenous.
That imagined heterogeneity is displayed here:
https://hark.readthedocs.io/en/latest/readme.html#learning-hark
It looks like the audiences for the "Gentle Introduction to HARK" tutorial is:

"For people with a technical/scientific/computing background but little economics background"
"For economists who have not yet done any structural modeling but might be persuadable to start"

So I think I'm going to go with my instincts here and plan to add more background in structural modeling and basic economic theory in the "Gentle Introduction". I hope that's acceptable to you.
It looks like other notebooks are recommended for those with more background in this area.

Two points:

I’m generically sympathetic to criticisms involving too much jargon.

The key trick is to find a way to express your point in plain
language in a way where the expert will know precisely what you are
signaling (basically, they will substitute the jargon term for your plain
language term), and the nonexpert will know at least vaguely what you are
saying. But this is easier said than done, which is part of the reason
jargon is so pervasive.

I’d distinguish between jargon (which is about language) and content.
You are quite convincing on the point that people who come to the toolkit
from outside of economics will find the “Gentle Intro” material an
imperfect intro because it leaves out a bunch of epistemological
foundations that are assumed (like the importance of expectations). If
there are two dimensions (high/low) in familiarity with economics, and
high/low in computer stuff, the “Gentle Intro” is kind of written for the
high/low (=Econ/Computation) dimension, and you are coming to it from the
low/high corner. Seems to me that we are better off just being more
explicit about providing different starting points based on prior
knowledge. So, we should probably have a (low/high) and a (high/high) to
complement the (high/low) intro we have now. I think three paths into the
toolkit are enough. (The number of low/low people who will be exploring our
toolis is probably — well — low.)

On Tue, Oct 22, 2019 at 8:47 AM Sebastian Benthall<EMAIL_ADDRESS>wrote:

I'm editing the introductory materials (see #409
https://github.com/econ-ark/HARK/issues/409 ) This task is taking me
back to this issue.
I think a source of confusion is that there are many imagined
audiences/potential users of HARK.
I.e., the pool of potential community members is heterogenous.
That imagined heterogeneity is displayed here:
https://hark.readthedocs.io/en/latest/readme.html#learning-hark
It looks like the audiences for the "Gentle Introduction to HARK" tutorial
is:

"For people with a technical/scientific/computing background but
little economics background"
"For economists who have not yet done any structural modeling but
might be persuadable to start"

So I think I'm going to go with my instincts here and plan to add more
background in structural modeling and basic economic theory in the "Gentle
Introduction". I hope that's acceptable to you.
It looks like other notebooks are recommended
https://hark.readthedocs.io/en/latest/readme.html#for-economists-who-have-done-some-structural-modeling
for those with more background in this area.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=AAKCK762REU2YSTKKTKVJ5LQP3Y7TA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOEB5TIKY#issuecomment-544945195,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AAKCK73YQNX5SXEVMMNMUY3QP3Y7TANCNFSM4JCVWAMA
.

--

Chris Carroll

See #380

Agree with Chris here.  Multiple entry points might be a better solution,
and we need to be clear about which door is for which person.  Given the
audiences we've presented to, we've often been told that we don't need to
explain the economics, just show how it works.
HARK can be used to teach graduate-level dynamic modeling for the first
time, but it wasn't our intent.
On Wed, Oct 23, 2019 at 11:21 PM Christopher Llorracc Carroll <
<EMAIL_ADDRESS>wrote:

Two points:

I’m generically sympathetic to criticisms involving too much jargon.

The key trick is to find a way to express your point in plain
language in a way where the expert will know precisely what you are
signaling (basically, they will substitute the jargon term for your plain
language term), and the nonexpert will know at least vaguely what you are
saying. But this is easier said than done, which is part of the reason
jargon is so pervasive.

I’d distinguish between jargon (which is about language) and content.
You are quite convincing on the point that people who come to the toolkit
from outside of economics will find the “Gentle Intro” material an
imperfect intro because it leaves out a bunch of epistemological
foundations that are assumed (like the importance of expectations). If
there are two dimensions (high/low) in familiarity with economics, and
high/low in computer stuff, the “Gentle Intro” is kind of written for the
high/low (=Econ/Computation) dimension, and you are coming to it from the
low/high corner. Seems to me that we are better off just being more
explicit about providing different starting points based on prior
knowledge. So, we should probably have a (low/high) and a (high/high) to
complement the (high/low) intro we have now. I think three paths into the
toolkit are enough. (The number of low/low people who will be exploring our
toolis is probably — well — low.)

On Tue, Oct 22, 2019 at 8:47 AM Sebastian Benthall <
<EMAIL_ADDRESS>wrote:

I'm editing the introductory materials (see #409
https://github.com/econ-ark/HARK/issues/409 ) This task is taking me
back to this issue.
I think a source of confusion is that there are many imagined
audiences/potential users of HARK.
I.e., the pool of potential community members is heterogenous.
That imagined heterogeneity is displayed here:
https://hark.readthedocs.io/en/latest/readme.html#learning-hark
It looks like the audiences for the "Gentle Introduction to HARK"
tutorial
is:

"For people with a technical/scientific/computing background but
little economics background"
"For economists who have not yet done any structural modeling but
might be persuadable to start"

So I think I'm going to go with my instincts here and plan to add more
background in structural modeling and basic economic theory in the
"Gentle
Introduction". I hope that's acceptable to you.
It looks like other notebooks are recommended
<
https://hark.readthedocs.io/en/latest/readme.html#for-economists-who-have-done-some-structural-modeling
for those with more background in this area.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
<
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=AAKCK762REU2YSTKKTKVJ5LQP3Y7TA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOEB5TIKY#issuecomment-544945195
,
or unsubscribe
<
https://github.com/notifications/unsubscribe-auth/AAKCK73YQNX5SXEVMMNMUY3QP3Y7TANCNFSM4JCVWAMA
.

--

Chris Carroll

—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=ADKRAFISTZYT7FW3VD57NFLQQEIERA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOECDRVAI#issuecomment-545725057,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/ADKRAFOTQIENTRNUJDPJKO3QQEIERANCNFSM4JCVWAMA
.

Clarification: It wasn't our intent when making things like the Gentle Intro
On Thu, Dec 5, 2019 at 10:19 AM Matthew White<EMAIL_ADDRESS>wrote:

Agree with Chris here.  Multiple entry points might be a better solution,
and we need to be clear about which door is for which person.  Given the
audiences we've presented to, we've often been told that we don't need to
explain the economics, just show how it works.
HARK can be used to teach graduate-level dynamic modeling for the first
time, but it wasn't our intent.
On Wed, Oct 23, 2019 at 11:21 PM Christopher Llorracc Carroll <
<EMAIL_ADDRESS>wrote:

Two points:

I’m generically sympathetic to criticisms involving too much jargon.

The key trick is to find a way to express your point in plain
language in a way where the expert will know precisely what you are
signaling (basically, they will substitute the jargon term for your plain
language term), and the nonexpert will know at least vaguely what you are
saying. But this is easier said than done, which is part of the reason
jargon is so pervasive.

I’d distinguish between jargon (which is about language) and content.
You are quite convincing on the point that people who come to the toolkit
from outside of economics will find the “Gentle Intro” material an
imperfect intro because it leaves out a bunch of epistemological
foundations that are assumed (like the importance of expectations). If
there are two dimensions (high/low) in familiarity with economics, and
high/low in computer stuff, the “Gentle Intro” is kind of written for the
high/low (=Econ/Computation) dimension, and you are coming to it from the
low/high corner. Seems to me that we are better off just being more
explicit about providing different starting points based on prior
knowledge. So, we should probably have a (low/high) and a (high/high) to
complement the (high/low) intro we have now. I think three paths into the
toolkit are enough. (The number of low/low people who will be exploring
our
toolis is probably — well — low.)

On Tue, Oct 22, 2019 at 8:47 AM Sebastian Benthall <
<EMAIL_ADDRESS>wrote:

I'm editing the introductory materials (see #409
https://github.com/econ-ark/HARK/issues/409 ) This task is taking me
back to this issue.
I think a source of confusion is that there are many imagined
audiences/potential users of HARK.
I.e., the pool of potential community members is heterogenous.
That imagined heterogeneity is displayed here:
https://hark.readthedocs.io/en/latest/readme.html#learning-hark
It looks like the audiences for the "Gentle Introduction to HARK"
tutorial
is:

"For people with a technical/scientific/computing background but
little economics background"
"For economists who have not yet done any structural modeling but
might be persuadable to start"

So I think I'm going to go with my instincts here and plan to add more
background in structural modeling and basic economic theory in the
"Gentle
Introduction". I hope that's acceptable to you.
It looks like other notebooks are recommended
<
https://hark.readthedocs.io/en/latest/readme.html#for-economists-who-have-done-some-structural-modeling
for those with more background in this area.
—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
<
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=AAKCK762REU2YSTKKTKVJ5LQP3Y7TA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOEB5TIKY#issuecomment-544945195
,
or unsubscribe
<
https://github.com/notifications/unsubscribe-auth/AAKCK73YQNX5SXEVMMNMUY3QP3Y7TANCNFSM4JCVWAMA
.

--

Chris Carroll

—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
https://github.com/econ-ark/HARK/issues/407?email_source=notifications&email_token=ADKRAFISTZYT7FW3VD57NFLQQEIERA5CNFSM4JCVWAMKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGOECDRVAI#issuecomment-545725057,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/ADKRAFOTQIENTRNUJDPJKO3QQEIERANCNFSM4JCVWAMA
.

Ok, I see now where to make some impact on this.
I should complete the "Journey into HARK" for engineers.
That makes this issue redundant with #362, which I've now claimed.
Thanks for your patience with my stumbling around, getting my bearings, and so on.


Misspelling in documentation at https://github.com/tensorflow/tfjs-tsne

config is an optinal object with the following params

optinal  should be optional

Also
// Runs for 1000 iterations be default.
should be
// Runs for 1000 iterations by default.

Thanks, I made a PR